Show stories

Hey HN,

It’s Vineeth from Plastic Labs. We've been building Honcho, an open-source memory library for stateful AI agents.

Most memory systems are just vector search—store facts, retrieve facts, stuff into context. We took a different approach: memory as reasoning. (We talk about this a lot on our blog)

We built Neuromancer, a model trained specifically for AI-native memory. Instead of naive fact extraction, Neuromancer does formal logical reasoning over conversations to build representations that evolve over time. Its both cheap ( $2/M tokens ingestion, unlimited retrieval), token efficient and SOTA: LongMem (90.4%), LoCoMo (89.9%), and BEAM. On BEAM 10M—which exceeds every model's context window—we hit 0.409 vs prior SOTA of 0.266, using 0.5% of context per query.

Github: https://github.com/plastic-labs/honcho

Evals: https://evals.honcho.dev

Neuromancer Model Card: https://plasticlabs.ai/neuromancer)

Memory as Reasoning Approach: https://blog.plasticlabs.ai/blog/Memory-as-Reasoning

Read more about our recent updates: https://blog.plasticlabs.ai/blog/Honcho-3

Happy to answer questions about the architecture, benchmarks, or agent memory patterns in general

The article discusses an audit of the European Union's policies and institutions, highlighting the need for greater transparency, accountability, and efficiency in the EU's governance. It emphasizes the importance of addressing concerns about the EU's democratic legitimacy and decision-making processes.

This article explores the concept of a 'one human, one agent, one browser' approach to AI assistants, where each user has a dedicated AI agent that operates exclusively within their web browser, providing personalized and privacy-preserving interactions.

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.

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.

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.

Hi HN!

I’m Hélène. My husband and I are builders from Belgium, and we’ve spent the last few months building a side project called 13 Virtues.

The idea comes from Benjamin Franklin’s personal character system. Instead of tracking many habits at once, he focused on one virtue per week (Temperance, Silence, Order, etc.), cycling through 13 virtues over 13 weeks, then repeating the cycle. He documented this practice for many years.

We wanted an app that follows this structure strictly, rather than another flexible habit tracker. One virtue at a time. One day at a time. Repeat.

You can try the ledger directly on the homepage without creating an account. You can mark faults for today and see the current virtue with Franklin’s original quotes:

https://www.13-virtues.com

Why we built it:

We were frustrated with productivity apps that optimize for streaks and metrics rather than reflection. Franklin’s system felt refreshingly constrained and intentional, and we wanted something we’d actually use ourselves. My husband handled the engineering; I focused on product and design.

Pricing model:

We deliberately avoided subscriptions.

- Free tier: the full 13-week cycle and daily ledger

- Lifetime upgrade ($79 launch price): long-term history beyond the current cycle, guided reflections, data export, and a downloadable Modern Virtue Guide (PDF) that explains the method and its rationale in more depth.

Franklin’s system predates SaaS by a few centuries, and a monthly fee felt wrong for something meant to be practiced quietly over years.

Tech:

- Backend: Laravel

- Frontend: Vue (Inertia)

- CSS: Tailwind

- Hosting: Hostinger

Built over ~12 weekends.

We’ll be around today (CET) to answer questions — happy to discuss the implementation, the pricing decision, or Franklin’s original writings. Thoughtful UI/UX feedback is especially welcome.

https://microclimates.solofounders.com/

ActionBase is an open-source Java framework that provides a set of tools and utilities for building scalable and maintainable web applications. It simplifies the development process by abstracting away common tasks and providing a well-structured architecture.

Hey HN!

I built this after getting frustrated with losing great ideas while driving, cooking, or exercising. You know that moment when inspiration strikes but your hands are occupied?

The Problem: Doubao AI earphones (popular in China, similar to AirPods but with built-in AI) are great for Q&A, but all conversations disappear after listening. It's a closed ecosystem with no way to export valuable content.

My Solution: A Python tool that monitors the Doubao web interface and automatically syncs voice notes to Obsidian in real-time.

What makes it interesting:

30+ speech variation recognition - Works even if you say "note" instead of "take note" or use filler words like "um, note this down" Hands-free operation - Just say "Doubao, take a note, [your content]" and it appears in Obsidian instantly Smart deduplication - Won't create duplicate entries for similar content Cross-platform - Works on Windows, macOS, Linux Technical approach:

Uses Playwright to monitor DOM changes and network requests Regex engine handles speech variations and colloquialisms SQLite for deduplication logic Async I/O for real-time file operations Real use cases I've tested:

Capturing meeting insights while driving between offices Recording workout thoughts during runs Noting recipe improvements while cooking Quick idea capture during walks The tool essentially breaks the walled garden of AI earphones and turns them into a proper knowledge management device. It's like having a voice assistant that actually remembers and organizes everything you tell it.

Demo: Say "Doubao, note this: remember to research async patterns" → Instantly appears in Inbox/Voice Notes/2026-01-21.md

Built with Python + Playwright + SQLite. MIT licensed.

What do you think? Have you faced similar issues with voice assistants that don't persist information? Would love to hear about your workflows for capturing ideas on-the-go!

GitHub: https://github.com/GptsApp/doubao-earphone-to-obsidian

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.

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.

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.

It's an open-source project that lets you create, translate, and work with multiple agents at the same time, and more.

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.

Hello HN, this is Sai and Kaushik from ClickHouse. Today we are launching a Postgres managed service that is natively integrated with ClickHouse. It is built together with Ubicloud (YC W24).

TL;DR: NVMe-backed Postgres + built-in CDC into ClickHouse + pg_clickhouse so you can keep your app Postgres-first while running analytics in ClickHouse.

Try it (private preview): https://clickhouse.com/cloud/postgres Blog w/ live demo: https://clickhouse.com/blog/postgres-managed-by-clickhouse

Problem

Across many fast-growing companies using Postgres, performance and scalability commonly emerge as challenges as they grow. This is for both transactional and analytical workloads. On the OLTP side, common issues include slower ingestion (especially updates, upserts), slower vacuums, long-running transactions incurring WAL spikes, among others. In most cases, these problems stem from limited disk IOPS and suboptimal disk latency. Without the need to provision or cap IOPS, Postgres could do far more than it does today.

On the analytics side, many limitations stem from the fact that Postgres was designed primarily for OLTP and lacks several features that analytical databases have developed over time, for example vectorized execution, support for a wide variety of ingest formats, etc. We’re increasingly seeing a common pattern where many companies like GitLab, Ramp, Cloudflare etc. complement Postgres with ClickHouse to offload analytics. This architecture enables teams to adopt two purpose-built open-source databases.

That said, if you’re running a Postgres based application, adopting ClickHouse isn’t straightforward. You typically end up building a CDC pipeline, handling backfills, and dealing with schema changes and updating your application code to be aware of a second database for analytics.

Solution

On the OLTP side, we believe that NVMe-based Postgres is the right fit and can drastically improve performance. NVMe storage is physically colocated with compute, enabling significantly lower disk latency and higher IOPS than network-attached storage, which requires a network round trip for disk access. This benefits disk-throttled workloads and can significantly (up to 10x) speed up operations incl. updates, upserts, vacuums, checkpointing, etc. We are working on a detailed blog examining how WAL fsyncs, buffer reads, and checkpoints dominate on slow I/O and are significantly reduced on NVMe. Stay tuned!

On the OLAP side, the Postgres service includes native CDC to ClickHouse and unified query capabilities through pg_clickhouse. Today, CDC is powered by ClickPipes/PeerDB under the hood, which is based on logical replication. We are working to make this faster and easier by supporting logical replication v2 for streaming in-progress transactions, a new logical decoding plugin to address existing limitations of logical replication, working toward sub-second replication, and more.

Every Postgres comes packaged with the pg_clickhouse extension, which reduces the effort required to add ClickHouse-powered analytics to a Postgres application. It allows you to query ClickHouse directly from Postgres, enabling Postgres for both transactions and analytics. pg_clickhouse supports comprehensive query pushdown for analytics, and we plan to continuously expand this further (https://news.ycombinator.com/item?id=46249462).

Vision

To sum it up - Our vision is to provide a unified data stack that combines Postgres for transactions with ClickHouse for analytics, giving you best-in-class performance and scalability on an open-source foundation.

Get Started

We are actively working with users to onboard them to the Postgres service. Since this is a private preview, it is currently free of cost.If you’re interested, please sign up here. https://clickhouse.com/cloud/postgres

We’d love to hear your feedback on our thesis and anything else that comes to mind, it would be super helpful to us as we build this out!

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)

Hi HN!

Fence wraps any command in a sandbox that blocks network by default and restricts filesystem writes. Useful for running semi-trusted code (package installs, build scripts, unfamiliar repos) with controlled side effects, or even just blocking tools that phone home.

> fence curl https://example.com # -> blocked

> fence -t code -- npm install # -> template with registries allowed

> fence -m -- npm install # -> monitor mode: see what gets blocked

