Show stories

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 book page links to a blog post that explains how I got about it (and has a link to sample content), but the TL&DR is that I could not find a lot of books that were on "our" history _and_ were larded with technical details. So I set about writing one, and some five years later I'm happy to share the result. I think it's one of the few "computer history" books that has tons of code, but correct me if I'm wrong (I wrote this both to tell a story and to learn :-)).

My favorite languages are Smalltalk and Lisp, but as an Emacs user, I've been using the latter for much longer and for my current projects, Common Lisp is a better fit, so I call myself "a Lisp-er" these days. If people like what I did, I do have plans to write some more (but probably only after I retire, writing next to a full-time job is heard). Maybe on Smalltalk, maybe on computer networks - two topics close to my heart.

And a shout-out to Dick Gabriel, he contributed some great personal memories about the man who started it all, John McCarthy.

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.

Box of Rain is an open-source project that provides a simple, flexible, and extensible system for managing user settings and configurations across different applications and platforms. It aims to simplify the process of managing user preferences and settings, making it easier for developers to build applications with customizable user experiences.

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!

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,

I’ve been experimenting with archive format design and built 6cy as a research project.

The goal is not to replace zip/7z, but to explore: • block-level codec polymorphism (different compression per block) • streaming-first layout (no global seek required) • better crash recovery characteristics • plugin-based architecture so proprietary codecs can exist without changing the format

Right now this is an experimental v0.x format. The specification may still change and compatibility is not guaranteed yet.

I’m mainly looking for feedback on the format design rather than performance comparisons.

Thanks for taking a look.

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.

We now write most of our code with agents. For a while, PRs piled up, causing review fatigue, and we had this sinking feeling that standards were slipping. Consistency is tough at this volume. I’m sharing the solution we found, which has become our main product.

