Show stories

Hi HN!

My name's Robert Escriva. I got my PhD from Cornell's Computer Science department back in 2017. And three years ago I had a psychotic episode that irreversibly shook up my world.

Since then I've been applying a skill I learned in grad school---namely, debugging distributed and complex systems---to my own mind.

What I've found I've put into a [book (pdf)](https://rescrv.net/engineering-schizophrenia.pdf) on engineering, my particular schizophrenic delusions, and how people who suffer as I once did can find a way through the fog to the other side.

This is not a healing memoir; it is a guide and a warning for all those who never stopped to ask, "What happens if my brain begins to fail me?"

I am writing because what I've found is not a destination, but a process. It is an ongoing process for me and for people like me. I also believe it is automate-able using the same techniques we apply to machine-based systems.

I am looking for others who recognize the stakes of the human mind to engage in discussion on the topic.

Happy hacking, Robert

Most consensus libraries (Raft, Paxos) treat the state machine as a pure black box. This is fine until your state machine needs to actually do something, like charge a credit card, fire a webhook, or send an email.

If a leader crashes after the side effect but before committing it, you get duplicates. This is my attempt at fixing this problem from first principles ish: build chr2 to make crash-safe side effects first-class citizens.

mechanism:

Replicated Outbox: Side effects are stored as "pending" in replicated state. Only the leader executes them under a fencing token.

Durable Fencing: A manifest persists the highest view using atomic tmp+fsync+rename. This ensures a "zombie" leader can't wake up and double-execute stale effects.

Deterministic Context: Application code receives a deterministic RNG seed and block_time from the log, ensuring 1:1 state transitions during replay.

Strict WAL: Entries are CRC’d and hash chained. it is designed to prefer halting on mid-log corruption over guessing.

The Trade-offs: Side effects are intentionally at-least-once; "exactly-once" requires stable effect IDs for sink-side deduplication. It’s a CP system safety over availability.

Repo: https://github.com/abokhalill/chr2

if you’ve ever had “exactly once” collapse the first time a leader died mid flight, you know exactly why I built this.

There's been a lot of discussion around the california budget and some proposed tax policies, so I asked claude code to research the budget and turn it into an interactive dashboard.

Using async subagents claude was able to research ~a dozen budget line items at once across multiple years, adding lots of helpful context and graphs to someone like me who was starting with little familiarity.

It still struggles with frontend changes, but for research this probably 20-40x's my throughput.

Let me know any additional data or visualizations that would be interesting to add!

Threw together this very specific proxy that allows the downstream to define which IP will be used for the proxied request, and has built-in rate limiting mechanism to coordinate upstream rate limiting across clients.

This is particularly useful when you have a proxy node with many IPs, and you either want to use a specific one, or rotate through them. It also helps prevent upstream rate limiting due to disjoint clients being unable to coordinate on rate limits.

Opus was largely able to one-shot each feature from my specs, which was pretty cool (shows how effective a spec is).

so you can start vibe-coding your ad-hoc terminal dashboard. With session replay and mouse click support built-in.

Ferrite: Fast Markdown/Text/Code editor in Rust with native Mermaid diagrams

Built a Markdown editor using Rust + egui. v0.2.1 just dropped with major Mermaid improvements:

→ Native Mermaid diagrams - Flowcharts, sequence, state, ER, git graphs - pure Rust, no JS

→ Split view - Raw + rendered side-by-side with sync scrolling

→ Syntax highlighting - 40+ languages with large file optimization

→ JSON/YAML/TOML tree viewer - Structured editing with expand/collapse

→ Git integration - File tree shows modified/staged/untracked status

Also: minimap, zen mode, auto-save, session restore, code folding indicators.

~15MB binary, instant startup. Windows/Linux/macOS.

GitHub: https://github.com/OlaProeis/Ferrite

v0.2.2 coming soon with performance improvements for large files. Looking for feedback!

While working on a proof of concept project, I kept hitting Claude's token limit 30-60 minutes into their 5-hour sessions. The accumulating context from the codebase was eating through tokens fast. So I built a language designed to be generated by AI rather than written by humans.

GlyphLang

GlyphLang replaces verbose keywords with symbols that tokenize more efficiently:

  # Python
  @app.route('/users/<id>')
  def get_user(id):
      user = db.query("SELECT * FROM users WHERE id = ?", id)
      return jsonify(user)

  # GlyphLang
  @ GET /users/:id {
    $ user = db.query("SELECT * FROM users WHERE id = ?", id)
    > user
  }

  @ = route, $ = variable, > = return. Initial benchmarks show ~45% fewer tokens than Python, ~63% fewer than Java.

Before anyone asks: no, this isn't APL with extra steps. APL, Perl, and Forth are symbol-heavy but optimized for mathematical notation, human terseness, or machine efficiency. GlyphLang is specifically optimized for how modern LLMs tokenize. It's designed to be generated by AI and reviewed by humans, not the other way around. That said, it's still readable enough to be written or tweaked if the occasion requires.

It's still a work in progress, but it's a usable language with a bytecode compiler, JIT, LSP, VS Code extension, PostgreSQL, WebSockets, async/await, generics.

Docs: https://glyphlang.dev/docs

GitHub: https://github.com/GlyphLang/GlyphLang

I was curious to see how some of the latest models behaved and played no limit texas holdem.

I built this website which allows you to:

Spectate: Watch different models play against each other.

Play: Create your own table and play hands against the agents directly.

The article explores the concept of worldview and how it shapes our understanding of the world. It discusses the importance of recognizing and challenging our own biases and perspectives to gain a more comprehensive and objective understanding of complex issues.

The article explores the life, crimes, and mysterious death of Jeffrey Epstein, a wealthy financier with connections to powerful individuals. It examines the allegations of sexual abuse and sex trafficking against Epstein, as well as the ongoing investigations and controversies surrounding his case.

Hi HN,

I ported the teaching OS xv6-riscv to HiFive Unmatched and got it running on real hardware, including passing usertests.

I've been self-studying OS internals using the MIT 6.1810 materials. After finishing most of the labs, I was eager to see what it's like to run the OS on bare metal, rather than QEMU.

The Unmatched may not have the latest RISC-V features, but it's well-documented, and the Rev B release has made it more affordable, which makes it a good learning platform.

The porting process involved several interesting challenges:

- Hardware Quirks: Handling things like enabling A/D bits in PTEs (the hardware doesn't set them automatically, causing page faults), proper handling of interrupts, and instruction cache synchronization.

- Boot Flow: xv6 expects M-mode on startup, but standard RISC-V boot flows (typically via OpenSBI) jump to S-mode. To bridge this gap, I created a minimal U-Boot FIT image that contains only the xv6 kernel. This way, U-Boot SPL handles the complex CPU/DDR initialization, then hands control to xv6 in M-mode (skipping OpenSBI).

- Drivers: Ported an SPI SD card driver, replacing the virtio disk driver.

I wrote up implementation notes here: https://github.com/eyengin/xv6-riscv-unmatched/blob/unmatche...

Hopefully, this is useful for others who are learning OS internals and want to try running their code on real RISC-V hardware.

I think LLMs are overused to summarise and underused to help us read deeper.

I built a system for Claude Code to browse 100 non-fiction books and find interesting connections between them.

I started out with a pipeline in stages, chaining together LLM calls to build up a context of the library. I was mainly getting back the insight that I was baking into the prompts, and the results weren't particularly surprising.

On a whim, I gave CC access to my debug CLI tools and found that it wiped the floor with that approach. It gave actually interesting results and required very little orchestration in comparison.

One of my favourite trail of excerpts goes from Jobs’ reality distortion field to Theranos’ fake demos, to Thiel on startup cults, to Hoffer on mass movement charlatans (https://trails.pieterma.es/trail/useful-lies/). A fun tendency is that Claude kept getting distracted by topics of secrecy, conspiracy, and hidden systems - as if the task itself summoned a Foucault’s Pendulum mindset.

Details:

* The books are picked from HN’s favourites (which I collected before: https://hnbooks.pieterma.es/).

* Chunks are indexed by topic using Gemini Flash Lite. The whole library cost about £10.

* Topics are organised into a tree structure using recursive Leiden partitioning and LLM labels. This gives a high-level sense of the themes.

* There are several ways to browse. The most useful are embedding similarity, topic tree siblings, and topics cooccurring within a chunk window.

* Everything is stored in SQLite and manipulated using a set of CLI tools.

I wrote more about the process here: https://pieterma.es/syntopic-reading-claude/

I’m curious if this way of reading resonates for anyone else - LLM-mediated or not.

I've always used benchmark.js for my benchmark tests, but I noticed that changing the tests order also changed the performance outcome. They were getting polluted between them somehow. V8 optimizations/deoptimizations maybe? I decided to take advantage of forking to do tests in completely separated processes with their own V8 instances, memory and so on, to avoid present and future optimization/deoptimization pollution.

Is my main benchmark library now (obviously), although not because "is mine", but because of the peace of mind. I've suffered the pollution one time and with this I avoid the paranoia in my head each time I do a benchmark: "will this maybe be polluted? let's reorder". And AI's help a lot to do some quick benchmarks without overthinking, like this example prompt:

Add a Buffer vs DataView benchmark using iso-bench. Read the npmjs iso-bench documentation including the Notes section.

If you are paranoid like me, well, here you have this tool.

GitHub: https://github.com/Llorx/iso-bench

TLDR: Librario is a book metadata API that aggregates data from Google Books, ISBNDB, and Hardcover into a single response, solving the problem of no single source having complete book information. It's currently pre-alpha, AGPL-licensed, and available to try now[0].

My wife and I have a personal library with around 1,800 books. I started working on a library management tool for us, but I quickly realized I needed a source of data for book information, and none of the solutions available provided all the data I needed. One might provide the series, the other might provide genres, and another might provide a good cover, but none provided everything.

So I started working on Librario, a book metadata aggregation API written in Go. It fetches information about books from multiple sources (Google Books, ISBNDB, Hardcover. Working on Goodreads and Anna's Archive next.), merges everything, and saves it all to a PostgreSQL database for future lookups. The idea is that the database gets stronger over time as more books are queried.

You can see an example response here[1], or try it yourself:

  curl -s -H 'Authorization: Bearer librario_ARbmrp1fjBpDywzhvrQcByA4sZ9pn7D5HEk0kmS34eqRcaujyt0enCZ' \
  'https://api.librario.dev/v1/book/9781328879943' | jq .
  

The merger is the heart of the service, and figuring out how to combine conflicting data from different sources was the hardest part. In the end I decided to use field-specific strategies which are quite naive, but work for now.

Each extractor has a priority, and results are sorted by that priority before merging. But priority alone isn't enough, so different fields need different treatment.

For example:

- Titles use a scoring system. I penalize titles containing parentheses or brackets because sources sometimes shove subtitles into the main title field. Overly long titles (80+ chars) also get penalized since they often contain edition information or other metadata that belongs elsewhere.

- Covers collect all candidate URLs, then a separate fetcher downloads and scores them by dimensions and quality. The best one gets stored locally and served from the server.

For most other fields (publisher, language, page count), I just take the first non-empty value by priority. Simple, but it works.

Recently added a caching layer[2] which sped things up nicely. I considered migrating from net/http to fiber at some point[3], but decided against it. Going outside the standard library felt wrong, and the migration didn't provide much in the end.

The database layer is being rewritten before v1.0[4]. I'll be honest: the original schema was written by AI, and while I tried to guide it in the right direction with SQLC[5] and good documentation, database design isn't my strong suit and I couldn't confidently vouch for the code. Rather than ship something I don't fully understand, I hired the developers from SourceHut[6] to rewrite it properly.

I've got a 5-month-old and we're still adjusting to their schedule, so development is slow. I've mentioned this project in a few HN threads before[7], so I’m pretty happy to finally have something people can try.

Code is AGPL and on SourceHut[8].

Feedback and patches[9] are very welcome :)

[0]: https://sr.ht/~pagina394/librario/

[1]: https://paste.sr.ht/~jamesponddotco/a6c3b1130133f384cffd25b3...

[2]: https://todo.sr.ht/~pagina394/librario/16

[3]: https://todo.sr.ht/~pagina394/librario/13

[4]: https://todo.sr.ht/~pagina394/librario/14

[5]: https://sqlc.dev

[6]: https://sourcehut.org/consultancy/

[7]: https://news.ycombinator.com/item?id=45419234

[8]: https://sr.ht/~pagina394/librario/

[9]: https://git.sr.ht/~pagina394/librario/tree/trunk/item/CONTRI...

The article describes the Mcp-CLI, a command-line interface tool for managing and deploying Apify cloud platform resources. It provides information on installing, configuring, and using the tool to perform various operations, such as deploying and managing actors, schedules, and datasets.

I've never posted on ShowHN before, but I wanted to share my Xmas 2025 project; to try a new approach to controlling our kids screen time.

This also involved massively over-engineering a solution in order to play with a shiny new gadget (and avoid the in laws at Christmas, obviously)

I've shared some learnings on AI coding with embedded devices, and how I approached the product design/hardware selection side of things.

The Web App is at https://screenie.org - and I'm Open Sourcing the device and web app code later today (links to follow on that site)

Hey all- I just released a New tab replacement Chrome extension that makes browsing a lot easier - it also solves many of the annoyances with browser tabs. It's called Yellopages and it's free. Hope you'll give it a try.

* Groups all tabs from same domain. Makes it simple to kill all your Gmail tabs in one click (or keep just one).

* Groups all tabs playing audio. Toggle the sound for each one.

* Single text search for open tabs, bookmarks, and browsing history.

* Groups all tabs with new notifications (e.g. emails, likes, posts, replies, etc.)

* One click to kill all tabs (e.g. you're sharing screen in Zoom). A second click brings them all back.

I'm a solo web developer and I'm hoping to build an audience with my work. More at: https://buymeacoffee.com/kawaicheung

Hi HN! I built VAM Seek because I was frustrated with 1D seek bars – you never know where you're going until you get there.

VAM Seek renders a 2D thumbnail grid next to your video. Click any cell to jump. All frame extraction happens client-side via canvas – no server processing, no pre-generated thumbnails.

- 15KB, zero dependencies - One-line integration - Works with any <video> element

Live demo: https://haasiy.main.jp/vam_web/deploy/lolipop/index.html

Would love feedback!

Hi All.

I made this as an fun intro to help people who have zero IBM mainframe experience and no access to a modern IBM mainframe (at least, not access to do whatever you want with it). I appreciate tips, suggestions and anything that might improve the experience for someone who has no idea of how those machines operate(d).

This is a small TailwindCSS alternative based on a css template literal. I was inspired by styled-components and EmotionCSS, which however do not work well with ViteJS and specifically Preact.

This provides a better experience than Tailwind, as you can use all CSS language features without learning new conventions while maintaining a per-component styling approach.

This also turns out to be more inspectable in the browser's dev-tools, as snippets are extracted as-is and are not fragmented across thousands of small classes.

I wanted something more optimized than other CSS-in-JS alternatives that generate CSS at runtime, so I created a ViteJS plugin for this. It extracts all style snippets, replaces them with classes like css-a1b2c3, and injects all the corresponding styles into a CSS file in place of an "@extracted-css" directive.

There is also a preact options hook that adds a custom "classList" attribute, which maps to clsx for easy class composition (similarly to VueJS, Svelte, etc.).

P.S. I know other frameworks exist, but I have really been enjoying using Preact for frontend development lately.

The article explores the development of a new solar-powered electric vehicle, highlighting its innovative design, impressive performance, and the potential impact it could have on the future of sustainable transportation.

Vibe is a platform that allows users to create and share interactive audio experiences. It provides tools for recording, editing, and publishing spatial audio content, enabling users to build immersive audio-based applications and experiences.

The article provides an introduction to the Marten, a .NET document database and event store built on top of PostgreSQL. Marten offers features such as document storage, event sourcing, and querying capabilities, making it a versatile choice for building modern .NET applications.

Inspired by TAWS. Built as a learning exercise.

Umaro is a mobile app that helps users manage their finances, set savings goals, and track their spending habits. The app provides personalized insights and recommendations to help users make informed financial decisions.

I deal with a lot of geometry stuff at work with computer vision and photogrammetry, which usually comes from the real world. It's seldom clean and neat, and I'm often trying to find a way to "make it nice" or "make it pretty". I've always struggled with what that really means formally.

That led me to shape regularization (a technique used in computational geometry to clean up geometric data). CGAL had implemented a few methods for that, but there are more ways to do it, which I thought were nice. Also I typically work in Python, so it was nice to have a pure Python library could handle this.

I struggled to get the first version working as a QP. At a high level most of these boil down to minimizing a cost A + B where A is the cost associated the geometry and goes up the more you move it, and B is the cost associated "niceness" or rather the constraints you impose, and goes down the more you impose them. Then you try and minimize A + B or rather HA + (1-H)B where H is a hyper-parameter that controls the relative importance of A and B.

I needed a Python implementation so started with the examples implemented in CGAL then added a couple more for snap and joint regularization and metric regularization.

I kept running into the same problem in large codebases: “temporary” code almost never gets removed. People add TODOs, FIXMEs, or quick hacks to hit a deadline, and six months later nobody remembers why they’re there or who owns them. They quietly turn into production bugs. I built a small CLI that treats those comments as time-bounded instead of permanent. You can attach an expiry date to a TODO in the code, and when the date passes, CI fails and points to exactly where the expired code lives. It works by: scanning comments across any language parsing structured annotations and optionally using git blame to infer who added them and when I tried to keep it simple and CI-friendly rather than tied to any particular language or linter. Here’s the repo if anyone wants to look at the implementation: https://github.com/jobin-404/debtbomb I’d love feedback from people who’ve dealt with long-lived “temporary” code in production.

I wanted to run markdown files like shell scripts. So I built an open source tool that lets you use a shebang to pipe them through Claude Code with full stdin/stdout support.

task.md:

    #!/usr/bin/env claude-run

    Analyze this codebase and summarize the architecture.

    chmod +x task.md

    ./task.md

A script that runs your tests and reports results (`run_tests.md`):

    #!/usr/bin/env claude-run --permission-mode bypassPermissions

    Run ./test/run_tests.sh and summarize what passed and failed.

    cat data.json | ./analyze.md > results.txt

    git log -10 | ./summarize.md

    ./generate.md | ./review.md > final.txt

    for f in logs/\*.txt; do

        cat "$f" | ./analyze.md >> summary.txt

    done

One thing we didn't expect is that these are more auditable (and shareable) than shell scripts. Install scripts like `curl -fsSL https://bun.com/install | bash` could become:

    `curl -fsSL https://bun.com/install.md | claude-run`

The (really cool) executable markdown idea and auditability examples are from Pete Koomen (@koomen on X). As Pete says: "Markdown feels increasingly important in a way I'm not sure most people have wrapped their heads around yet."

We implemented it and added Unix pipe semantics. Currently works with Claude Code - hoping to support other AI coding tools too. You can also route scripts through different cloud providers (AWS Bedrock, etc.) if you want separate billing for automated jobs.

GitHub: https://github.com/andisearch/claude-switcher

What workflows would you use this for?

Dota2.tools is a comprehensive website that provides a range of resources and tools for Dota 2 players, including hero guides, item builds, and gameplay analytics to help improve their in-game performance and strategy.