One use-case is to use it with AI coding agents to reduce the risk of running agents with fewer interactive permission prompts:

> fence -t code -- claude --dangerously-skip-permissions

You can import existing Claude Code permissions with `fence import --claude`.

Fence uses OS-native sandboxing (macOS sandbox-exec, Linux bubblewrap) + local HTTP/SOCKS proxies for domain filtering.

Why I built this: I work on Tusk Drift, a system to record and replay real traffic as API tests (https://github.com/Use-Tusk/tusk-drift-cli). I needed a way to sandbox the service under test during replays to block localhost outbound connections (Postgres, Redis) and force the app to use mocks instead of real services. I quickly realized that this could be a general purpose tool that would also be useful as a permission manager across CLI agents.

Limitations: Not strong containment against malware. Proxy-based filtering requires programs to respect `HTTP_PROXY`.

Curious if others have run into similar needs, and happy to answer any questions!

Standing on the shoulders of OpenStreetMap, three.js, and other open-source projects, I made an open-source, game-like 3D explorer for OSM.

It’s barebones right now (currently loads one scene), renderings need work, and it’s buggy in places. But you can get driving on most roads around the world.

Contributions welcome!

I built a tool that adds word-by-word animated captions to videos. All processing happens client-side using the browser - no server uploads.

Tech: 1. Whisper WASM (tiny and small models) 2. Canvas Text 3. MediaBunny to stitch everything together.

The privacy angle was important to me. This processes everything locally and exports directly.

Free, no account, no watermark. Feedback welcome.

BonSplit is an open-source app that allows friends to easily split bills and track expenses. It simplifies the process of dividing costs and managing shared payments, making it a useful tool for groups and households.

Hey HN! I wanted to share something I built over the last few weeks: isometric.nyc is a massive isometric pixel art map of NYC, built with nano banana and coding agents.

I didn't write a single line of code.

Of course no-code doesn't mean no-engineering. This project took a lot more manual labor than I'd hoped!

I wrote a deep dive on the workflow and some thoughts about the future of AI coding and creativity:

http://cannoneyed.com/projects/isometric-nyc

I usually build web games in C++, but using Emscripten always felt like overkill for what I was doing. I don't need full POSIX emulation or a massive standard library just to render some stuff to a canvas and handle basic UI.

The main thing I wanted to solve was the JS/WASM interop bottleneck. Instead of using the standard glue code for every call, I moved everything to a Shared Memory architecture using Command and Event buffers.

The way it works is that I batch all the instructions in WASM and then just send a single "flush" signal to JS. The JS side then reads everything directly out of Shared Memory in one go. It’s way more efficient, I ran a benchmark rendering 10k rectangles on a canvas and the difference was huge: Emscripten hit around 40 FPS, while my setup hit 100 FPS.

But writing DOM logic in C++ is painful, so I built Coi. It’s a component-based language that statically analyzes changes at compile-time to enable O(1) reactivity. Unlike traditional frameworks, there is no Virtual DOM overhead; the compiler maps state changes directly to specific handles in the command buffer.

I recently benchmarked this against React and Vue on a 1,000-row table: Coi came out on top for row creation, row updating and element swapping because it avoids the "diffing" step entirely and minimizes bridge crossings. Its bundle size was also the smallest of the three.

One of the coolest things about the architecture is how the standard library works. If I want to support a new browser API (like Web Audio or a new Canvas feature), I just add the definition to my WebCC schema file. When I recompile the Coi compiler, the language automatically gains a new standard library function to access that API. There is zero manual wrapping involved.

I'm really proud of how it's coming along. It combines the performance of a custom WASM stack with a syntax that actually feels good to write (for me atleast :P). Plus, since the intermediate step is C++, I’m looking into making it work on the server side too, which would allow for sharing components across the whole stack.

Example (Coi Code):

component Counter(string label, mut int& value) {

    def add(int i) : void {
        value += i;
    }

    style {
        .counter {
            display: flex;
            gap: 12px;
            align-items: center;
        }
        button {
            padding: 8px 16px;
            cursor: pointer;
        }
    }

    view {
        <div class="counter">
            <span>{label}: {value}</span>
            <button onclick={add(1)}>+</button>
            <button onclick={add(-1)}>-</button>
        </div>
    }

component App { mut int score = 0;

    style {
        .app {
            padding: 24px;
            font-family: system-ui;
        }
        h1 {
            color: #1a73e8;
        }
        .win {
            color: #34a853;
            font-weight: bold;
        }
    }

    view {
        <div class="app">
            <h1>Score: {score}</h1>
            <Counter label="Player" &value={score} />
            <if score >= 10>
                <p class="win">You win!</p>
            </if>
        </div>
    }

app { root = App; title = "My Counter App"; description = "A simple counter built with Coi"; lang = "en"; }

Live Demo: https://io-eric.github.io/coi

Coi (The Language): https://github.com/io-eric/coi

WebCC: https://github.com/io-eric/webcc

I'd love to hear what you think. It's still far from finished, but as a side project I'm really excited about :)

Seven modules teaching C the way safety-critical systems are actually built: MATH → STRUCT → CODE → TEST.

Each module answers one question: Does it exist? (Pulse), Is it normal? (Baseline), Is it regular? (Timing), Is it trending? (Drift), Which sensor to trust? (Consensus), How to handle overflow? (Pressure), What do we do about it? (Mode).

Every module is closed (no dependencies), total (handles all inputs), deterministic, and O(1). 83 tests passing.

Built this after 30 years in UNIX systems. Wanted something that teaches the rigour behind certified systems without requiring a decade of on-the-job learning first.

MIT licensed. Feedback welcome.

This article discusses the development of a tool called AutoShorts, which automatically generates short video clips from long-form video content. The tool uses machine learning techniques to identify key moments and summarize the content, enabling efficient content repurposing and distribution.

Shows rendered preview for unfocused lines and raw markdown for the line or block being edited.

Writeup (includes good/bad sample generations): https://www.linum.ai/field-notes/launch-linum-v2

We're Sahil and Manu, two brothers who spent the last 2 years training text-to-video models from scratch. Today we're releasing them under Apache 2.0.

These are 2B param models capable of generating 2-5 seconds of footage at either 360p or 720p. In terms of model size, the closest comparison is Alibaba's Wan 2.1 1.3B. From our testing, we get significantly better motion capture and aesthetics.

We're not claiming to have reached the frontier. For us, this is a stepping stone towards SOTA - proof we can train these models end-to-end ourselves.

Why train a model from scratch?

We shipped our first model in January 2024 (pre-Sora) as a 180p, 1-second GIF bot, bootstrapped off Stable Diffusion XL. Image VAEs don't understand temporal coherence, and without the original training data, you can't smoothly transition between image and video distributions. At some point you're better off starting over.

For v2, we use T5 for text encoding, Wan 2.1 VAE for compression, and a DiT-variant backbone trained with flow matching. We built our own temporal VAE but Wan's was smaller with equivalent performance, so we used it to save on embedding costs. (We'll open-source our VAE shortly.)

The bulk of development time went into building curation pipelines that actually work (e.g., hand-labeling aesthetic properties and fine-tuning VLMs to filter at scale).

What works: Cartoon/animated styles, food and nature scenes, simple character motion. What doesn't: Complex physics, fast motion (e.g., gymnastics, dancing), consistent text.

Why build this when Veo/Sora exist? Products are extensions of the underlying model's capabilities. If users want a feature the model doesn't support (character consistency, camera controls, editing, style mapping, etc.), you're stuck. To build the product we want, we need to update the model itself. That means owning the development process. It's a bet that will take time (and a lot of GPU compute) to pay off, but we think it's the right one.

What’s next? - Post-training for physics/deformations - Distillation for speed - Audio capabilities - Model scaling

We kept a “lab notebook” of all our experiments in Notion. Happy to answer questions about building a model from 0 → 1. Comments and feedback welcome!

LLMNet is an open-source library for building and deploying large language models (LLMs) using PyTorch. It provides a modular and extensible framework for training, fine-tuning, and evaluating LLMs, allowing developers to quickly experiment with different model architectures and techniques.

I built NukeCast because I’ve always wanted a tool that answers one question fast. If it happened today, where would the fallout plumes go and where would you drive to get out of it. NukeCast uses weather forecasts to drive a Lagrangian particle dispersion model with wet and dry deposition. Scenarios are defined by selecting strike site(s) and yield(s); the setup uses preselected US sites and yields based on FEMA emergency data. Outputs are shown as estimated ground level radiation dose at the surface over a 12 hour integration. Free to use with limits, and a paid tier if you want more runs/features because AWS compute time ain’t cheap.

Hi HN, founders of VibeFlow (YC S25) here.

We mostly work on backend and workflow tooling, but we needed a way to turn Figma designs into frontend code as a kickstart for prototyping. It takes a Figma frame and converts it into React + Tailwind components (plus assets).

If you want to try it: You can run it locally or use it via the VibeFlow UI to poke at it without setup (https://app.vibeflow.ai/)