Show stories

micasa is a terminal UI that helps you track home stuff, in a single SQLite file. No cloud, no account, no subscription. Backup with cp.

I built it because I was tired of losing track of everything in notes apps, and "I'll remember that"s. When do I need to clean the dishwasher filter? What's the best quote for a complete overhaul of the backyard. Oops, found some mold behind the trim, need to address that ASAP. That sort of stuff.

Another reason I made micasa was to build a (hopefully useful) low-stakes personal project where the code was written entirely by AI. I still review the code and click the merge button, but 99% of the programming was done with an agent.

Here are some things I think make it worth checking out:

- Vim-style modal UI. Nav mode to browse, edit mode to change. Multicolumn sort, fuzzy-jump to columns, pin-and-filter rows, hide columns you don't need, drill into related records (like quotes for a project). Much of the spirit of the design and some of the actual design choices is and are inspired by VisiData. You should check that out too. - Local LLM chat. Definitely a gimmick, but I am trying preempt "Yeah, but does it AI?"-style conversations. This is an optional feature and you can simply pretend it doesn't exist. All features work without it. - Single-file SQLite-based architecture. Document attachments (manuals, receipts, photos) are stored as BLOBs in the same SQLite database. One file is the whole app state. If you think this won't scale, you're right. It's pretty damn easy to work with though. - Pure Go, zero CGO. Built on Charmbracelet for the TUI and GORM + go-sqlite for the database. Charm makes pretty nice TUIs, and this was my first time using it.

Try it with sample data: go install github.com/cpcloud/micasa/cmd/micasa@latest && micasa --demo

If you're insane you can also run micasa --demo --years 1000 to generate 1000 years worth of demo data. Not sure what house would last that long, but hey, you do you.

I run a lot of Claude Code and Codex sessions in parallel. I was using Ghostty with a bunch of split panes, and relying on native macOS notifications to know when an agent needed me. But Claude Code's notification body is always just "Claude is waiting for your input" with no context, and with enough tabs open, I couldn't even read the titles anymore.

I tried a few coding orchestrators but most of them were Electron/Tauri apps and the performance bugged me. I also just prefer the terminal since GUI orchestrators lock you into their workflow. So I built cmux as a native macOS app in Swift/AppKit. It uses libghostty for terminal rendering and reads your existing Ghostty config for themes, fonts, colors, and more.

The main additions are the sidebar and notification system. The sidebar has vertical tabs that show git branch, working directory, listening ports, and the latest notification text for each workspace. The notification system picks up terminal sequences (OSC 9/99/777) and has a CLI (cmux notify) you can wire into agent hooks for Claude Code, OpenCode, etc. When an agent is waiting, its pane gets a blue ring and the tab lights up in the sidebar, so I can tell which one needs me across splits and tabs. Cmd+Shift+U jumps to the most recent unread.

The in-app browser has a scriptable API ported from agent-browser [1]. Agents can snapshot the accessibility tree, get element refs, click, fill forms, evaluate JS, and read console logs. You can split a browser pane next to your terminal and have Claude Code interact with your dev server directly.

Everything is scriptable through the CLI and socket API – create workspaces/tabs, split panes, send keystrokes, open URLs in the browser.

Demo video: https://www.youtube.com/watch?v=i-WxO5YUTOs

Repo (AGPL): https://github.com/manaflow-ai/cmux

[1] https://github.com/vercel-labs/agent-browser

We ported pbrt-v4 to Julia and built it into a Makie backend. Any Makie plot can now be rendered with physically-based path tracing.

Julia compiles user-defined physics directly into GPU kernels, so anyone can extend the ray tracer with new materials and media - a black hole with gravitational lensing is ~200 lines of Julia.

Runs on AMD, NVIDIA, and CPU via KernelAbstractions.jl, with Metal coming soon.

Demo scenes: github.com/SimonDanisch/RayDemo

