Show stories

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 —

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

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.

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.

Cuecard.dev is an open-source web application that provides a modern, user-friendly interface for managing and organizing personal notes, tasks, and other information. The platform offers features like note-taking, task management, and integration with popular productivity tools.

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

Every Claude Code session starts fresh. You re-explain your project structure, build commands, and conventions. Every. Single. Time.

I built cck to solve this. Two modes:

*1. CLAUDE.md Generation* ```bash git clone https://github.com/takawasi/claude-context-keeper && cd claude-context-keeper && pip install . cck sync ``` Scans your codebase, generates CLAUDE.md. Claude reads it at session start.

*2. Per-Turn Context Injection (the real power)* ```bash cck setup --cb-style cck watch --with-history & cck hook install --use-history ``` This tracks every file change in SQLite and injects recent changes on every turn: ``` [CCK] Recent changes: 15:23:45 ~ src/main.py 15:22:30 + src/utils/helper.py 15:20:12 ~ tests/test_main.py ```

Claude sees exactly what you just edited. No more "I just changed X" explanations.

Built from 300+ Claude Code sessions. Zero AI calls, pure static analysis.

GitHub: https://github.com/takawasi/claude-context-keeper

Hey HN! I’m Gui from deco (decocms.com). We’ve been using this tool internally as the foundation for a few customer AI platforms, and today we’re open-sourcing it as MCP Mesh.

MCP is quickly becoming the standard for agentic systems, but… once you go past a couple servers it turns into the same problems for every team:

- M×N config sprawl (every client wired to every server, each with its own JSON + ports + retries) - Token + tool bloat (dumping tool definitions into every prompt doesn’t scale) - Credentials + blast radius (tokens scattered across clients, hard to audit, hard to revoke) - No single place to debug (latency, errors, “what tool did it call, with what params?”)

MCP Mesh sits between MCP clients and MCP servers and collapses that mess into one production endpoint you can actually operate.

What it does:

- One endpoint for Cursor / Claude / VS Code / custom agents → all MCP traffic routes through the mesh - RBAC + policies + audit trails at the control plane (multi-tenant org/workspace/project scoping) - Full observability with OpenTelemetry (traces, errors, latency, cost attribution) - Runtime strategies as “gateways” to deal with tool bloat: Full-context (small toolsets), Smart selection (narrow toolset before execution), Code execution (load tools on-demand / run code in a sandbox) - Token vault + OAuth support, proxying remote servers without spraying secrets into every client - MCP Apps + Bindings so apps can target capability contracts and you can swap MCP providers without rewriting everything

A small but surprisingly useful thing: the UI shows every call, input/output, who ran it, and lets you replay calls. This ended up being our “Wireshark for MCP” during real workflows.

It’s open-source + self-hosted (run locally with SQLite; Postgres or Supabase for prod).

You can start with `npx @decocms/mesh` or clone + run with Bun.

We’d love your feedback!

Links below:

Repo: https://github.com/decocms/mesh

Landing: https://www.decocms.com/mcp-mesh

Blog post: https://www.decocms.com/blog/post/mcp-mesh

edit: layout

Hey HN, we’re Avi, Kiet, and Satya. We’re building Superset, an open-source terminal made for managing a bunch of coding agents (Claude Code, Codex, etc) in parallel.

- Superset makes it easy to spin up git worktrees and automatically setup your environment

- Agents and terminal tabs are isolated to worktrees, preventing conflicts

- Built-in hooks [0] to notify when your coding agents are done/needs attention,

- A diff viewer to review the changes and make PRs quickly

We’re three engineers who’ve built and maintained large codebases, and kept wanting to work on as many features in parallel as possible. Git worktrees [1] have been a useful solution for this task but they’re annoying to spin up and manage. We started superset as a tool that uses the best practices we’ve discovered running parallel agents.

Here is a demo video:

https://www.youtube.com/watch?v=pHJhKFX2S-4

