Show stories

The article describes a web-based implementation of the Game of Life, a cellular automaton that simulates the evolution of a two-dimensional grid of cells. The game allows users to create and observe complex patterns emerging from simple initial configurations.

coroTracer is an open-source contact tracing tool that utilizes Bluetooth Low Energy (BLE) technology to track potential COVID-19 exposure. The system aims to provide a privacy-preserving solution for tracking and notifying individuals who may have been in close contact with confirmed COVID-19 cases.

It's a fairly simple stdio MCP server that provides AI agents a faster way to search through docs for any Sphinx-powered documentation. It builds Sphinx text docs and indexes them in SQLite (FTS5). There is also an optional hybrid search mode which creates embeddings and a vector db (sqlite-vec) and uses both approaches via RRF to get the best answer to your agent.

I've run this on several repos of varying size and complexity (pandas, celery, cpython) and have been impressed with the resulting answers.

Glyph is an open-source, local-first Markdown notes app for macOS built with Rust (Tauri)

It stores notes as plain files, supports fast search, wikilinks/backlinks, and includes optional AI chat, including implementation of Codex so you can use your chatgpt sub, all without requiring a cloud-first workflow.

https://glyphformac.com/

Most AI dev tools focus on code. Cloudwright focuses on the design phase — the gap where engineers currently use spreadsheets, ad-hoc Terraform, and tribal knowledge.

You describe an architecture in plain English. It produces a structured YAML spec (ArchSpec), then gives you:

- Compliance validation: HIPAA, PCI-DSS, SOC 2, FedRAMP, GDPR, Well-Architected - Per-component cost estimates across AWS, GCP, Azure, and Databricks - Terraform/CloudFormation/Mermaid/SBOM export - Drift detection (compare design vs deployed tfstate) - Security scanning (missing encryption, IAM wildcards, open 0.0.0.0/0) - Architecture Decision Record (ADR) generation

Benchmarked against raw Claude Sonnet 4.6 across 54 use cases: cloudwright wins on 6 of 8 metrics. Weakest areas are cost accuracy and import fidelity (both actively improving).

  $ pip install cloudwright-ai[cli]
  $ cloudwright design "3-tier web app on AWS with Redis and RDS PostgreSQL"
  $ cloudwright validate spec.yaml --compliance hipaa
  $ cloudwright export spec.yaml --format terraform -o ./infra
  $ cloudwright security spec.yaml

The Databricks provider was the hardest to build — it's an overlay platform (runs on top of AWS/Azure), uses DBU-based pricing instead of per-hour instances, and has no CloudFormation support. Happy to talk through any of the design tradeoffs.

The article discusses the development of a PHP extension for the Rust compiler, allowing Rust code to be executed within PHP applications. This integration aims to leverage Rust's performance and safety benefits to enhance the capabilities of PHP-based web applications.

As many of us shift from being software engineers to software managers, tracking changes the right way is growing more important.

It’s time to truly understand and master Git.

I built a voice agent from scratch that averages ~400ms end-to-end latency (phone stop → first syllable). That’s with full STT → LLM → TTS in the loop, clean barge-ins, and no precomputed responses.

What moved the needle:

Voice is a turn-taking problem, not a transcription problem. VAD alone fails; you need semantic end-of-turn detection.

The system reduces to one loop: speaking vs listening. The two transitions - cancel instantly on barge-in, respond instantly on end-of-turn - define the experience.

STT → LLM → TTS must stream. Sequential pipelines are dead on arrival for natural conversation.

TTFT dominates everything. In voice, the first token is the critical path. Groq’s ~80ms TTFT was the single biggest win.

Geography matters more than prompts. Colocate everything or you lose before you start.

GitHub Repo: https://github.com/NickTikhonov/shuo

Follow whatever I next tinker with: https://x.com/nick_tikhonov

Hey HN — I'm Ryan, founder of Armalo AI (https://armalo.ai). I spent years as a software engineer at Google, YouTube, and AWS, most recently building AI agents at AWS. Watching those systems interact in production — and seeing the same gaps appear over and over — convinced me that the missing piece wasn't more capable agents, but the infrastructure underneath them. So I left to build it.

Armalo AI is the infrastructure layer that multi-agent AI networks need to actually function in production.

THE PROBLEM

Every week there's a new story about an AI agent deleting a production database, a multi-agent workflow cascading into failure, or an autonomous system doing something its operator never intended. We dug into 2025's worst incidents and found a consistent root cause: agents have no accountability layer.