The article discusses the development of Mini Diarium, a simple and lightweight daily journal application that focuses on privacy and minimalism. The project aims to provide users with a straightforward tool to record their daily thoughts and experiences without the clutter of unnecessary features.

Hi HN,

I’ve been building a small infrastructure tool called Provisioner: a per-board provisioning sidecar for SBC bring-up and lab automation. https://github.com/alessandrocarminati/provisioner

The model is simple: one instance per board. It sits next to the hardware, owns the serial console, exposes access over SSH, and serves boot artifacts (kernel, initramfs, rootfs) via TFTP/HTTP. It’s designed for the phase where networking is unreliable, storage is half-flashed, and UART is the only thing still telling the truth.

What it does

- Serial console ownership + SSH multiplexing - Monitor shell + serial tunnels - Scriptable boot interaction - Artifact provisioning (TFTP + HTTP) - In-band file transfer over serial - gzip/base64 hacks + XMODEM - Derived from my earlier send_console-ng utility https://github.com/alessandrocarminati/send_file-ng - Pluggable power control - SNMP PDUs, among others cheap ESP8266/Tasmota devices - Serial logging - Lightweight access control

Provisioner also embeds a minimal init runtime (goinit) inside the kernel initramfs, acting as its on-board provisioning agent, handling flashing, artifact retrieval, and reporting management state back over serial.

Routing & stream handling

Internally, Provisioner routes serial traffic through a pluggable router:

- Producers/consumers attach as components - Human vs machine clients handled differently - Unicast control sessions - Broadcast multiplexing to multiple observers

This allows several users or services to watch the same console without interfering.

Filters

A filter subsystem can intercept and modify serial streams on the fly.

Originally added to mitigate ANSI Device Status Reports (e.g. Cursor Position Report issues) when tunneling serial consoles, but it doubles as a general stream rewriting mechanism for automation and normalization.

Positioning

Not trying to replace large systems like LAVA.

This is aimed at:

- Homelabs - Bring-up benches - Kernel/BSP work - Small shared labs

Think lab automation you can deploy in an afternoon, not fleet orchestration.

Project is still evolving but already in daily use. Feedback and abuse welcome.

I’ve been working on a modular N-body simulator in Python called Astroworld. It started as a Solar System visualizer, but I recently refactored it into a general-purpose engine that decouples physical laws from planetary data.Technical Highlights:Symplectic Integration: Uses a Velocity Verlet integrator to maintain long-term energy conservation ($\Delta E/E \approx 10^{-8}$ in stable systems).Agnostic Architecture: It can ingest any system via orbital elements (Keplerian) or state vectors. I've used it to validate the stability of ultra-compact systems like TRAPPIST-1 and long-period perturbations like the Planet 9 hypothesis.Validation: Includes 90+ physical tests, including Mercury’s relativistic precession using Schwarzschild metric corrections.The Planet 9 Experiment:I ran a 10k-year simulation to track the differential signal in the argument of perihelion ($\omega$) for TNOs like Sedna. The result ($\approx 0.002^{\circ}$) was a great sanity check for the engine’s precision, as this effect is secular and requires millions of years to fully manifest.The Stack:NumPy for vectorization, Matplotlib for 2D analysis, and Plotly for interactive 3D trajectories.I'm currently working on a real-time 3D rendering layer. I’d love to get feedback on the integrator’s stability for high-eccentricity orbits or suggestions on implementing more complex gravitational potentials.

The article describes a Docker image that provides a Lisp development environment, allowing users to easily set up and run Lisp applications in a containerized setup. The image includes a Lisp implementation, a REPL, and a set of development tools, making it a convenient solution for Lisp developers.

Hi HN,

I built https://rebrain.gg. It's a website which is intended to help you learn new things.

I built it for two reasons:

1. To play around with different ways of interacting with a LLM. Instead of a standard chat conversation, the LLM returns question forms the user can directly interact with (and use to continue the conversation with the LLM).

2. Because I thought it would be cool to have a site dedicated to interactive educational content instead of purely consuming content (which I do too much).

