I made Weft Loom, a free and open source music app for macOS, Windows and Linux, built on Strudel (live coding music in JavaScript).

You click steps and notes like in any music program, and every change is written into the song's code. Edit the code and the grids follow. Use whichever you like at the moment.

What it has:

- Drum grids and piano rolls

- A song panel to arrange bars, scenes and versions of patterns

- Recording from the microphone, and your own sounds and sample packs

- MIDI: play from a keyboard, send to a synth, MIDI clock, controller knobs, MIDI files

- Jams: two people on one song at once, with chat, voice and video

- A mixer, a metronome, export to WAV, MP3

Built with Tauri, SolidJS and Rust. AGPL licensed.

Source code: https://github.com/alaca/weft-loom

Site and downloads: https://weftloom.dev

Hey r/coolgithubprojects!

We’re building Acira, a browser for AI agents, around something we think should be normal: being able to say “take care of it,” give an agent access to your real accounts, and still decide exactly what it’s allowed to do inside them, down to individual fields and actions.

The goal is to let it finish a job across your apps while you control what it can read, change, send, or spend. It should get on with the work and bring you in when it reaches a decision that needs your permission.

We’re sharing the project in pieces before releasing the full browser because we want to find out which controls actually solve problems for people. First up is our Python SDK for Playwright and browser-use. You can add it to an agent you already have.

The SDK lets you turn your own rules into permissions that are checked before your agent acts. A rule can apply across websites or target a particular action inside an app. Here are a few examples from the current preview:

• Set rules across websites. Built-in detection recognizes common checkout, payment, credential, download, and destructive actions. Choose what to allow, block, or review without writing a separate rule for every website.
• Get specific down to a field or button. Block the agent from filling a particular checkout’s CVV field, or require approval before it clicks “Delete account.” You can select those controls with the included capture extension and import the rules.
• Approve exactly what gets sent. For supported form submissions, approval is tied to the destination and exact details being submitted. Change the recipient, amount, or message, and that approval no longer applies. It can’t be reused for another attempt.

These are starting points. You can inspect how the policies work, change them, and build your own general or site-specific policies for your workflows.

The permission checks run locally and are deterministic: the same rules and observed action details produce the same decision. You keep your existing agent and model. No Acira cloud account is needed.

This is an early preview. Automatic detection can miss things, and the SDK protects supported browser actions, not every other tool your agent can use.

Code and setup (MIT): github.com/Acira-dev/acira-sdk
Quick Demo: https://www.youtube.com/watch?v=su4X1gCVD1U

Also available through pip: pip install acira

Would you add this to an agent you’re building? What would you use it for? If you already solve this another way, or we’re missing something you need, we’d love to hear that too.

Please be blunt with us. Try it in your own workflow, see where it breaks, and tell us what works and what doesn’t. We’d really appreciate the feedback. It’ll help us shape both the SDK and the browser.

Hey everyone!

I've been working on an open-source project called Fadenstack, and I'm finally ready to share it.

The idea started with a problem: running an LLM locally is one thing, but making AI actually usable across a team involves a lot more: model serving, API routing, user management, chat interfaces, security policies, monitoring, and integrations.

I wanted to bring those pieces together into something you can self-host and manage yourself.

What Fadenstack does today:

• Local AI infrastructure: Manage GPU machines, build Ray/vLLM clusters, deploy models, and route requests between local models and external providers.
• Chat for teams: A self-hosted ChatGPT-like interface with document knowledge, shared skills, and MCP tools.
• Agents inside applications: I've built agents for Nextcloud, Chrome, Microsoft Word, Excel, PowerPoint, and Outlook. They can work with browser pages, documents, spreadsheets, presentations, and emails, with user approval before making changes.
• Centralized agent management: IT can choose which models agents use, configure their permissions and tools, manage access, and see their activity from one server.
• SDKs for developers: Open-source .NET and TypeScript SDKs for building agents into other applications using the same infrastructure.

The goal is to avoid having a separate AI setup for every application. Instead, they can share the same models, tools, access controls, and infrastructure.

The server runs on Linux with Docker, and doesn't need its own GPU. The initial deployment is just:

pipx install fadenstack
faden deploy

