Show stories

Click any city, mountain, country, sea or whatever on a globe, propose a new name, community votes (or your proposal gets auto-accepted in a few minutes if nobody cares).

It's live now and I'm genuinely curious what happens when strangers on the internet get collective control over world geography. Either it becomes something interesting or it turns into a mess of edgy jokes, stereotypes, and stuff that will make me regret this whole idea

AgentGram is an open-source, decentralized social media platform built on the Ethereum blockchain, enabling users to own their data and earn crypto rewards for engaging with content.

I would like to share Minimal - Its a open source collection of hardened container images build using Apko, Melange and Wolfi packages. The images are build daily, checked for updates and resolved as soon as fix is available in upstream source and Wolfi package. It utilizes the power of available open source solutions and contains commercially available images for free. Minimal demonstrates that it is possible to build and maintain hardened container images by ourselves. Minimal will add more images support, and goal is to be community driven to add images as required and fully customizable.

Hey everyone!

Just made this over the past few days.

Moltbots can sign up and interact via CLI, no direct human interactions.

Just for fun to see what they all talk about :)

We built tooling that connects LLMs directly to case law databases with citation verification to address hallucination in legal AI. Think of it as giving the model access to actual legal sources instead of relying on training data.

Built this because tones are killing my spoken Mandarin and I can't reliably hear my own mistakes.

It's a 9M Conformer-CTC model trained on ~300h (AISHELL + Primewords), quantized to INT8 (11 MB), runs 100% in-browser via ONNX Runtime Web.

Grades per-syllable pronunciation + tones with Viterbi forced alignment.

Try it here: https://simedw.com/projects/ear/

hi there! i’ve been working on a project called Narwhal, and I wanted to share it with the community to get some valuable feedback.

what is it? Narwhal is a lightweight Pub/Sub server and protocol designed specifically for edge applications. while there are great tools out there like NATS or MQTT, i wanted to build something that prioritizes customization and extensibility. my goal was to create a system where developers can easily adapt the routing logic or message handling pipeline to fit specific edge use cases, without fighting the server's defaults.

why Rust? i chose Rust because i needed a low memory footprint to run efficiently on edge devices (like Raspberry Pis or small gateways), and also because I have a personal vendetta against Garbage Collection pauses. :)

current status: it is currently in Alpha. it works for basic pub/sub patterns, but I’d like to start working on persistence support soon (so messages survive restarts or network partitions).

i’d love for you to take a look at the code! i’m particularly interested in all kind of feedback regarding any improvements i may have overlooked.

I got really interested in biology and genetics a few months ago, just for fun.

This was largely inspired by the work of Sydney Brenner, which became the basis of my brennerbot.org project.

In particular, I became very fascinated by phages, which are viruses that attack bacteria. They're the closest thing to the "fundamental particles" of biology: the minimal units of genetic code that do something useful that allows them to reproduce and spread.

They also have some incredible properties, like having a structure that somehow encodes an icosahedron.

I always wondered how the DNA of these things translated into geometry in the physical world. That mapping between the "digital" realm of ACGT, which in turn maps onto the 20 amino acids in groups of 3, and the world of 3D, analog shapes, still seems magical and mysterious to me.

I wanted to dig deeper into the subject, but not by reading a boring textbook. I wanted to get a sense for these phages in a tangible way. What are the different major types of phages? How do they compare to each other in terms of the length and structure of their genetic code? The physical structure they assume?

I decided to make a program to explore all this stuff in an interactive way.

And so I'm very pleased to present you with my open-source Phage Explorer:

phage-explorer.org

I probably went a bit overboard, because what I ended up with has taken a sickening number of tokens to generate, and resulted in ~150k lines of Typescript and Rust/Wasm.

It implements 23 analysis algorithms, over 40 visualizations, and has the complete genetic data and 3D structure of 24 different classes of phage.

It actually took a lot of engineering to make this work well in a browser; it's a surprising amount of data (this becomes obvious when you look at some of the 3D structure models).

It works fairly well on mobile, but if you want to get the full experience, I highly recommend opening it on a desktop browser in high resolution.

As far as I know, it's the most complete informational / educational software about phages available anywhere. Now, I am the first to admit that I'm NOT an expert, or even that knowledgeable, about, well, ANY of this stuff.

