Show stories

I got DOOM running in KiCad by rendering it with PCB traces and footprints instead of pixels.

Walls are rendered as PCB_TRACK traces, and entities (enemies, items, player) are actual component footprints - SOT-23 for small items, SOIC-8 for decorations, QFP-64 for enemies and the player.

How I did it:

Started by patching DOOM's source code to extract vector data directly from the engine. Instead of trying to render 64,000 pixels (which would be impossibly slow), I grab the geometry DOOM already calculates internally - the drawsegs[] array for walls and vissprites[] for entities.

Added a field to the vissprite_t structure to capture entity types (MT_SHOTGUY, MT_PLAYER, etc.) during R_ProjectSprite(). This lets me map 150+ entity types to appropriate footprint categories.

The DOOM engine sends this vector data over a Unix socket to a Python plugin running in KiCad. The plugin pre-allocates pools of traces and footprints at startup, then just updates their positions each frame instead of creating/destroying objects. Calls pcbnew.Refresh() to update the display.

Runs at 10-25 FPS depending on hardware. The bottleneck is KiCad's refresh, not DOOM or the data transfer.

Also renders to an SDL window (for actual gameplay) and a Python wireframe window (for debugging), so you get three views running simultaneously.

Follow-up: ScopeDoom

After getting the wireframe renderer working, I wanted to push it somewhere more physical. Oscilloscopes in X-Y mode are vector displays - feed X coordinates to one channel, Y to the other. I didn't have a function generator, so I used my MacBook's headphone jack instead.

The sound card is just a dual-channel DAC at 44.1kHz. Wired 3.5mm jack → 1kΩ resistors → scope CH1 (X) and CH2 (Y). Reused the same vector extraction from KiDoom, but the Python script converts coordinates to ±1V range and streams them as audio samples.

Each wall becomes a wireframe box, the scope traces along each line. With ~7,000 points per frame at 44.1kHz, refresh rate is about 6 Hz - slow enough to be a slideshow, but level geometry is clearly recognizable. A 96kHz audio interface or analog scope would improve it significantly (digital scopes do sample-and-hold instead of continuous beam tracing).

Links:

KiDoom GitHub: https://github.com/MichaelAyles/KiDoom, writeup: https://www.mikeayles.com/#kidoom

ScopeDoom GitHub: https://github.com/MichaelAyles/ScopeDoom, writeup: https://www.mikeayles.com/#scopedoom