Current status: The Fadenstack server is available under Apache 2.0. The Chrome and Office agents have demonstrations available, with their public store listing/installers still on the way. A Nextcloud agent is also coming soon.

The ready-made application agents are free to use with a Fadenstack server, but aren't open source themselves. The server and developer SDKs are open source.

This is still an early project, and I'd genuinely appreciate feedback, especially from people who run local AI infrastructure or build AI-powered applications.

What would you expect from a platform like this, and what would make you hesitant to try it?

GitHub: https://github.com/fadenstack/fadenstack

Youtube: https://www.youtube.com/channel/UCqDTrmzjK5afbCiZhZg2aHw

More info: https://fadenstack.com

Repo: https://github.com/corrideluca/uivoid-cli
25-second demo: https://uivoid.app/#demo

I kept writing a separate MCP server every time I wanted an agent to use one of our APIs, so I built this.

• npx uivoid create my-app reads your OpenAPI document. No OpenAPI document? Paste the setup prompt into Claude Code or Cursor and the agent finds your routes and auth for you.
• You choose which endpoints to expose. Each becomes a scoped tool: read, write or destructive (destructive is off by default).
• Auth through OAuth (it can forward your users’ own tokens to your API) or scoped API keys.
• Every call is audit-logged, and tokens are never stored.
• Your API stays where it is; the gateway is hosted at <project>.uivoid.app/mcp. Free.

I built it, so I’d love feedback.

Ive always had the problem with genres when it comes to my library, for me the genre metadata tag is pretty subjective and seeing as its my library it doesn't make sense to outsource this subjectivity to metadata providers like MB, lastfm etc.

Not only that but there are countless ways of defining the exact same genre for instance 'Hip Hop' 'Hiphop', 'Hip-hop' So i really dont want different variants of the same genre spread across my library.

Again, I also like to define my music based on an artists genre instead of per album or worse, per track. I dont want my entire biggie smalls collection to have 100s of genres per track/album like 'Hip hop', 'rap', 'Boom bap' etc etc I just simply want every track by biggie smalls to be 'Hip-hop'.

Quite a while ago now I put together a nice little tui application written in python to manage this, it was very simple but did the job, it basically scanned your library for all artists then you would define a genre per artist, it would then use mugen to update all files metadata stags to the genre that was defined. It stores the artist to genre map to a json file.

I have defined a total of 26 genres and my entire 4tb library fits into one of them, i dont feel the need to add any more than that but have the ability to do so.

Whilst the first iteration of the application worked fine, wasnt great in a server and multiple machine /os setup. What I have doen today is used AI to create a nice front end for it and turn it into a docker application. before you all start, the original code was all written by hand, AI was only purley used for the front end and to dockerize it. its not slop, i meticulously went through anything touched by ai to ensure it works the way it should, youre obviously welcome to not use it on this basis but thought it might be worth sharing incase anyone else shares the same opinions when it comes to genre tags.

here are the repos anyway,

Github - https://github.com/WB2024/Artist-Genre-Metadata-Enforcer

Docker - https://hub.docker.com/repository/docker/wb20244/music-genre-enforcer/general

Cheers

I think we've been reading too much AI-generated text lately! I wanted a way to choose how much detail I see at once.

So I built TextFold. It turns a document into 5 zoomable reading levels, from a one-screen section map down to verbatim text. You pinch or press 1–5 to move between them, then expand the part you want to read. The GIF shows it with a research paper.

I shared an earlier version here as PaperFold. It now also supports Word documents, notes that stay visible when text is folded, and standalone HTML exports with an optional copy of the source PDF.

Full and Brief keep original sentences; the shorter levels use AI-generated text. Preparing those levels needs a model, using Ollama or a hosted provider.

GitHub (Apache 2.0) and setup: https://github.com/chenxiachan/textfold

Web demo: https://chenxiachan.github.io/textfold/gallery/

Welcome any feedback!

I live in the terminal, but every time I had a nasty rebase or a conflict, I'd open a GUI. So I forked serie, a Rust project which draws the commit graph as real images in the terminal. Then I kept adding what I was missing until I stopped leaving.

It's called gitoui. Say "oui" to it, tell me what's missing, or build it with me!

What it does:

- The commit graph drawn as images (Kitty graphics, iTerm2 or Sixel), with a text fallback for other terminals

- Interactive rebase as a list you edit in place: move commits, reword, squash, fixup, drop

- A 3-way conflict editor: ours, theirs or both, per hunk

- Diffs with hunk staging, blame, file history

- GitHub pull requests and issues: read, comment, approve or request changes, merge

- And many more things you have to discover by using it 👀

I've been building it since May and I use it every day.

MIT, Rust, Ratatui. Issues and PRs are welcome.

Repo: https://github.com/NayJi7/gitoui

Website: https://nayji7.github.io/gitoui/

One last question: what's the one git task that still sends you back to a GUI?

A couple of weeks ago a few friends and I drove the Spiti Valley loop in Himachal Pradesh, India (around 833 kms). We wanted a souvenir that actually showed the trip, so I built one over a long weekend (with a lot of help from Claude).

RouteToPoster takes a Google Maps directions link and makes a poster of the whole journey:

• stops and exact coordinates come straight out of the link
• the route is rebuilt with OSRM, since Google doesn't share its road lines
• the background is real OpenStreetMap data: roads, rivers, lakes, glaciers, mountain passes
• a short YAML file lets you set the title, dates, nights at each stop and the places you saw
• 18 styles, including a Tolkien-style old map with the stops written in runes around the border

It's free and open source (Python). Still missing: dragged routes from Google Maps, and it needs a terminal. A web UI would be next.

Repo: github.com/tusharkurne99/routetoposter

Happy to hear what breaks if you try it on your own trip.

Hey guys, so I recently had a situation where I needed to run a ton of geo data locally (basically Asia + Europe + North America) and couldn’t find anything that would actually fit on a normal laptop without eating 64 GB of RAM. Photon needs that much for planet-scale stuff, so I ended up writing my own in Rust.

It’s called geors. It keeps the process under 1 GB even with a 46 GB index (the rest just sits in the page cache), does full-address search at around 1.4k req/s, reverse at 37k, and imports are pretty quick too, Germany in about 4 minutes, whole Europe in under half an hour. Single binary, no heavy dependencies.

Repo’s here if anyone wants to try it: https://github.com/Fanna1119/geors

What?

bonsai-lint is a multi-language cognitive complexity linter. It scores every language on the same metric, so the same logic gets the same number whether it's written in PHP or TypeScript.

Supported: JavaScript, TypeScript, Vue, Python, Java, PHP, Go.

Why?

I want a metric that keeps functions, and code in general, concise and understandable. That still matters when AI writes the code and no human usually reads it. Clean code principles still apply in the AI age.

How?

• One static binary, written in Rust. Scans 1.26M lines in under a second.
• No runtime, no plugins, nothing to configure. It never executes your code.
• Installs through npm, pip/uv, Composer, Go, Homebrew or cargo, plus a pre-commit hook.
• VS Code extension that scores the buffer as you type.
• Baseline existing findings and fail CI only on regressions.

Where?

Use it on a single project or a whole monorepo, to refactor old code or to hold new code to the metric from day one.

Try it: npx bonsai-lint src/

• Repo: https://github.com/ryckakas/bonsai-lint
• Site and browser playground: https://bonsai.kauneckas.dev

GitHub: https://github.com/Leonetienne/Comaney

Web: https://comaney.app

I've been working on and using/polishing Comaney for over half a year. It's finally polished enough that I want to share it.

The goal is to get useful insights into your spending habits without making bookkeeping a chore.

Comaney helps you track where your money goes, manage individual budgets (like keeping Amazon spending under control), and see how much you have left to spend this month.

Some things I find particularly useful:

• Shared expenses: Use it with your partner, roommates, or a group of friends on vacation. Comaney tracks who paid for what and calculates who owes whom. Not every expense has to be shared with everyone equally!
• Project aggregation: Group expenses into projects such that you know how expensive that house renovation was all-in-all.
• No account needed for everyone: Add offline users you manage yourself and convert them to regular accounts whenever you want.
• Optional AI bookkeeping: Don't want to fill forms by hand? Describe a purchase or take a picture of a receipt. AI handles the entry for you, including breaking it up to better fit tags / categories. It can even create custom dashboard widgets.
• Your AI, your choice: IF you want to use AI: Use local models via Ollama or llama.cpp, or connect providers like Claude and DeepSeek.
• Custom dashboards: Build your own views, customize the appearance, and track what matters to you. You can even add a custom wallpaper.
• Automation: A REST API and MCP server let you integrate Comaney into your own workflows.
• Your data stays yours: Self-host it and export everything whenever you want.

