Show stories

I needed a web terminal I could drop into K8s sidecars and internal tools without pulling in heavy dependencies or running a separate service. Existing options were either too opinionated about the shell or had fragile session handling around reconnects.

WooTTY wraps any binary -- bash, ssh, or custom tools -- and serves a browser terminal over HTTP. Sessions survive reconnects via output replay. There's a Resume/Watch distinction so multiple people can attach to the same session without stepping on each other.

https://github.com/vnglst/stacked-game-of-life

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.

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.

My personal Bash scripts turned full-on toolkit. Great for managing large datasets, backups, or just for quick file navigation.

Hi HN,

I’m an indie dev, and as my tech stack grew, so did the number of SaaS subscriptions and invoices. Every month, I’d get a chaotic pile of PDFs and image receipts. I absolutely hate bookkeeping. It breaks my flow state, and honestly, the last thing I want to do on a weekend is open an Excel spreadsheet to manually input tax data.

So I built Recite. Originally, it was just a simple web app that used vision models to parse receipts into clean CSV. But I realized I didn't even want to log into my own web app.

So I pivoted and turned it into a Public APIs/agent skill and an MCP server. Now, I just download all my invoices into a single local folder and tell my agent (I use OpenClaw), "Process my receipts."

The agent hits the Recite API, reads the images/PDFs, categorizes them using standard accounting logic, renames the files by date, and generates a structured CSV for me. I literally don't look at spreadsheets anymore.

How to use it:

Public API: Because we all love APIs. Agent Skill: The easiest way to let your agent do the work in environments like OpenClaw or Claude Desktop. MCP Server: If you want more control and want to build your own custom agentic workflows.

I’m currently focused on maxing out accuracy and keeping costs as close to zero as possible. There’s a generous free tier for indie devs because I know the pain.

I would love for you to try hooking it up to your agents and see if it saves you as much time as it saves me. Any feedback on the API or the categorization logic is highly appreciated!

Website: https://recite.rivra.dev/

API Docs: https://recite.rivra.dev/docs/api

MCP Setup: https://recite.rivra.dev/help#mcp-server

GitHub Skill: https://github.com/rivradev/recite-agent-skill

This week we released the Kodus CLI.

It took a bit longer than we expected to ship. The reason was simple: there are already many ways to run reviews locally today. IDEs, extensions, terminal commands, agents inside the editor. So building “just another AI CLI” didn’t seem like a good idea.

The question that guided the project was different: how can we bring the quality of PR reviews to the moment when the code is still being written?

Today the CLI does two main things.

The first is running local reviews using the same context we use in PRs. The goal was to avoid that shallow review that only looks at the diff currently open in the editor. We try to reconstruct more repository context, similar to what happens during a PR review.

The second is helping resolve comments that Kody has already left on a PR, but directly from the local environment. Instead of opening the PR, reading the comment, going back to the editor, making the change, and repeating the process, you can work through those fixes directly in your coding workflow.

The whole idea revolves around reducing the feedback loop time.

Some design decisions came from things we heard from teams using other CLIs.

Auth in large teams often turns into friction. Many tools assume each developer will create an account before using the CLI. That becomes painful when someone just wants to try it, or when an entire team decides to experiment.

We introduced team keys. An admin generates the key and shares it with the team. Anyone who installs the CLI can start using it right away.

Rate limits can ruin the local experience. Some tools work well at first but become too restricted for continuous use.

The CLI runs BYOK by default, so you can use your own API key if you want.

Code agents are already part of the workflow. Instead of treating this as something separate, we built two layers.

The CLI works as a direct interface to our API. On top of that, there are Skills that teach agents how to use the same review flow.

There’s still a lot to improve. Repo context, how suggestions are presented, integration with different developer workflows. We’re using it heavily internally and adjusting things as problems show up.

If anyone wants to try it or contribute:

- repo: https://github.com/kodustech/cli - feedback is very welcome - issues and PRs are too

If you usually run local reviews, I’d be curious to hear what actually works and what only sounds good in theory.

process demo - https://i.redd.it/fbhlwsq1gcmg1.gif render demo - https://i.redd.it/smddwtryhcmg1.gif in-app demo - http://app.topomaker.com/demo