So if you’re a biology expert, please take a look and let me know what you think of what I've made! And if I've gotten anything wrong, please let me know in the GitHub Issues and I'll fix it:

https://github.com/Dicklesworthstone/phage_explorer

The article discusses the open-source project Booktest, which is a collection of tools and resources for testing and evaluating book recommendation algorithms. It provides a standardized dataset, evaluation metrics, and a framework for comparing the performance of different book recommendation systems.

WASM sandbox for running LLM-generated code safely.

Agents get a bash-like shell and can only call tools you provide, with constraints you define. No Docker, no subprocess, no SaaS — just pip install amla-sandbox

Hi HN,

Since AutoGPT in 2023, I’ve been uneasy about fully unsupervised AI agents. I see the productivity upside, but “kick it off and walk away” felt risky.

Recently, the “Ralph Wiggum loop” pattern has gone viral. The idea is simple: An autonomous coding agent runs repeatedly until all PRD items are complete, with fresh context each loop and state stored outside the model in git, JSON, etc.

What bothered me was this part: what protects the system while I’m AFK?

Traditional AI-assisted dev today looks like: AI writes code → human reviews → CI scans → human fixes

What I wanted instead: AI writes code → security scans immediately → AI fixes issues → repeats until secure → escalates if stuck

So I built a prototype that embeds security scanning directly inside the agent loop. The agent runs tools like Semgrep, Grype, Checkov, etc. inside its own session, sees the findings, and iteratively fixes them before anything is committed.

The loop looks like this:

PRD → Agent → Scan → Pass? → Commit Fail → Fix → Retry (3x) → Escalate to human

A few design principles that mattered:

* Baseline delta: pre-existing issues are tracked separately. Only new findings block commits. * Sandbox constraints: no network access, no sudo, no destructive commands. * Human override: nothing is fully autonomous. You can step back in at any point.

Is this bulletproof? Definitely not. Is it production-ready? No. But it’s a starting point for applying DevSecOps thinking to autonomous agents instead of trusting “AI magic.”

Repo link: https://github.com/agairola/securing-ralph-loop

Would love feedback from folks experimenting with agent loops, secure automation, or AI-assisted development gone wrong.

Happy to iterate.

We’re Maria and Jonatan, a married couple running a small music night in Norrköping, Sweden, called Kolibri.

It’s not a software project. We run it through our own small Swedish company, pay artists, and do the operations ourselves. We do one night a month (usually the last Friday) in a restaurant venue called Mitropa. A typical night is about 50–70 paying guests. The first years it was DJs only, but last year we started doing live bands as well.

We made a simple site with schedule plus photos/video so you can see what it looks like: https://kolibrinkpg.com/

On the site:

  * photos and short videos (size/atmosphere)

  * the kind of acts we book (post-punk, darkwave, synth, adjacent electronic)

  * enough context to copy parts of the format if you’re building something similar locally

  * for the tech-curious: we built our own ticketing system (first used in February) and a media ingestion pipeline for Instagram and external photographers

What made it take off was doing things in person. People will show up alone if they trust the room. Maria ended up doing a lot of that work: greeting newcomers, noticing who looks uncertain, and setting a tone where people treat each other decently.

Maria didn’t come from a DJ background. Klubbvärdinnan started as a joke name at Kolibri and then became her DJ moniker. She got good quickly, and after a first gig outside our own night she started getting booked elsewhere too.

Marketing-wise, what worked best was very analogue: walking around town, visiting local businesses we genuinely like, buying something, introducing ourselves, and asking if we could leave a flyer.

In the beginning we weren’t sure how to present it on social media. So we filmed headphone walks: one person walking through town listening to a track we picked. It looked good, people wanted to be in them, and afterwards we’d buy them a couple of drinks and actually talk. That turned a social media interaction into a real connection. It was a bit of luck, but it worked.

Questions welcome about what worked, what failed, costs/logistics, and what we’d do differently if we started over.

https://github.com/stepandel/pinecone-explorer

Most peptide calculators ask the wrong question.

They ask: How much water are you adding?

But in practice, what you actually know is your vial size and your target dose.