An example of a (useful-for-me) interactive conversation is: https://rebrain.gg/conversations/6. In it I'm learning how to use the `find` bash command. (Who ever knew to exclude a directory from a look-up you need to do `find . -path <path> -exclude -o <what you want to look for>`, where `-o` stands for "otherwise"!)

Still very early on, so interested in and open to any feedback.

Thanks!

BLite is a lightweight and efficient blockchain implementation written in C++. It is designed to be a platform for building decentralized applications with a focus on performance, security, and ease of use.

I’ve just released VectorNest — an open-source, browser-based SVG editor.

If you have an SVG and need quick edits (paths, alignment, small fixes, animations, LLM assistance) without installing software, this is for you.

Try the demo: https://ekrsulov.github.io/vectornest/ GitHub repo: https://github.com/ekrsulov/vectornest

Feedback, issues and contributions are welcome.

Hi HN, I built a PostScript interpreter from scratch in Python.

PostForge implements the full PostScript Level 2 specification — operators, graphics model, font system, save/restore VM, the works. It reads .ps and .eps files and outputs PNG, PDF, SVG, or renders to an interactive Qt window.

Why build this? GhostScript is the only real game in town for PostScript interpretation, and it's a 35-year-old C codebase. I wanted something where you could actually read the code, step through execution, and understand what's happening. PostForge is modular and approachable — each operator category lives in its own file, the type system is clean, and there's an interactive prompt where you can poke at the interpreter state.

Some technical highlights:

- Full Level 2 compliance with selected Level 3 features - PDF output with Type 1 font reconstruction/subsetting and TrueType/CID embedding - ICC color management (sRGB, CMYK, Gray profiles via lcms2) - Optional Cython-compiled execution loop (15-40% speedup) - 2,500+ unit tests written in PostScript itself using a custom assertion framework - Interactive executive mode with live Qt display — useful for debugging PS programs

What it's not: A GhostScript replacement for production/printer use. It's interpreted Python, so it's slower. But it handles complex real-world PostScript files well and the output quality is solid.

I'd love feedback, especially from anyone who's worked with PostScript or built language interpreters. The architecture docs are at docs/developer/architecture-overview.md if you want to dig in.

Hey HN! I'm Rodrigo, I run distributed systems across a few countries. I built Openfuse because of something that kept bugging me about how we all do circuit breakers.

If you're running 20 instances of a service and Stripe starts returning 500s, each instance discovers that independently. Instance 1 trips its breaker after 5 failures. Instance 14 just got recycled and hasn't seen any yet. Instance 7 is in half-open, probing a service you already know is dead. For some window of time, part of your fleet is protecting itself and part of it is still hammering a dead dependency and timing out, and all you can do is watch.

Libraries can't fix this. Opossum, Resilience4j, Polly are great at the pattern, but they make per-instance decisions with per-instance state. Your circuit breakers don't talk to each other.

Openfuse is a centralized control plane. It aggregates failure metrics from every instance in your fleet and makes the trip decision based on the full picture. When the breaker opens, every instance knows at the same time.

It's a few lines of code:

  const result = await openfuse.breaker('stripe').protect(
    () => chargeCustomer(payload)
  );

The other thing I couldn't let go of: when you get paged at 3am, you shouldn't have to find logs across 15 services to figure out what's broken. Openfuse gives you one dashboard showing every breaker state across your fleet: what's healthy, what's degraded, what tripped and when. And, you shouldn't need a deploy to act. You can open a breaker from the dashboard and every instance stops calling that dependency immediately. Planned maintenance window at 3am? Open beforehand. Fix confirmed? Close it instantly. Thresholds need adjusting? Change them in the dashboard, takes effect across your fleet in seconds. No PRs, no CI, no config files.

It has a decent free tier for trying it out, then $99/mo for most teams, $399/mo with higher throughput and some enterprise features. Solo founder, early stage, being upfront.

