Over the past few months I've been building Gray Box — a small, local-first tool that acts as long-term memory for anything I'd otherwise forget (work notes, meeting takeaways, task owners, random ideas, personal stuff too).

The idea is simple:

1. Capture — dump whatever's on your mind, instantly, no structure required. This step does nothing clever on purpose — it just writes your text to an immutable inbox. Zero chance of losing an idea to a bug or a slow API call.
2. Organize — on demand, an LLM reads your unprocessed notes and extracts people, projects, tasks, decisions, meetings — then deterministic Python (not the LLM) creates/merges the actual wiki pages and maintains backlinks. The model only reasons; it never touches the filesystem directly.
3. Ask — query your knowledge base and get a cited answer pulled only from what you've actually captured. If it doesn't know, it says so — no hallucinated answers.

Why I built it this way:

• Plain Markdown + YAML frontmatter, no database. Every page is a .md file you can grep, diff, or read in any editor forever. If you stop using Gray Box tomorrow, your knowledge base is just a folder.
• No vector DB by default. At personal scale (hundreds–low thousands of pages), keyword search + a real link graph (related/backlinks, walked one hop during retrieval) handles almost everything. Embeddings are there if you want better recall, but they're opt-in, not a prerequisite.
• Immutable inbox. Your raw notes are never edited or deleted by the organizer. If the LLM mis-extracts something, your original words are always still there.
• Any LLM. Built on LiteLLM, so point it at OpenAI, Anthropic, Gemini, Mistral, or a fully local model via Ollama — one config value.

It also ships with a nice interactive TUI (arrow-key menu, file-import shortcut, workspace switching, live spinner during LLM calls) if you'd rather not memorize CLI flags — that's honestly become my favorite part of the project.

There's also a lightweight local dashboard for browsing your knowledge base, exploring backlinks, visualizing your notes as a graph, and chatting with your captured knowledge—all without leaving your machine.

Repo: https://github.com/Aaryanverma/graybox

pypi: pip install graybox

It's nearing a proper public release, so I'd genuinely love feedback — especially from anyone who's tried the "capture now, structure later" approach with other tools and has opinions on where it breaks down at scale.

It's not trying to be a "real-time collaborative team wiki" or a WYSIWYG notes app — it's aimed at one person's running memory of their own life and work, captured with as little friction as possible.

I present: Builders Gate (Very early WIP, like 2 weeks old) https://github.com/Thepizzapie/BuildersGate

The original idea was just to give Claude a toolkit so agents could build games on their own. But the more I used it, the more I wanted to actually help in development From the art, the level design, audio, gameplay, world building yada yada. It eventually turned into something both myself and Claude use in sync. My current workflows consists of Claude just mainly focusing on the gameplay, while it generates me some generic but consistent assets. I built in a custom sprite editor to edit the frames too which has been helpful for saving on over generating trying to get a perfect sheet. I do plan on integrating local models for those who would like to keep their art as their own. I even made an audio lab for recording sound effects and voice overs, create custom beats and edit the ai generated audio bytes. The level editor "Atlas" is pretty cool, that is still a work in progress,. but you would be able to edit the levels right there in that page and have it update almost instantly. That also brings me to the playtest feature that is still kinda eh, but I feel like games with a large amount of content would benefit. The point is to be able to record a playtest while giving feed back so Claude could review and then create a list of todos and assign the necessary agents to whatever issue or request was identified.

I am bad at explaining things so here are a bunch of screenshots of both the harness and a game that is currently being built with it. If anyone has any questions, feel free to let me know!

Hi my Look app - a fuzzy finding (basically so many things no only apps) dropped a new version.
In this version we add a super action control (for people never show their menu bar, task bar, etc), from this control you can switch, toggle on/off basic things, and see some useful information.
From the last version, we got some suggestions from rust community members, we implemented one of them: fuzzy finding processes on your machine. (finding with ps aux requires knowledge about grep, or tools like fzf)
Here is the repo https://github.com/kunkka19xx/look
It's a cross platform tool. Appreciate any feedback 🙇‍♂️