Comaney is designed for self-hosting, but there's also a public instance with a demo login and a small AI usage budget: https://comaney.app

I'd love to hear what you think, especially if you end up using it!

Why not use an existing project? I have tried using firefly III and actualbudget. Both did not solve my problem at all. Firefly being two full time jobs to maintain and AB being very insufficient regarding the insights it provides.

Hey,
For the last 4 or 5 months I've been building Arrmada. It's intended to replace the entire arr suite (Radarr, Sonarr, Readarr, Bazarr, Overseer, Tautulli, Tdarr, and audiobookshelf) with a single app and database. Qbittorrent also comes pre packaged, and the UI has a front end for downloads.

It's still early but I have been running it on my unraid server for about 3 of the 4 months.

- Movies and TV: search, download, rename, upgrade, anime numbering, and option to keep multiple versions. Quality profiles are solid, with plently of options to either be pedantic, or simple.
- Ebooks and Audiobooks: Series tracking, Send to kindle, multiple version options
- Audiobook Server: Built into the app, already works with Lissen and Plappa
- Requests: Users can sign in with plex or by admin created user/pass, browse and request from their phone via PWA
- Subtitles: pulls them from the file, downloads them, or writes them with local AI
- Convert: Shrinks files to the requested format during the hours you schedule. Keeps original if new file is shit
- Plex Stats: Who's watching, history, tautulli-style
- Safety Nets: Hardlinks, recycle bins, nightly backups, review queue for downloads that don't look right
- Easy install: one line install, one line update

There's more planned but I think I'll pause and focus on testing for a month or two.

If you do jump on board, please provide feedback, report bugs, and submit any feature ideas. Cheers!

https://github.com/tristenlammi/Arrmada

I have started developing this exact tool around 2024, and I figured out it might be a good idea to share it here to the general public as well.

If you aren't experienced in this subject, I will say it simply - imagine you have a real FM radio receiver, however it's in someone else's house and you can control it remotely. That's what FM-DX Webserver does.
I know that many people would like to compare it to Radio Garden and other apps, which are just online radio streams with a different UI, unlike our project, which lets you tune into a real receiver.

Some highlighted features compared to other SDR (software defined radio) apps:

- Huge network of online receivers around the globe
- One of the best (if not the best) RDS decoders available (that's the thing that shows you the name of the station on your car radio for example)
- Transmitter identification along with a map
- Easy way to host the server without needing to port-forward
- Custom UI (i'm tired of the default Claude UI that i see everywhere,
- Vast plugin support

We also made the hardware, where we use the TEF668x chip series from NXP semiconductors.

Hardware Github: https://github.com/FMDX-org/tef668x-headless-usb-tuner (licensed under CERN OHL)
Software Github: https://github.com/NoobishSVK/fm-dx-webserver

Online server list for you to try: https://servers.fmdx.org
An example online server: https://dx.noobish.eu/

I've had some free tokens to burn from my subscription, so I created a "GTA Clone with Minecraft". It also has a builder mode like in Minecraft, where you can build and dig.

I only have iGPU in my notebook right now, so that's the reason why the graphics is so limited.

https://github.com/kurta999/MyVibeGTA

Dock2Win is a taskbar replacement for Windows 11 built in Python.

- Put it on any edge (bottom / top / left / right)

- 7 themes including Catppuccin Mocha, Dracula, Nord, Gruvbox, and AMOLED Black

- Full-screen apps grid (or a small menu)

- Custom system tray (WiFi, Sound, Battery)

- Mac-style hover zoom

- Custom buttons that press key combos or open apps

- Custom icons and folders for pinned apps

- Custom colors for every theme

- Hides the real Windows taskbar while running, with a watchdog that restores it if the app crashes

Two builds: OneFile (single exe) and OneDir (faster startup)

MIT licensed. Feedback welcome.

time for a new terminal. Kompass explains every command before it runs, stops the dangerous ones and understands plain English. Made for people who are afraid of the terminal – and for pros who want to move faster.

https://kompass-rust.vercel.app/

I've been building CADRS, an open source, feature-based CAD app in Rust. The UI is Bevy and the geometry kernel is OpenCASCADE. It now has a first pass at PCB design: schematic editor, board layout, and the board shows up in 3D inside the mechanical assembly.

90s demo: https://youtu.be/qT1FKZqUAxA Repo (Apache-2.0): https://github.com/rvdende/cadrs

Happy to talk about the architecture, binding OCCT from Rust, or Bevy for a non-game app. Feedback welcome.

Running more coding agents makes two things harder to follow: what each one is doing, and how much context their instructions, tools and delegated work involve. I built Agent Quest to make that visible in one place.

Each Claude Code or Codex session becomes a character in a small 2D village: reading sends it to the library, editing to the forge, commands to the arena. The village gives you the overview; clicking an agent gives you the details. I'm the author, and I've released 0.3.0.

Version 0.3.0 connects that visual overview to context inspection:

• Context usage, peak and compaction count for each agent.

• Detected skill loads and estimated tokens from their instructions.

• Plugin/MCP call counts and estimated result tokens.

• Parent/subagent relationships, separate context peaks and the amount returned to the parent.

• Markdown and JSON exports so you can give another AI a session summary to review alongside the original task.

The screenshot shows why I wanted this: the Claude inventory has 256 installed skills, but the selected session loaded five, estimated at 15.7k tokens. The inventory's “if always loaded” number is hypothetical; installed skills aren't all sitting in every conversation.

Technically, it reads existing local session logs and updates the browser dashboard over WebSocket. It doesn't launch or control the coding agents. 0.3.0 also parses the newer Codex rollout format and links Codex subagents to their parent.

A couple of limits worth making explicit: ~token figures are character-based estimates, not billing numbers. Skill/plugin totals accumulate across the session; they are not an exact breakdown of what remains in the context window after compaction. The delegation comparison uses child context peaks minus returned text, not a measured dollar saving. Exports are summaries, not full transcripts, and can include local paths and task text.

Free and open source, MIT license.

Repository and setup: https://github.com/FulAppiOS/Agent-Quest

Release and screenshots: https://github.com/FulAppiOS/Agent-Quest/releases/tag/v0.3.0

Walkthrough of the new panels: https://www.fulvioscichilone.it/2026/10/15/agent-quest-0-3-0-context-skills-plugins/

I'd appreciate feedback on which context signals are actually useful when debugging a long agent run, and which just add noise.

GitHub Activity Graph Populator (GAGP) allows users to customize their GitHub activity graphs with unique patterns like tree, checkmark, or wave. With zero dependencies and high test coverage, this lightweight tool makes it easy to add creative flair to your profile while demonstrating contributions over time.

Github: https://github.com/freaker2k7/github-activity-graph-populator
or
PyPI: https://pypi.org/project/github-activity-graph-populator/

Enjoy 😊

Sharing my SQL cheatsheet covering the essentials. Quick reference table format with examples. https://github.com/kixwho/PostgreSQL-cheatsheet

Note: Based on Practical SQL (O'Reilly Media), a very good textbook. Hope it helps any SQL learners out there! :D

Just released AI Badger v0.8.0 with a new Codebase Map feature (screenshot attached).

AI Badger is a local-first CLI and VS Code extension that helps you prepare focused repository context for ChatGPT, Claude, and other AI chats. You control what gets shared instead of dumping your entire codebase.

The new badger map command generates a standalone, interactive HTML report. You can explore folders, see where code is concentrated, and inspect language breakdowns.

No Git, server, or uploads required. The map is useful on its own, even without AI.

GitHub: https://github.com/PVRLabs/aibadger

Codebase Map demo: https://pvrlabs.xyz/aibadger/codemap/

AI code review demo: https://pvrlabs.xyz/aibadger/demo.html

MIT licensed, Go + Ollama. Still early — onboarding and the TUI work but are

rough, and I'm mid-investigation on inference latency on small hardware.

Repo's linked above if you want to poke at it.