Would love to hear from people who've fought cascading failures in production. What am I missing?

I've been working on creating a Low Power FM radio station for the east San Fernando Valley of Los Angeles. We are not yet on the broadcast band but our channel will be 95.9FM and our range can been seen on the homepage of our site.

KPBJ is a freeform community radio station. Anyone in the area is encouraged to get a timeslot and become a host. We make no curatorial decisions. Its sort of like public access or a college station in that way.

This month we launched our internet stream and on-boarded about 60 shows. They are mostly music but there are a few talk shows. We are restricting all shows to monthly time slots for now but this will change in the near future as everyone gets more familiar with the systems involved.

All shows are pre-recorded until we can raise the money to get a studio.

We have a site secured for our transmitter but we need to fundraise to cover the equipment and build out costs. We will be broadcasting with 100W ERP from a ridgeline in the Verdugos at about 1500ft elevation. The site will need to be off grid so we will need to install a solar system with battery backup. We are planning to sync the station to the transmit site with 802.11ah.

I've built all of our web infrastructure using Haskell, NixOS, Terraform, and HTMX: https://github.com/solomon-b/kpbj.fm

This is a pretty substantial project involving a bunch of social and technical challenges and a shoe string budget. I'm feel pretty confident we will pull it off and make it a high impact local radio station.

The station is managed by a 501c3 non-profit we created. We are actively seeking fundraising, especially to get our transmit site up and running. If you live in the area or want to contribute in any way then please reach out!

Hey HN,

I've used Generative.fm for years and love it, but I always wanted to just describe what I was in the mood for instead of scrolling through presets. So I built this.

You type a text description of anything - from "mountain sunrise" to "neon city" - and it generates a procedural/ambient stream matching that mood. It runs locally, no account, no tracking, no ads.

Under the hood it's a custom synthesizer driven by sentence embeddings, not a generative AI model (although you can choose to use one!) — so there's no GPU, no API calls, and it starts playing almost instantly. The whole thing is open source: https://github.com/prabal-rje/latentscore

If you're a developer and want to use it programmatically it's also a Python library - pip install latentscore — one line to render audio. But honestly I just use the web player myself when I'm working.

Fair warning: it's still alpha and the synth has limits, so please don't expect full songs or vocals. It's ambient/procedural only. But for focus music or background atmosphere, I think it's pretty good.

Would love to know what vibes you try and whether they land!

- Prabal

Hey HN! I’m Simone. We re-built Breadboard, a visual app builder that mixes Figma-style UI design with Shortcuts-style logic so you can build, preview, and publish interactive web apps directly from the canvas.

What it does

    Design UIs visually with a flexible canvas –like Figma–.
    Define app logic with a visual, instruction-stacked editor inspired by Shortcuts.
    Live preview apps directly on the canvas –no separate preview window–.
    Publish working web apps with one click.

    Modernize the HyperCard idea: combine layout, behavior, and instant sharing in one place.
    Reduce friction between design and a working app.
    Make simple web apps approachable for non-developers while keeping power features for developers.
    Build a foundation for LLM integration so users can design and develop with AI while still understanding what’s happening, even without coding experience –in progress!–.

Weather forecast app: https://app.breadboards.io/playgrounds/weather

Swiss Public Transit: https://app.breadboards.io/playgrounds/public_transit

info: https://breadboards.io

I would appreciate any feedback :)

Hi HN, After roughly 8 years of silently rolling 1.1 nightlies, we finally tagged a proper stable 2.0 release. We built this because wrist-sized Linux is genuinely fun to hack on, and because a handful of us think it's worth keeping capable hardware alive long after manufacturers move on. Smartwatches don't really get old — the silicon is basically the same as it was a decade ago. We just keep making it useful for us.

No usage stats, no tracking, no illusions of mass adoption. The only real signal we get is the occasional person who appears in our Matrix chat going "hey, it booted on my watch from 2014 and now it's usable again" — and that's plenty.

