Show HN for May 3, 2026

Hi HN,

I built a RISC-V emulator that implements the RV32IM instruction set and a minimal syscall interface to run DOOM. A few weeks ago, I got my first output with a simple hello world assembly program.

Since then I have been working tirelessly to get DOOM to run.

I needed to figure out how to run C programs first, and came across newlib, which allows the underlying environment to implement the syscall stubs one by one until the programs run.

I have also added ELF loading, but currently only a single `PT_LOAD` segment is supported.

To port DOOM, I used doomgeneric, which was quite convenient to get working once the required stubs were in place.

DOOM renders to a fixed area in memory (0x705FDD = VRAM_START):

  0x7FFFFF  +-------------------------------------+
            |                                     |
            |        QUEUE_SIZE (32 bytes)        |
            |                                     |
  0x7FFFDF  +-------------------------------------+ <-- QUEUE_START
  0x7FFFDE  |          QUEUE_READ_IDX             |
  0x7FFFDD  |          QUEUE_WRITE_IDX            |
            +-------------------------------------+
            |                                     |
            |                                     |
            |       VRAM (1,024,000 bytes)        |
            |                                     |
            |                                     |
  0x705FDD  +-------------------------------------+ <-- STACK_START
            |                Stack                |
            |                  |                  |
            |                  v                  |
            |                                     |
            |                  ^                  |
            |                  |                  |
            |         Program data + Heap         |
            |                                     |
  0x000000  +-------------------------------------+

I made a small linker script so that the entry point of a C program is at _start and virtual address is always 0. That kept the ELF loader code simple.

Inputs are written to the queue by rvcore which are then intercepted by DOOM running inside it.

Demo link: https://www.youtube.com/watch?v=f5uygzEmdLw

Hey HN community,

I built a tool that helps optimize your post for hitting the first page of Show HN.

How it works: I used a Hugging Face dataset of all Hacker News posts from the past 3 years and trained a model that predicts how successful your post might be. There's still a lot of randomness on HN, so nothing is guaranteed, but the tool helps optimize your post for higher odds.

A couple of interesting findings:

- GitHub repo links work x3 better than regular domains - Open-source tools have a steady virality rate (13.9% - one of the highest) - "I built" outperforms "We built" - Using parentheses and mentioning technologies (Lua, Postgres, Rust, etc.) helps a ton.

You can try the tool at wannalaunch.com or read the blog posts for more insights from the analysis. The model is also available as open source if you want to retrain it or look under the hood.

Happy to hear the feedback!

