Show stories

Paste in my prompt to Claude Code with an embedded API key for accessing my public readonly SQL+vector database, and you have a state-of-the-art research tool over Hacker News, arXiv, LessWrong, and dozens of other high-quality public commons sites. Claude whips up the monster SQL queries that safely run on my machine, to answer your most nuanced questions.

There's also an Alerts functionality, where you can just ask Claude to submit a SQL query as an alert, and you'll be emailed when the ultra nuanced criteria is met (and the output changes). Like I want to know when somebody posts about "estrogen" in a psychoactive context, or enough biology metaphors when talking about building infrastructure.

Currently have embedded: posts: 1.4M / 4.6M comments: 15.6M / 38M That's with Voyage-3.5-lite. And you can do amazing compositional vector search, like search @FTX_crisis - (@guilt_tone - @guilt_topic) to find writing that was about the FTX crisis and distinctly without guilty tones, but that can mention "guilt".

I can embed everything and all the other sources for cheap, I just literally don't have the money.

I built a visual editor that represents Excel formulas as blocks, making it easier to inspect, refactor, and reason about complex formulas structurally. Frockly is not an Excel replacement. It focuses on understanding and refactoring formulas before bringing them back to Excel. Demo: https://ryuu12358.github.io/Frockly/ GitHub: https://github.com/ryuu12358/Frockly Write-up: https://note.com/ryuu12358/n/naa65d9d5facd （Japanese）

https://fwsgonzo.medium.com/notes-on-libloong-loongarch-64-b...

I built an open-source org management platform for Star Citizen, a space MMO where player orgs can have 50K+ members managing fleets worth millions.

https://scorg.org

The problem: SC's official tools won't launch until 2026, but players need to coordinate now - track 100+ ship fleets, schedule ops across timezones, manage alliances, and monitor voice activity during battles.

Interesting challenges solved:

1. Multi-org data isolation - Users join multiple orgs, so every query needs scoping.

2. Canvas + Firebase Storage CORS - Couldn't export fleet layouts as PNG. Solution: fetch images as blobs, convert to base64 data URLs, then draw to canvas. No CORS config needed.

3. Discord bot - Built 4 microservices (VoiceActivityTracker, EventNotifier, ChannelManager, RoleSync) sharing Firebase state. Auto-creates channels for ops, cleans up when done.

Features: role-based access, event calendar with RSVP, LFG matchmaking, drag-and-drop fleet builder, economy tools, alliance system, analytics dashboard, mobile-responsive.

~15 pages, fully functional. Custom military-inspired UI (monospace, gold accents).

Community, All the HN belong to you. This is an archive of hacker news that fits in your browser. When I made HN Made of Primes I realized I could probably do this offline sqlite/wasm thing with the whole GBs of archive. The whole dataset. So I tried it, and this is it. Have Hacker News on your device.