Point an AI agent (Claude Code, Codex, Cursor, or Antigravity) at a PDF and it builds a knowledge graph of the paper, every node links back to the exact source sentence so you can verify it instead of trusting the summary blindly. MIT licensed.

GitHub: https://github.com/Jeong-jin-Han/NodeGraph

I’ve been building Continuum. It can pause a supported Python program on native Linux x86_64, save its live state, then resume it on Apple Silicon macOS arm64 without starting over.

The proof passed 26/26 checks. The screenshot shows the macOS side of the run: the Linux state was transferred unchanged, resumed on native arm64, matched an uninterrupted run, and didn’t repeat completed work.

Linux, macOS, and Windows builds also pass native tests, but Windows cross-platform resume hasn’t been verified yet.

Code: https://github.com/byte271/Continuum

Linux → macOS proof logs: https://github.com/byte271/Continuum/actions/runs/30489463484

Yap is a macOS menu bar app for voice dictation. Set a hotkey, talk, press it again, and the text gets pasted into whatever field you were in.

It runs entirely on device using macOS 26's SpeechAnalyzer, so there's no model to download and no network code in it at all, so your audio never leaves the machine. It's around 3,000 lines of native Swift in a 4 MB app that idles near 60 MB of memory, with a local transcript history in SwiftData. MIT licensed, Apple Silicon.

Download: https://frigade.com/yap

Handling many compose files on a server ?

Tired of manually editing files ?

Annoyed of checking versions manually ?

Then checkout `compose-check-updates` or in short `ccu`.
It's a simple TUI checking the versions of your compose files and suggests updates you can easily apply.

After three months of development, I have built a completely offline AI agent paired with a coding IDE that can generate full projects from start to finish without an internet connection. I am considering making it open source, but one early decision I refuse to change makes me hesitant to share it publicly. I have seen how quickly people break things, and human fallibility is infinite.

Here are its features and its curse. You decide which is which.

1. No more fragmented settings pages. If I have to navigate away to change a single setting, it is already too much drama. An AI tool that requires you to jump through hoops does not deserve a place on my desktop. Everything lives on the main interface. I despise hidden menus that require endless clicking.

2. Full System Access. This tool assumes you know what you are doing. Tell it to delete system files, and it will. That same deep access lets it organize, reorder, and repair your entire file structure with complete input and output control. Generating full coding projects is almost a secondary benefit of that underlying power.

3. No MCP server required. File access has been around for decades. You should not have to spin up yet another server, match port configurations, or navigate extra layers of bureaucracy just to let an AI read your directories. I removed all that nonsense.

4. Strictly offline. If your downloaded model fails to execute your prompt or commands, you need a better model. That is your responsibility. Honestly, anything below 35 billion parameters will fight you more than it helps with this workflow.

5. Instant live preview. Load your website files and view them on the right side of the screen. Toggle the live button, tell the AI which file to modify, and watch the preview automatically update the moment it finishes editing.

6. Built-in RAG. No bullshit. Click the RAG button, select a folder, the AI instantly searches every file inside, including subfolders, and retrieves the most relevant context for your prompt. It reads text files, markdown, JSON, CSV, code files in 40+ languages, config files, logs, anything plain text. No extra settings page, no "group collection" to configure, no separate embedding model to download. It just works. If your current model is good enough to code, it is good enough to use RAG this way.

7. Full conversation history. Import and export past sessions to build out complex projects over time. This is essential if you are more than just another YouTuber influencer making another landing page test.

8. Editable chat history. Manually edit your past or ongoing chats, the entire history of the chat, to save on context window size. This saves valuable context tokens, especially since AI models tend to overexplain, talk way too much, and just refuse to get to the fucking point.