After long stretches in 2d animation and film, recently I've been really drawn to 3d. It's closer to the way my brain thinks and I feel like it has so much power to realize cool ideas. Naturally, I kicked off a google search and fired up Blender. After an hour, I went on a walk and got sad realizing I'm going to have to become a master before I can do anything fun. That's when my dev ego brain struck the usual phrase "i'll just build my own".

So, I built Topomaker (name tentative), which is a minimal browser-based 3D modeler and animator. You can color individual faces, build simple characters or objects, animate them on a timeline, and export to gif, mp4, glb, or obj. The goal wasn't to make a Blender competitor, but more of a sketchpad or alternative. Something you can just doodle in, make some funny animations or characters for a small game with a closer connection to the web since thats my programming language of choice. Anyone who's tried to get Blender assets to match up in a Three.js environment knows the process — I wanted something that just lives in that ecosystem natively.

I just started it a couple weeks ago so there are probably tons of bugs, but feel free to play around with it and let me know what you think!

GitPulse is a web-based tool that provides insights and analytics for software development teams working on GitHub repositories. It offers features like branch visualization, commit activity analysis, and team collaboration tracking to help teams improve their workflow and productivity.

I use Claude every day but there are things I will not type into a cloud service. I have a Mac with Apple Silicon running Apple Foundation Models locally and privately. But I was not always at my Mac. So we built Perspective Intelligence Web. One Mac runs Perspective Server. Any device on your network opens a browser and chats with Apple Intelligence through it. Phone, Windows laptop, Chromebook, Linux machine. Streaming responses, token by token. Nothing leaves your network. MIT License. Next.js, TypeScript, Tailwind. Full writeup: https://taylorarndt.substack.com/p/i-opened-claude-and-then-...

I wrote a small Zsh plugin that lets you switch macOS Terminal.app profiles directly from the command line.

It's useful if you color-code environments (prod, staging, dev) or when you have a lot of terminals open of the same thing — multiple Claude or Codex sessions, SSH connections, or different projects — and want a quick visual way to tell them apart.

Type `profile` and press Tab to see and autocomplete all available Terminal.app profiles.

BePurple.ai is an AI-powered platform that helps businesses streamline their operations by automating various tasks, from customer support to marketing and sales. The platform leverages advanced AI and machine learning technologies to improve efficiency, reduce costs, and enhance the overall customer experience.

The article provides an overview of the Open Medical Language Exchange (OMLX), an open-source platform that enables the exchange and standardization of medical terminologies and ontologies. The OMLX aims to facilitate interoperability and improve the sharing of medical knowledge across various healthcare systems and applications.

Hi HN,

I've been using Claude Code etc. for nearly all my work lately, and I wanted to see how many of my commits it was actually co-authoring. So I made this little tool to visualize my usage.

You log in with Github (read-only), it scans your commits from the last year, and visualizes how many came from Claude, Cursor, or any tool that adds Co-Authored-By trailer to the commit message.

Caveat: not all tools add this trailer, so this doesn't include e.g. Codex. Still, hope you find it interesting!

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.

This article discusses the ClawSandbox project, a sandbox environment for running and testing applications that interact with the Linux file system and command-line interface. The project aims to provide a safe and isolated environment for developers to experiment and troubleshoot their programs without affecting the host system.

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 building mem.net, a file-first agent memory framework for .NET. In production, it scales out to Azure Blob and Azure AI Search. But I wanted the local execution experience to accurately mirror those production hybrid search capabilities—without forcing developers to spin up a heavy vector DB.

To bridge that gap, I built Retrievo: a pure in-memory hybrid search engine written entirely in C#. I’ve now integrated it as the default local search provider for mem.net.

Under the hood of Retrievo:

- BM25 + Vector search + RRF fusion

- Entirely in-process (zero external infrastructure needed)

- Validated retrieval quality against standard BEIR benchmarks

The result is you get production-grade hybrid search characteristics entirely in-process.

Repos:

- https://github.com/TianqiZhang/Retrievo

- https://github.com/TianqiZhang/mem.net

Curious to hear how others are handling local hybrid search for agent architectures. Happy to answer questions on the C# implementation or the BEIR benchmarking!

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.

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.

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)

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.

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.

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/

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

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!

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.

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