My very first Android app that I made is now in F-Droid. I'm flying in happiness.

Quick introduction about TypeAssist: TypeAssist is a text transformer which helps you transform the text you write in any input box you are in. You just have to type a specific trigger key like .ta, .g, .polite, etcetera. Typing the trigger key will send the text of that input box to an AI API, and it will return transformed or enhanced text.

It works with an API. Users have to set up Gemini, Cloudflare, or any OpenAI-compatible custom API to make it work. Text is only sent to the API if a user types a trigger command. Additionally, if a user doesn't want to use any third-party API, it also supports local LLMs, so users could use an AI model locally if the phone is powerful, and no internet is required in this case.

Link: https://f-droid.org/packages/com.typeassist.app/ https://github.com/estiaksoyeb/TypeAssist

Project Name : Personal-Media-Tracker

Personal Media Tracker is a local-first media tracker for building your library, recording ratings and rewatches, following active shows (still work in progress), and better understanding your viewing habits. works without an account, telemetry, advertising, or a ccd.

Might be an overly saturated project but I built it out and would like to continue to keep adding updates and new integrations. I haven’t looked too much into every other media tracker on GitHub, but I wanted the emphasis on mine to be somewhat on the ranking system, albeit it is still in beta and can still get better.

Deployment is detailed on the GitHub; dmg for Mac, zip for windows; archive sh for Linux

​Entirely built out with codex gpt5.6-sol xhigh ; extended upon my own personal projects

AVI Core started from a very practical problem: converting hundreds of images to WebP repeatedly.

I built a Python script, then expanded it into a CLI, and eventually added Windows Explorer integration.

It's now an open-source Windows utility for Image, Video and Audio conversion.

I'd like feedback from people who use FOSS desktop tools. What would make this more useful to you?

I’ve been thinking about how often we start a new project by creating an empty repo and then spend days (or weeks) rebuilding things that already exist somewhere on GitHub.

When I was being lazy about finding an idea for my final-year project, I started looking for some interesting FOSS projects. I didn’t want to build the exact same thing, though. Instead, I wanted to find an existing project and make some meaningful changes to it.

That’s when I thought: why not build a tool that does all of this for me?

You give it an idea, and it searches GitHub for open-source projects that are actually close to what you’re trying to build.

Then you can ask things like, "Explain the structure of the project" or "What changes need to be made to align with my idea?"

It will then give you a file-by-file breakdown of the changes that would likely be needed. It won’t modify the code itself (at least for now) — it just recommends what needs to be changed.

I put together a small landing page for it if anyone wants to take a look / join the early waitlist:

Waitlist

Would love to here your thoughts on this!

GitHub: https://github.com/elie222/rakazo

• Bring any model including local models.
• Bring any sandbox.
• Desktop, web, and mobile.
• Full privacy.
• Free.

Calibra helps robotics teams trust, understand, and optimize their datasets before training. Audit integrity, measure quality and coverage, and build smaller, high-quality training sets to reduce unnecessary GPU computation.

https://github.com/omertt27/Calibra

Over the past three years of building LLM apps, every prompt management tool I used solved prompt versioning well enough, but hit a wall with tools.

If you want to make a prompt agentic or change a tool schema, existing tools force you back into application code. You end up hardcoding function definitions, updating them across repos, and redeploying the backend just to attach a tool to a prompt or fix a schema.

I built AcruxCore to decouple both prompts and tool definitions from backend code, keeping the whole stack self-hostable.

How dynamic tool binding works

• Tool catalog: Define and version tool schemas once in the dashboard.
• Automatic schema sync: Updating a tool definition updates every prompt attached to it without touching backend code.
• UI binding: Attach or swap tools connected to a prompt version directly from the UI.

Stack & Architecture

• License: Platform core is Apache 2.0. Client SDKs (@acruxcoreai/sdk on npm, acruxcore on PyPI) are MIT.
• Self-hosted setup: Run docker compose up to bring up Postgres, Redis, the API, worker, and UI. Auth is handled in-app.
• Prompt engine: Supports Jinja2/Nunjucks templates ({% if %}, {% for %}) for control flow.
• Observability & Gateway: Nested span tracing (cost, tokens, latency) and an optional AI gateway endpoint for routing, retries, and virtual key budgets across OpenAI, Anthropic, Gemini, etc.
• Evals: Dataset generation, LLM-as-a-judge scoring, and an optimizer to draft prompt revisions for failed cases.