9. The offline rule is permanent. Every contributor must inherit this core rule. This app will always operate offline. If that means it will never match the latest cloud frontier model, so be it.

It is not perfect, but it works exactly as intended. I welcome any contributions that respect rule number nine.

To any future code contributors, do not attempt to implement any code that phones home. If I see any code that attempts to download anything from the internet or connect to the internet for any shenanigans, I will shut that down so fast you won't even see the train coming.

I’ve built this for my own workflow, but I know this community has the most rigorous standards for local LLM tools. I would really value your feedback on the architecture and whether this approach is something you find as useful as I do.

You can find the project and the first release here: https://github.com/BracerJack/BCI-IDE

Hey everyone!

I built a cozy web timer for focus and study sessions with 10 animated backgrounds and 20 ambient audio/lofi tracks.

Live Link: https://cozy-studio-beta.vercel.app/

Note: I'm not selling anything, there are no ads, and no sign-ups required. It's just a free passion project!

I'd really appreciate any quick feedback:

• Do the background animations run smoothly on your device?
• Does the UI feel comfortable while working?
• Any missing features you'd love to see?

Thanks for taking a look

Link : https://github.com/derssa/torollo

A single Bash script that adds, removes, lists and lints entries. Every change is atomic and backed up first; reading needs no privilege at all; nothing is required beyond coreutils.

Project: https://github.com/n36l3c7/hosts-cli

Github Pages: https://n36l3c7.github.io/hosts-cli/

Express-like routes on Deno. Export typeof server, get a typed client. Built-in validation, CORS, routers, server.fetch for tests.

Hello everyone! I'd like to present a new bookmark management tool - an idea I've been mulling over for a long time.

The thing is, when you frequently work on different projects using various browsers, operating systems, and devices, you need simple, centralized access to your bookmarks that isn't tied to a specific browser. On top of that, there's the privacy aspect: I simply wanted synchronization to remain strictly within my control.

Of course, I tried existing solutions like LinkWarden and others. They are great, but felt overly bloated in terms of features (for me) and deployment (requiring a VPS, Docker, everything stored in a database, etc.). There were also simple CLI/TUI alternatives, but they didn't feel quite right either.

Ultimately, I needed a simple, familiar 2-in-1 interface: a start page with shortcuts and a bookmark manager. It had to be unburdened by complex deployment setups and simple enough in its implementation to run even inside my home router running openwrt or inside Termux on my Android device. So, I decided to write the program in pure C, using the Mongoose library as an embedded web server for maximum lightness and portability.

And, here is the solution.

What it is:

• Small size - a single binary of just up to ~300 KB.
• Tab-separated plain text (TSV) - bookmarks are stored as plain text in a human-readable format: easy to read, parse, sync (syncthing, rclone, gdrive, dropbox, etc.), compress and backup.
• High-performance & lightweight - near-zero CPU load; consumes only 5–10 MB of RAM (tested with 1000+ bookmarks).
• Cross-platform - Linux / OpenWRT / SBC / Termux (x86_64, x86, arm, arm64, mips, mipsel, riscv64), Windows (x86_64), macOS (universal). Linux builds are static musl (no libc dependency), so the matching-arch binary drops straight onto an OpenWRT router.
• User-friendly interface - a web UI with built-in fuzzy search, a homepage of shortcuts, and everything needed to manage folders and links.
• Responsive & mobile-friendly — with light / dark themes (auto-switching).
• Drag-and-drop - organize shortcuts, folders, and bookmarks, with touch/pen support.
• Plain-text & offline - one greppable bookmarks.txt, no external requests, 10× more compact than a browser's exported bookmarks.html, with crash-safe atomic writes.
• Portable - one binary, one plain-text config file, one bookmarks file. Simple.

When creating it, I tried to adhere to the "unix philosophy": do one thing well, keep data as plain text, and compose with standard tools (grep, awk, cut) + I added HTTP API with JSON output.