The water amount should be the output, not the input.

It should also make your dose land on a real syringe tick mark. Not something like 17.3 units.

I built a peptide calculator that works this way: https://www.joyapp.com/peptides/

What’s different:

- You pick vial size and target dose → reconstitution is calculated for you

- Doses align to actual syringe markings

- Common dose presets per peptide

- Works well on mobile (where this is usually done)

- Supports blends and compounds (e.g. GLOW or CJC-1295 + Ipamorelin)

- You can save your vials. No account required.

Happy to hear feedback or edge cases worth supporting.

Got a Molty with time on their claws? Put them to work. Got one drowning in tasks? Let them delegate.

Pinchwork is a marketplace where agents post tasks, pick up work, and earn credits. Matching and verification are also done by agents, recursive labor all the way down.

Why? Every agent has internet, but not every agent has everything. You lack Twilio keys but a notification agent doesn't. You need an image generated but only run text. You can't audit your own code. You're single-threaded but need 10 things done in parallel.

  POST /v1/register            → 100 free credits
  POST /v1/tasks               → post work with a bounty
  POST /v1/tasks/pickup        → grab a task
  POST /v1/tasks/{id}/deliver  → get paid

Live at https://pinchwork.dev — docs at https://pinchwork.dev/skill.md

Hey HN, we just shipped v0.1 of Hebo Gateway.

There are plenty of gateways already, but we kept running into the same issue: once you need real customization (auth, routing, rate limits, observability, request/response transforms), most “off the shelf” gateways get hard to extend.

Hebo Gateway is for cases where you want the gateway to be part of your app. You can run it standalone, or embed it into an existing backend. It exposes OpenAI-compatible endpoints (/chat/completions, /embeddings, /models), works with any Vercel AI SDK provider, and adds a hook system so you can plug logic into the request lifecycle without forking the core.

Quickstart, examples, and “what’s next” are in the post: https://hebo.ai/blog/260127-hebo-gateway

I would love feedback on OpenAI-compat edge cases you have been bitten by (especially streaming and reasoning-related stuff), and what hooks you wish gateways provided out of the box.

Hi HN,

I’m Linn, the creator of ToolKuai (https://toolkuai.com).

Like many of you, I’ve always been wary of "free" online file converters. Most of them are black boxes: you upload your private documents or images to a remote server, and you have no idea where that data ends up or how it’s being used to train models.

I wanted to build a suite of tools (Video/Image compressor, OCR, AI Background Remover) that runs entirely in the browser. No files ever leave your machine. The Tech Stack

To make this performant enough to rival server-side processing, I leaned heavily into modern web APIs:

- AI Background Removal: I'm using ONNX models (Xenova/modnet and ISNet) running locally via Transformers.js. The processing is 100% client-side, fallbacking to WASM when WebGPU isn't available.

- Frontend: Built with SvelteKit (Svelte 5) for its lean footprint and fast reactivity.

- Storage & Delivery: AI models are self-hosted on Cloudflare R2 to avoid massive bandwidth costs and ensure fast delivery.

Current Stats (13 days in):

The site is only 2 weeks old. Surprisingly, I’ve seen strong organic interest from Taiwan and Hong Kong. Average time on site is currently around 3.5 minutes, which suggests people are actually staying to process multiple files, confirming that the client-side speed is hitting the mark.

Future & Monetization

The tool is free. I’ve decided to avoid the "Pro/Premium" subscription model, as I believe these utility tools should be accessible. I'm exploring non-intrusive ads to cover the infrastructure costs (mostly R2 and Vercel).

I’d love to get some feedback from the HN community on:

- Performance on different hardware (especially the WebGPU-based video compressor).

- Privacy concerns or suggestions on how to further harden the "No-Server" promise.

- Any specific media tools you feel are currently lacking in the "client-side only" ecosystem.

Link: https://toolkuai.com

Thanks!

I wrote a lightweight scripting language that runs together with C. Specifically, it's a C library, you run it through a C function call, and it can callback your own C functions. Compiles to ~250 kB. No dependencies beyond the C standard library.

Key language features: * Uses aliases not pointers, so it's memory-safe * Arrays are N-dimensional and resizable * Runs scripts or its own 'shell' * Error trapping * Methods, inheritance, etc. * Customizable syntax

Hi all,

I wanted a robust way to keep track of my receipts without needing to keep them in a box and so i found paperless - but the existing paperless ai projects didn't really convert my receipts to usable data.

so I created a fork of nutlope's receipthero (actually it's a complete rewrite, the only thing that remains over is the system prompt) The goal of this project is to be a one stop shop for automatically detecting tagged docs and converting them to json using schema definitions - that includes invoices, .... i can't think of any others right now, maybe you can? If you do please make an issue for it! I would appreciate any feedback/issues thanks!