I just published my first book, Means and Motive. ( https://www.amazon.com/dp/B0GYCZJVGX )

As a software engineer, I approached writing like a software project. I used familiar tools (Emacs and HTML) for the primary writing.

I built my own tool (EPublish) to transform the HTML manuscript into an .epub file, the source for the ebook version. And I wrote shell scripts to reliably and repeatably transform the .epub version into PDF files for the printed editions.

I wrote 'design' and 'architecture' docs, describing the world, key actors, and timelines. I kept a task list of chapters and key scenes that needed to be written, in priority order. Along the way, I kept my files version-controlled so I could see the progress of the novel and edit mercilessly, without worrying about keeping old text around in backup files should I want it back for some reason.

If you've thought about writing a book, I highly recommend it. There are many similarities to the software engineering process. You'll also gain a newfound appreciation of the design, layout, and typesetting world, exactly how much work goes into each book you read.

Hello HN,

This is my first Show HN and hopefully a fun one for y'all.

Parrot is a web app for easily recording throwaway audio clips. It was originally intended for pronunciation practice but may find other uses.

I got the idea to work on Parrot after reading the Launch HN of Issen [1]. Thinking about ways to help language learners improve their pronunciation, I remembered an easy method I've humbled myself with in the past: listening to a recording of my own voice.

The idea is to repeatedly record and listen to yourself, adjusting your pronunciation until you get it right. What makes Parrot different from other audio recording apps is that it doesn't save a log of all these throwaway audio clips that you then have to clean up. A recording only exists until it is overwritten by a new one (all "offline" and strictly local to your own device, of course).

That seems like a scant premise to justify making a whole new app, but that small change really makes a big difference for this use case. Though I'm not sure I would have made it if that was the only reason; more of a practical excuse.

The main reason was for stupid fun. Once I imagined this music gear-like device I knew I wanted to actually make it, in all its skeuomorphic glory (only missing is the wooden table).

I don't want to spoil all the fun bits, so play around and see for yourself :)

On dark mode being too dark and "unusable": that's an intentional joke. Do try it if you haven't!

Tech-wise it's rather basic: a bit of HTML, lots of CSS, some plain JS. The difficulty was in getting all the details dialed in. My biggest takeaway:

Surprise surprise, testing and QA are so important! The number of embarrassing bugs and flaws I would have missed had I not tested across all browsers and platforms is surprisingly high. The most basic things you assume to be true might very well not be! (`audio.currentTime = 0.0;` sets audio's play head to the beginning, right? Not in Firefox it doesn't!) I 110% recommend manual testing at various points in development: some things you have to experience for yourself.

My hosted version of Parrot is not Free, but there's a GPL'd version with personal touches removed available to download [2]. Inside the tarball is also a standalone version, fully contained in a single HTML file (for use without localhost).

I'll conclude on a personal insight. Listening to recorded audio of your voice can help improve your speech (or singing!), yes. It also gets you used to the sound of your own voice, which I've found helps build confidence.

Happy to discuss :)

[1] https://news.ycombinator.com/item?id=44387828

[2] https://www.zkhrv.com/parrot/free-parrot.tar.xz

A small site created to see the hell world example in many different languages. I got tired of sites which only showed 10-30 languages. I'm sure there are some inaccuracies (some languages are not I languages per se).

Have fun with the disk defragmenter.

I've been running Pi using SmolVM to build SmolVM!

SmolVM provides an abstraction over microVMs to easily create sandboxes for coding agents, OpenClaw, or just to build a custom harness.

To use it, install using: curl -sSL https://celesto.ai/install.sh | bash

and then run: smolvm pi start

I built Enoch after working with OpenClaw and trying to get an agentic coding system setup with Codex. In the past, I was trying to manually generate, code, and test this all manually. Then - I figured I'd try to start automation. Too many times have I typed "Continue" and gone back to my work. I figured I could automate that. Well - Enoch is what stemmed from that.

My first implementations were a mess with OpenClaw. I'll spare you the details. I moved to n8n. n8n was not bad but it felt like I had to strong arm it to do what I wanted. Had issues, but less.

Then this system - LangGraph / FastAPI... it has been working pretty well. The papers generated seem to have meaning. Generation of ideas have shown to have some positive substance. All ideas are grounded on a basis of pass / fail or positive / negative - based on criteria set on idea generation.

I will spare you too much reading.

Disclaimer: Yes, I used Codex to help code and Claude for some verbiage. I am not new to coding but I know there is a huge stigma in the business for this AI coding assistance bits. AI has helped to allow me dump my ideas down to a worker - and not have to take the time to sit and learn to code to get ideas out. Democratized software could have a grand effect.

Sup HN,

So a couple of months ago I posted my OSINT app ShadowBroker here and got WAY more attention than I expected. Some of the feedback was brutal, but honestly, a lot of it was right, and it made the project a lot better.

And sure, I had a blast tracking billionaire jets and yachts or discovering GPS jamming in Ukraine was a thrill, and so was watching CCTV feeds from London, along with ships, satellites, conflict zones, etc., but eventually it dawned on me…where does my OSINT dashboard actually go from there? What good is all of the telemetry if people cannot communicate with each other about it, and it was just something that sat in my Docker container?

I let the notion stew for a while, and eventually the idea of an OSINT dashboard started mutating into something more. I started thinking about utility. What usefulness could telemetry like this have? What lanes were underdeveloped in this space? Soon the angle became more clear. P2P obfuscated communication.