Continue (https://docs.continue.dev) runs AI checks on every PR. Each check is a source-controlled markdown file in `.continue/checks/` that shows up as a GitHub status check. They run as full agents, not just reading the diff, but able to read/write files, run bash commands, and use a browser. If it finds something, the check fails with one click to accept a diff. Otherwise, it passes silently.

Here’s one of ours:

  .continue/checks/metrics-integrity.md

  ---
  name: Metrics Integrity
  description: Detects changes that could inflate, deflate, or corrupt metrics (session counts, event accuracy, etc.)
  ---

  Review this PR for changes that could unintentionally distort metrics.
  These bugs are insidious because they corrupt dashboards without triggering errors or test failures.

  Check for:
  - "Find or create" patterns where the "find" is too narrow, causing entity duplication (e.g. querying only active sessions, missing completed ones, so every new commit creates a duplicate)
  - Event tracking calls inside loops or retry paths that fire multiple times per logical action
  - Refactors that accidentally remove or move tracking calls to a path that executes with different frequency

  Key files: anything containing `posthog.capture` or `trackEvent`

---

To get started, paste this into Claude Code or your coding agent of choice:

  Help me write checks for this codebase: https://continue.dev/walkthrough

- Explore the codebase and use the `gh` CLI to read past review comments

- Write checks to `.continue/checks/`

- Optionally, show you how to run them locally or in CI

Would love your feedback!

tiny_coro is a lightweight, educational M:N asynchronous runtime written from scratch using C++20 coroutines. It's designed to strip away the complexity of industrial libraries (like Seastar or Folly) to show the core mechanics clearly.

Key Technical Features:

M:N Scheduling: Maps M coroutines to N kernel threads (Work-Stealing via Chase-Lev deque).

Memory Safety: Implements EBR (Epoch-Based Reclamation) to manage memory safely in lock-free structures without GC.

Visualizations: I used Manim (the engine behind 3Blue1Brown) to create animations showing exactly how tasks are stolen and executed.

Why I built it: To bridge the gap between "using coroutines" and "understanding the runtime." The code is kept minimal (~1k LOC core) so it can be read in a weekend.

OpenBoot is an open-source project that aims to create a secure, customizable, and extensible bootloader for a wide range of devices, providing a foundation for building robust and flexible embedded systems.

A high-performance internet radio streaming server written in Python with Cython optimizations.

KrillClaw is an open-source project that provides a flexible, modular, and extensible framework for building and deploying serverless applications. It offers a set of tools and templates to simplify the development, testing, and deployment of serverless functions.

Related: Show HN: JeffTube - https://news.ycombinator.com/item?id=47030797

My great-grandfather Reuben P. Box was a US Forest Ranger in Northern California, and I've got his daily work diary from 1927-1945, through the depression, WWII, Conservation Corps, and lots of forest fires. I've scanned the entire thing, had Claude help with transcription, indexing, and web site building, and put the whole thing here:

https://forestrydiary.com/

This is one of those projects I've sat on for years, but with Claude and Mistral helping with the handwriting recognition, and even helping me write a custom scanning app that would auto scan each page and put it into a database as I assembled everything.

As far as I know, this is the only US Forestry Diary that has been fully scanned in and published. I understand that there are other diaries in some collections, but none have been scanned in. I hope this helps somebody. Please let me know if it does.

This is the sort of project Claude and AI can help with - A personal project that sits on the shelf forever, but now a reasonable project that can be published in my spare time. I'm not trying to earn money on this, but just improving our knowledge and history just a little bit.

I read a lot of research papers for work. My workflow evolved around an ever-growing inbox of bookmarked papers from arXiv et al. Great for exploration, but hard to keep track of what I read.

Distillate bridges the tools I already use: Zotero (literature management), reMarkable (reader + highlighter), and Obsidian (notes). It automates the whole pipeline:

$ distillate

save to Zotero ──> auto-syncs to reMarkable

                        │

         read & highlight on tablet
         just move to Read/ when done

                        │

                        V

         auto-saves notes + highlights

- Parses .rm files using rmscene to extract highlighted text (GlyphRange items)

- Searches for that text in the original PDF using PyMuPDF and adds highlight annotations

- Enriches metadata from Semantic Scholar (publication date, venue, citations)

- Creates a structured markdown note with metadata, highlights grouped by page, and the annotated PDF (I keep mine in an Obsidian vault)

The core workflow just needs Zotero and a reMarkable — no paid APIs, no cloud backend, your notes stay on your machine. Optional extras if you plug them in:

- AI summaries via Claude (one-liner + key learnings from your highlights)

- Daily reading suggestions from your queue

- Weekly email digest via Resend

- Obsidian Bases database for tracking your reading

Stack: rmapi for reMarkable Cloud, rmscene for .rm parsing, PyMuPDF for PDF annotation. Python 3.10+, pip installable.

The trickiest part was highlight extraction: reMarkable stores highlighted text as GlyphRange items in a scene tree, and matching that text back to positions in the original PDF required fuzzy search with OCR cleanup, plus special merging logic for e.g. cross-page highlights. Happy to say it works well ~99% of the time now.

Install: pip install distillate && distillate --init

Code: https://github.com/rlacombe/distillate

Site: https://distillate.dev

I built this for myself but would love feedback, especially from other reMarkable + Zotero users. What's missing from your workflow? What else should I add?

Dear HN,

My wife and I both love nature and have always wanted a Pokémon go style app, to collect and learn about different species we find.

All the usual species identifying apps were didn’t feel fun enough, so we designed and built one together!

Would love for you guys to give it a try and share any thoughts you have.

Relay is a powerful open-source framework for building GraphQL servers on top of Node.js. It provides a modern, efficient, and scalable way to manage data flow and state in web and mobile applications.

The article introduces a TypeScript-based NBA API that provides easy access to NBA data, including player and team statistics, scores, standings, and more. The API offers a simple and organized way to fetch and utilize NBA data in web applications.

Hey HN, I don’t know who else has the same issue, but:

Textbooks often bury good ideas in dense notation, skip the intuition, assume you already know half the material, and get outdated in fast-moving fields like AI.

Over the past 7 years of my AI/ML experience, I filled notebooks with intuition-first, real-world context, no hand-waving explanations of maths, computing and AI concepts.

In 2024, a few friends used these notes to prep for interviews at DeepMind, OpenAI, Nvidia etc. They all got in and currently perform well in their roles. So I'm sharing.

This is an open & unconventional textbook covering maths, computing, and artificial intelligence from the ground up. For curious practitioners seeking deeper understanding, not just survive an exam/interview.

To ambitious students, an early careers or experts in adjacent fields looking to become cracked AI research engineers or progress to PhD, dig in and let me know your thoughts.

Freeflow is an open-source, self-hosted, and privacy-focused alternative to popular social media platforms. It aims to provide users with a decentralized and ad-free social networking experience that prioritizes user control and data privacy.

A pretty simple but fun to play with simulator for a concept from mathematical physics called the "2D Coulomb gas". I originally made this for my Bachelor's thesis to create pretty pictures and build intuition but have recently gotten it a fresh coat of paint and better performance curtesy of WebGPU acceleration (ported with liberal help from Codex to get through all of the boilerplate).

Play around with it - hopefully read up more on the 2D Coulomb gas because it is an incredibly deep topic research wise.

Hi HN!

I built SimplePDF 7 years ago, with the vision from day one to help get rid of bureaucracy (I'm from France, I know what I'm talking about)

Fast forward to this week where I finally released something I had on my mind for a long time: a repository of the main US forms that are ready to be filled, straight from the browser, as opposed to having to find a PDF tool online (or local).

I focused on healthcare, ED, HR, Legal and IRS/Tax for now.

On the tech-side, it's SimplePDF all the way down: client-side processing (the data / documents stay in your browser).

I hope you find the resource useful!

NiP

I like to use org files a lot, but I wanted some way to browse and edit them on my phone when I'm out. Yesterday I used Codex to make this simple one-file web server that just displays all my org files with backlinks. It doesn't have any authentication because I only run it on my wireguard VPN. I've been having fun with it, hopefully it's useful to someone else!

I’ve been a software engineer for 10+ years and a hobby photographer for even longer. Over time my family archive grew to 100k+ photos and videos, and browsing it smoothly on macOS became surprisingly hard.

So I started building Lap app.

The current focus (v0.1.6) is simple: fast local photo library browsing and management - Smooth scrolling through very large libraries - Works directly on your existing folders (no import/catalog) - Fully local

Planned next: deduplication, photo comparison tools, and RAW support.

Hey HN,

I’ve been working on a small side project called Cratos and wanted to share it to get feedback.

Cratos is a self-hosted task scheduling system. You configure a URL, define when it should be called, and Cratos handles scheduling, retries, execution history, and real-time updates. The goal was to have something lightweight and fully owned - no SaaS dependency, no external cron service.

It’s split into three repositories:

Backend service: https://github.com/Ghiles1010/Cratos

Web dashboard: https://github.com/Ghiles1010/Cratos-UI

Python SDK: https://github.com/Ghiles1010/Cratos-SDK

Why I built it:

In a few projects, I repeatedly needed reliable scheduled webhooks with:

Retry logic

Execution logs/history

A dashboard to inspect runs

Easy local deployment

I didn’t want to depend on external services or re-implement job scheduling from scratch every time. The goal was simple deployment (docker compose up) and full control.

It’s still early, but usable. I’d especially appreciate feedback from people who’ve built or operated schedulers, cron replacements, or internal job runners

I would love some feedback, or tell me how it would be useful to you

This article discusses a new website called PlaceTheSound, which allows users to place sound effects on an interactive map. The site offers a wide range of sound effects and enables users to collaborate on sound projects by adding and arranging sounds in a shared virtual environment.

This article discusses the training of YOLOX, an object detection model, for aircraft detection. The author shares their experience and insights in training YOLOX on a custom dataset, highlighting the model's performance and the benefits of using the MIT license.

Hi HN,

I built this because I got tired of the Claude Code CLI hiding details from me.

Recent updates have replaced critical output with summaries like "Read 3 files" or "Edited 2 files". To see what actually happened, I was forced to use `--verbose`, which floods the terminal with unreadable JSON and system prompts.

I wanted a middle ground: *Full observability without the noise.*

`claude-devtools` is a local Electron app that tails the session logs in `~/.claude/` to reconstruct the execution trace in real-time.

*Unlike wrappers, it solves the visibility gap in your native terminal workflow:* 1. *Real Diffs:* It shows inline diffs (red/green) the moment files are edited, instead of just a checkmark. 2. *Context Forensics:* It breaks down token usage by File vs Tool Output vs Thinking (so you know exactly why your context window is full). 3. *Agent Trees:* It visualizes sub-agent execution paths which are usually interleaved and confusing in the CLI.

It’s 100% local, and works with the logs already on your machine. No API keys required.

Repo: https://github.com/matt1398/claude-devtools (Screenshots and diff viewer demo are in the README)

This was a quick, fun project that solves a practical problem I had — wanting to learn the names of piano chords, but not seeming to want to spend time staring at chord charts. I figured perhaps I could learn some music theory more deeply by encoding the logic into software, as well.

I came across this table <https://en.wikipedia.org/wiki/Chord_(music)#Examples> that breaks down the composition of chords logically. I was reminded of a bitmask, so I translated each chord into a 12–bit bitmask with a bit for each distinct note letter name (e.g. “C” or “B♭”). Decoding binary was involved in interfacing with MIDI … that might have been the inspiration — regardless, a bitmask seems ideal for this purpose.

The most challenging part by far was the logic that determines whether say, “A♯/B♭” (which are considered to be the same note in the 12–tone chromatic scale) should be rendered as “A♯” or “B♭”. As best as I understand, this depends on key signature context, and the logic regarding this isn’t well-described. I settled on finding the diatonic scale (7–note) that contains the maximum number of notes that the chord also contains. That diatonic scale provides the context for the note letter names. This logic isn’t perfect yet — the scales that include double flats and double sharps (which I wasn’t previously aware of) still provide ambiguous results.