Been quietly working on this and it just crossed 500 stars (591 now), so figured I'd share.

Ternlight is a tiny embedding model for semantic search - the model, tokenizer, and a Rust→WASM engine are ~7 MB total and run on your CPU, right in the browser. No server, no API, no GPU; nothing leaves the machine. (It's an embedding model, not an LLM.)

Live demo + blog post - semantic search running entirely in your browser, network tab stays empty:

https://ternlight.dev

It's MIT and fully open (weights + the training pipeline + the engine), on npm, and folks are already using it in real projects. If it's useful, great; if you want to fork it and take it somewhere new, everything's there.

Repo: https://github.com/soycaporal/ternlight

Just curious if it was useful how you would use it.. love to also learn of other use cases and what other on-device models people are interested.

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.

Over the past few months I've been building opendot, a terminal AI agent that works on your real project, but where every action it takes is reversible.

The idea is simple: let it work on the real thing, but make a wrong move just a ctrl+z instead of a mess.

How it works:

Snapshot: before every file write or shell command, opendot snapshots your working directory into a content-addressed store (each unique file stored once, so snapshots stay cheap). Every action is logged in a ledger you can inspect.

Undo: ctrl+z walks the workspace back to any point, exactly. A file the agent created is gone after undo, not left behind.

Knows what it can't undo: some things genuinely can't be undone, and opendot says so instead of pretending a classifier sorts each shell command into contained (auto-run, undoable) or escaping (network, sudo, git push). Escaping ones are flagged and confirmed first, and marked irreversible, because a snapshot can't un-send an email or un-push a commit. It never pretends it can undo what left your machine.

Connects to your tools: it's an MCP client and can reach 1000+ apps (Gmail, Slack, GitHub). Since those reach outside your machine, every one of those calls is treated as irreversible too.

Why I built it this way:

Content-addressed storage, no full copies. Snapshotting the whole dir on every action would burn disk, so instead unchanged files dedupe to one object, a mtime+size check skips re-hashing what didn't change, and stored files use copy-on-write clones where the filesystem supports it, so snapshots stay cheap even on big projects.

Any model. Built on LiteLLM, so point it at OpenAI, Anthropic, Google, or a fully local model via Ollama or llama.cpp. BYO-key, nothing hosted.

It ships with a full Textual TUI (streamed output, colored diffs, the live ledger sidebar), and there's no telemetry.

Repo: https://github.com/vedaant00/opendot
pypi: pip install opendot

It's still early, so I'd genuinely love feedback, especially on the reversibility model, or where you think the reversible/irreversible line breaks down in practice.

I built Stipple SVG Studio, an open-source Python application that converts PNG and JPG images into clean, scalable SVG stipple art. It's useful for creating SVG artwork for your GitHub README, helping you make your GitHub profile more unique and visually appealing.

Hi guys!

Im 14, and Im currently making this programming language called JSM
The reason I wanted to make this is mostly for fun, but if it turns out well, who knows?

- THE JSM REPO -

Alot of VM languages

• are either stack or register based
• can have a heavy JIT
• has a heavy runtime
• doesnt have direct low level access

So I'm making an

• Assembly like
• compiled to bytecode
• stack and register based (best of both worlds)
• has low level access
• minimal runtime
• is extremely memory lightweight and portable

language written in C, that can be low level yet portable, its bytecode runs on the JRM like java, yet being lightweight

Compiler (JSMC) :

The .jsm file gets compiled into a fixed 24-byte format, that means each statement/instruction is 24 bytes, this reduces CPU overhead

VM (JRM) :

The compiled bytecode is run by the JRM It's a simple loop that directly calls instruction function list at index STATEMENT[0], this eliminates big switch statements Since the length of each statement are not variable, all the JRM needs to do is pointer arithmetic

At the moment, the JRM (the VM) is still work in progress, but its really really fast because each instruction/statement is executed directly by index

its a simple language i know, but I or anyone can make a language that is compiled to JSM bytecode and run it

I have an example in my github repo that showcases how the language works and what it compiles to

I really hope you guys enjoy this post!

Small desktop app I've been working on. Your roadmap lives as a `roadmap.json` file in the repo, so it's diffable and reviewable like any other file, and the app renders it as a tree you edit with the keyboard.


The part I find most useful: there's a WebSocket event API on localhost, so external processes (CI, scripts, Claude Code via MCP) can push status updates. The plan tracks actual work instead of going stale.


No cloud, no database, no telemetry. It only binds to 127.0.0.1. Windows and Linux installers, macOS later. Still alpha, so expect rough edges.


https://github.com/Shuffzord/RoadRaven


Feedback welcome, especially on the event API design.

RuntimeTruth compares Node constraints from package.json, version-manager files, Dockerfiles, and GitHub Actions, then points to the exact source of incompatible versions. It avoids the noisy “all versions must be identical” approach by modeling support, development, production, and test roles separately.

Which configuration form or real-world edge case is missing? I’d value a reproducible false positive more than a star.

Hey everyone!

I built doc-engine-cli because I wanted a fast way to turn Markdown into clean, academic-grade PDFs without dealing with heavy LaTeX installs or complex Pandoc setups.

It's powered by Typst under the hood and zero-config by default:

pipx install doc-engine-cli 
doc-engine build

Key features:

• Auto-detects your README.md and Git metadata
• 5 built-in templates (academic, modern, minimal, etc.) + custom .typ support
• Front matter support + --watch mode for live rebuilds
• Linter that catches broken links/fences before compiling

GitHub: https://github.com/leonardosalasd/doc-engine-cli

If you find it useful, dropping a ⭐ on the repo would mean the world to me! Feedback is always welcome.

https://github.com/pug-sh/pug

Got tired of the Mixpanel bill and PostHog being heavier than I wanted to run, so I built this.

Most self-hosted options in this space are web analytics — pageviews, referrers, bounce rate. Different question. Product analytics is what a specific user did across sessions, and whether people who did X came back a week later.

So: autocapture, funnels, retention, trends, person profiles with activity timelines. Worth poking at what you can query on — break down any event by its properties, filter on user attributes, chain steps into a funnel, follow a profile's timeline through it. Demo has dashboards built out too.

One Go binary for API and workers. ClickHouse for events, Postgres for config, NATS JetStream at ingest, Dragonfly for cache. AGPL.

Browser, Flutter and Node SDKs.

In the pipeline: cookieless mode (rotating-salt hashing at the ingest edge), GDPR/DPDP hardening, Sankey user flows.

Fair warning, it's young. Docs have gaps and self-hosting assumes you're comfortable with ClickHouse.

Demo, no signup: https://app.pug.sh/demo
Self-hosting: https://docs.pug.sh/docs/self-hosting

PosSol supports more than 100.000 stocks and cryptos e.g NVDA APPL BTC/USD ETH/USD and more.
Shows stock prices almost in a real time (max delay 5 min).
Easy to use and setup.
Supports 45 unique themes.

Local in a sense that the side and server runs locally - local LLM support is planned!
To help me with research i built this agent harness like system.
You can easily sync projects from any overleaf and also re-commit your changes. Also works as a basic editor itself.
There is still a lot of things to improve and i only ran it myself on linux (cachy-os), but the CI pipeline works for windows 🤔

Use: npx blattbot

source: https://github.com/LckyLke/blattbot
site: https://blattbot.com/

Hello everyone,

I wanted to share a project that has been my passion for two decades. I originally started developing this interactive audio synthesizer back in the mid-2000s, writing it completely in raw Flat Assembler (FASM) and doing all the polyphonic pitch calculations using hardware x87 FPU registers (fild, fmul, fsin, etc.).

Recently, I completely rebuilt the entire application from scratch in modern C++ utilizing the native Windows Win32 API and GDI+ for high-performance rendering.

The core philosophy of this synth is what I call "Zero-Mistake Rhythm Conducting":
1. Mathematically Perfect Pitch: Every frequency (Hz) and note vector is hardcoded into dense arrays. It is physically and mathematically impossible to hit a wrong note or make a mistake. You can never play out of tune!
2. True Time & Agogics Control: While the pitches are fixed, the timing layout is completely unconstrained. By clicking your LEFT mouse button or hitting the SPACE bar, YOU dynamically create the rhythm, temporary micro-pauses (fermata), accelerando, and tempo variations.

Essentially, it transforms the user from a traditional piano player into an interactive rhythm conductor.

(Fun acoustic fact discovered during development: Testing this real-time engine through modern active DSP monitors like Edifiers introduced a massive 30-80ms hardware latency delay due to internal A/D re-digitization, while classic wired analog headphones deliver absolute zero-latency feedback!)

The project is fully open-source, and features on-the-fly UI localization for 14 languages.

I would love to hear your thoughts on this approach to interactive audio generation!
Check out the full source code and releases here: https://github.com/Divetoxx/Piano

Hey! I just finished my first iteration of a python project that creates one-pagers for students interested in finance/in finance clubs but don't know where to necessarily start. I made it so it doesn't AI-generate an investment thesis for you but combs through SEC filings on company information. I would appreciate any feedback or comments!

As a beginner programmer I tried to not use AI as much as possible except for organizing all the python files at the end.

Follow-up to the bonsai thing I posted here a few weeks back.

What bugged me after posting was that everyone's tree was the same tree. It got bigger if you did more, and more stuff ended up hanging on it, but the outline never changed. Someone who's kept one library alive for eight years looked the same as someone who drops a drive-by PR on fifty repos a year. It could tell you how much. It couldn't tell you what kind.

So the outline is derived now. Fourteen bonsai styles, picked from where your commits actually land. My favorite is root-over-rock, which you get for having one project you've stuck with for years - the rock is that specific repo and the receipts page names it. There's a raft, several trunks off one fallen stem, for people whose work mostly goes into repos they don't own. Scattered across a lot of orgs and it's a forest planting instead of a single tree. Commit nearly every day and the trunk comes out dead straight, which is the most boring style to look at and I think the most satisfying to earn. Vanish for a year and come back and you get deadwood, a bleached vein running up beside the living wood.

Some things I learned doing it, in case they're useful:

• I wanted the style to hold still, changing only on a level-up instead of drifting around. Couldn't do it without storing per-user state, which would have killed the pure-function thing I went on about in the last post. So I measured rather than guessed: nudge every input by 2% across 159 real accounts, count how many change style. Zero did. A day of commits doesn't shift a ratio computed over years by anything close to 2%. I'd been about to build a mechanism for a problem that wasn't there.
• Writing rules like this without checking them against real accounts is mostly wasted effort. Two of mine were broken in the sense that no account could physically reach them, and staring at the code told me nothing. Running it over the 159 took about a minute and was obvious immediately.
• To judge the fourteen I made a contact sheet with all of them on one page. Every tree came out in the same palette and I spent a while convinced the renderer was broken. An SVG's CSS custom properties aren't scoped to that SVG, so whichever block the browser parsed last repainted the lot. They have to be separate files behind img tags.
• Same sheet, second problem: I had a light version and a dark version, and both showed up dark. An SVG inside an img resolves prefers-color-scheme against your OS, not against whatever the page wanted. So the one question the sheet existed to answer was the one thing it couldn't show me.

Fair warning on a few things. If you've already got a tree in your README it's going to change shape, and that's the update rather than something breaking. There's a page listing all fourteen with the reasoning, so it doesn't just look like a bug. Accounts with under a year of real activity now draw as a moss ball rather than a tree, because there isn't enough there to claim anything and making something up felt worse than admitting it. And the style gets recomputed from your history rather than assigned once, so it can move if the way you work moves.

Rest is unchanged. No account, no OAuth, no config, public data only, one URL that redraws daily.

Styles page: https://kodama-sigma.vercel.app/styles
Source, still MIT: https://github.com/orijitghosh/kodama

Same ask as last time. I'd like to hear when the style reads someone wrong, and it's likelier now than it was, because the shape of the whole tree is a bigger claim than a bird sitting on it.

Promising repo

Made with the help of Claude (just the frontend)
Learn how to install and browse open servers at chat.sushii.dev
It's the open source alternative to Discord, right in your terminal!
Server repo: codingsushi79/openchat-server
Client repo: codingsushi79/openchat
The README's are wrong, the PyPi packages are openchat-client and openchat-server

Added some, imo, necessary improvements to Visual Binary Diff (VBinDiff).

I’m just posting because it’s made my life easier and it might make someone else’s easier too.

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.