Hi HN! For the past bit we’ve been building Flowglad (https://flowglad.com) and can now feel it’s just gotten good enough to share with you all:

Repo: https://github.com/flowglad/flowglad

Demo video: https://www.youtube.com/watch?v=G6H0c1Cd2kU

Flowglad is a payment processor that you integrate without writing any glue code. Along with processing your payments, it tells you in real time the features and usage credit balances that your customers have available to you based on their billing state. The DX feels like React, because we wanted to bring the reactive programming paradigm to payments.

We make it easy to spin up full-fledged pricing models (including usage meters, feature gates and usage credit grants) in a few clicks. We schematize these pricing models into a pricing.yaml file that’s kinda like Terraform but for your pricing.

The result is a payments layer that AI coding agents have a substantially easier time one-shotting (for now the happiest path is a fullstack Typescript + React app).

Why we built this:

- After a decade of building on Stripe, we found it powerful but underopinionated. It left us doing a lot of rote work to set up fairly standard use cases - That meant more code to maintain, much of which is brittle because it crosses so many server-client boundaries - Not to mention choreographing the lifecycle of our business domain with the Stripe checkout flow and webhook event types, of which there are 250+ - Payments online has gotten complex - not just new pricing models for AI products, but also cross border sales tax, etc. You either need to handle significant chunks of it yourself, or sign up for and compose multiple services

This all feels unduly clunky, esp when compared to how easy other layers like hosting and databases have gotten in recent years.

These patterns haven’t changed much in a decade. And while coding agents can nail every other rote part of an app (auth, db, analytics), payments is the scariest to tab-tab-tab your way through. Because the the existing integration patterns are difficult to reason about, difficult to verify correctness, and absolutely mission critical.

Our beta version lets you:

- Spin up common pricing models in just a few clicks, and customize them as needed - Clone pricing models between testmode and live mode, and import / export via pricing.yaml - Check customer usage credits and feature access in real time on your backend and React frontend - Integrate without any DB schema changes - you reference your customers via your ids, and reference prices, products, features and usage meters via slugs that you define

We’re still early in our journey so would love your feedback and opinions. Billing has a lot of use cases, so if you see anything that you wish we supported, please let us know!

I built the first multi-agent OS where constitutional governance is architecturally enforced.

Agents literally cannot boot without cryptographically verified oath.

Try it: python scripts/research_yagya.py Code: kernel_impl.py lines 544-621

Challenge: Prove it wrong.

I read through the years about Bourdain's content on the defunct li.st service, but was never able to find an archive of it. A more thorough perusing of archive.org and a pointer from an Internet stranger led me to create this site. Cheers

Hi HN,

I built a WordPress plugin called Bandwidth Saver. It takes the images your site already has and serves them through Cloudflare R2 and Workers, which means zero egress fees and extremely low storage cost. The goal is to make image delivery fast and cheap without adding any of the complexity of traditional optimization plugins.

The idea is simple. WordPress keeps generating images normally. The plugin rewrites the URLs on the frontend so images are served from a Cloudflare Worker. On the first request, the Worker fetches the original image and stores it in R2. After that, Cloudflare’s edge serves the image from its global cache with no egress charges. There’s no need to preload or sync anything, and if something fails, the original image loads. That’s the entire system.

I built this because most image CDN plugins try to do everything: compression, resizing, AI transforms, asset management, custom dashboards, and monthly fees. That’s useful for some users, but it’s unnecessary for most sites that just want their existing media to load faster without breaking the bank. Bandwidth Saver focuses only on delivery, not transformations. It’s intentionally minimal.

There are two ways to use it. The plugin is completely free if you want to run your own Cloudflare Worker. I included the Worker code and the steps needed to deploy it. If you don’t want to deal with any Cloudflare setup, there’s a managed option for $2.99 per month that uses my Worker and my R2 bucket. I’m trying to keep it accessible while also covering operational costs.

The plugin works with any theme or builder and doesn’t modify the database. It only rewrites URLs on output. WordPress remains the system of record for all media. R2 simply becomes a cheap, durable cache layer backed by Cloudflare’s edge.

I’m especially interested in feedback about the approach. Does the fetch-on-first-request model make sense? Is the pricing fair for a plugin of this scope? Should I prioritize allowing users to connect their own R2 buckets or the managed service? And for those with experience in edge compute or CDNs, I would love thoughts on how to improve the Worker or the rewrite strategy.

Thanks for reading, happy to answer any questions.

Hey HN! Just for fun, I built an interactive Hacker News Simulator.

You can submit text posts and links, just like the real HN. But on HN Simulator, all of the comments are generated by LLMs + generate instantly.

The best way to use it (IMHO) is to submit a text post or a curl-able URL here: https://news.ysimulator.run/submit. You don't need an account to post.

When you do that, various prompts will be built from a library of commenter archetypes, moods, and shapes. The AI commenters will actually respond to your text post and/or submitted link.

I really wanted it to feel real, and I think the project mostly delivers on that. When I was developing it, I kept getting confused between which tab was the "real" HN and which was the simulator, and accidentally submitted some junk to HN. (Sorry dang and team – I did clean up after myself).

The app itself is built with Node + Express + Postgres, and all of the inference runs on Replicate.

Speaking of Replicate, they generously loaded me up with some free credits for the inference – so shoutout to the team there.

The most technically interesting part of the app is how the comments work. You can read more about it here, as well as explore all of the available archetypes, moods, and shapes that get combined into prompts: https://news.ysimulator.run/comments.html

I hope you all have as much fun playing with it as I did making it!

Hi all, I built a CLI tool that allows you to seamlessly install software from GitHub release assets, similar to how your system's package manager installs software.

It works by exploiting common patterns among GitHub releases across different open-source software such as naming conventions and file layouts to fetch proper release assets for your system and then downloading the proper asset onto your machine via the GitHub API. Parm will then extract the files, find the proper binaries, and then add them to your PATH. Parm can also check for updates and uninstall software, and otherwise manages the entire lifecycle of all software installed by Parm.

Parm is not meant to replace your system's package manager. It is instead meant as an alternative method to install prebuilt software off of GitHub in a more centralized and simpler way.

It's currently in a pre-release stage, and there's a lot of features I want to add. I'm currently working (very slowly) on some new features, so if this sounds interesting to you, check it out! It's completely free and open-source and is currently released for Linux/macOS. I would appreciate any feedback.

Link: https://github.com/yhoundz/parm

I built OCR Arena as a free playground for the community to compare leading foundation VLMs and open-source OCR models side-by-side.

Upload any doc, measure accuracy, and (optionally) vote for the models on a public leaderboard.

It currently has Gemini 3, dots.ocr, DeepSeek, GPT5, olmOCR 2, Qwen, and a few others. If there's any others you'd like included, let me know!

Hi everyone,

I built a small web tool called Datamorph because I kept running into JSON/CSV converters that either broke with nested data, required login, or added weird formatting.

Datamorph is a minimal, fast, no-login tool that can:

• Convert JSON → CSV and CSV → JSON • Auto-detect structure (arrays, nested objects, mixed data) • Handle uploads or manual text input • Beautify / fix invalid JSON • Give clean, flat CSV output for real-world messy data

It’s built with React + Supabase + serverless functions. Everything runs client-side except file parsing, so nothing is stored.

I know there are many similar tools, but I tried focusing on:

• better handling of nested JSON, • simpler UI, • zero ads / zero login, • instant conversion without waiting.

Would love feedback on edge cases it fails on, or features you think would make this actually useful for devs and analysts.

Live tool: https://datamorphio.vercel.app/

Thanks for checking it out!

Adama is an open-source platform that enables developers to build, deploy, and manage AI applications. The platform provides tools and services to help streamline the AI development lifecycle, from model training to deployment and monitoring.

Inspired by All Text in NYC (https://alltext.nyc) by Yufeng Zhang I thought I would replicate something similar for London.

A searchable tool that lets you explore text captured across Google Street View imagery in London; shop signs, posters, graffiti, van numbers etc

Easy to use, portable app to play midi music files on all flavours of Microsoft Windows.

Brief Background - Used midi playback way back in the days of Windows 95 for some fun and entertaining apps, but as Windows progressed, it seemed their midi support (for Win32 anyway) regressed in both startup speed and reliability. Midi playback used to be near instant on Windows 95, but on later versions of Windows this was delayed to about 5-7 seconds. And reliability became somewhat patchy. This made working with midi a real headache.

Cynthia was built to test and enjoy midi music once again. It's taken over a year of solid coding, recoding, testing, re-testing, and a lot more testing, and some hair pulling along the way, but finally Cynthia works pretty solidly on Windows now.

Some of Cynthia's Key Features: * 25 built-in sample midis on a virtual disk - play right out-of-the box * Play Modes: Once, Repeat One, Repeat All, All Once, Random * Play ".mid", ".midi" and ".rmi" midi files in 0 and 1 formats * Realtime track data indicators, channel output volume indicators with peak hold, 128 note usage indicators * Volume Bars to display realtime average volume and bass volume levels * Use an Xbox Controller to control Cynthia's main functions * Large list capacity for handling thousands of midi files * Switch between up to 10 midi playback devices in realtime * Playback through a single midi device, or multiple simultaneous midi devices with lag and channel output support * Custom built midi playback engine for high playback stability * Custom built codebase for low-level work to GUI level * Also runs on Linux/Mac (including apple silicon) via Wine * Smart Source Code - compiles in Borland Delphi 3 and Lazarus 2 * MIT License

YouTube Video of Cynthia playing a midi: https://youtu.be/IDEOQUboTvQ

GitHub Repo: https://github.com/blaiz2023/Cynthia

The article discusses the migration from Voyage Embedding to a more modern embedding solution, highlighting the challenges, considerations, and the overall process undertaken to ensure a smooth transition for the company's product and its users.

I made a free tool that stuns LLMs with invisible Unicode characters.

*Use cases:* Anti-plagiarism, text obfuscation against LLM scrapers, or just for fun!

Even just one word's worth of “gibberified” text is enough to block most LLMs from responding coherently.

A fun toy memory allocator (not thread safe, that's a future TODO). I also wanted to explain how I approached it, so I also wrote a tutorial blog post (~20 minute read) covering the code which you can find the link to in the README.

I’ve been working on a Rust implementation of UTCP, a vendor-neutral protocol for LLM tool calling. The goal is to avoid every model/vendor defining its own schema and instead make tool ↔ model interoperability predictable and boring. What works:

- Full UTCP message parse/serialize - Strongly typed request/response model - Transport-agnostic (stdin/stdout, HTTP, WS, anything) - Minimal dependencies, straightforward API

Still to do:

- Validation helpers - Higher-level client/server wrappers - More real-world examples

Repo: https://github.com/universal-tool-calling-protocol/rs-utcp

Feedback + contributions welcome!

I built an open-source malware detection daemon that monitors all running processes in real-time using ML + heuristics. No kernel modules or eBPF required.

Key points:

- Polls /proc for new processes (works on any Linux kernel 2.6+)

- Random Forest model trained on EMBER 2018 dataset (2.3M samples)

- Heuristic rules for crypto miners, ransomware, rootkits

- ~20MB RAM, <1% CPU, sub-millisecond scan latency

- Pure C, zero runtime dependencies

- Model embedded directly in binary (50KB)

Why I built this: Existing solutions either require modern kernels (eBPF) or are heavy/proprietary. I wanted something lightweight that works everywhere - servers, containers, old distros.

Detection approach: Extract features from executables (entropy, imports, sections), run ML prediction, apply heuristic rules, combine scores. If above threshold, kill the process.

Happy to discuss implementation details or Linux security in general.

I’ve been working on a small experimental eBPF/XDP-based firewall written in Rust (using Aya). It’s not a full IPS and not an antivirus — it’s a packet-level reputation engine for learning purposes.

What it currently does

Rust + eBPF (XDP) packet inspection

Per-IP risk scoring (0–1000)

Detects:

Port scans: SYN/FIN/NULL/XMAS

TTL variance (possible spoofing)

Burst traffic patterns (DoS-like)

ICMP misuse and oversized payloads

Malformed packets

Bloom filter blocklist (up to 400k entries)

LRU map tracking port access timing

Auto-blocking on critical risk

Tarpit behavior on high-risk IPs

Why I built it

I wanted to learn:

Rust in kernel-level constraints

How XDP works internally

Practical heuristics for lightweight threat detection

Efficient state tracking inside eBPF maps

What it is NOT

Not production-ready

Not a malware scanner

Not a Suricata/Snort alternative

Looking for feedback

Particularly interested in:

Map design improvements

Heuristic tuning

Performance considerations

Ideas to avoid false positives

Repo: https://github.com/N1ghttm4r33/Antivirus/tree/main

This article explores the concept of a 4D camera, which would capture images in four dimensions (three spatial dimensions and one time dimension), allowing viewers to experience scenes from different perspectives and time frames. The article discusses the potential applications and technical challenges of developing such a camera.

Too often I find myself being lazy with commit messages. But I don't want AI to write them for me... only i truly know why i wrote the code i did.

So why don't i get AI to help me get that into words from my head?

That's what i built: smartcommit asks you questions about your changes, then helps you articulate what you already know into a proper commit message. Captures the what, how, and why.

Built this after repeatedly being confused 6 months in a project as to why i made the change i had made...

Would love feedback!

I'm the main developer behind vHPC, a SLURM HPC cluster in a docker compose.

As part of my job, I'm working on a software solution that needs to interact with one of the largest Italian HPC clusters (Cineca Leonardo, 270 PFLOPS). Of course developing on the production system was out of question, as it would have led to unbearably long feedback loops. I thus started looking around for existing containerised solutions, which were always lacking some key ingredient in order to suitably mock our target system (accounting, MPI, out of date software, ...).

I thus decided that it was worth it to make my own virtual cluster from scratch, learning a thing or two about SLURM in the process. Even though it satisfies the particular needs of the project I'm working on, I tried to keep vHPC as simple and versatile as possible.

I proposed the company to open source it, and as of this morning (CET) vHPC is FLOSS for others to use and tweak. I am around to answer any question.

SafeShare is a tiny web app + bookmarklets that remove tracking params (utm_, gclid, fbclid, etc.) and unwrap common redirects – all locally in the browser (no accounts, no servers).

• What it does: clean URLs, unwrap t.co/google redirectors, team whitelist for allowed params. • How it works: client-only JS, PWA + service worker; no network calls to our servers. • Try it: https://j-ai-71.github.io/Supersystem/quickstart.html • Feedback welcome (edge cases, params/redirectors to add).

Hi HN — we've built a testing framework for Supabase that spins up fast, isolated Postgres databases for each test case. It’s designed to make RLS policies easy to validate with real database state, without global test fixtures or mock auth.

Features: - Instant isolated Postgres DBs per test - Automatic rollback after each test - RLS-native testing with `.setContext()` for auth simulation - Flexible seeding (SQL, CSV, JSON, JS) - Works with Jest, Mocha, and any async test runner - CI-friendly (runs cleanly in GitHub Actions)

We also published example projects and a free set of tutorials: https://launchql.com/learn/supabase

Package: https://www.npmjs.com/package/supabase-test

Source + full test suite: https://github.com/launchql/supabase-test-suite

Happy to answer questions and get feedback, cheers :)

I've been recreating the original MacPaint in the browser on and off for a few years. It's still alpha quality, but I'm finally ready to share it more widely.

The goal was pixel-perfect accuracy, so I spent a lot of time with Atkinson's original QuickDraw source code, emulators, and my iBook G3 to get details like font rendering and the shape tools exactly right.

Some technical notes:

- Font rendering was surprisingly tricky; understanding the original pipeline's quirks took lots of experimentation, and avoiding canvas smoothing/aliasing required careful handling.

- Written declaratively with React; performance is kept reasonable with a buffer pool and copy-on-write semantics. - You can share links to artwork from within the UI.

E.g.: https://zenpaint.org/#p=KQumBQ5x

- Mobile support was not considered here (for obvious reasons). It might still be usable on a larger phone or tablet but I have not tested this at all.

There's something magical about making art within MacPaint's constraints: the 1-bit graphics, the limited resolution, the peculiar set of tools that still feel surprisingly expressive.

Still some rough edges and missing features, but I'd love feedback from anyone who remembers the original.

I built a live interactive map that shows where top AI companies hire around the world. I collected this data for a hackathon project. Many ATS providers have a public API that you can hit with the slug of the companies to get open jobs. The hardest part was finding the companies. I tried Firecrawl but it returned around 200 companies per provider which wasn’t enough for me. Then, I tried SERPAPI but it was expensive. I ended up using SearXNG to discover companies by ATS type and fetch their job postings. This produced a large dataset of 200k+ jobs (I only use a subset as it would have taken too much time processing). A few days ago, I decided to build a visualization of the data as I didn’t know what to do with it and wanted people to benefit.

I kept catching myself wanting to ask simple questions like “show only research roles in Europe” or “filter for remote SWE positions” (and had plenty of free ai credits) so I added a small LLM interface that translates natural language into filters on the map.

The map is built with Vite + React + Mapbox. Live demo: https://map.stapply.ai GitHub (data): https://github.com/stapply-ai/jobs

Would love feedback, ideas for improvement, or contributions.

This started as a reaction to a conversational trope. Despite being a tranquil place, even conversations at my yoga studio often start with, "Can you believe what's going on right now?" with that angry/scared undertone.

I'm a news avoider, so I usually feel some smug self-satisfaction in those instances, but I wondered if there was a way to satisfy the urge to doomscroll without the anxiety.

My hypothesis: Apply a 40-year latency buffer. You get the intellectual stimulation of "Big Events" without the fog of war, because you know the world didn't end.

40 years creates a mirror between the Reagan Era and today. The parallels include celebrity populism, Cold War tensions (Soviets vs. Russia), and inflation economics.

The system ingests raw newspaper scans and uses a multi-step LLM pipeline to generate the daily edition:

OCR & Ingestion: Converts raw pixels to text.

Scoring: Grades events on metrics like Dramatic Irony and Name Recognition to surface stories that are interesting with hindsight. For example, a dry business blurb about Steve Jobs leaving Apple scores highly because the future context creates a narrative arc.

Objective Fact Extraction: Extracts a list of discrete, verifiable facts from the raw text.

Generation: Uses those extracted facts as the ground truth to write new headlines and story summaries.

I expected a zen experience. Instead, I got an entertaining docudrama. Historical events are surprisingly compelling when serialized over weeks.

For example, on Oct 7, 1985, Palestinian hijackers took over the cruise ship Achille Lauro. Reading this on a delay in 2025, the story unfolded over weeks: first they threw an American in a wheelchair overboard, then US fighter jets forced the escape plane to land, leading to a military standoff between US Navy SEALs and the Italian Air Force. Unbelievably, the US backed down, but the later diplomatic fallout led the Italian Prime Minister to resign.

It hits the dopamine receptors of the news cycle, but with the comfort of a known outcome.

Stack: React, Node.js (Caskada for the LLM pipeline orchestration), Gemini for OCR/Scoring.

Link: https://forty.news (No signup required, it's only if you want the stories emailed to you daily/weekly)

If you've ever worked in a large company, you've probably encountered "shadow infrastructure": scripts nobody understands or custom connectors written once and never touched again. This glue layer isn't documented, isn't owned by anyone, and tends to break when systems are upgraded or someone leaves. It's also the part everybody dreads working on, because it's hard to understand, painful to work with, and full of unknown unknowns.

We built superglue so that engineers stop wasting time on deciphering legacy APIs and documentation.

superglue ingests existing glue code, SQL, configs, docs, OpenAPI specs and reverse-engineers what the system is actually doing. It then maps dependencies and regenerates everything as clean javascript code that can run directly or be exposed via MCP or SDK. It also monitors API changes and schema drift, and automatically repairs integrations when upstream systems change.

In short: It turns legacy integrations into code you can easily understand, test, and update. So that engineers can do more exciting feature work, and companies can migrate and upgrade systems faster.

Think of it as: a context engine + code generator + integration runtime for legacy glue.

What we'd love feedback on

- How do you deal with "nobody knows what this script does" situations?

- What would you want to know about your legacy systems?

OSS/community version: https://github.com/superglue-ai/superglue

More info: https://superglue.ai

Happy to go deeper on the technical details.

Hi HN, creator of Wealthfolio here.

A year ago, I posted the first version. Since then, the app has matured significantly with two major updates:

1. Multi-platform Support: Now available on Mobile (iOS), Desktop (macOS, Windows, Linux), and as a Self-hosted Docker image. (Android coming soon).

2. Addons System: We added explicit support for extensions so you can hack around, vibe code your own integrations, and customize the app to fit your needs.

The core philosophy remains the same: Always private, transparent, and open source.

friend and i were curious what's actually involved in email verification services like usebouncer.com. turns out the basics aren't that complicated.

vibe coded a simple npm package in (mostly) one shot that does:

- syntax validation

- mx record lookup

- smtp mailbox check (without sending emails)

- catch-all domain detection

  npx email-reachable user@example.com

works as a library too:

  import { verifyEmail } from 'email-reachable'
  const result = await verifyEmail('user@example.com')