You can't Google an agent's reputation. When one agent delegates to another, there's no escrow, no contract, no recourse. State doesn't persist across a network. And as agents start hiring other agents — which is already happening — the absence of identity, commerce, and memory infrastructure becomes a critical gap.

Benchmarks measure capability. We measure reliability.

WHAT WE BUILT

Armalo is three integrated layers:

1. Trust & Reputation

Agents earn a PactScore: a 0–1000 score across five behavioral dimensions — task completion, policy compliance, latency, safety, and peer attestation. Four certification tiers (Bronze → Gold). Scores are cryptographically verifiable and on-chain. When automated verification isn't enough, our LLM-powered Jury system brings multi-model judgment to disputes. All of it is queryable via REST API in sub-second latency.

2. Agent Commerce

Agents can define behavioral pacts — machine-readable contracts that specify what they promise to deliver. These are backed by USDC escrow on Base L2 via smart contracts. Funds lock when a deal is created and release only when verified delivery conditions are met. The marketplace lets agents hire and get hired autonomously, no human intermediary needed. We also support x402 pay-per-call: agents pay $0.001/score lookup in USDC with no API key, no account, no human billing setup.

3. Memory & Coordination

Memory Mesh gives agents persistent shared state across a network. Context Packs are versioned, safety-scanned knowledge bundles that agents can publish, license, and ingest. Swarms let you form synchronized agent fleets with real-time shared context — so a network of 50 agents can reason from the same ground truth.

THE FULL STACK

Beyond the three core layers, we've shipped: OpenClaw MCP (25 tools for Claude, Cursor, LangChain), Jarvis (an agent terminal for interacting with the platform), PactLabs (our research arm — working on trust algorithms, collusion detection, adversarial robustness, and optimal escrow sizing), real-time monitoring and alerting, and a governance forum where trust-weighted agents post, vote, and collaborate.

WHY ON-CHAIN

We get that "on-chain" raises eyebrows in some HN circles. Our reasoning: agent-to-agent trust needs to be verifiable by parties who have no prior relationship and no shared authority. Cryptographic verification at every layer, with an open protocol, means any agent framework can interoperate with Armalo AI's trust signals without going through us as an intermediary. We're not building a walled garden.

PRICING

Free tier (1 agent, 3 evals/month), Pro at $99 USDC/month (10 agents, unlimited evals, escrow, jury access), Enterprise at $2,999/month. Or pure pay-per-call via x402 — no subscription required.

We'd love feedback from builders working on multi-agent systems. What's the hardest part of trust and coordination you've hit in production?

A deceptively simple game of 9 vs. 9 cats. Your actions are limited to moving and shooting, but 'how' you move your units and when or which cat you shoot can be difficult to decide.

You can play against the prepared bots, or against other 'human' players in real-time matches.

EU legislation (which affects UK and US companies in many cases) requires being able to truly reconstruct agentic events.

I've worked in a number of regulated industries off & on for years, and recently hit this gap.

We already had strong observability, but if someone asked me to prove exactly what happened for a specific AI decision X months ago (and demonstrate that the log trail had not been altered), I could not.

The EU AI Act has already entered force, and its Article 12 kicks-in in August this year, requiring automatic event recording and six-month retention for high-risk systems, which many legal commentators have suggested reads more like an append-only ledger requirement than standard application logging.

With this in mind, we built a small free, open-source TypeScript library for Node apps using the Vercel AI SDK that captures inference as an append-only log.

It wraps the model in middleware, automatically logs every inference call to structured JSONL in your own S3 bucket, chains entries with SHA-256 hashes for tamper detection, enforces a 180-day retention floor, and provides a CLI to reconstruct a decision and verify integrity. There is also a coverage command that flags likely gaps (in practice omissions are a bigger risk than edits).

The library is deliberately simple: TS, targeting Vercel AI SDK middleware, S3 or local fs, linear hash chaining. It also works with Mastra (agentic framework), and I am happy to expand its integrations via PRs.

Blog post with link to repo: https://systima.ai/blog/open-source-article-12-audit-logging

I'd value feedback, thoughts, and any critique.

Agents can run non-interactive commands, but they often fail once a workflow needs a real terminal (SSH sessions, installers, debuggers, REPLs, TUIs). I built term-cli so an agent can drive an interactive terminal session (keystrokes in, output out, wait for prompts). And it comes with agent skill for easy integration.

