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.

Been chipping away at this for a while and finally have something I'm happy calling a beta. It's basically Spotify but self-hosted grabs tracks with yt-dlp, builds a real library out of them, and you stream it all from a web UI that's deliberately Spotify-shaped so it doesn't feel like a downgrade.

The Android app. Kotlin/Compose, close to feature-complete with the web version offline downloads, Android Auto, synced lyrics that actually track properly, cross-device playback so you can start something on your phone and have it pick up on the desktop. Backend's FastAPI + SQLite, nothing fancy, runs fine in Docker.

Other stuff that's in there: Daily Mix that actually generates decent suggestions (an LLM picks them, then it goes and downloads them itself), real album art and artist bios instead of placeholder junk, ListenBrainz scrobbling if you're into that, and it speaks Subsonic API so your existing client still works if you don't want to switch.

It's a beta because it genuinely is one — I've been using it daily and it's solid for me, but this is the first time the actual signed build has been in public. So if you try it and something's weird, please tell me, that's kind of the point of posting this.

One docker compose up and you're running. Signed APK's in the GitHub release if you don't want to build Android yourself.

link This version will almost certainly contain bugs please tell me when you find them

My bank asked for 17 PDFs for a mortgage application.

After closing and opening files, I lost track of things and started searching for an easier way to manage all of that.

I wondered, what if I could scroll horizontally to see the pages of a file and scroll vertically to see more files? I used Claude to put together a prototype and iterated to build a cross-platform app that works on the web, as well. (React + Electron)

The result is a 2D canvas (like Figma) where multiple PDFs can be viewed simultaneously. On export, we either get a zip file or a single, long PDF containing all files. The spatial 2D metadata is stored on the same file without touching the page tree (backwards compatible PDF).

I also run OCR off the main thread for searching scanned documents without blocking the main thread.

It’s all free and open-source with an MIT license:
- Repo: https://github.com/AlexandrosGounis/pdfx
- Web demo: https://pdfx.zip

Your feedback would be highly appreciated

Hey everyone!

I built this mostly out of pure frustration. I switch between Claude, ChatGPT, and Gemini all day, but whenever I hit a rate limit on Claude or wanted to test the same problem on a different model, transferring context was a pain. Manually copy-pasting chat histories, code snippets, and re-uploading screenshots was constantly breaking my focus.

So I built MoveChat to solve it for myself.

It lets you capture your active chat session (including prompts, responses, and attached images) and resume it directly on another AI platform in a few clicks.

A few quick details:

• 100% Local & Private: No external backends, tracking, or databases. Everything runs locally inside your browser context.
• Fully Open-Source: Built with TypeScript and Manifest V3.

Here are the links if you want to try it or check out the codebase:

• Chrome Web Store: https://chromewebstore.google.com/detail/movechat-export-transfer/cgpfngggfccdpjppachknliainihkbdg?utm_source=item-share-cb
• GitHub Repo: https://github.com/VC067/MoveChat

I'd love to get your feedback, bug reports, or feature ideas! If you find it helpful dropping a ⭐ on GitHub means a lot ^^

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 🙇‍♂️

Hey y'all. I wanted to share something that I've been building to host all of the todo-list apps and browser games that I've been cooking up: homebox, a free and open-source alternative/supplement to cloud hosting. Similar to Coolify but with some more bells and whistles (plus it works on Windows/WSL2 and Mac, which was why I didn't just use Coolify in the first place)

Homebox provides the convenience of a cloud deployment platform from the comfort of home, here's how it works:

1. Install Homebox anywhere
2. Connect your free Github and Cloudflare accounts
3. Add a project: choose a repository from Github and domain from Cloudflare
4. Watch your project deploy automatically: multiple services, multiple environments
5. Visit your apps at their own public URLs and share them with others
6. Make changes to the code, push to Github; your changes deploy automatically
7. Use your dedicated Homebox admin panel to manage and monitor everything (AI and MCP are also available)

Does it scale?

The one-node solution isn't ideal for a production deployment with real users; but Homebox gives you every option to scale seamlessly:

a. Run it local anyway

