Show stories

OP here.

I took the unofficial IKEA US dataset (originally scraped by jeffreyszhou) and converted all 30,511 products into a flat, markdown-like protocol called CommerceTXT.

The goal: See if a flatter structure is more efficient for LLM context windows.

The results: - Size: 30k products across 632 categories. - Efficiency: The text version uses ~24% fewer tokens (3.6M saved total) compared to the equivalent minified JSON. - Structure: Files are organized in folders (e.g. /products/category/), which helps with testing hierarchical retrieval routers.

The link goes to the dataset on Hugging Face which has the full benchmarks.

Parser code is here: https://github.com/commercetxt/commercetxt

Happy to answer questions about the conversion logic!

Hi HN,

I built DevicePrint after running into problems with duplicate accounts and unreliable cookies in my own projects.

DevicePrint is a lightweight device fingerprinting tool designed for developers. It helps identify devices across sessions without relying on cookies.

Use cases include fraud detection, preventing duplicate signups, and security-sensitive workflows.

I'd really appreciate feedback — especially around privacy concerns or edge cases you’ve run into.

Link: https://deviceprint.io

Author here.

I started seapie as a reaction to pdb's command-driven interface in 2019. I wanted a breakpoint to simply mean 'open a Python REPL here', with debugging functionality layered on top instead of replacing the REPL.

`seapie.breakpoint()` opens a working `>>>` REPL at the current execution state. Any changes to variables or function definitions persist. Debugger state is exposed via built-ins (e.g. `_magic_`), and stepping/frame control/etc is handled via small `!commands`.

I've been using this regularly in my own work for a few years now. Happy to answer questions or hear criticism, especially from people who've used debuggers heavily.

Shellock is an open-source project that provides a simple and lightweight web server written in Rust. It aims to be a secure, fast, and scalable alternative to traditional web servers, making it suitable for a wide range of applications and environments.

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

The article describes a Node.js library called 'stream-unzip' that provides a simple and efficient way to unzip large files while streaming the data, reducing memory usage and enabling real-time processing of the unzipped content.

The article discusses the potential of large language models (LLMs) in programming, including their ability to generate code, explain concepts, and even act as an interactive programming companion. It explores the opportunities and challenges of using LLMs for software development tasks.

A fun game for playing moral dilemmas with friends. I gave 12 AI agents zodiac personalities (not that I believe in them) using the same LLM with different personality prompts.

Most neovim users will be familiar with flash.nvim, which amongst other things, allows you to quickly jump to a word in your visible buffer. It’s a great tool for developers who want to quickly navigate their codebase.

I was looking for something similar, but for tmux. I wanted to be able to search visible words in the current tmux pane, then copy that word to the system clipboard by pressing the associated label key.

I built https://github.com/Kristijan/flash-copy.tmux, with the aim to bring that functionality to tmux.

Here’s a bit of a write up https://blog.kristijan.org/posts/TMUX-Flash-Copy for those interested. I welcome any 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 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.

Startup time is ~10ms with Zig, which is why I built this small CLI tool for Claude Code that shows context usage, git branch, and model info in the status line.

The original JavaScript version took ~143ms to start. Reducing this to ~10ms matters since the tool runs frequently during editor use.

Built this over the weekend to bridge the gap between "can hum a melody" and "can code algorithmic music patterns" (Strudel/TidalCycles) for live coding and live dj'ing.

What it does:

Real-time pitch detection in browser using multiple algorithms: CREPE (deep learning model via TensorFlow.js) YIN (autocorrelation-based fundamental frequency estimation) FFT with harmonic product spectrum AMDF (average magnitude difference function) Outputs: visual piano roll, MIDI files, Strudel/TidalCycles code All client-side, nothing leaves your machine Why multiple algorithms: Different pitch detection approaches work better for different inputs. CREPE is most accurate but computationally expensive; YIN is fast and works well for clean monophonic input; FFT/HPS handles harmonic-rich sounds; AMDF is lightweight. Let users switch based on their use case.

Technical details:

React, runs entirely in browser via Web Audio API Canvas-based visualization with real-time waveform rendering

The original problem: I wanted to learn live coding but had zero music theory. This makes it trivial to capture melodic ideas and immediately use them in pattern-based music systems.

Try it: https://dioptre.github.io/tidal/

Works best on desktop. Will work more like a Digital Audio Workbench (DAW).

Source: https://github.com/dioptre/tidal

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!

I've always found raw SEC filings painful to parse, so I built a site to make institutional holding data more accessible and visual.

I recently updated the data to analyze the peter thiel stock portfolio (tracking Founders Fund and associated vehicles) for Q3 2025. It's interesting to see the divergence from standard tech indices—heavy on defense/hard tech and very little consumer SaaS.

You can see the visualization here: https://www.13radar.com/guru/peter-thiel

Would love any feedback on the UI or suggestions on other metrics I should calculate from the 13F data.

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...

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).

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!

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.

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.

Little tool that I made to understand how (un)reasonable my prompts are.

The Thiele Machine is a formally verified universal computational model the surpasses Turing machines in key ways. It's fully proven in Coq (including kernel theorems and universality containment), features a python implementation for simulation and includes hardware designs in Verilog for potential FPGA/ASIC builds. The core idea: a paradigm shift using μ-bits for stricter computation under real-world constraints, tying into physics (e.g., Noether’s theorem) and emergence in chaotic systems.

The repo includes a 13-chapter thesis (PDF and sources), proofs, and tools for exploration. It’s aimed at formal methods enthusiasts, AI researchers, and hardware devs interested in verifiable, adaptive reasoning beyond traditional limits. Feedback welcome on the proofs, emergence chapter, or hardware impl, let’s collaborate!

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!

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

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.

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

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?

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.