(p.s i made sure its simple to setup with dockge/basic docker-compose.yml)

repo: https://github.com/smashah/receipthero-ng

tutorial: https://youtu.be/LNlUDtD3og0

Hi HN, I've been building Mystral Native — a lightweight native runtime that lets you write games in JavaScript/TypeScript using standard Web APIs (WebGPU, Canvas 2D, Web Audio, fetch) and run them as standalone desktop apps. Think "Electron for games" but without Chromium. Or a JS runtime like Node, Deno, or Bun but optimized for WebGPU (and bundling a window / event system using SDL3).

Why: I originally started by starting a new game engine in WebGPU, and I loved the iteration loop of writing Typescript & instantly seeing the changes in the browser with hot reloading. After getting something working and shipping a demo, I realized that shipping a whole browser doesn't really work if I also want the same codebase to work on mobile. Sure, I could use a webview, but that's not always a good or consistent experience for users - there are nuances with Safari on iOS supporting WebGPU, but not the same features that Chrome does on desktop. What I really wanted was a WebGPU runtime that is consistent & works on any platform. I was inspired by deno's --unsafe-webgpu flag, but I realized that deno probably wouldn't be a good fit long term because it doesn't support iOS or Android & doesn't bundle a window / event system (they have "bring your own window", but that means writing a lot of custom code for events, dealing with windowing, not to mention more specific things like implementing a WebAudio shim, etc.). So that got me down the path of building a native runtime specifically for games & that's Mystral Native.

So now with Mystral Native, I can have the same developer experience (write JS, use shaders in WGSL, call requestAnimationFrame) but get a real native binary I can ship to players on any platform without requiring a webview or a browser. No 200MB Chromium runtime, no CEF overhead, just the game code and a ~25MB runtime.