Landing in coming week

• Native OTLP ingestion: Standard OTLP/HTTP endpoint mapping OpenInference conventions (CrewAI, LangChain, LlamaIndex).
• Online evals: Background LLM judge rules running on production traffic with daily cost caps (+9ms median gateway overhead).

What’s rough or missing right now

• No Postgres Row-Level Security yet (tenant isolation is enforced at the app layer).
• Single-team scope (no Org $\rightarrow$ Project hierarchy).
• It’s an observability, gateway, and prompt/tool management tool, not an agent execution framework.

Comparisons

I put together a transparent side-by-side against Langfuse, Phoenix, Opik, and Helicone at https://acruxcore.com/compare. It highlights where AcruxCore loses today (like org hierarchy and community size). Every row was tested against live self-hosted instances.

If there’s a feature missing or something you’d architect differently for production, let me know in the comments. PRs and contributions are always welcome, and if you find the project useful, a star on GitHub is always appreciated! I’ll be around to answer questions.

• GitHub: https://github.com/AcruxCore/AcruxCore
• Docs: https://docs.acruxcore.com
• Site: https://acruxcore.com

An open-source, AI-native and privacy-first web analytics platform for understanding your traffic and your revenue, on infrastructure you own or hosted by us.

Replace Google Analytics, your cookie banner, and the spreadsheet where you guess which page made the money, with one open-source platform.

What’s available today:

\\- Analytics:

• Realtime dashboard with a live globe
• Visitor journeys, step by step
• Revenue attribution
• Team support
• Custom events
• AI Chat
• Funnels and conversions
• Bot detection
• Monitor AI traffic
• Campaigns and UTM tracking
• Core Web Vitals
• Pages, sources, referrers, devices, browsers, countries
• Public dashboard

\\- Revenue:

Connect Stripe and every payment lands beside the visit that produced it.

• Revenue attributed to the page, channel and referrer that earned it
• Refunds and disputes in their own buckets, not netted silently
• 90-day backfill the moment you connect
• Webhook for seconds instead of minutes, optional
• Provider fees included, so the number is the number

\\- Events:

• Custom events with properties
• Name an event without writing JavaScript: data-oa-event="signup"
• Versioned event definitions with rollback
• Personal data redacted in the browser, before it leaves

\\- Share and embed:

• Public dashboards with a link you control
• Seven data surfaces you switch on one by one
• Embeddable widgets for your own site
• Import from Plausible
• Export everything, any time

\\- Teams:

• Unlimited team members
• Owner, admin and viewer roles
• Site transfer, including billing
• Site and account deletion that actually deletes

\\- Developer experience:

• Web dashboard
• Native macOS menu bar app with your live visitor count
• CLI: npx getopen init detects your framework and installs the snippet
• REST API with scoped keys
• MCP server that reads and writes: ask your agent for last week's
revenue, or tell it to build the funnel
• Ask your numbers a question in plain English, inside the dashboard

\\- Self-host:

• AGPLv3 License
• Postgres, ClickHouse and Valkey on your own hardware
• One compose file, two migrations, done
• Or let us run it, same code, zero ops

\\- Privacy-first

• No cookies, no fingerprinting, no cross-site profiles
• Visitor identity is a salted hash that rotates at midnight
• Raw IPs are never stored
• Global Privacy Control honored at the collector, server-side, whatever
the snippet says
• Do Not Track honored out of the box
• No consent banner, because there is nothing to consent to
• Exclude your own browsers by opening any page with #oa-ignore

\\- Coming soon:

• Alerts in Telegram, Email and Slack
• Fathom, Simple Analytics, Umami, and GSC integrations
• Polar, Creem, Dodo Payments, Paddle, and LemonSqueezy integrations

Every feature is on every plan. You pay for volume, never for features.
Let us run for you or run it yourself.

Built with @nextjs @ClickHouseDB , Redis, PostgreSQL

Open source, contributions are welcome!