We all use Superset to build Superset, and it more than doubles our productivity (you’ll be able to tell from the autoupdates). We have many friends using it over their IDE of choice or replacing their terminals with Superset, and it seems to stick because they can keep using whatever CLI agent or tool they want while Superset just augments their existing set of tools.

Superset is written predominantly in Typescript and based on Electron, xterm.js, and node-pty. We chose xterm+node-pty because it's a proven way to run real PTYs in a desktop app (used by VSCode and Hyper), and Electron lets us ship fast. Next, we’re exploring features like running worktrees in cloud VMs to offload local resources, context sharing between agents, and a top-level orchestration agent for managing many worktrees or projects at once.

We’ve learned a lot building this: making a good terminal is more complex than you’d think, and terminal and git defaults aren’t universal (svn vs git, weird shell setups, complex monorepos, etc.).

Building a product for yourself is way faster and quite fun. It's early days, but we’d love you to try Superset across all your CLI tools and environments, we welcome your feedback! :)

[0] https://code.claude.com/docs/en/hooks

[1] https://git-scm.com/docs/git-worktree

It's a a long puzzle, somewhat akin to a 2000 piece jigsaw puzzle. Solving it collectively with others is encouraged.

If you are the sort that likes rules, the rules are you can use Google or whatever external sources you like for help. View page source, however, is cheating.

Hat tip to Octagon and the TND crew for help in play testing and proposing categories.

I got frustrated with every financial calculator requiring an email before showing results. So I built alternatives. 28 calculators - retirement, FIRE, compound interest, rent vs buy, debt payoff, etc. Everything runs client-side. No data tracking - full privacy.

I built an modular MCP server that lets AI control a Flipper Zero.

The basic idea: you tell Claude "write a BadUSB script that opens a rickroll" and it generates the DuckyScript, validates it, saves it to your Flipper, and can execute it.

I've launched the project with 14 MCP tools across 4 modules:

1. BadUSB: generate/validate/save/diff/execute DuckyScript from natural language

2. Music: create and load FMF files to be played over the Flipper's piezo speaker ("make me the theme song to Castlevania")

3. System: device info, SD card status, connection health

4. Connection: health checks, reconnect

...the code is modular so you can create your own modules.

To me, the interesting technical bit is the WiFi support. Flipper's protobuf RPC is designed to work over USB serial. The stock WiFi dev board firmware is for debugging, not RPC.

I wrote custom ESP32-S2 firmware, a TCP <-> UART bridge that exposes the full RPC interface over your network. It includes a captive portal for WiFi config and handles Flipper's Expansion Protocol negotiation. Firmware is in the repo: /firmware/tcp_uart_bridge

Architecture:

- MCP client (Claude Desktop, Cursor, etc.) <-> MCP server (Python, stdio) <-> Flipper Zero (protobuf RPC over USB or TCP)

- Transport-agnostic: same protobuf either way

- Modular: easy to add new Flipper capabilities

This is (I believe) the first MCP server for Flipper Zero. There are MCP servers for ESP32s and Arduinos, but those control the microcontroller itself. This controls the Flipper as a tool.

I look forward to feedback, especially from any other Flipper users who get it running over Wifi!

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.

The article discusses the concept of the Minimum Viable Product (MVP), its importance in product development, and how it can be effectively implemented to minimize risks and maximize learning.

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

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

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

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

Hi HN,

I'm a solo founder working on a project that uses AI to help with finding files in Google Drive.

The Problem: With Google Docs and Sheets, it's easy to make documents but very hard to find them again unless you organize them manually, which takes time.

This is a big problem for startups, who often use Google Docs for the convenience but struggle with information management. It leads to a lot of time wasted searching for documents and a lack of clarity.

The Solution: Paper Tray uses AI to organize Drive files automatically. It 'tags' each file so you can then use a filter interface to find them.

By default, it tags by the type of document (meeting notes, plan, pitch deck etc), the topic of the document, and the department it belongs to (product, engineering, sales etc).