Go to this repo (https://github.com/DOSAYGO-STUDIO/HackerBook): you can download it. Big Query -> ETL -> npx serve docs - that's it. 20 years of HN arguments and beauty, can be yours forever. So they'll never die. Ever. It's the unkillable static archive of HN and it's your hands. That's my Year End gift to you all. Thank you for a wonderful year, have happy and wonderful 2026. make something of it.

I’m building a Unicode reference where each symbol has its own dev-friendly page with all relevant encodings.

Example: [https://fontgenerator.design/symbol/almost-equal-to](https://fontgenerator.design/symbol/almost-equal-to)

Includes Unicode, HTML, CSS, JS, UTF-8/16 bytes, URL encoding, and usage examples.

The same structure is used across thousands of symbols (math, arrows, currency, tech/UI, punctuation).

Built because existing references are fragmented. Feedback welcome.

I’m a student and I built this because my old lightning controller (DMX) became a brick after the vendor’s control software was deprecated in 2025.

My focus was entirely on developing a robust backend architecture to guarantee maximum performance. Everything is released under GPLv3.

The current frontend is just a "vibecoded" dashboard made with plain HTML and JavaScript to keep rendering latency as low as possible. In earlier versions Svelte was used. Svelte added too much complexity for an initial mvp.

Video: https://streamable.com/95kd4r Repo: https://github.com/Arian-Ott/hyperion

Technical Details: The system uses a distributed architecture where a FastAPI server manages the state in a Redis. State changes are pushed via WebSockets to Raspberry Pi gateways, which then independently maintain the constant 44Hz binary stream to the lights. This "push model" saves massive amounts of bandwidth and ensures low latency. In a stress test, I processed 10 universes (5,120 channels) at 44Hz with zero packet loss (simulated). An OTP-based pairing makes the setup extremely simple (plug-and-play).

I’m looking forward to your feedback on the architecture and the Redis approach!

Happy New Year!

Hello,

Circuit Artist is a game about drawing digital circuits as pixel art — like MS Paint, but pixels are wires and little triangles are NANDs. Hit play and the simulation runs in real time. It's fully white-box: every wire's state is visible.

I launched it last year with a unit-delay simulation that ran until convergence on each update. It worked, but I realized it had some fundamental problems:

(i) It hid what was actually happening. Players couldn't tell the difference between a ripple carry adder and a look-ahead adder — everything just resolved instantly.

(ii) Design bugs became "game bugs." When players had non-converging wires (like A = not(A)), the game couldn't explain why or where the error was.

(iii) Layout didn't matter. A NAND on one side of the map would instantly propagate to the opposite side, making spatial decisions meaningless. Unit delay probably works better for schematic-based simulators like Logisim, not a layout-focused game like this.

(iv) Propagation visualization couldn't be added on top of the unit-delay engine — there was no notion of direction or distance.

So I rebuilt the engine with variable-delay event-based simulation using an adaptation of Elmore delay. The delay for each wire depends on distance and fanout — longer wires are slower, higher fanout adds delay, branching wires are faster.

For the implementation: I compute Elmore delay over wire trees. Each pixel has resistance and capacitance, with NAND inputs as nodes to account for fanout. For non-tree wire graphs, I build a Dijkstra-based spanning tree (driver as root) and interpolate for edges outside the tree. I calculate the delay for each node and project it back to the image so every pixel has a distance.

This lets me animate propagation with a glow effect during simulation. The shader knows when each wire was triggered, the current time, and the Elmore distance of each pixel, so it resolves state per-pixel in real time.

On top of that:

- Time rewind: the simulation is now delta-based, so players can freeze and scrub backwards to debug. Super useful for cyclic circuits.

- Layers: since timing matters now, I added up to 3 layers. NANDs only go on the bottom layer, upper layers propagate faster (lower capacitance). Lets you route wires above dense NAND areas.

The game has a campaign for learning from scratch, though it's still incomplete and in progress. I'm working toward Steam Workshop support so people can create their own campaigns to teach different concepts or cover more advanced topics.

GitHub (full source): https://github.com/lets-all-be-stupid-forever/circuit-artist

Steam: https://store.steampowered.com/app/3139580/Circuit_Artist/

The article introduces a lazy image loading technique using the Intersection Observer API, which efficiently loads images only when they are about to become visible on the user's screen, improving page load times and user experience.

Hi HN,

I’m the developer behind Eimi (https://eimi.tech/).

The Problem: I found myself constantly distracted. I wanted to learn new words and keep up with specific news, but every time I opened an app, I ended up doomscrolling for 20 minutes. The signal-to-noise ratio was too low.

The Solution: I built Eimi to "calm down" my consumption. It’s a card-based app that delivers content depends on your personal needs. Instead of an infinite feed, you get curated highly customizable cards.

Use Cases:

Language Learning: Instead of flashcards without context, it generates cards with usage examples for words I'm trying to learn.

News/Market Watch: I hook up my interests (e.g., tech news, specific stocks), and it generates a summary card. No clickbait, just the gist.

It's currently in Public Beta. I’d love to hear your thoughts on the UX and what other "card types" you’d find useful.

Thanks!

Hey HN, I built this because the generational gap online is getting wider (and weirder). It’s an LLM-wrapper that translates "Boomer" (normal/corporate English) into "Brainrot" (Gen Alpha slang) and vice versa. It also has an "Image-to-Rot" feature that uses vision to describe uploaded images in slang. It’s mostly for fun, but actually kind of useful for deciphering what your younger cousins are saying. Would love to hear what you think!

I got tired of Claude Code forgetting all my context every time I open a new session: set-up decisions, how I like my margins, decision history. etc.

We built a shared memory layer you can drop in as a Claude Code Skill. It’s basically a tiny memory DB with recall that remembers your sessions. Not magic. Not AGI. Just state.

Install in Claude Code:

  /plugin marketplace add https://github.com/mutable-state-inc/ensue-skill
  /plugin install ensue-memory
  # restart Claude Code

What it doesn’t do: - it won’t read your mind - it’s alpha; it might break if you throw a couch at it

Repo: https://github.com/mutable-state-inc/ensue-skill

If you try it and it sucks, tell me why so I can fix it. Don't be kind, tia

Hi HN —

Tidy Baby is a new game made by me and Wyna Liu (of NYT Connections!) that is inspired by the legendary card-based game SET that we assume many of you love (we too love SET).

In SET, you’ve got four dimensions: shape, number, color, and shading, each with three variants.

In Tidy Baby you only have to deal with three dimensions:

- word length (3, 4, or 5 letters) - part of speech (noun, verb, or adjective) - style (bold, underline, or italic)

Like in SET, you are trying to form sets of three cards where, along each dimension, the set is either all the same or all different. If you’ve never played SET there are more details/examples at “how to play” in the game.

The mechanics of Tidy Baby are sort of inspired by a solitaire/practice version of SET I sometimes play where you draw two random cards and have to name the third card that would make a valid set.

In Tidy Baby you are presented with two “game cards” and a grid of up to nine candidates to complete a valid set – your job is to pick the right one before the clock runs out.

Unlike in SET, you get points for “partial” sets where your set is valid on one or two dimensions (but not all three). It’s actually a pretty fun challenge to try to get only sets that are invalid along all three dimensions.

In building the game, we were sort of surprised that the biggest challenge was ensuring that all words were unambiguously one part of speech. You’d be surprised how hard it is to find three-letter adjectives that are not also common verbs or nouns. We did our best!

We’ve got three “paces” in the game: Steady, Strenuous, and Grueling (s/o MECC!)

Let us know what you think!

I used the time over Christmas and in between the years to redesign my website.

This time I decided to make it in the theme of an evil Sith Lord that commands the Galactic Cookie Empire, because I found my previous cookie consent game a bit boring after a while.

Here's the website's welcome page and the cookie consent game: https://cookie.engineer/index.html

(the cookie consent game isn't started on any other page of my website, only on the welcome page)

I also made a "making of" weblog article series, in case you're interested in the development process and how I implemented it and what kind of troubles I went through already:

- Making of the Game: https://cookie.engineer/weblog/articles/making-of-my-website...

- Making of the Avatar: https://cookie.engineer/weblog/articles/making-of-my-website...

- Debuggers to toy around with: https://cookie.engineer/design/consent/index.html

It "should" work on modern browsers. I tested it on Firefox on Linuxes, Chrome/Chromium on Linuxes, and Safari on Macbook. Don't have an iPhone so I can't test that, but my two old Android phones were also working fine with the meta viewport hack (I can't believe this is still the "modern" way to do things after 15 years. Wtf).

Best experience is of course with a bigger display. On smaller screen sizes, the game will use a camera to zoom around the game world and follow the player's spaceship. Minimum window width is 1280 pixels for no camera, and I think 800 pixels to be playable (otherwise the avatar gets in the way too much in the boss fights).

Oh, there's also a secret boss fight that you can unlock when you toy around with the Dev Tools :)

What's left to do on the avatar animation side:

- I have to backport CMUdict to JavaScript / ECMAScript. That's what I'm working on right now, as I'm not yet satisfied with the timings of the phonemes. Existing tools and pipelines that do this in python aren't realtime, which leads to my next point.

- I want to switch to using the "waveform energy detection" and a zero cross rate detector to time phonemes more correctly. I believe that changes in waveforms and their structures can detect differences in phonemes, but it's a gut feeling and not a scientific fact. Existing phoneme animation papers were kind of shit and broken (see my making of article 2). The phoneme boundary detector is highly experimental though and is gonna need a couple weeks more time until it's finished.

That's it for now, hope you gonna enjoy your stay on my website and I hope you gonna have fun playing the Cookie Consent Game :)

Oh, also, because it might not be obvious: No LLMs were used in the making of this website. Pretty much everything is hand-coded, and unbundled and unminified on purpose so visitors can learn from the code if they want to.

~Cookie

Hi HN,

Every year, we ask thousands of readers (and authors) to share their 3 favorite reads of the year.

Now you can enter a book/author you love and see what books readers loved who also loved that book/author.

Try it here: https://shepherd.com/bboy/2025

This goes wide and doesn't try to limit itself to the genre, so you get some interesting results.

What do you think?

Background:

I want better recommendations based on my reading history. I'm incredibly frustrated with what is out there.

This system is based on 5,000 readers voting on their 3 favorite reads from 2023 to 2025. So, this covers ~15,000 books and is a high-quality vote. We wanted to keep the dataset small for now while we play with approaches.

We are building a full Book DNA app that pulls in your Goodreads history and delivers deeply personalized book recommendations based on people who like similar books (a significant challenge).

You can sign up to beta test it here if you want to help me with that:

https://docs.google.com/forms/d/1VOm8XOMU0ygMSTSKi9F0nExnGwo...

The first beta is coming out in late January, but it's pretty basic to start.

Past Show HNs as we've built Shepherd:

https://news.ycombinator.com/item?id=40084193

https://news.ycombinator.com/item?id=38600246

https://news.ycombinator.com/item?id=26871660

Thanks, looking forward to your comments :)

Ben

TL;DR explanation (go to https://github.com/Sakura-sx/Aroma?tab=readme-ov-file#tldr-e... if you want the formatted version)

This is done by measuring the minimum TCP RTT (client.socket.tcpi_min_rtt) seen and the smoothed TCP RTT (client.socket.tcpi_rtt). I am getting this data by using Fastly Custom VCL, they get this data from the Linux kernel (struct tcp_info -> tcpi_min_rtt and tcpi_rtt). I am using Fastly for the Demo since they have PoPs all around the world and they expose TCP socket data to me.

The score is calculated by doing tcpi_min_rtt/tcpi_rtt. It's simple but it's what worked best for this with the data Fastly gives me. Based on my testing, 1-0.7 is normal, 0.7-0.3 is normal if the connection is somewhat unstable (WiFi, mobile data, satellite...), 0.3-0.1 is low and may be a proxy, anything lower than 0.1 is flagged as TCP proxy by the current code.

Airbnb is missing out on the biggest rental opportunity of 2026 so I built the solution.

Need to open Microsoft Teams and your other favorite Electron app? Get a temporary increase of memory

16 GB ought to be enough for everybody but in case it's not, you can rent more

Hi HN, We wanted to celebrate the new year so we built this little toy. Enjoy it and happy new year!

P.S. If you want, take a look at our product (now in early access) - userjam.com

I've been working on a little open source [1] search engine, nilch. I noticed that nearly all well known search engines, including the alternative ones, tend to be run by companies of various sizes with the goal to make money, so they either fill your results with ads or charge you money, and I dislike this because search is the backbone of the internet and should not be commercial, so it runs in a not-for-profit style and aims to survive on donations. Additionally I'm personally really sick of AI in my search results so I got rid of that, and I wanted DuckDuckGo bangs so it supports all of them. Like many alternative search engines, it is fully private.

Sadly, it currently does not have its own index but rather uses the Brave search API. Once I'm in a financial position that it's possible, I would absolutely love to build a completely new index from the ground up which is open source, as well as an open source ranking and search algorithm, to back it.

I posted on Reddit and got an amazing amount of feedback which I implemented a number of feature requests, so I would really like your ideas, critiques, and bug reports as well. Thank you and sorry for the long post!

[1] https://github.com/UnmappedStack/nilch

How small can a language model be while still doing something useful? I wanted to find out, and had some spare time over the holidays.

Z80-μLM is a character-level language model with 2-bit quantized weights ({-2,-1,0,+1}) that runs on a Z80 with 64KB RAM. The entire thing: inference, weights, chat UI, it all fits in a 40KB .COM file that you can run in a CP/M emulator and hopefully even real hardware!

It won't write your emails, but it can be trained to play a stripped down version of 20 Questions, and is sometimes able to maintain the illusion of having simple but terse conversations with a distinct personality.

--

The extreme constraints nerd-sniped me and forced interesting trade-offs: trigram hashing (typo-tolerant, loses word order), 16-bit integer math, and some careful massaging of the training data meant I could keep the examples 'interesting'.

The key was quantization-aware training that accurately models the inference code limitations. The training loop runs both float and integer-quantized forward passes in parallel, scoring the model on how well its knowledge survives quantization. The weights are progressively pushed toward the 2-bit grid using straight-through estimators, with overflow penalties matching the Z80's 16-bit accumulator limits. By the end of training, the model has already adapted to its constraints, so no post-hoc quantization collapse.

Eventually I ended up spending a few dollars on Claude API to generate 20 questions data (see examples/guess/GUESS.COM), I hope Anthropic won't send me a C&D for distilling their model against the ToS ;P

But anyway, happy code-golf season everybody :)

The article discusses the creation of the BrainKernel project, which aims to develop an open-source, cross-platform, deep learning framework for brain-computer interface applications. The project focuses on building a modular and scalable system to facilitate research and development in the field of brain-computer interfaces.

This article discusses the importance of implementing a safety net for AI language models like Claude, which can help prevent unintended behaviors or outputs. It highlights key considerations, such as model oversight, prompt engineering, and the need for comprehensive testing and monitoring.

A small web puzzle game where you guess coordinates in n-dimensional space. Tutorial and manual are available. Available in 17 languages.

Play here: https://euclidle.com/ Note: Google Analytics and AdSense are used.

Tutorial: https://docs.euclidle.com/en/tutorial.html Manual: https://docs.euclidle.com/en/manual.html

Bluesky: https://bsky.app/profile/euclidle.com

I work with perfetto traces for ML/GPU optimization a lot. Copy pasting trace info to LLM is not easy. As usually the traces are gzip compressed, have very large file sizes. Also there is no way to select a certain section and sending it to LLM easily (can maybe write a query to do this but not ergonomic). So vibe coded this tool to quickly select the kernels/slices/threads I want to ask about and one click to get a text/json/markdown in my clipboard to paste for LLMs.

I think an MCP server for this might also be useful (tried a few but all miss certain things i wanted so chose to just build this quickly)

Spacelist is an open-source project that allows users to create interactive lists and dashboards. It provides a lightweight and customizable platform for organizing and visualizing information, making it useful for project management, task tracking, and data presentation.

The article discusses the LLMRouter, a tool that enables efficient routing and management of large language models (LLMs) on modern hardware. It highlights the LLMRouter's ability to optimize model execution and resource utilization, improving performance and scalability for large-scale AI applications.

OP here.

Most Deep Learning approaches for TSP rely on pre-training with large-scale datasets. I wanted to see if a solver could learn "on the fly" for a specific instance without any priors from other problems.

I built a solver using PPO that learns from scratch per instance. It achieved a 1.66% gap on TSPLIB d1291 in about 5.6 hours on a single A100.

The Core Idea: My hypothesis was that while optimal solutions are mostly composed of 'minimum edges' (nearest neighbors), the actual difficulty comes from a small number of 'exception edges' outside of that local scope.

Instead of pre-training, I designed an inductive bias based on the topological/geometric structure of these exception edges. The agent receives guides on which edges are likely promising based on micro/macro structures, and PPO fills in the gaps through trial and error.

It is interesting to see RL reach this level without a dataset. I have open-sourced the code and a Colab notebook for anyone who wants to verify the results or tinker with the 'exception edge' hypothesis.

Code & Colab: https://github.com/jivaprime/TSP_exception-edge

Happy to answer any questions about the geometric priors or the PPO implementation!

It's almost New Year's and here's an original way to show the countdown using Tetris. I'm sure something similar has been done before, but I had a lot of fun building this (TDD style) using Claude Code.

After New Year's it can also function as a regular clock:

https://tetris-time.koenvangilst.nl/

For the impatient, it's possible to increase the speed using url parameters:

https://tetris-time.koenvangilst.nl/?to=2025-12-31T23:00:00....