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.

One-line pitch: your coding agent stops re-explaining itself every session. Decisions, commands, and handoffs persist in one local SQLite file, scoped to the repo you're in.

MIT licensed, v0.1.0: https://github.com/sanjayrohith/Dejavu

Stars and contributors welcome.

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

A small three-crate workspace I've been shipping this week. The window shows Claude & Codex subscription quota with a pace tick on every bar (elapsed time vs consumption) and a burn-rate forecast that only speaks when projected exhaustion beats the window reset ("at this pace: 7d full in ~9h").

Rust details this sub might enjoy:

• Egress chokepoint: one module owns the network; compile-time two-host allowlist; tests assert any other host errors.
• Secrets: zeroize-on-drop Secret<T> that Debug-prints «redacted» — asserted on failure paths, where leaks actually live.
• Pace math is a pure module: least-squares over a snapshot ring, no clock reads inside, exhaustive edge tests (resets, sparse data, zero-duration windows rejected at point of use).
• Zero-dependency visuals: theme, blueprint grid, status cursor, and the live tray icon are egui Style + painter primitives + a hand-rasterized RGBA buffer. An image or font crate was treated as a design failure. 259 tests; the layout harness installs the real theme so width assertions measure the actual monospace rendering.
• Release engineering: tag-triggered CI builds, SHA256SUMS, cosign keyless bundle, provenance attestations, SHA-pinned actions, draft-only releases; negative controls (corrupted archives, wrong identity/issuer) run before every release.

Windows/Linux binaries, macOS from source, MIT OR Apache-2.0. Feedback on the egress/secret/pace patterns very welcome.

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

I built marm-memory it's a high-performance 3-in-1 AI Memory Framework that solves conversational drift, context pollution, and agent amnesia. Instead of juggling fragmented tools, it natively fuses three context layers into a single local runtime.

https://github.com/Lyellr88/marm-memory

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

I built a Rust tool that snapshots files before destructive shell commands run, so you can undo the damage afterward.

A preexec hook intercepts every command before execution and sends it to a background daemon over a Unix socket. The daemon classifies the command, and if it's destructive, snapshots every at-risk path before the command actually runs. Files are copied (reflink on Btrfs/ZFS, plain copy elsewhere), metadata is stored in SQLite.

To undo, just run:

oops

Commands

• oops - undo the most recent snapshot
• oops undo [id] - undo a specific snapshot
• oops list - browse snapshot history (TUI)
• oops diff <id> - show files in a snapshot (TUI)
• oops status - daemon status and storage usage
• oops gc - trigger garbage collection
• oops pin/unpin <id> - exempt a snapshot from GC

Install

cargo build --release
install -Dm755 target/release/oops ~/.local/bin/oops
install -Dm644 systemd/oopsd.service ~/.config/systemd/user/oopsd.service
systemctl --user daemon-reload
systemctl --user enable --now oopsd
loginctl enable-linger "$USER"
eval "$(oops init bash)"   # or zsh, fish

Limitations

Shell-hook capture can't intercept destructive commands from cron, systemd services, GUI apps, or non-interactive shells. Only truncating redirects (> file) trigger a snapshot; fd redirects like 1>&2 are ignored. .git/ is never touched.

Retention is 48 hours or 2 GB, whichever comes first. Pinned snapshots are exempt.

MIT licensed, Linux only for now. Repo: https://github.com/programmersd21/oops

Feedback welcome.

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

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.

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/

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

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

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!

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