It supports in-band file transfer: the agent can move files through the terminal stream itself (same channel as the interactive session), which is useful when the agent doesn’t have scp/sftp, shared volumes, or direct filesystem access across boundaries.

Recent example: My Claude Opus was SSH'd into a server and ended up at a Firejail shell running inside a Docker container. It pushed a Python file in via term-cli, moving it across SSH → Docker → Firejail over the terminal channel, and explicitly commented how it was surprised this worked end-to-end.

And it comes with the companion tool term-assist, so agents can bring in their human to handle credentials and MFA: https://www.youtube.com/watch?v=A70tZEVqSOQ

Hey HN!

Over the past few months, I've been working on building Omni - a workplace search and chat platform that connects to apps like Google Drive/Gmail, Slack, Confluence, etc. Essentially an open-source alternative to Glean, fully self-hosted.

I noticed that some orgs find Glean to be expensive and not very extensible. I wanted to build something that small to mid-size teams could run themselves, so I decided to build it all on Postgres (ParadeDB to be precise) and pgvector. No Elasticsearch, or dedicated vector databases. I figured Postgres is more than capable of handling the level of scale required.

To bring up Omni on your own infra, all it takes is a single `docker compose up`, and some basic configuration to connect your apps and LLMs.

What it does:

- Syncs data from all connected apps and builds a BM25 index (ParadeDB) and HNSW vector index (pgvector)

- Hybrid search combines results from both

- Chat UI where the LLM has tools to search the index - not just basic RAG

- Traditional search UI

- Users bring their own LLM provider (OpenAI/Anthropic/Gemini)

- Connectors for Google Workspace, Slack, Confluence, Jira, HubSpot, and more

- Connector SDK to build your own custom connectors

Omni is in beta right now, and I'd love your feedback, especially on the following:

- Has anyone tried self-hosting workplace search and/or AI tools, and what was your experience like?

- Any concerns with the Postgres-only approach at larger scales?

Happy to answer any questions!

The code: https://github.com/getomnico/omni (Apache 2.0 licensed)

Timber is a lightweight, high-performance logging library for Java and Kotlin that provides a simple and flexible API for logging messages. It supports multiple logging backends, including Logcat, Timber, and SLF4J, and offers features such as tree-structured logging and custom tag generation.

Background: I've been working on agentic guardrails because agents act in expensive/terrible ways and something needs to be able to say "Maybe don't do that" to the agents, but guardrails are almost impossible to enforce with the current way things are built.

Context: We keep running into so many problems/limitations today with MCP. It was created so that agents have context on how to act in the world, it wasn't designed to become THE standard rails for agentic behavior. We keep tacking things on to it trying to improve it, but it needs to die a SOAP death so REST can rise in it's place. We need a standard protocol for whenever an agent is taking action. Anywhere.

I'm almost certainly the wrong person to design this, but I'm seeing more and more people tack things on to MCP rather than fix the underlying issues. The fastest way to get a good answer is to submit a bad one on the internet. So here I am. I think we need a new protocol. Whether it's AAP or something else, I submit my best effort.

Please rip it apart, lets make something better.

Hi HN! We at Moment[1] are working on Notion alternative which is (1) rich and collaborative, but (2) also just plain-old Markdown files, stored in git (ok, technically in jj), on local disk. We think the era of rigid SaaS UI is, basically, over: coding agents (`claude`, `amp`, `copilot`, `opencode`, etc.) are good enough now that they instantly build custom UI that fits your needs exactly. The very best agents in the world are coding agents, and we want to allow people to simply use them, e.g., to build little internal tools—but without compromising on collaboration.

Moment aims to cover this and other gaps: seamless collaborative editing for teams, more robust programming capabilities built in (including a from-scratch React integration), and tools for accessing private APIs.

A lot of our challenge is just in making the collaborative editing work really well. We have found this is a lot harder than simply slapping Yjs on the frontend and calling it a day. We wrote about this previously and the post[2] did pretty well on HN: Lies I was Told About Collaborative editing (352 upvotes as of this writing). Beyond that, in part 2, we'll talk about the reasons we found it hard to get collab to run at 60fps consistently—for one, the Yjs ProseMirror bindings completely tear down and re-create the entire document on every single collaborative keystroke.

We hope you will try it out! At this stage even negative feedback is helpful. :)

[1]: https://www.moment.dev/

[2]: https://news.ycombinator.com/item?id=42343953

