Show stories

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.

AsteroidOS 2.0, a free and open-source smartwatch operating system, has been released. The update introduces several new features, including support for more smartwatch models, improved performance, and enhanced user experience.

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.

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!

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.

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.

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.

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

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

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.

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.

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.

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.

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

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

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.

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.

I built a software-defined radio transmission platform that runs on a Raspberry Pi Zero W. It spawns its own WiFi hotspot and serves a web UI — connect from any device and you have a portable RF signal generator with 12 transmission modes: FM broadcasting with RDS, FT8, RTTY, FSK, POCSAG paging, Morse code, SSTV image transmission, voice cloning via live mic, spectrum painting, IQ replay, carrier wave, and frequency sweeps.

Everything runs through a browser interface. Upload audio files, type messages, configure frequencies, and transmit. The Pi's GPIO pin does the actual RF generation via rpitx — no external radio hardware needed.

Written in Go with a real-time WebSocket frontend. Includes a preset system, playlist builder, and multi-device support (connect multiple phones/laptops to the AP and share control).

Without an antenna the signal barely reaches 5 meters, which makes it perfect for indoor experimentation and learning about RF protocols without causing interference. All my testing was done indoors with no antenna attached.

Built this because I wanted a single portable tool to experiment with every common RF transmission mode without hauling around expensive SDR equipment.

Pre-built SD card image available if you want to skip the build process.

GitHub: https://github.com/psyb0t/piraterf Blog post: https://ciprian.51k.eu/piraterf-turning-a-20-raspberry-pi-ze...

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.

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.

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.

I built a browser extension that does text replacement across all websites -- specifically replacing "Trump" with rotating humorous nicknames.

The interesting technical bits:

- TreeWalker for DOM traversal (skips scripts, inputs, contenteditable, iframes)

- MutationObserver with debouncing for SPAs and dynamically loaded content

- Fisher-Yates shuffle bag for even nickname distribution (no repeats until all are used)

- Case preservation via regex (TRUMP -> MANGO MUSSOLINI, Trump -> Mango Mussolini)

- CSS-only animations with prefers-reduced-motion support

- Zero dependencies, plain JS, Manifest V3

The architecture is generic enough to fork for any text replacement use case. All the replacement logic lives in a single file.

No external requests, no analytics, no data leaves the browser. Settings sync via Chrome Storage / browser.storage.

Available for Chrome, Firefox, and Safari. Free.

Feedback on the implementation welcome -- the code is straightforward and I'd rather someone tell me my MutationObserver setup is wrong than find out the hard way.

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.

A new tool for analyzing keyfobs! Still in beta. Keyfob Analysis Toolkit (KAT)

The article discusses a tool called 'jvm-hotpath' that provides a visual representation of a Java application's hot paths, helping developers identify performance bottlenecks and optimize their code.

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!

Galatea.sh is a scalable, open-source platform that provides pre-trained language models and tools for building natural language processing applications. The article highlights Galatea's features, including its support for multiple languages, model customization, and integration with popular machine learning frameworks.

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)