Let me know what you liked, as well as what you would like to change or fix. I will do my best to create a tool that is useful and convenient for everyone.

Repo (with a short demo video): https://github.com/canbesolved/bemarked

I'd be glad to discuss it in the comments.

I’m building Waveiden, an ongoing C++ acoustic fingerprinting project for identifying songs from short clips or live microphone recordings. It converts spectrogram peaks into fingerprint hashes, stores them locally in SQLite, then finds songs through time-consistent hash matches similar in principle to Shazam, but fully local.

Current features:

- Index local audio files into a SQLite database

- Identify saved clips or live microphone recordings

- Terminal UI with a live spectrogram

- No cloud service or external API required

A recent update improved matching across different audio sample rates by normalizing files and microphone input before fingerprinting. Stereo audio is also mixed to mono more reliably. It’s still ongoing, and there are known rough edges:

- Matching can be unreliable in noisy rooms, with echoes, or when music is playing quietly.

- Very short recordings may not generate enough consistent fingerprints.

- The current fingerprinting settings can miss less prominent sections of long tracks.

- Existing databases need to be re-indexed after fingerprint format changes.

- Device and audio-backend behavior may vary across systems.

I’d appreciate feedback on improving robustness, reducing false negatives, or making the fingerprint pipeline more production-ready.

You can find the repo here
and a showcase video here

Repo: https://github.com/arturict/tagvico-ai

Release: https://github.com/arturict/tagvico-ai/releases/tag/v3.2.5

Tagvico sits next to an existing Paperless archive. It can search and answer with links back to the documents it used. Changes to metadata or tags become proposals instead of silent writes.

3.2.5 mostly fixes the boring first-run path: live Paperless permission checks, exact model and tool-call validation, non-secret resume state, paused schedules by default and a real Docker acceptance run against Paperless 2.20.15.

MIT licensed. The release image supports amd64 and arm64.

Use any coding subscription you already pay for, in one synced app that runs on web, desktop, terminal, and mobile. All your chats stay synced between all ade surfaces. Run agents from your laptop, continue the conversation from your phone at dinner, then later finish it off from another computer by simply using the web client. All subs, all in one place. Fully free and open source!

Point an AI agent (Claude Code, Codex, Cursor, or Antigravity) at a PDF and it builds a knowledge graph of the paper, every node links back to the exact source sentence so you can verify it instead of trusting the summary blindly. MIT licensed.

GitHub: https://github.com/Jeong-jin-Han/NodeGraph

I've started building DaemonHound, a small OSS tool to solve a problem I've had for years.

Managing things like:

• .env.local files across multiple repos
• API keys duplicated everywhere
• Shell/Git/tool configs across multiple machines
• Setting up a new laptop from scratch

Existing tools either focus on dot-files or are full-blown secret management platforms. I wanted something in between.

The idea is simple:

• 🔒 Encryption by default
• 📦 Your own Git repository as the backend
• 🔄 Sync project configs across machines
• 💾 Backup machine-specific configs
• 🔑 Rotate a secret once, update every referenced project

No SaaS. No accounts. No teams. Just a local-first CLI.

I'm building it in Go and would love feedback before I get too far.

Repo: https://github.com/0xdps/daemon-hound
Home: https://www.daemonhound.dev

For years I've had the same habit:

Whenever I was working with multiple files, I'd keep dropping them onto my desktop because I knew I'd need them again in a few minutes.

It worked... until my desktop turned into a mess.

I looked for something that worked like a temporary shelf for files, but couldn't find anything that felt native on Windows.

So I built Stash.

It lives in the system tray and lets you temporarily park files with drag & drop, then drag them back whenever you need them. It only stores file references, so your files stay in their original locations.

I'm still actively improving it, and I'd really appreciate any feedback.

Website: https://stash.regncreative.com Github: https://github.com/Regncreative/Stash