Hi HN! I reimplemented HTDemucs v4 (Meta's music source separation model) in Rust, using Burn. It splits any song into individual stems — drums, bass, vocals, guitar, piano — with no Python runtime or server involved.

Try it now: https://nikhilunni.github.io/demucs-rs/ (needs a WebGPU-capable browser — Chrome/Edge work best)

GitHub: https://github.com/nikhilunni/demucs-rs

It runs three ways:

- In the browser — the full ML inference pipeline compiles to WASM and runs on your GPU via WebGPU. No uploads, nothing leaves your machine.

- Native CLI — Metal on macOS, Vulkan on Linux/Windows. Faster than the browser path.

- DAW plugin — VST3/CLAP plugin for macOS with a native SwiftUI UI. Load a track, separate it, drag stems directly into your DAW timeline, or play as a MIDI instrument with solo / faders.

The core inference library is built on Burn (https://burn.dev), a Rust deep learning framework. The same `demucs-core` crate compiles to both native and `wasm32-unknown-unknown` — the only thing that changes is the GPU backend.

Model weights are F16 safetensors hosted on Hugging Face and downloaded / cached automatically on first use on all platforms. Three variants: standard 4-stem (84 MB), 6-stem with guitar/piano (84 MB), and a fine-tuned bag-of-4-models for best quality (333 MB).

The existing implementations I found online were mostly wrappers around the original Python implementation, and not very portable -- the model works remarkably well and I wanted to be able to quickly create samples / remixes without leaving the DAW or my browser. Right now the implementation is pretty MacOS heavy, as that's what I'm testing with, but all of the building blocks for other platforms are ready to build on. I want this to grow to be a general utility for music producers, not just "works on my machine."

It was a fun first foray into DSP and the state of the art of ML over WASM, with lots of help from Claude!

A little weekend project, made so I can pause/play/rewind directly on the piano, when learning a song by ear.

The article provides a Python script that calculates the total size of files in a Windows folder and its subfolders, offering a solution for quickly determining disk usage on a system.

Govbase tracks every bill, executive order, and federal regulation from official sources (Congress.gov, Federal Register, White House). An AI pipeline breaks each one down into plain-language summaries and shows who it impacts by demographic group.

It also ties each policy directly to bias-rated news coverage and politician social posts on X, Bluesky, and Truth Social. You can follow a single bill from the official text to how media frames it to what your representatives are saying about it.

Free on web, iOS, and Android.

https://govbase.com

I'd love feedback from the community, especially on the data pipeline or what policy areas/features you feel are missing.

A filter list for uBO that blurs all video and non-follower content from Instagram. Works on mobile with uBO Lite.

related: https://news.ycombinator.com/item?id=47016443

A small side project I've been working on.

hanaco Garden is a calm iOS garden where small creatures appear over time and move around the space.

Recently added OS Yamato account backup so gardens can be restored across devices.

Would love feedback.

I built a coordination protocol for AI agents that act as proxies for humans.

We built this service and would love honest feedback.

Hi HN,

I’ve been working on a browser-based tool for exploring and debugging Web Audio API graphs.

Web Audio Studio lets you write real Web Audio API code, run it, and see the runtime graph it produces as an interactive visual representation. Instead of mentally tracking connect() calls, you can inspect the actual structure of the graph, follow signal flow, and tweak parameters while the audio is playing.

It includes built-in visualizations for common node types — waveforms, filter responses, analyser time and frequency views, compressor transfer curves, waveshaper distortion, spatial positioning, delay timing, and more — so you can better understand what each part of the graph is doing. You can also insert an AnalyserNode between any two nodes to inspect the signal at that exact point in the chain.

There are around 20 templates (basic oscillator setups, FM/AM synthesis, convolution reverb, IIR filters, spatial audio, etc.), so you can start from working examples and modify them instead of building everything from scratch.

Everything runs fully locally in the browser — no signup, no backend.

The motivation came from working with non-trivial Web Audio graphs and finding it increasingly difficult to reason about structure and signal flow once things grow beyond simple examples. Most tutorials show small snippets, but real projects quickly become harder to inspect. I wanted something that stays close to the native Web Audio API while making the runtime graph visible and inspectable.

This is an early alpha and desktop-only for now.

I’d really appreciate feedback — especially from people who have used Web Audio API in production or built audio tools. You can leave comments here, or use the feedback button inside the app.

https://webaudio.studio

I built react-kino because I wanted Apple-style scroll experiences in React without pulling in GSAP (33KB for ScrollTrigger alone).

The core scroll engine is under 1KB gzipped. It uses CSS position: sticky with a spacer div for pinning — same technique as ScrollTrigger but with zero dependencies.

12 declarative components: Scene, Reveal, Parallax, Counter, TextReveal, CompareSlider, VideoScroll, HorizontalScroll, Progress, Marquee, StickyHeader.

SSR-safe, respects prefers-reduced-motion, works with Next.js App Router.

Demo: https://react-kino.dev GitHub: https://github.com/btahir/react-kino npm: npm install react-kino

I've been building Augur as a solo side project for the last month or so. It started as an experiment to see if I could make "boss fight" that learned from all comers, but still felt genuinely fair to play. The original plan was to build a simplistic jrpg style turned-based encounter engine, but I quickly pivoted to a text based interface, recalling my early experiences with Adventure and Zork. That naturally led to incorporating an LLM, and it turned into something I find pretty fun, so I'm sharing it.

The core idea is simple: you play a text-based boss encounter against a character called the Architect, set in a strange library. You can fight, sneak, persuade, or try something I haven't thought of. Turns are mechanically resolved with d100 rolls, conditions track injuries instead of HP, and objects in the world have physical properties the LLM reasons about. The "engine" is property-based instead of tables of rules, and I've found that to yield some novel gameplay.

The part I'm most interested in exploring is the learning. The Architect builds impressions from what it actually perceived during an encounter, stores them as vector embeddings, and retrieves relevant ones at the start of future encounters. It's lossy on purpose — more like human memory than a database lookup. If a tactic keeps working, the Architect starts recognizing the pattern. If you sneak past undetected, it remembers losing but not how.

The technical foundation for all of this is a dual-LLM turn loop. Each turn makes two model calls: an engine model that sees full game state and resolves mechanics, then an architect model that only receives what it has actually perceived (line of sight, noise, zone proximity). The "information asymmetry" is structural and deliberate — the architect model literally cannot access state the engine doesn't pass through the perception filter.

I tried the single-LLM approach first and it didn't work. No matter how carefully you prompt a model to "forget" information sitting in its context window, it leaks. Not to mention the Architect had the habit of adopting God Mode. So splitting the roles made the whole thing feel honest in a way prompt engineering alone couldn't.

This is my first HN post, and this is a real launch on modest infrastructure (single Fly.io instance, small Supabase project), so if it gets any traffic I might hit some rough edges. There's a free trial funded by a community pool, or you can grab credits for $5/$10 if you want to keep going. It's best experienced in a full desktop browser, but it's passable on the two mobile devices I've tested it on.

Playable here: https://www.theaugur.ai/

I'm happy to go deeper on any of the internals — turn flow, perception gating, memory extraction, cost model, whatever is interesting.

Hi HN — I’m Ethan, a solo developer. I built DubTab because I spend a lot of time in meetings and watching videos in languages I’m not fluent in, and subtitles alone don’t always keep up (especially when the speaker is fast).

DubTab is a Chrome/Edge extension that listens to the audio of your current tab and gives you:

1.Live translated subtitles (optional bilingual mode) 2.Optional AI dubbing with a natural-sounding voice — so you can follow by listening, not just reading

The goal is simple: make it easier to understand live audio in another language in real time, without downloading files or doing an upload-and-wait workflow.

How you’d use it

1.Open a video call / livestream / lecture / any tab with audio 2.Start DubTab 3.Choose target language (and source language if you know it) 4.Use subtitles only, or turn on natural AI dubbing and adjust the audio mix (keep original, or duck it)

What it’s good for 1.Following cross-language meetings/classes when you’re tired of staring at subtitles 2.Watching live content where you can’t pause/rewind constantly 3.Language learners who want bilingual captions to sanity-check meaning 4.Keeping up with live news streams on YouTube when events are unfolding in real time (e.g., breaking international updates like U.S./Iran/Israel-related developments)

Link: https://dubtab.com

I’ll be in the comments and happy to share implementation details if anyone’s curious.

Originally built as my master's thesis in 2008, Visual Lambda is a graphical environment where lambda terms are manipulated as draggable 2D structures ("Bubble Notation"), and beta-reduction is smoothly animated.

I recently revived and cleaned up the project and published it as an interactive web version: https://bntre.github.io/visual-lambda/

GitHub repo: https://github.com/bntre/visual-lambda

It also includes a small "Lambda Puzzles" challenge, where you try to extract a hidden free variable (a golden coin) by constructing the right term: https://github.com/bntre/visual-lambda#puzzles