I began to gravitate towards the possibility that the app could be designed to pseudonymously communicate over Tor or Reticulum in Reddit like groups or in rooms with rules and governance dictated by code. Then another notion hit...what if people off-grid using Meshtastic could communicate halfway across the world? What if you could DM those off-grid devices and they could relay messages back to civilization? What if the whole thing was tied to telemetry on and off the grid?

What about letting agents like Openclaw or whatever are peoples favorite agents communicate with you and use their analytical capabilities to find correlations in the data that slip through human analysis?

That's where this stopped being "just an OSINT map" and turned into something like a decentralized intelligence protocol.

So I started building something on top of ShadowBroker called InfoNet. It's in testnet right now. The short version is that it's an experimental mesh with the long-term goal of eventually becoming a protocol that combines communication with fact checking and rewards it where information is incentivized to be anchored to verifiable reality instead of whoever has the most money, status, institutional power, or just the loudest voice.

Some of this is working, some of it is scaffolding, and a lot of it still needs tons of hardening.

If you want to see what an AI agent can do with the telemetry, the recommended setup is letting OpenClaw/Hermes, or whatever agent you use install the repo locally. You can connect to a remote instance, too, but its responses will be insanely slow. The hope here is that by giving agents all of this telemetry they would also

I would like to stress that it is absolutely not production safe. I do not trust it yet. Neither should anyone else.

Right now, the Dead Drop lane is the strongest privacy path. Gate chat is still experimental and not truly private. I'd rather be honest about that because fake privacy claims are worse than no privacy at all.

The governance side is where it gets weird.

I started adding prediction market telemetry as a reputation engine…what if reputation came from choosing outcomes correctly?

I honestly have no idea if this works.

There are a million ways this can go wrong…spam, Sybil attacks, fake confidence, bad incentives, privacy theater, gaming prediction market outcomes, or even people gaming the reputation layer itself. I'm trying to build enough of the system to see where it breaks, and specifically whether reputation makes Sybil behavior less useful or just moves the attack surface somewhere else.

There is a very real chance I'm just building cyberpunk infrastructure gone off the rails in public.

Maybe. It is still experimental and rough around the edges.

But I'd genuinely love brutal criticism from people who have thought deeply about game theory, distributed systems, privacy, and trust networks, because I know there are holes in this thinking I haven't seen yet.

A match made in heaven ;-)

Hey HN! I've been working on this for the past few months and I think it's at the point where I'm ready for some user feedback.

It's a WASM engine attempting to accurately model all of MTG's rules and cards. AFAIK, this is the first MTG engine which tries to accomplish this by live compiling the entire card collection at runtime, instead of coding each individual card.

You can create your own unique cards to playtest against ("Compile Card" button is what you're looking for), as long as they follow the engine's supported grammar (which I'm working on so that it fully supports Magic's ~30k legally playable cards, currently at 23k partially/17k fully supported).

It also supports 4-way P2P multiplayer lobbies via PeerJS, though I haven't had enough time to test everything network related so there may be some hidden bugs there!

My dev process was heavily influenced by the recent surge in agentic coding, but I think I've settled on an architecture which successfully manages to avoid slop creeping in:

Each card from its original, normalized oracle text into a CardDefinition struct which contains every single behavior for that particular card. By the time this card definition is compiled, we no longer have access to the original oracle text.

Each effect in the card's compiled definition can be decompiled into human readable text, after which a series of normalization steps based on the AST structure of the card's compilation and a post-pass to cleanup awkward wording is applied. The resulting compiled oracle text is compared against the original card's using vector embeddings, which gives us a semantic similarity score.

The entire purpose of this development workflow is making it obvious to the AI which cards are working correctly and which ones still need better support, without having to rely on behavioral tests for every single card. It took me some time until I finally managed to get the architecture to the point where the AI doesn't cheat its way into improving the card coverage, but the whole experience has been a fantastic way of getting used to this new way of coding and I'm excited to see how the future of our profession looks like in a few years.

I'm looking for any kind of feedback, both UI/UX and engine related, so please share your thoughts!

An idle clicker where you don't really click a cookie. Check the repo for more info ;)

Glucera will be a blood glucose viewer for iPhone and Apple Watch. No account, no subscription, no cloud. One-time $2.99 (or maybe free).

Reads from HealthKit and pairs with the Bluetooth enabled Glucose Meters that don't roll their own crypto/weird standard. (standard GATT Glucose Profile). Data never leaves the device. No analytics SDKs, no third parties.

Not a CGM app — Libre and Dexcom users won't get value here. Those ecosystems already have decent native apps, and Libre's protocol is closed to third parties anyway..

Built for fingerstick users.

Looking for beta testers :)