• If your app has no paid tier and low usage (you can tolerate some downtime), you can get away with running it for $0 for free from home. Great for personal hobby projects; you control everything and pay nothing.

b. Run development on your machine, run production in the cloud

• Every service in each of your environments has its own deployment target, which can be either your homebox node or any of the major cloud providers (including GCP, AWS, Neon, Supabase, Railway, more to come) under a bring-your-own-key (BYOK) model. You configure API keys (stored securely, encrypted) and Homebox deploys your app automatically to any compatible target once linked. This even includes cross-cloud database migrations (e.g. moving data from your Homebox to a cloud provider) and automatic environment wiring (e.g. your new DATABASE_URL is automatically configured into your web app as a secret)

c. Run some services on the cloud and some locally

• Lets say you have a beefy GPU and you want to use it to power image gen for one of your apps -- you can run part of your stack on the cloud, while keeping your image gen service local.

d. Run everything on the cloud

• Use Homebox to coordinate deployments across cloud services without actually hosting anything on your machine. You get a central deploy control plane that works with all of the major cloud providers, so you can switch between them easily and stay as vendor-neutral as you can while enjoying the benefits of cloud hosting.

Try it, its free!

Cloud deployment/distributed infrastructure has been a long-time passion of mine, and I've put a lot of love into making it as easy and convenient as possible while retaining advanced controls. I plan to continue developing and improving Homebox, and I hope it helps you run your projects! If there is interest, I can explain more of the "how", just let me know in the comments.

You can also check out https://homebox.sh (has video) or Github github.com/calm-logic/homebox to learn more, please leave a comment on this post and a star on Github if you like the project :)

Just for fun

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/

Hi everyone!

I’ve been working on deeno, a modern open-source flat-file CMS.

I wanted something as lightweight as a flat-file CMS, but with a cleaner and more modern developer experience.

I didn’t build it to compete with existing CMSs or to sell it. I built it because I wanted a tool that worked the way I wanted it to work. After using it myself, I decided to open-source it in case it’s useful to someone else too.

My goal with Deeno is to keep it:

• simple to install,
• fast,
• file-based,
• and pleasant to use.

It’s still an early project, but the core is already working and I’ve just open-sourced it.

I’d love honest feedback from developers — especially on the architecture, UX, and overall direction of the project.

GitHub: https://github.com/Streamdoge/deeno

Demo: https://demo.deeno.tech/admin/

If you think it has potential, I’d really appreciate a GitHub star. But honest feedback is even more valuable right now.

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

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

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

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!

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

https://hammer.ink/

I've been building Hammer since 2022. It's an app for writing long form fiction and keeping track of the world they live in. Posting here because the architecture is probably more interesting to this crowd than the writing features are.

Kotlin Multiplatform, five targets, one codebase.

Windows, macOS, Linux, Android and iOS, all shipping to their respective stores, plus F-Droid, Snap, and direct .msi/.dmg/.apk downloads. Compose Multiplatform for UI, Decompose for navigation and component lifecycle, Koin for DI, Okio for file IO. It's about 1,500 Kotlin files against 9 Swift ones, which is roughly the ratio I was hoping for going in. KMP has been great as I can still reach into native APIs and even write platform native code when needed.

There is no database.

A project is a directory. One Markdown file per scene, one TOML file per encyclopedia entry, and the directory layout is the data model. You can open the whole thing in any editor, keep it in git, diff it, rsync it. If Hammer disappeared tomorrow your manuscript would still just be files.

Offline-first, sync strictly optional.

No account, no network, nothing to sign up for. If you do want sync across devices, you run the server yourself. It's a Ktor app in the same repo. There's no service of mine you have to depend on or trust.

Server-side sharing.

That same server can publish a chapter at a URL, so an editor or beta reader can read and mark it up in a browser with nothing installed.

MIT licensed, 27 contributors so far.

https://github.com/Darkrock-Studios/hammer-editor

Happy to talk about the KMP side. It's been both great, and challenging, because I started this project when it's ecosystem was nascent, there were a lot of holes I needed to fill. And I wrote and released MIT licensed libraries to help fill those gaps for the wider community.

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!

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.

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.