Privacy is non-negotiable: zero telemetry, no cloud, full local control. Longevity is the other half: we refuse to let good hardware become e-waste just because support ended. On the learning side, it's been one of the best playgrounds: instant feedback on your wrist makes QML/Qt, JavaScript watchfaces and embedded Linux feel tangible. The community is small and kind — perfect for people who want to learn open-source dev without gatekeeping.

Technically we're still pragmatic: libhybris + older kernels on most devices since it just works, but we've already mainlined rinato (Samsung Gear 2) and sparrow (ASUS ZenWatch 2) — rinato even boots with a usable UI. That's the direction we're pushing toward.

Repo: https://github.com/AsteroidOS Install images & docs: https://asteroidos.org 2.0 demo video : https://www.youtube.com/watch?v=U6FiQz0yACc Announcement post: https://asteroidos.org/news/2-0-release/

Questions, port requests, mentoring offers, criticism, weird ideas — all welcome. We do this because shaping a tiny, open wearable UX and infrastructure is oddly satisfying, and because Linux on the wrist still feels like a playground worth playing in.

Cheers, the AsteroidOS Team

The article discusses the development of Vibe, a new deep learning model that can infer the personality and emotional state of a person from their text. The model aims to provide deeper insights into the nuances of human communication and help with various applications, such as customer service and mental health support.

Last year I built an Android app to block Reels and Shorts while keeping "healthy" features like stories and DMs. I didn't want to block the whole app. I just wanted to message friends and see their posts without losing an hour scrolling on Reels. This was the HN post for the Android version: https://news.ycombinator.com/item?id=44923520

When people asked for an iOS version, I thought it was not possible. Apple is way more restrictive and doesn't allow that level of app access.

But I ended up building the iOS app using a different approach. On iOS, it uses WebApps. It's not exactly the same experience as the native app, but it works surprisingly well.

I also combined it with iOS Shortcuts to auto-redirect the native apps to WebApps, so I can keep Instagram installed for notifications but get sent to the WebApp without Reels and any feed when I tap.

Curious what you think, especially about the WebApp approach on iOS.

I started a job board to help semiconductor design students (and more senior semiconductor folks) find their next internship (and job). We have a few hundred jobs up, and adding more every day.

This claude code plugin and npx skill bundles the full CE.SDK documentation, guided code generation, and a builder agent that scaffolds complete photo/video/design editor projects from scratch, all offline, no API calls or MCP servers needed.

Supports 10 frameworks: React, Vue, Svelte, Angular, Next.js, Nuxt.js, SvelteKit, Electron, Node.js, and vanilla JS.

Throughout my career, I tried many tools to query PostgreSQL, and in the end, concluded that for what I do, the simplest is almost always the best: raw SQL queries.

Until now, I typed the results manually and relied on tests to catch problems. While this is OK in e.g., GoLang, it is quite annoying in TypeScript. First, because of the more powerful type system (it's easier to guess that updated_at is a date than it is to guess whether it's nullable or not), second, because of idiosyncrasies (INT4s are deserialised as JS numbers, but INT8s are deserialised as strings).

So I wrote pg-typesafe, with the goal of it being the less burdensome: you call queries exactly the same way as you would call node-pg, and they are fully typed.

It's very new, but I'm already using it in a large-ish project, where it found several bugs and footguns, and also allowed me to remove many manual type definitions.

I've been teaching LLMs to play Magic: The Gathering recently, via MCP tools hooked up to the open-source XMage codebase. It's still pretty buggy and I think there's significant room for existing models to get better at it via tooling improvements, but it pretty much works today. The ratings for expensive frontier models are artificially low right now because I've been focusing on cheaper models until I work out the bugs, so they don't have a lot of games in the system.

Hi HN,

We built CandyDocs after watching SaaS teams stitch together docs, roadmaps, feedback tools, release notes, and API references across multiple products.

CandyDocs is a unified, fully branded workspace that brings all of this into one place.

Core modules (all customizable):