I build a raspberry pico rp2040 synth named LISA which relies on a live dynamic wavetables approach to build a sound from low-speed signals.

It has up to 6 voices, it proposes the BRAIDS macro-oscillators, exposing +40 differents sound engines, and it adds an additional experimental engine where the wavetables are created by an async brain, named Nallely. Nallely is a small modular environment coded in Python which runs on a raspberry pi and is built for exploring emergent behaviors. You program it by patching independent autonomous modules together.

How does it works? The brain generates signals which are streamed via MIDI (via pitchwheel on 4 different channels for 14bits resolution) at slow speed in 4 different circular wavetables of the synth. LISA lets you play while the wavetables are constantly rewritten in real-time. The brain execution model is a fully async hybrid actor model based on independent threads. No global clock or synchronization is enforced. Consequently, because of the CPU load, temperature, OS scheduler, network,... and message passing, the modules constantly drift unpredictibly, either lightly, or harshly depending on the topology of your patch. The signals that are produced by Nallely can be used as waveform for the wavetables, as notes sequences, or as CV equivalent, there is no distinction in what signals represent, the topology of the patch determines what will be the final piece.

In the demo video, I just built an harmonic oscillator using 2 integrators patched in feedback, which is fed to one of the wavetables. This oscillator is then connected to other modules to derive other wavetables and functions which are patched in the other wavetables and the synth parameters.

https://www.youtube.com/watch?v=fxvfnqQKWsY

LISA firmware is written in C/C++ and runs on rp2040, while Nallely is written purely in Python, and can run on a Raspberry Pi. Nallely have been successfully tested on a rpi zero2, a rpi3, and a rpi5.

You don't have to use Nallely to use LISA, it's a standalone MIDI synth, and you don't have to use LISA to use Nallely, it's a generic modular brain which happens to speak MIDI, but LISA coupled with Nallely become the Fodongo synth: a synth that lets you sculpt your wavetables in real-time.

I'm just starting to experiment with this and I try to explore what can be done with slow cv-rate signals feeding wavetables to create sounds. So far I can get a nice variety of sounds, from very pure sine if using LFOs, to very harsh drifting phasing sawtooth sound, or massive organ-like sounds.

It fits well for drone, especially using the envelope: the release can go up to 5s, emphasizing all the micro-drifts and variations in the wavetables, sounds overlap, changes, fades, etc.

LISA and Nallely are free open-source projects:

Nallely: https://github.com/dr-schlange/nallely-midi LISA: https://github.com/dr-schlange/LISA

I created a simple project to allow you to use a phone as a web proxy. This is not a proxy for the phone, its a way to proxy web traffic from elsewhere via the phone. One practical use case is accessing geo-restricted content. If you have a trusted contact in the country with an Android phone, this can serve as a simple alternative to a commercial VPN.

To set it up you need to run a proxy server which can run as a docker container. You then need to install the app on the Android phone which will connect to the server. Finally you configure a browser to use the proxy server as the HTTP/HTTPS proxy.

More details here: https://github.com/vgaj/proxy#mobile-phone-proxy

Let me know how you go and if you run into any issues.