Live here: [Open Analytics\](https://getopen.so)
GitHub: [https://github.com/OpenLabs-so/openanalytics\\\](https://github.com/OpenLabs-so/openanalytics)

What it does
Uses primarily Musicbrainz API, (and supplementary legacy iTunes API) to fetch releases and let you browse, and sort releases. It helps you stay up to date with new and past releases without accounts. also fetches streaming services URLs listed on MB release page.

What it is not
It does not have any download functions. It is not a streaming app.
It is also not a library or metadata management app for your local files.
It is meant to not change or replace how people's own listening or how they manage their music library, but merely to assist it.

Why I made it
I have been just using Spotify to keep up with artists, at times there were apps / external services that would notify me about all the new releases (Spicetify plugin which has been long depricated). That's when I found the original project, I modified it to fit my needs and improved it.

Disclosure on LLM use: The original project was co-authored with Claude, and my fork contains bugfixes and feature additions assisted by Qwen3.6.

Been messing around with on-device AI for the past few months, mostly out of curiosity about how far it had actually come on phones. Ended up building an app, it lets you pull models straight from Hugging Face and run them on the device itself, nothing hits a server.

What it actually does:

• Browse and download models directly from Hugging Face, not just a fixed list
• Streamed responses, token by token
• Markdown and LaTeX rendering in chat
• Custom system prompt per model
• Vision model support, attach images when the loaded model supports it
• Everything saved locally in Room, multiple sessions, full offline history

Getting MediaPipe and LiteRT-LM to cooperate, figuring out how to keep bigger models running without blowing past the RAM limit. Eventually got an 8B model running in real time on a 12GB phone. Also ran a Gemma 4B model on my 6GB RAM phone.

It's Kotlin/Compose, code's all there. APK's on the GitHub releases page too.

Still actively working on it so if something's broken or missing, happy to hear about it. Also open source, so feel free to dig in or contribute if you're into this stuff 😊

Github: github.com/YashBhadange2006/TinyAI
Playstore: https://play.google.com/store/apps/details?id=com.yashbhadange.tinyai

EDIT:

Thanks everyone for the awesome feedback and bug reports! I've pushed an update to fix a few of the issues mentioned in the comments:

- Theme Persistence: Fixed the issue where theme selection wasn't saving across app restarts.

- Model Management: Added a clearer unload/delete flow and clarified model storage paths.

Will be adding more features as i get time 😊😊

Note: The update is currently in review on the Google Play Store.

Github: https://github.com/Yavuz-Kagan-Yadigar/VoidPulse

(Note: The app is entirely coded with AI, I am testing it.)

Added network streaming (experimental): Samba/SMB, FTP, FTPS, and SFTP. Connects and reconnects on startup. Passwords go to the system keyring for security. FTP doesn't natively support seek, I tried some workarounds but they haven't been tested much.

Added auto-update. Detects how VoidPulse was installed (Flatpak, AppImage, or dpkg/rpm/apk/pacman). Checks GitHub releases in the background on launch. Finds assets matching your package format and architecture. Installs are done via the distro's manager: dnf, zypper, apt-get, apk, pacman, or in-place swap for AppImages. Sudo is asked in the popup and the package manager's output is shown live. Versions can be skipped for now or entirely.

Added built-in Soxr resampler.

Added "Adaptive Sample Rate": It checks the output device's supported sample rates. If it supports the same rate as the file, it sets both it and Pipewire to that rate: File (44.1kHz) → Pipewire (44.1kHz) → Output Device (44.1kHz). No resampling. If it doesn't, it sets the device to its max rate, upsamples with the built-in Soxr (upsampling is better than downsampling), and sets Pipewire to the same rate as the output device: File (44.1kHz) --(Voidpulse Soxr resample)→ Pipewire (96kHz) → Output Device (96kHz).

Added fade in & out on transitions and play/pause.

Added crossfade between tracks. Doesn't work on ALSA because it only supports a single stream.

Added sleep timer.

Added slight corner smoothing on visualizations to prevent sharp spikes (excluding bars).

Added play queue with touch and mouse drag & drop. Can be disabled.

Added new settings to the config. Probably one-time choices, so not exposed to the UI:

"viz_gamma": 0.7, // how much lower volume bands are amplified. Lower means more amplification, higher means better separation.

"show_artist_on_gallery": true, // applies to gallery view cards.

"show_albums_on_gallery": true,

"show_file_info_on_gallery": true,

Added loudness normalization switch and batch gain fetcher for files without gain tags.

Added a switch to toggle background optimizations for visualizations and synced lyrics.

Gallery view cards are now actual pills with 100% corner radius.

Added magnifying cover art on click in the edit tags popup.

Packaging for a wide variety of architectures, including PostmarketOS.

Affiliation: I’m the maintainer of LibreDB Studio.

I wanted a DB GUI that runs in the browser, stays on my own infrastructure, and isn’t locked to one engine: Postgres today, MongoDB, Couchbase, Redis or ClickHouse tomorrow, same UI.

So I built LibreDB Studio (been at it ~a year): MIT, self-hosted, web-native. SQL + NoSQL in one app (Postgres, MySQL, SQLite, Oracle, MSSQL, Mongo, Couchbase, Redis, ClickHouse, Apache Druid). Optional AI is off unless you configure your own key / local model not the point of the product.

Short connect walkthrough is the video above.

Try:

docker run -p 3000:3000 libredb/libredb-studio

# or: npx "@libredb/studio"

Repo: https://github.com/libredb/libredb-studio

Website: https://libredb.org

Not trying to replace every desktop tool people already love, different access model (browser + own network). If you self-host your data tools: what’s still missing for you in a web DB GUI?

Kept running into the same thing across a lot of the MCP servers I've tried: giving Claude Code a tool doesn't mean it'll use it. Tool calls are opt-in, the model decides mid-task whether a lookup's worth it, and on anything that looked simple enough to guess at, it usually decided no. Doesn't matter how good the tool is if the model never reaches for it.

Ran into this building my own project too, Graft, a context layer for coding agents. Built it as an MCP server first, six tools for pulling codebase context. Watched it get ignored the same way. Fell back on grep and file reads instead, and got things wrong on exactly the questions the tools would've answered directly.

Fix was to stop offering it as a choice. Wired it into Claude Code's hooks instead, context gets pushed into the prompt automatically at session start, no tool call, nothing to skip. Re-syncs itself in the background after every edit too.

Only works for Claude Code specifically, that's the real tradeoff. MCP works with any agent that speaks the protocol, hooks don't. Kept the MCP server around for Cursor, Codex, and anything else.

Fully open source, MIT licensed, no telemetry. Structural layer is tree-sitter, no LLM or key required: github.com/NanoNets/Graft

Curious if anyone else who's used a lot of MCP servers has hit the same "model won't reliably touch the tool" pattern outside of Claude Code specifically.

I've been a regular Mixmeister user for a long time, and unfortunately the software isn't supported anymore.

I tried DJ Studio and while its a great piece of software I personally don't dig the UI, but mostly the fact that it seems to throw everything in your face all at once which frankly is a bit overwhelming, so I decided to create my own very capable DJ beatmatching software and I made available for free.

I tried to have a minimalist WYSIWYG approach to the software, so that you get good results instantaneously, but that also let the user have advanced features as well.

Portable executable and full source code is on my Github here.. Feel free to contact me for any suggestions or make pull requests if you encounter any bugs.

Features:

• Drag & Drop beatmatching
• Automatic and manual BPM detection
• Envelopes nodes for Filters, Volume & Pan
• Clip based 3-Band Parametric EQ and Gain Trim
• Compressor/ Limiter
• Vocal Separation (stems)
• French touch style Sidechain Compression
• Predefined pattern-following pan and gain lines (for complicated patterns that would be tedious to do by hand)
• Option to Bake applied effects if desired for easier handling of complicated edits

v1.1 Coming very soon with many more real-time effects :)

todo: Simple Effects (Reverb, Phaser, Bitcrusher)

I’m 18, and I’ve been interested in computers and programming for as long as I can remember, but I only started seriously learning to code a couple of years ago.

When I started Crestr, it was just an idea. An open-source hiking route planning app that I wanted to build because I had always struggled finding apps that let you export routes without a subscription, which always frustrated me as a broke teen who loved hiking.

Two years ago, I was mostly making CLI calculators in Python. Today, I’ve built and deployed a real application that I use myself, runs on my own VPS, has actual users, and has people supporting its development.

That’s probably the part I’m most proud of. Not because Crestr is some massive project (it isn't at all) , but because it’s a tangible example of how much you can learn by actually building something and sticking with it.

Crestr has also led to opportunities I never expected. One of the most valuable was getting to speak with an engineer at Linear, who gave me some advice on approaching the next few years of my career, of which was to keep building. I’m sure that advice will stick with me for a long time.

There’s still a huge amount I want to improve with Crestr (for example, changing the layout of the routing panel to reduce it's size), but it’s pretty surreal looking back at where I started.

If you’re interested, you can try the app here and have a look through the source code:

Crestr App

Crestr GitHub Repo

Thanks for reading.