Show stories

very much inspired by karpathy's microgpt of the same name. it's (by default) a 4000 param GPT/LLM/NN that learns to generate names. this is sorta an educational tool in that you can visualize the activations as they pass through the network, and click on things to get an explanation of them.

Body: I built a polyphonic synthesizer in Python with a tkinter GUI styled after the Moog Subsequent 37.

  Features: 3 oscillators, Moog ladder filter (24dB/oct), dual ADSR envelopes, LFO, glide, noise generator, 4 multitimbral channels, 19 presets, rotary
  knob GUI, virtual keyboard with mouse + QWERTY input, and MIDI support.

  No external GUI frameworks — just tkinter, numpy, and sounddevice.

Pangolin (https://github.com/fosrl/pangolin) is an open-source tool for identity-based remote access to internal resources - an alternative to Cloudflare ZTNA, Zscaler, and Twingate.

It’s different than existing approaches: mesh VPNs (Tailscale, ZeroTier, etc.) create flat overlay networks where ACL and IP space management becomes complex at scale and every device can talk to every other device, while corporate ZTNA solutions (Zscaler, Cato, Netskope etc.) are closed-source and add latency by forcing traffic through a central server.

Pangolin takes a resource-centric approach. You deploy lightweight connectors that bridge to specific resources (private web apps, SSH, databases, CIDR ranges). Admins delegate resource-access to specific users and roles. It uses WireGuard with NAT hole-punching for peer-to-peer connections and traffic goes directly between the user and connector instead of through a central server. It supports native clients (Mac/Windows/Linux/iOS/Android) plus identity-aware, browser-based access when a client isn’t required.

Pangolin has a cloud and is optionally self-hosted. The Community Edition is AGPLv3. The Enterprise Edition is also open-source under the commercial license which enables free personal/small business use.

Everything, from the server to the clients, is fully open-source and you can even self-host the whole stack. We’d love to hear what you think and I'm happy to answer any questions!

As far as I can tell, this paper (in which Einstein solves a decades old question about Crookes Radiometers) has never been available in English! Einstein’s work became public domain on 1st January 2026, which meant that I could finally release this translation that I did during my PhD in 2019!

I have a blog post that gives a little more context: https://adaptive-machine-patterns.com/blog.html#einstein [alt. link: http://archive.today/381Pl] I am new to blogging, so advice welcome.

The preprint is hosted at CULA repository (many thanks) https://www.repository.cam.ac.uk/handle/1810/398349 and it has a DOI: https://doi.org/10.17863/CAM.127224

Rover is the world's first Embeddable Web Agent, a chat widget that lives on your website and takes real actions for your users. Clicks buttons. Fills forms. Runs checkout. Guides onboarding. All inside your UI.

One script tag. No APIs to expose. No code to maintain.

We built Rover because we think websites need their own conversational agentic interfaces as users don't want to figure out how your site works. If they don't have one then they are going to be disintermediated by Chrome's or Comet's agent.

We are the only Web Agent with a DOM-only architecture, thus we can setup an embeddable script as a harness to take actions on your site. Our DOM-native approach hits 81.39% on WebBench.

Beta with embed script is live at rtrvr.ai/rover.

Built by two ex-Google engineers. Happy to answer architecture questions.

Hi HN!

I've been building this solo for about three and a half years. I kept trying every new project/notes tool (Notion, Asana, Trello, etc.) and always ended up back in a plain text file. I wanted something that felt like a text editor on first touch but could grow into real structure when you needed it.

https://lightwave.so (desktop only)

The tech stack is Laravel, MySQL, Redis, and hand-rolled JavaScript on the client. No frameworks like React/Vue/etc. ~270 lines of jQuery (out of 80k+ total LOC) for a few legacy DOM utilities, plus IndexedDB for local persistence. Real-time collaboration uses a hybrid approach: HTTP/2 POST for resilient ops + WebSockets via Laravel Reverb for live cursors, presence, and edits.

This is a pre-release stress test, not a launch. Lightwave will be a paid product. Right now I'm opening it up because no amount of solo testing replicates getting punched in the mouth by real traffic.

The link above has a button to create a test account in 1 click.

Known rough edges: the cursor and selection system are built from scratch (like VS Code, not a contenteditable wrapper), so there's a lot of surface area. Some keyboard shortcuts may be missing. Desktop only, accessibility not yet implemented. I'm shipping fixes in real time.

There's a "Submit Bug or Feedback" button inside the app if something breaks. Happy to answer any questions about the architecture, or anything else.

Some highlights:

- Paste markdown in, get native blocks. Copy blocks out, get markdown back.

- Hierarchical document, structure. Hierarchichal file manager.

- Live collab with shared cursors, selection, and presence.

- Code blocks with syntax highlighting. LaTeX math blocks.

- Full data export: markdown, JSON, and attachments. No lock-in.

- Full undo/redo with cursor restoration.

I’m nervous, announcing this, as it isn’t ready to ship out to the general public yet, and I haven’t had any feedback at all from anyone, I’m out on my own here. I think this concept itself is kind of dismissed outright a lot too, and I understand why, I wouldn’t believe me either actually.

But, I do believe this is very much worth your time to check out, I am not aware of anything else very much like it.

I won’t repeat what is already written on the github README here, but some info:

I am a successful semi-retired solo game developer, I have been making my own bespoke game engines since 2003 for all of my games across a number of platforms and languages. Last year, I ripped out the engine of my latest game, and stripped it back with the goal to start a new project, as I have done a number of times before.

But this time, I decided to ditch lua and make my own programming language, and that was sort of the tipping point. Once I thought about multiplayer, and realized I wanted a general purpose network that didn't exist, I was on my way down this extremely deep rabbit hole.

I want to just make a few things clear, then I hope that some of you might have some questions or feedback.

- I'm disillusioned by capitalism and the AI transition, and that influences my motives

- I have made all of this open source and free not because I am overly altruistic, but because it is the only way something like this can succeed

- I don’t think it can or should replace the internet, I see it as a cycleway alternative to the internet highway, they have different purposes

- I have no real desire to run an open source project or lead anyone, I mostly just want software that works for me and my family and friends. I love coding and I like to make nice things and share them.

- There is still a lot to do, I'm very excited about messaging and the whole client-side data thing in particular, but for now there are only a few weeks of work to go until a bare bones browser will be functional enough to release and ship.

You can have a play and build it all yourself though right now, host sites, and build apps.

Hey HN, I'm Tavi. I built this for my 4-year-old.

He and I used to "computer code" together in IPython: typing words to see emojis, mixing colors, making sounds. Eventually he wanted his own computer. So I took an old laptop and made him one.

That IPython session evolved into Explore mode, a REPL where kids type things and something always happens: "cat * 5" shows five cats, "red + blue" mixes colors like real paint, math gets dot visualizations. Then came Play mode (every key makes a sound and paints a color) and Doodle mode (write and paint). The whole machine boots straight into Purple. No desktop, no browser, no internet.

It felt different from "screen time." He'd use it for a while, then walk away on his own. No tantrum, no negotiation.

Some technical bits: it's a Python TUI (Textual in Alacritty) running on Ubuntu, so even very old laptops run it well. Keyboard input bypasses the terminal entirely via evdev for true key-down/key-up events, which lets me do sticky shift and double-tap capitals so kids don't have to hold two keys. Color mixing uses spectral reflectance curves so colors actually mix like paint (yellow + blue = green, not gray).

Source is on GitHub: https://github.com/purplecomputerorg/purplecomputer

GPU rental prices are super volatile but there's no derivatives market to hedge. I built a perpetual futures platform to see what this could look like.

The idea is airlines hedge jet fuel, starbucks hedges coffee beans - as GPU compute becomes critical infrastructure the same hedging tools should exist. Not sure if anyone actually needs this but it was interesting to build.

How it works: - Pulls live H200 spot prices from Vast.ai every 15s into a tradeable index - Full perp mechanics: funding rates, mark price calc, real-time P&L - Event-driven Rust backend with supervisor pattern and circuit breakers - Next.js frontend with TradingView charts, real-time WebSocket updates

What's real vs simulated: - Real: Index construction, funding rate engine, forward curve, state persistence - Simulated: Order book depth and trade matching (its a single-client demo)

The backend is the part I'm most proud of - isolated tasks coordinated by a supervisor, each has it's own state machine so if one component fails it doesn't take down the others. Tried to build it with production patterns in mind even though its just a demo.

Also made a 15-page derivatives pricing doc that covers the economic model and hedging scenarios. Basically: rental prices = f(CAPEX, utilization, depreciation) so futures pricing reveals market expectations about GPU supply/demand.

GitHub: https://github.com/zacharyfrederick/compex

Would love feedback on the architecture or if the market mechanics actually make sense. First time building something like this.

I built Copapy as an experiment: Can Python be used for hard real-time systems?

Instead of an interpreter or JIT, Copapy builds a computation graph by tracing Python code and uses a custom copy-and-patch compiler. The result is very fast native code with no GC, no syscalls, and no memory allocations at runtime.

The copy-and-patch compiler currently supports x86_64 as well as 32- and 64-bit ARM. It comes as small Python package with no other dependencies - no cross-compiler, nothing except Python.

The current focus is on robotics and control systems in general. This project is early but already usable and easy to try out.

Would love your feedback!

DSCI is a ci pipeline framework integrated with some existed cicd systems like gitea/firgejo/gitlab via web hooks and allowing authors to use general programming languages to write cicd code. It provides SDK for many programming languages. SDK helps process input parameters, write plugins, pass results between tasks and jobs, handle secrets, enable self tests, etc

Target auditory - self hosted cicd systems with devops using general programming languages instead of yaml

Link to the article - https://github.com/melezhik/DSCI/blob/main/introduction.md

Disclosure - Feel free to ask me any questions or provide constructive feedback - I am the tool author

Thanks

Hi HN!

I wanted a simple UI for notes and observations around my neighborhood (e.g. this garden has beautiful poppies, this coffee shop has excellent espresso, etc.) and built this. It’s open and free to use, I hope you enjoy it as much as I do!

Feedback welcome.

HabitStreak is a mobile app that helps users build and maintain positive habits through a simple and rewarding streak-based system. The app aims to make habit formation and tracking more engaging and motivating for users.

Your phone has a GPU more powerful than most 2018 laptops. Right now it sits idle while you pay monthly subscriptions to run AI on someone else's server, sending your conversations, your photos, your voice to companies whose privacy policy you've never read. Off Grid is an open-source app that puts that hardware to work. Text generation, image generation, vision AI, voice transcription — all running on your phone, all offline, nothing ever uploaded.

That means you can use AI on a flight with no wifi. In a country with internet censorship. In a hospital where cloud services are a compliance nightmare. Or just because you'd rather not have your journal entries sitting in someone's training data.

The tech: llama.cpp for text (15-30 tok/s, any GGUF model), Stable Diffusion for images (5-10s on Snapdragon NPU), Whisper for voice, SmolVLM/Qwen3-VL for vision. Hardware-accelerated on both Android (QNN, OpenCL) and iOS (Core ML, ANE, Metal).

MIT licensed. Android APK on GitHub Releases. Build from source for iOS.

The article provides an overview of the ManasPDF project, an open-source PDF manipulation library written in Rust. It highlights the library's key features, such as support for rendering, editing, and extracting data from PDF documents, as well as its potential use cases and ongoing development.

Hey HN! I was a long-time Arc browser user and loved how its sidebar organized tabs and bookmarks into workspaces. I wanted to switch to other browsers without losing that workflow. So I built Arcmark, it's a macOS bookmark manager (Swift/AppKit) that floats as a sidebar attached to any browser window. It uses macOS accessibility API to follow the browser window around.

You get workspace-based links/bookmarks organization with nested folders, drag-and-drop reordering, and custom workspace colors. For the most part I tried replicating Arc's sidebar UX as close as possible.

1. Local-first: all data lives in a single JSON file ( ~/Library/Application Support/Arcmark/data.json). No accounts, no cloud sync.

2. Works with any browser: Chrome, Safari, Brave, Arc, etc. Or use it standalone as a bookmark manager with a regular window.

3. Import pinned tab and spaces from Arc: it parses Arc's StorableSidebar.json to recreate the exact workspace/folder structure.

4. Built with swift-bundler rather than Xcode.

There's a demo video in the README showing the sidebar attachment in action. The DMG is available on the releases page (macOS 13+), or you can build from source.

This is v0.1.0 so it's a very early version. Would appreciate any feedback or thoughts

GitHub: https://github.com/Geek-1001/arcmark

I made a chess engine today, and made it fit within 2KB. I used a variant of MinMax called Negamax, with alpha beta pruning. For the board representation I have used a 120-cell "mailbox". I managed to squeeze in checkmate/stalemate in there, after trimming out some edge cases.

I am a great fan of demoscene (computer art subculture) since middle school, and hence it was a ritual i had to perform.

For estimating the Elo, I measured 240 automated games against Stockfish Elo levels (1320 to 1600) under fixed depth-5 and some constrained rules, using equal color distribution.

Then converted pooled win/draw/loss scores to Elo through some standard logistic formula with binomial 95% confidence interval.

The article provides an overview of the StockData.dev API, which offers real-time and historical stock data, market indices, economic indicators, and other financial data for users to access and analyze stock market information.

sql-tap is a transparent proxy that captures SQL queries by parsing the PostgreSQL/MySQL wire protocol and displays them in a terminal UI. You can run EXPLAIN on any captured query. No application code changes needed — just change the port.

Hi everyone,

I run a generative AI infra company, unified API for 600+ models. Our team started deploying AI agents for our marketing and lead gen ops: content, engagement, analytics across multiple X accounts.

OpenClaw worked fine for single agents. But at ~14 agents across 6 accounts, the problem shifted from "how do I build agents" to "how do I manage them."

Deployment, monitoring, team isolation, figuring out which agent broke what at 3am. Classic orchestration problem.

So I built klaw, modeled on Kubernetes: Clusters — isolated environments per org/project Namespaces — team-level isolation (marketing, sales, support) Channels — connect agents to Slack, X, Discord Skills — reusable agent capabilities via a marketplace

CLI works like kubectl: klaw create cluster mycompany klaw create namespace marketing klaw deploy agent.yaml

I also rewrote from Node.js to Go — agents went from 800MB+ to under 10MB each.

Quick usage example: I run a "content cluster" where each X account is its own namespace. Agent misbehaving on one account can't affect others. Adding a new account is klaw create namespace [account] + deploy the same config. 30 seconds.

The key differentiator vs frameworks like CrewAI or LangGraph: those define how agents collaborate on tasks. klaw operates one layer above — managing fleets of agents across teams with isolation and operational tooling. You could run CrewAI agents inside klaw namespaces.

Happy to answer questions.

Hi HN,

I built MOL, a domain-specific language for AI pipelines. The main idea: the pipe operator |> automatically generates execution traces — showing timing, types, and data at each step. No logging, no print debugging.

Example:

    let index be doc |> chunk(512) |> embed("model-v1") |> store("kb")

Other features: - 12 built-in domain types (Document, Chunk, Embedding, VectorStore, Thought, Memory, Node) - Guard assertions: `guard answer.confidence > 0.5 : "Too low"` - 90+ stdlib functions - Transpiles to Python and JavaScript - LALR parser using Lark

The interpreter is written in Python (~3,500 lines). 68 tests passing. On PyPI: `pip install mol-lang`.

Online playground (no install needed): http://135.235.138.217:8000

We're building this as part of IntraMind, a cognitive computing platform at CruxLabx. """

Hi HN! I'm currently a Master's student at USTC (University of Science and Technology of China). I've been diving deep into Data Engineering, especially in the context of Large Language Models (LLMs).

The Problem: I found that learning resources for modern data engineering are often fragmented and scattered across hundreds of medium articles or disjointed tutorials. It's hard to piece everything together into a coherent system.

The Solution: I decided to open-source my learning notes and build them into a structured book. My goal is to help developers fast-track their learning curve.

Key Features:

LLM-Centric: Focuses on data pipelines specifically designed for LLM training and RAG systems.

Scenario-Based: Instead of just listing tools, I compare different methods/architectures based on specific business scenarios (e.g., "When to use Vector DB vs. Keyword Search").

Hands-on Projects: Includes full code for real-world implementations, not just "Hello World" examples.

This is a work in progress, and I'm treating it as "Book-as-Code". I would love to hear your feedback on the roadmap or any "anti-patterns" I might have included!

Check it out:

Online: https://datascale-ai.github.io/data_engineering_book/

GitHub: https://github.com/datascale-ai/data_engineering_book

Source code: https://github.com/cedric-h/cketchbook

Geo Racers is a mobile game that combines geography and racing, allowing players to explore real-world locations and compete in fast-paced races. The game aims to make learning about different countries and landmarks engaging and fun.

I was inspired by mitchellh's Vouch project, an explicit trust system where maintainers vouch for contributors before they can interact with a repo. Ghostty uses it to filter out AI slop PRs.

Because Vouch exposes the vouch list as a plain text file (VOUCHED.td), I realized I could aggregate them across GitHub and build a reputation index. A crawler finds every VOUCHED.td file, pulls the entries, and computes a weighted score per user. Vouches from high-star repos count more than vouches from zero-star repos.

Next step is to wire up an API so that the vouch GH action can start to use this data to auto approve contributors.