Hey HN, my name is Tom and I'm the founder of Svix. We've been working on Diom (https://diom.com) for the last 6 months, and I'm excited to finally share it on HN!

Diom is a single Rust binary that replaces Redis, RabbitMQ, Kafka, and a lot of custom code for many common use-cases. It's open-source, self-contained, and has no external runtime dependencies.

While building Svix, we had to reimplement the same backend primitives that everyone reimplements when building a service: robust caching, rate-limiting, idempotency, and more. We also constantly felt the tension between building something custom on top of existing infra (like Redis and Postgres) and adding more dedicated services (like RabbitMQ and Kafka) which we would then need to configure, operate, back up, and maintain. This was even worse for us because Svix is open-source, so additional infrastructure meant additional burden on our customers.

Six months ago we finally decided to build Diom. It's a self-contained open-source service that people can run in their infrastructure with a focus on developer experience and ease of operation. It manages its own storage using fjall (a fast LSM-tree-based storage similar to RocksDB) and therefore requires no external runtime dependencies (no redis/postgres/kafka/etc), and supports running as a single node or a highly-available Raft based cluster.

The goal is for Diom to replace Redis, RabbitMQ, Kafka, and a lot of custom code for most use-cases, by offering pre-built implementations for common backend primitives. It currently supports cache, key-value, idempotency, rate-limiting, queues, and streams. We also plan on adding auth-tokens, distributed settings, feature flags, and other common components; as well as adding more functionality to existing components.

The closest existing project is probably NATS with JetStream, which is also a single self-contained binary with KV, streams, and queues. One of the main differences is that Diom ships higher-level primitives like idempotency, rate limiting, and cache as first-class APIs, rather than something you build on top of KV and streams.

Diom favors ease of operation over scale, so it doesn't match Kafka-level throughput or very high QPS like Redis and Dragonfly. However, most products and developers don't process multiple terabytes and billions of events per second anyway. That said, Diom can still hit high performance for its target use-cases as it implements higher-level primitives rather than basic operations. Additionally, because the primitives live in the same process as the storage, there are fewer network round-trips, which keeps latency low.

It uses HTTP/2 with msgpack as the wire protocol (works fine from browsers), and ships a CLI and SDKs for Python, TypeScript, Rust, Go, and Java, with more on the way.

We have Svix fully ported to Diom and continuously running tests and simulated workloads in one of our staging environments. GA (general availability) is planned for later this year, once we've moved Svix production workloads over.

Repo (MIT licensed): https://github.com/svix/diom

Docs: https://docs.diom.com

Live playground: https://diom.com/playground

I'm excited to finally share Diom, and would love to hear what everyone thinks, if you find it useful, and what other components we should build! Would also love help figuring out what to call this. We currently say "component platform," but I'm not a fan of the name.

Free tool to discover possibly forgotten subdomains with issued certificates.

Some domains might need to get submitted in a few repeated attempts, since the public CT logs registries are very overloaded, and Tidelock is trying to pick the most accessible one, without caching anything, so the provided report is always up-to-date with live information.

I will be grateful for any feedback regarding this tool, or in general any SSL/DNS related tools you would appreciate in your daily work.

HI HN!

First time poster here, but I feel that my product is finally ready to showcase to HN. Me and my team built an amazing privacy tool that uses computer vision to analyze, detect, and hide sensitive data in photos or videos. It detects the identifiable visual data (faces, license plates, tattoos, phone numbers, etc.) and applies a blur effect over them to remove them from sight automatically!

Right now it only works on faces, we are working to add license plates but the biggest milestone for us has been video support. We just added it and even though it is getting better and improving it is a huge step forward, as it is about 1000x harder than processing an image.

We are currently searching for concrete PMF with business and creator niches, but we would love any feedback the community can provide!

We made it 100% anonymous, with no personal data required for signup, in memory processing only, and zero photos and videos stored! Privacy is our focus. Just create a password and your account will be created!