- Knowledge base (guides, FAQs, onboarding)

- Roadmap (planned / in progress / shipped, with voting)

- Feedback (feature requests + comments)

- Updates (release notes and announcements)

- API documentation (endpoints, params, examples)

- Custom pages (policies, flows, anything else)

Platform features:

- Custom domains + branding

- Dynamic navigation

- Searchable knowledge base

- Public roadmap with voting

- Structured feedback collection

- Release notes publishing

- API reference docs

- Analytics and engagement insights

- Role-based permissions (admins/moderators)

The goal is to replace scattered tools with one consistent product communication hub.

We’re early and actively iterating. Would love technical feedback, criticism, or feature requests.

Baby monitors are a great boon. We use the audio-only Motorola AM21, which is excellent. But being on pat leave with a 2-month-old right now, I decided to build a browser-based alternative using WebRTC and some AI coding agents (Codex & Gemini).

It is an open-source, zero-latency P2P monitor. Hardware reuse: You can repurpose an old phone or tablet to be the child unit instead of buying single-purpose hardware. Actually private: Unlike using a never-ending Google Meet or Zoom, your stream stays private via WebRTC (PeerJS for signaling). No cloud routing. The backgrounding hack: Mobile Safari aggressively kills background audio. I used a hidden 1x1 base64 looping video to keep the microphone active when the screen dims.

Links: Live Demo: https://legodud3.github.io/kgbaby/ Repo: https://github.com/legodud3/kgbaby

Welcome all feedback!

Fun little side project I built after learning about circuit bending in cameras for intentional glitch effect. It is browser based camera toy where you "rewire" CCD pin pairs, turn knobs to get different glitch artefacts in real time to capture as photos. I had fun learning to simulate different pin modes - channel split, hue/phase shifts, horizontal clock delays, colour kill etc.

Here are some photos taken: https://glitchycam.com/gallery

I intentionally leaned towards skeuomorphic design for nostalgia. I miss the days where I'd spend hours making a button to look like a physical button. Here I chose to make it look like a "good enough" Teenage Engineering device UI.

I tested/used GPT-5.3-Codex to build this from scratch, since there was a lot of hype around it on X. Maybe I wasn’t using it right, but I found it needed a lot of code cleanup at every step and a lot of hand holding along the way. It missed details/nuances and didn't land the skeuomorphic buttons or the interaction polish. It mostly helped with boilerplate where there wasn't much thinking/detailing. It did give a basic starting point for the effect calculations, but didn't really move the needle on the details.

Please give it a go and let me know what you think - your photos and video never leave your browser (you can download them if you choose to). Everything is processed locally in your browser (works offline), nothing is uploaded or seen by anyone.

Hey HN,

I've been working on Aegis.rs for a bit, and I wanted to share it. It's the first open-source Rust-based LLM security proxy (that I could find, at least).

I kept having the same issue, since existing LLM security tools are either Python libraries you have to manually integrate into your app, or cloud SaaS products that route your traffic through a third party (which you can't control), and i wanted something that just sat in the middle without touching my code or sending prompts anywhere.

So I built a transparent reverse proxy. You point your requests at localhost:8080 instead of your LLM endpoint and, so far, it catches prompt injections, jailbreaks, PII leakage, and other LLM attacks, blocking them before any malicious request even reaches the model. If a request is clean, it forwards it. If it's malicious, it blocks it. Zero code changes.

It runs two layers: a fast heuristic engine with 150+ hand-crafted (expandable) regex rules that runs in under 1ms (thanks to Actix-web), plus an AI judge using Groq for semantic analysis on ambiguous cases.

Can be easily shipped as a single binary with a live dashboard, hot-reloadable rules, and structured JSON logs.

Still v0.1 but it's working well enough for me to share its first version. The heuristic layer is fast enough for prod, and extending the rules is pretty easy.

Would love feedbacks (or contributions lol), especially from anyone dealing with LLMs' security and threat modeling :)