Show stories

I love seeing all the small games that people build and post to this site.

I don't want to forget any, so I have built a directory/arcade for the games here that I maintain.

Feel free to check it out, add your game if its missing and let me know what you think. Thanks!

Related: https://simonwillison.net/2026/Jan/27/one-human-one-agent-on...

Hey HN, we're the co-founders of LemonSlice (try our HN playground here: https://lemonslice.com/hn). We train interactive avatar video models. Our API lets you upload a photo and immediately jump into a FaceTime-style call with that character. Here's a demo: https://www.loom.com/share/941577113141418e80d2834c83a5a0a9

Chatbots are everywhere and voice AI has taken off, but we believe video avatars will be the most common form factor for conversational AI. Most people would rather watch something than read it. The problem is that generating video in real-time is hard, and overcoming the uncanny valley is even harder.

We haven’t broken the uncanny valley yet. Nobody has. But we’re getting close and our photorealistic avatars are currently best-in-class (judge for yourself: https://lemonslice.com/try/taylor). Plus, we're the only avatar model that can do animals and heavily stylized cartoons. Try it: https://lemonslice.com/try/alien. Warning! Talking to this little guy may improve your mood.

Today we're releasing our new model* - Lemon Slice 2, a 20B-parameter diffusion transformer that generates infinite-length video at 20fps on a single GPU - and opening up our API.

How did we get a video diffusion model to run in real-time? There was no single trick, just a lot of them stacked together. The first big change was making our model causal. Standard video diffusion models are bidirectional (they look at frames both before and after the current one), which means you can't stream.

From there it was about fitting everything on one GPU. We switched from full to sliding window attention, which killed our memory bottleneck. We distilled from 40 denoising steps down to just a few - quality degraded less than we feared, especially after using GAN-based distillation (though tuning that adversarial loss to avoid mode collapse was its own adventure).

And the rest was inference work: modifying RoPE from complex to real (this one was cool!), precision tuning, fusing kernels, a special rolling KV cache, lots of other caching, and more. We kept shaving off milliseconds wherever we could and eventually got to real-time.

We set up a guest playground for HN so you can create and talk to characters without logging in: https://lemonslice.com/hn. For those who want to build with our API (we have a new LiveKit integration that we’re pumped about!), grab a coupon code in the HN playground for your first Pro month free ($100 value). See the docs: https://lemonslice.com/docs. Pricing is usage-based at $0.12-0.20/min for video generation.

Looking forward to your feedback!

EDIT: Tell us what characters you want to see in the comments and we can make them for you to talk to (e.g. Max Headroom)

*We did a Show HN last year for our V1 model: https://news.ycombinator.com/item?id=43785044. It was technically impressive but so bad compared to what we have today.

Back story:

I've been learning computer graphics on the side for several years now and gain so much joy from smooshing and stretching images/videos. I hope you can get a little joy as well with Fuzzy Studio!

Try applying effects to your camera! My housemates and I have giggled so much making faces with weird effects!

Nothing gets sent to the server; everything is done in the browser! Amazing what we can do. I've only tested on macOS... apologies if your browser/OS is not supported (yet).

I grew up on the Infocom games and when microsoft actually open-sourced Zork 1/2/3 I really wanted to figure out how to use LLMs to let you type whatever you want, I always found the amount language that the games "understood" to be so limiting - even if it was pretty state of the art at the time.

So I figured out how to wrap it with Tambo.. (and run the game engine in the browser) basically whatever you type gets "translated" into zork-speak and passed to the game - and then the LLM takes the game's output and optionally adds flavor. (the little ">_" button at the top exposes the actual game input)

What was a big surprise to me is multi-turn instructions - you can ask it to "Explore all the rooms in the house until you can't find any more" and it will plug away at the game for 10+ "turns" at a time... like Claude Code for Zork or something

I built Lapse because most of my blogs died quietly, abandoned after a few months.

lapse.blog is a minimal blogging platform with one rule: if you don't post for 30 days, your blog is permanently deleted. No warnings, no recovery.

How it works:

  - No signup. Your unique passphrase grants access to your blog. Same passphrase = same blog. (If two people pick the same one, they'll control the same blog by design)
  - The longer you post consistently, the longer it lives. Borrowing from social-media streaks, but for writing. If they can encourage you to Snapchat someone, surely we can encourage ourselves to write.
  - Markdown only. No images, no embeds.
  - RSS and Atom feeds included.
  - Forget your passphrase? Blog gets deleted. Stop posting? Blog gets deleted.
  - No ads, no tracking.

TetrisBench is a website that provides benchmarking tools and resources for the classic puzzle game Tetris. It offers performance analysis, comparison of different Tetris implementations, and insights into the game's mechanics and optimization techniques.

SnapBench is a benchmarking tool for serverless functions, enabling developers to measure the performance and cost-efficiency of their cloud functions across different cloud providers and configurations.

With AI agents getting more autonomous, controlling irreversible actions (sending money, emails, deploying code) is becoming critical.

Nyxi introduces execution-time governance: a clean veto/allow boundary that works regardless of whether proposals come from humans or models.

Public docs and demos here (proprietary, no source): https://github.com/indyh91/Nyxi-Showcase

Main overview: https://github.com/indyh91/Nyxi-Showcase/blob/main/docs/PROD...

Would love feedback on the concept!

Built two things:

Predictor Agent - Scrapes top Polymarket traders, finds their consensus bets, scores entry quality. Currently tracking 51 real signals.

AgentWallet - The "financial leash" I built so the agent can't go rogue. Spend limits, approval thresholds, time windows, full audit trail.

Live demos:

Predictor signals: https://predictor-dashboard.vercel.app

AgentWallet: https://agentwallet-dashboard.vercel.app

The idea: AI agents will need to spend money. Someone needs to build the guardrails. That's AgentWallet.

GitHub: https://github.com/JackD720/agentwallet

The article provides a quiz about the Supreme Court of the United States, testing users' knowledge of the court's history, structure, and landmark decisions. The quiz aims to engage readers and improve their understanding of the judiciary branch of the American government.

This is an interactive map of US navigational aids and lighthouses, which indicates their location, color, characteristic and any remarks the Coast Guard has attached.

I was sick at home with the flu this weekend, and went on a bit of a Wikipedia deep dive about active American lighthouses. Searching around a bit, it was very hard to find a single source or interactive map of active beacons, and a description of what the "characteristic" meant. The Coast Guard maintains a list of active lights though, that they publish annually (https://www.navcen.uscg.gov/light-list-annual-publication). With some help from Claude Code, it wasn't hard to extract the lat/long and put together a small webapp that shows a map of these light stations and illustrates their characteristic with an animated visualization..

Of course, this shouldn't be used as a navigational aid, merely for informational purposes! Though having lived in Seattle and San Francisco I thought it was quite interesting.

Siquil is an open-source, lightweight, and easy-to-use web framework for building modern, scalable, and secure web applications. It provides a simple and intuitive API for handling HTTP requests, routing, and middleware, making it a suitable choice for developers looking to create efficient and maintainable web applications.

Hey HN,

A CSV parser using Go 1.26's experimental simd/archsimd package.

I wanted to see what the new SIMD API looks like in practice. CSV parsing is mostly "find these bytes in a buffer"—load 64 bytes, compare, get a bitmask of positions. The interesting part was handling chunk boundaries correctly (quotes and line endings can split across chunks).

- Drop-in replacement for encoding/csv - ~20% faster for unquoted data on AVX-512 - Quoted data is slower (still optimizing) - Scalar fallback for non-AVX-512

Requires GOEXPERIMENT=simd.

https://github.com/nnnkkk7/go-simdcsv

Feedback on edge cases or the SIMD implementation welcome.

https://microclimates.solofounders.com/

Author here. I made this little TUI program for managing default applications on the Linux desktop.

Maybe some of you will find it useful.

Happy to answer any questions.

The ACME Proxy is an open-source software project that provides a secure proxy solution for the Automated Certificate Management Environment (ACME) protocol, enabling easy and automated SSL/TLS certificate management for web applications.

To power the firewalling for our agents so that they couldn't contact arbitrary services, I build netfence. It's like Envoy but for eBPF filters.

It allows you to define different DNS-based rules that are resolved in a local daemon to IPs, then pushed to the eBPF filter to allow traffic. By doing it this way, we can still allow DNS-defined rules, but prevent contacting random IPs.

There's also no network performance penalty, since it's just DNS lookups and eBPF filters referencing memory.

It also means you don't have to tamper with the base image, which the agent could potentially manipulate to remove rules (unless you prevent root maybe).

It automatically manages the lifecycle of eBPF filters on cgroups and interfaces, so it works well for both containers and micro VMs (like Firecracker).

You implement a control plane, just like Envoy xDS, which you can manage the rules of each cgroup/interface. You can even manage DNS through the control plane to dynamically resolve records (which is helpful as a normal DNS server doesn't know which interface/cgroup a request might be coming from).

We specifically use this to allow our agents to only contact S3, pip, apt, and npm.

The article introduces Script, a new programming language designed to be easy to learn and use, with a focus on simplicity and accessibility. It highlights Script's key features, including its concise syntax, cross-platform compatibility, and integration with popular web technologies.

42 validation errors in one run. Claude apologising instead of writing HTML. OAuth tokens expiring mid-digest.

Then I fixed the constraints. Eight days, zero failures, zero intervention.

The secret wasn't better prompts... it was treating the LLM as a constrained function: schema-validated tool calls that reject malformed output and force retries, two-pass architecture separating editorial judgment from formatting, and boring DevOps (retry logic, rate limiting, structured logging).

The Claude invocation is ~30 lines in a 2000-line system. Most of the work is everything around it.

https://seanfloyd.dev/blog/llm-reliability https://github.com/SeanLF/claude-rss-news-digest

This article discusses the growing field of robotics, exploring its applications in various industries and the advancements in artificial intelligence and machine learning that are driving this technology forward.

Hey HN,

I've been working on ModifyWithAI, a framework that lets you embed an AI agent into your app so users can complete multi-step tasks through chat.

The idea: instead of users clicking through multiple screens, they describe what they want and the agent handles the workflow—while still giving them control to approve/modify actions.

v2 focuses on latency (targeting sub-500ms responses) and better user control over what the agent can do.

Would love feedback on the approach, especially from anyone who's tried adding agentic features to existing products.

TraceOpt-AI's TraceML is an open-source Python library that provides tools for model tracing, optimization, and deployment. It offers features like model tracing, quantization, and export to support efficient and deployable deep learning models.

Hey HN,

I wanted to share a project I’ve been working on called Convoxa. It’s a native iOS transcriber/summarizer. I had two main goals: keep it efficient and keep it private.

THE TECH STACK

100% Swift & SwiftUI: No heavy cross-platform wrappers or bloated dependencies.

Binary Size: The final build is only 4.8 MB.

Transcription: Uses Apple's latest speech APIs for maximum privacy and efficiency.

THE CHALLENGE: BYPASSING THE 4K CONTEXT LIMIT

The biggest technical hurdle was working with Apple’s foundation models. The default context window is capped at 4096 tokens, which is practically useless for anything over a 10-minute meeting transcript.

I ended up building a recursive chunking method to "feed" the model long-form data without losing the global context of the conversation. I use a sliding window approach where each chunk's summary informs the next, ensuring the final output doesn't "hallucinate" at the seams where the chunks meet. It’s now stable enough for long-form audio while remaining entirely on-device for supported hardware.

PRIVACY & AI MODES

On-Device: (Apple Intelligence required) - Total local processing.

Cloud: With reasoning for intelligent insights (Zero Data Retention).

I’m currently in the pre-order phase (out on Feb 3rd) and would love to get some feedback from this community on the performance and the chunking logic.

App Store: https://apps.apple.com/us/app/convoxa-ai-meeting-minutes/id6...

This is a hobby project of mine that I started a few years ago to learn about programming language implementation. It was created 95% without AI, although a few recent commits include code from Gemini CLI.

I started out following Crafting Interpreters, but gradually branched off that until I had almost nothing left in common.

Tech stack: Rust, Cranelift (JIT compilation), LALRPOP (parser).

Original title: "A small programming language where everything is a value" (edited based on comments)

Hey! I'm eshaan and I'm building Ourguide -an on-screen task guidance system that can show you where to click step-by-step when you need help.

I started building this because whenever I didn’t know how to do something on my computer, I found myself constantly tabbing between chatbots and the app, pasting screenshots, and asking “what do I do next?” Ourguide solves this with two modes. In Guide mode, the app overlays your screen and highlights the specific element to click next, eliminating the need to leave your current window. There is also Ask mode, which is a vision-integrated chat that captures your screen context—which you can toggle on and off anytime -so you can ask, "How do I fix this error?" without having to explain what "this" is.

It’s an Electron app that works OS-wide, is vision-based, and isn't restricted to the browser.

Figuring out how to show the user where to click was the hardest part of the process. I originally trained a computer vision model with 2300 screenshots to identify and segment all UI elements on a screen and used a VLM to find the correct icon to highlight. While this worked extremely well—better than SOTA grounding models like UI Tars—the latency was just too high. I'll be making that CV+VLM pipeline OSS soon, but for now, I’ve resorted to a simpler implementation that achieves <1s latency.

You may ask: if I can show you where to click, why can't I just click too? While trying to build computer-use agents during my job in Palo Alto, I hit the core limitation of today’s computer-use models where benchmarks hover in the mid-50% range (OSWorld). VLMs often know what to do but not what it looks like; without reliable visual grounding, agents misclick and stall. So, I built computer use—without the "use." It provides the visual grounding of an agent but keeps the human in the loop for the actual execution to prevent misclicks.

I personally use it for the AWS Console's "treasure hunt" UI, like creating a public S3 bucket with specific CORS rules. It’s also been surprisingly helpful for non-technical tasks, like navigating obscure settings in Gradescope or Spotify. Ourguide really works for any task when you’re stuck or don't know what to do.

You can download and test Ourguide here: https://ourguide.ai/downloads

The project is still very early, and I’d love your feedback on where it fails, where you think it worked well, and which specific niches you think Ourguide would be most helpful for.

The article presents a comprehensive analysis of online political discourse, examining how different communication patterns and narratives emerge on social media platforms. It explores the dynamics of political polarization, the spread of misinformation, and the implications for democratic discourse.

Hi, I'm Tony, founder of Cosmic (AI-powered headless CMS and application development platform). We kept running into the same problem: create a blog post with the help of an AI agent, use the output for another prompt to create social posts, then manually post to X, LinkedIn, Facebook. Every single time.

So we built AI Workflows — chain multiple agents together and let them run autonomously, with each step receiving outputs from previous steps.

Three agent types you can chain:

- Code Agents: Build features in GitHub with commits and pull requests.

- Content Agents: Generate CMS content with context injection from previous steps.

- Computer Use Agents: Automate browser workflows and record demos.

How it works:

1. Define steps with agent type, prompt, and configuration

2. Steps run sequentially or in parallel (configurable)

3. Context passes automatically between steps

4. Trigger manually, on a schedule (cron), or via CMS and API events (object.created, object.edited, etc.)

5. Add approval gates for human review before critical steps

Example: Autopilot feature development:

Step 1: Content Agent writes a feature spec based on user feedback

Step 2: Code Agent builds the feature, creates PR, and deploys to production

Step 3: Content Agent generates documentation and a changelog entry

Step 4: Computer Use Agent posts update to team Slack with the PR link and preview URL

Currently in beta. Would love feedback on the workflow model and what use cases you'd want to automate.

The article describes a PostgreSQL to ClickHouse migration stack, which provides a framework for seamlessly migrating data from PostgreSQL to the ClickHouse analytical database, while maintaining data integrity and minimizing downtime.

I built Lightbox because I kept running into the same problem: an agent would fail in production, and I had no way to know what actually happened.

Logs were scattered, the LLM’s “I called the tool” wasn’t trustworthy, and re-running wasn’t deterministic.

This week, tons of Clawdbot incidents have driven the point home. Agents with full system access can expose API keys and chat histories. Prompt injection is now a major security concern.

When agents can touch your filesystem, execute code, and browse the web…you probably need a tamper-proof record of exactly what actions it took, especially when a malicious prompt or compromised webpage could hijack the agent mid-session.

Lightbox is a small Python library that records every tool call an agent makes (inputs, outputs, timing) into an append-only log with cryptographic hashes. You can replay runs with mocked responses, diff executions across versions, and verify the integrity of logs after the fact.

Think airplane black box, but for your hackbox.

*What it does:*

- Records tool calls locally (no cloud, your infra)

- Tamper-evident logs (hash chain, verifiable)

- Replay failures exactly with recorded responses

- CLI to inspect, replay, diff, and verify sessions

- Framework-agnostic (works with LangChain, Claude, OpenAI, etc.)

*What it doesn’t do:* - Doesn’t replay the LLM itself (just tool calls) - Not a dashboard or analytics platform - Not trying to replace LangSmith/Langfuse (different problem)

*Use cases I care about:*

- Security forensics: agent behaved strangely, was it prompt injection? Check the trace.

- Compliance: “prove what your agent did last Tuesday”

- Debugging: reproduce a failure without re-running expensive API calls

- Regression testing: diff tool call patterns across agent versions

As agents get more capable and more autonomous (Clawdbot/Molt, Claude computer use, Manus, Devin), I think we’ll need black boxes the same way aviation does.

This is my attempt at that primitive.

It’s early (v0.1), intentionally minimal, MIT licensed.

Site: <https://uselightbox.app> install: `pip install lightbox-rec`

GitHub: <https://github.com/mainnebula/Lightbox-Project>

Would love feedback, especially from anyone thinking about agent security or running autonomous agents in production.