The result is that it takes just a few seconds to find most of your documents, in an intuitive and satisfying way.

You can add your files easily with a Chrome Extension that adds a button to the header of Google Docs and Sheets. Click this button to add the file and manage the tags.

Business model: a 7-day free trial followed by monthly/annual subscription, currently priced at $12/mo, or $9/mo with an annual plan.

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

The article describes 'lazy-image', a lightweight JavaScript library that optimizes image loading on web pages by only loading images that are visible on the screen. This can improve page load times and reduce data usage for users.

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.

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!

Hi HN,

I’m a solo dev building a clinical search engine to help my wife (a resident physician) and her colleagues.

The Problem: Current tools (UpToDate/OpenEvidence) are expensive, slow, or increasingly heavy with pharma ads.

The Solution: I built Evidex to be a clean, privacy-first alternative. Search Demo (GIF): https://imgur.com/a/zoUvINt

Technical Architecture (Search-Based RAG): Instead of using a traditional pre-indexed vector database (like Pinecone) which can serve stale data, I implemented a Real-time RAG pattern:

Orchestrator: A Node.js backend performs "Smart Routing" (regex/keyword analysis) on the query to decide which external APIs to hit (PubMed, Europe PMC, OpenAlex, or ClinicalTrials.gov).

Retrieval: It executes parallel fetches to these APIs at runtime to grab the top ~15 abstracts.

Local Data: Clinical guidelines are stored locally in SQLite and retrieved via full-text search (FTS) ensuring exact matches on medical terminology.

Inference: I’m using Gemini 2.5 Flash to process the concatenated abstracts. The massive context window allows me to feed it distinct search results and force strict citation mapping without latency bottlenecks.

Workflow Tools (The "Integration"): I also built a "reasoning layer" to handle complex patient histories (Case Mode) and draft documentation (SOAP Notes). Case Mode Demo (GIF): https://imgur.com/a/h01Zgkx Note Gen Demo (GIF): https://imgur.com/a/DI1S2Y0

Why no Vector DB? In medicine, "freshness" is critical. If a new trial drops today, a pre-indexed vector store might miss it. My real-time approach ensures the answer includes papers published today.

Business Model: The clinical search is free. I plan to monetize by selling billing automation tools to hospital admins later.

Feedback Request: I’d love feedback on the retrieval latency (fetching live APIs is slower than vector lookups) and the accuracy of the synthesized answers.

I built a minimal browser game where you have to make 67 from four numbers.

https://simondarcyonline.com/67/

Hello HN, I made a simple web app for drawing up plays for amateur sports coaches: https://playmaker.click/playbook

It's inspired by Excalidraw; I love how you can hit buttons and go into different modes so I tried to replicate that for desktop users. It should work nicely on tablets, phones not so much.

The main motivation was to learn some Rust and WebAssembly, the recent WASM 64-bit address space update is interesting to me, so I put together a lttle playbook engine that handles player movement, trail recording, and ball possession tracking. It runs the animation/interpolation stuff in the browser.

The rest of the stack is Laravel/Vue on the frontend, Tailwind for styling. Nothing too fancy. I wanted something where I could drag players around, record movements, and play them back like a little animation (double tap outside the field). Supports football (soccer), basketball, rugby, and hockey fields, reasonably badly drawn

There's rough edges for sure; the Rust code could probably be cleaner, I got a bit of help from Claude but where applicable I dug down into the reasoning as to "why", so it was a good learning experience figuring out how to expose structs to JS via wasm-bindgen and learning about serde.

The playbook all runs locally in the browser, and saves the play config into the URL using LZ-String so it can be easily shared without blowing browser URL address bar limits, but I haven't tested silly-big plays on it yet.

Happy to answer any questions about the setup or my approach in general. Cheers! PG

The article explores the process of creating a virtual bookshelf using the Claude language, a new AI-powered programming tool. It discusses the challenges and techniques involved in building an interactive and visually appealing bookshelf application.