What it does: - Full WebGPU via Dawn (Chrome's implementation) or wgpu-native (Rust) - Native window & events via SDL3 - Canvas 2D support (Skia), Web Audio (SDL3), fetch (file/http/https) - V8 for JS (same engine as Chrome/Node), also supports QuickJS and JSC - ES modules, TypeScript via SWC - Compile to single binary (think "pkg"): `mystral compile game.js --include assets -o my-game` - macOS .app bundles with code signing, Linux/Windows standalone executables - Embedding API for iOS and Android (JSC/QuickJS + wgpu-native)

It's early alpha — the core rendering path works well & I've tested on Mac, Linux (Ubuntu 24.04), and Windows 11, and some custom builds for iOS & Android to validate that they can work, but there's plenty to improve. Would love to get some feedback and see where it can go!

MIT licensed.

Repo: https://github.com/mystralengine/mystralnative

Docs: https://mystralengine.github.io/mystralnative/

Hi HN,

I’m Tullie, founder of Shaped. Previously, I was a researcher at Meta AI, worked on ranking for Instagram Reels, and was a contributor to PyTorch Lightning.

We built ShapedQL because we noticed that while retrieval (finding 1,000 items) has been commoditized by vector DBs, ranking (finding the best 10 items) is still an infrastructure problem.

To build a decent for you feed or a RAG system with long-term memory, you usually have to put together a vector DB (Pinecone/Milvus), a feature store (Redis), an inference service, and thousands of lines of Python to handle business logic and reranking.

We built an engine that consolidates this into a single SQL dialect. It compiles declarative queries into high-performance, multi-stage ranking pipelines.

HOW IT WORKS:

Instead of just SELECT , ShapedQL operates in four stages native to recommendation systems:

RETRIEVE: Fetch candidates via Hybrid Search (Keywords + Vectors) or Collaborative Filtering. FILTER: Apply hard constraints (e.g., "inventory > 0"). SCORE: Rank results using real-time models (e.g., p(click) or p(relevance)). REORDER: Apply diversity logic so your Agent/User doesn’t see 10 nearly identical results.

THE SYNTAX: Here is what a RAG query looks like. This replaces about 500 lines of standard Python/LangChain code:

SELECT item_id, description, price

FROM

  -- Retrieval: Hybrid search across multiple indexes

  search_flights("$param.user_prompt", "$param.context"),

  search_hotels("$param.user_prompt", "$param.context")

  -- Filtering: Hard business constraints

  price <= "$param.budget" AND is_available("$param.dates")

  -- Scoring: Real-time reranking (Personalization + Relevance)

  0.5 * preference_score(user, item) +

  0.3 * relevance_score(item, "$param.user_prompt")

If you don’t like SQL, you can also use our Python and Typescript SDKs. I’d love to know what you think of the syntax and the abstraction layer!

Warden is a new open-source security tool developed by Sentry that helps teams detect and respond to security incidents in their applications. It provides a centralized dashboard for monitoring security-related events and offers integration with existing security tooling.

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.

Hey HN,

I built Tinman because finding LLM failures in production is a pain in the ass. Traditional testing checks what you've already thought of. Tinman tries to find what you haven't.

It's an autonomous research agent that: - Generates hypotheses about potential failure modes - Designs and runs experiments to test them - Classifies failures (reasoning errors, tool use, context issues, etc.) - Proposes interventions and validates them via simulation

The core loop runs continuously. Each cycle informs the next.

Why now: With tools like OpenClaw/ClawdBot giving agents real system access, the failure surface is way bigger than "bad chatbot response." Tinman has a gateway adapter that connects to OpenClaw's WebSocket stream for real-time analysis as requests flow through.

Three modes: - LAB: unrestricted research against dev - SHADOW: observe production, flag issues - PRODUCTION: human approval required

Tech: - Python, async throughout - Extensible GatewayAdapter ABC for any proxy/gateway - Memory graph for tracking what was known when - Works with OpenAI, Anthropic, Ollama, Groq, OpenRouter, Together

  pip install AgentTinman
  tinman init && tinman tui

Apache 2.0. No telemetry, no paid tier. Feedback and contributions welcome.

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!

Hey HN,

We’ve been building browser agents for a while. In production, we kept converging on the same pattern: deterministic scripts for the happy path, agents only for edge cases. So we built Demonstrate Mode.

The idea is simple: You perform your workflow once in a remote browser. Notte records the interactions and generates deterministic automation code.

How it works: - Record clicks, inputs, navigations in a cloud browser - Compile them into deterministic code (no LLM at runtime) - Run and deploy on managed browser infrastructure

Closest analog is Playwright codegen but: - Infrastructure is handled (remote browsers, proxies, auth state) - Code runs in a deployable runtime with logs, retries, and optional agent fallback

Agents are great for prototyping and dynamic steps, but for production we usually want versioned code and predictable cost/behavior. Happy to dive into implementation details in the comments.

Demo: https://www.loom.com/share/f83cb83ecd5e48188dd9741724cde49a

-- Andrea & Lucas, Notte Founders

Hi HN,

I’m sharing the alpha release of S2C, a state machine replication system built atop S3.

The goal is to enable a distributed application to maintain consistent state without needing a quorum of nodes for availability or consistency.

The idea came from a side project that was using S3 and where I needed strongly consistent distributed state but wanted to avoid adding a separate consensus dependency. I initially tried to use S3 directly for coordination, but it became messy. Eventually, I realized I need a replicated state machine with a deterministic log, and then it ended up as a standalone project.

To mitigate S3's latency and API costs, it uses time- and size-based batching by default.

S2C supports: - Linearizable reads and writes (with single node) - Exactly-once command semantics (for nodes with stable identities) - Dynamic node joins and cold-start recovery from zero nodes - Split-brain safety without clocks or leases - Snapshotting, log truncation, etc.

Of course, it trades latency and S3 operation costs for operational simplicity - not meant to replace high-throughput Raft rings. And clearly, only usable in architectures that already use S3 (or compatible with similar guarantees).

It has passed chaos/fault-injection tests so far (crashes, partitions, leader kills); formal verification planned.

It’s still alpha, but I’d love for people to try it, experiment, and provide feedback.

If you’re curious, the code, and an extensive deep dive guide are here: [https://github.com/io-s2c/s2c]

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

Hi, everyone!

I built SHDL (Simple Hardware Description Language) as an experiment in stripping hardware description down to its absolute fundamentals.

In SHDL, there are no arithmetic operators, no implicit bit widths, and no high-level constructs. You build everything explicitly from logic gates and wires, and then compose larger components hierarchically. The goal is not synthesis or performance, but understanding: what digital systems actually look like when abstractions are removed.

SHDL is accompanied by PySHDL, a Python interface that lets you load circuits, poke inputs, step the simulation, and observe outputs. Under the hood, SHDL compiles circuits to C for fast execution, but the language itself remains intentionally small and transparent.

This is not meant to replace Verilog or VHDL. It’s aimed at: - learning digital logic from first principles - experimenting with HDL and language design - teaching or visualizing how complex hardware emerges from simple gates.

I would especially appreciate feedback on: - the language design choices - what feels unnecessarily restrictive vs. educationally valuable - whether this kind of “anti-abstraction” HDL is useful to you.

Repo: https://github.com/rafa-rrayes/SHDL

Python package: PySHDL on PyPI

To make this concrete, here are a few small working examples written in SHDL:

1. Full Adder

component FullAdder(A, B, Cin) -> (Sum, Cout) {

    x1: XOR; a1: AND;
    x2: XOR; a2: AND;
    o1: OR;

    connect {
        A -> x1.A; B -> x1.B;
        A -> a1.A; B -> a1.B;

        x1.O -> x2.A; Cin -> x2.B;
        x1.O -> a2.A; Cin -> a2.B;
        a1.O -> o1.A; a2.O -> o1.B;

        x2.O -> Sum; o1.O -> Cout;
    }

2. 16 bit register

# clk must be high for two cycles to store a value

component Register16(In[16], clk) -> (Out[16]) {

    >i[16]{
        a1{i}: AND;
        a2{i}: AND;
        not1{i}: NOT;
        nor1{i}: NOR;
        nor2{i}: NOR;
    }
    
    connect {
        >i[16]{
            # Capture on clk
            In[{i}] -> a1{i}.A;
            In[{i}] -> not1{i}.A;
            not1{i}.O -> a2{i}.A;
            
            clk -> a1{i}.B;
            clk -> a2{i}.B;
            
            a1{i}.O -> nor1{i}.A;
            a2{i}.O -> nor2{i}.A;
            nor1{i}.O -> nor2{i}.B;
            nor2{i}.O -> nor1{i}.B;
            nor2{i}.O -> Out[{i}];
        }
    }

3. 16-bit Ripple-Carry Adder

use fullAdder::{FullAdder};

component Adder16(A[16], B[16], Cin) -> (Sum[16], Cout) {

    >i[16]{ fa{i}: FullAdder; }

    connect {
        A[1] -> fa1.A;
        B[1] -> fa1.B;
        Cin -> fa1.Cin;
        fa1.Sum -> Sum[1];

        >i[2,16]{
            A[{i}] -> fa{i}.A;
            B[{i}] -> fa{i}.B;
            fa{i-1}.Cout -> fa{i}.Cin;
            fa{i}.Sum -> Sum[{i}];
        }

        fa16.Cout -> Cout;
    }
}

Hi,

I built TalkBits because most language apps focus on vocabulary or exercises, but not actual conversation. The hard part of learning a language is speaking naturally under pressure.

TalkBits lets you have real-time spoken conversations with an AI that acts like a native speaker. You can choose different scenarios (travel, daily life, work, etc.), speak naturally, and the AI responds with natural speech back.

The goal is to make it feel like talking to a real person rather than doing lessons.

Techwise, it uses realtime speech input, transcription, LLM responses, and tts streaming to keep latency low so the conversation feels fluid.

I’m specially interested in feedback about: – Does it feel natural? – Where does the conversation break immersion? – What would make you use this regularly?

Happy to answer technical questions too.

Thanks