Show HN: Claude Code workflow: PRDs → GitHub Issues → parallel execution

Show HN: Dictly – Local, real‑time voice‑to‑text for macOS (sub‑100ms, no cloud)

Show HN: Dictly – Local, real‑time voice‑to‑text for macOS (sub‑100ms, no cloud) TL;DR: I built a native macOS dictation app that transcribes locally and instantly. Text appears as you speak (measured ~100 ms first‑character latency). No accounts, no servers, no tracking.Links: • Website: <a href="https://dictly.app" rel="nofollow">https://dictly.app</a> • Mac App Store: <a href="https://apps.apple.com/de/app/dictly-no-keys-just-clarity/id6752733596">https://apps.apple.com/de/app/dictly-no-keys-just-clarity/id...</a> • Free download; optional Pro tier (pipelines, unlimited history, etc.)What it doesReal‑time transcription — streaming text while you talk, not after you stop.Quick‑Capture Overlay (macOS) — global hotkey, drop text into any app/field.Custom Pipelines — local post‑processing steps for cleanup, punctuation, or house style.Dictionary Profiles — teach domain terms (names, brands, code tokens, etc.).Local Analytics — see time saved vs typing (computed on device, never sent anywhere).Why I built itI wanted dictation that felt as immediate as typing and was trustworthy. Most tools stream audio to a server; I wanted something that never leaves the machine.How it’s built (high‑level)Swift + Apple speech/ML frameworks. Streaming audio capture → on‑device recognition → local pipeline → paste into the active app. Works with Wi‑Fi off; there are no network requests in the transcription path.What’s different vs built‑insAlways on‑device + streaming with a global overlay that works in any app. Extensible, deterministic cleanup via pipelines (not a black‑box cloud). Per‑project dictionaries to tame jargon and proper nouns.Numbers (early)Latency: ~100 ms (first visible characters from speech onset) in typical conditions on modern Macs. Privacy: zero telemetry; no account; no background syncing. Everything stays local.Trade‑offs (calling them out up front)Accuracy depends on mic and environment (no surprise). For weird proper nouns/jargon, you’ll want a dictionary profile. Heavy background noise will degrade results (pipelines can only do so much).What I’m looking for from HNPerformance impressions on different hardware. Failure cases (accents, acronyms, coding, meetings). Pipeline ideas you’d actually use (e.g., Markdown formatting, code‑block guards, style rules). Integration wishes: CLI? Shortcut actions? Editor‑specific helpers?I’m a solo dev. Happy to answer pointed questions and ship fixes fast. If you spot hand‑wavy claims, call them out.

Show HN: Centia.io – Open PostgreSQL/PostGIS back end for developers

Show HN: Centia.io – Open PostgreSQL/PostGIS back end for developers Built a developer-friendly BaaS around PostgreSQL + PostGIS. Instant APIs, real-time updates, self-hostable Docker image. Feedback welcome

Show HN: The System Skill Pattern

Show HN: The System Skill Pattern Hello HN!I’ve been playing with Claude Skills and stumbled on a simple pattern for tiny, durable personal data systems:* CLI: a small, self-contained executable* SKILL.md: the operator guide (what to run, how to parse output, how to think about the system)* SQLite: a local DB for persistent stateIt’s nothing mind-blowing, but the ergonomics of this combo feel great.If you define a process/flow, Claude can "turn the crank" by running the CLI, accumulating context, and animating the system to life over time.They’re also easy to share: you can distribute System Skills via Claude Code’s `/plugin marketplace add <repo>`.More details in the blog post and the toy Pomodoro System Skill reference implementation here:Blog: <a href="https://www.shruggingface.com/blog/the-system-skill-pattern" rel="nofollow">https://www.shruggingface.com/blog/the-system-skill-pattern</a>Repo: <a href="https://github.com/jakedahn/pomodoro" rel="nofollow">https://github.com/jakedahn/pomodoro</a>--Curious whether any of this resonates. Also excited to hear any interesting System Skill ideas worth exploring!

Show HN: Open-source TypeScript SDK for sending and operating iMessages

Show HN: FlowLens – MCP server for debugging with Claude Code

Show HN: FlowLens – MCP server for debugging with Claude Code Hi HN,We often run into this with coding agents like Claude Code: debugging turns into copy-pasting logs, writing long explanations, and sharing screenshots.FlowLens is an MCP server plus a Chrome extension that captures browser context (video, console, network, user actions, storage) and makes it available to MCP-compatible agents like Claude Code.You can try it here: <a href="https://magentic.ai/flowlens" rel="nofollow">https://magentic.ai/flowlens</a>Any feedback—good, bad, or brutal—is welcome.

Show HN: Pg_textsearch – BM25 Ranking for Postgres

Show HN: Pg_textsearch – BM25 Ranking for Postgres I built pg_textsearch, a Postgres extension that brings proper BM25 ranking to full-text search. It's designed for AI/RAG workloads where search quality directly impacts LLM output.Postgres native ts_rank lacks corpus-aware signals (no IDF, no TF saturation, no length normalization). This causes mediocre documents to rank above excellent matches, which matters when your LLM depends on retrieval quality.Quick example:<pre><code> CREATE EXTENSION pg_textsearch; CREATE INDEX articles_idx ON articles USING bm25(content); SELECT title, content <@> to_bm25query('database performance', 'articles_idx') AS score FROM articles ORDER BY score LIMIT 10; </code></pre> Works seamlessly with pgvector or pgvectorscale for hybrid search. Fully transactional (no sync jobs). Preview release uses in-memory architecture (64MB default per index); disk-based segments coming soon.I love ParadeDB's pg_search but wanted something available on our managed Postgres. You can try pg_textsearch free on Tiger Cloud: <a href="https://console.cloud.timescale.com" rel="nofollow">https://console.cloud.timescale.com</a>Blog: <a href="https://www.tigerdata.com/blog/introducing-pg_textsearch-true-bm25-ranking-hybrid-retrieval-postgres" rel="nofollow">https://www.tigerdata.com/blog/introducing-pg_textsearch-tru...</a>Docs: <a href="https://docs.tigerdata.com/use-timescale/latest/extensions/pg-textsearch/" rel="nofollow">https://docs.tigerdata.com/use-timescale/latest/extensions/p...</a>Feedback welcome, especially from folks building RAG systems or hybrid search applications.

Show HN: Run any GitHub Action locally from your Cron job -- finally!

Show HN: Interactive timelines from Markdown – Chronos Timeline

Show HN: Interactive timelines from Markdown – Chronos Timeline Make time make sense. Create and share beautiful interactive timelines from plain text. Also available as an Obsidian plugin.Developers can render Chronos timelines in their apps with chronos-timeline-md library on NPM

Show HN: Django Keel – 10 Years of Django Best Practices in One Template

Show HN: Django Keel – 10 Years of Django Best Practices in One Template After a decade of shipping Django to production, I got tired of solving the same setup problems on every new project.Environment-first settings. Sensible auth defaults. Structured logging. CI from day zero. Pre-commit hooks. Docker. Security hardening. Every project meant two days of boilerplate before writing business logic.So I built Django Keel: a production-ready Django starter that eliminates the yak-shaving. GitHub: <a href="https://github.com/CuriousLearner/django-keel" rel="nofollow">https://github.com/CuriousLearner/django-keel</a>*What you get*:- 12-factor config with environment-based secrets - Production-hardened security defaults - Pre-wired linting, formatting, testing, pre-commit hooks - CI workflow ready to go - Clear project structure that scales - Documentation with real trade-offs explained*Background*:I maintained a popular cookiecutter template for years. Django Keel is what that should've been from the start—battle-tested patterns without the accumulated cruft.*Who it's for*:Teams and solo builders shipping Django to production who want a strong baseline without tech debt. Feedback welcome on what works, what doesn't, and what's missing. Issues and PRs appreciated.

Show HN: C and C++ preprocessor for modern memory safety

Show HN: C and C++ preprocessor for modern memory safety Cdefer A Next-Generation Memory-Safe Preprocessor for C & C++Bringing modern memory safety and zero-configuration builds to classic C & C++.

Show HN: Syna – Minimal ML and RL Framework Built from Scratch with NumPy

Show HN: Syna – Minimal ML and RL Framework Built from Scratch with NumPy Hello HN,I built Syna to understand how modern ML frameworks like PyTorch actually work — from the ground up.It’s a minimal, define-by-run (dynamic graph) framework inspired by DeZero, written entirely with NumPy. Unlike most libraries, Syna includes a basic reinforcement learning module right inside the same framework — no separate packages.It’s not about speed or GPUs — it’s about clarity, simplicity, and learning the internals of machine learning. Great for students, educators, and anyone curious about what’s really happening under the hood.GitHub: <a href="https://github.com/sql-hkr/syna" rel="nofollow">https://github.com/sql-hkr/syna</a>I also built a web app that visualizes how neural networks learn in real time — perfect for beginners exploring training dynamics:GitHub: <a href="https://github.com/sql-hkr/xor" rel="nofollow">https://github.com/sql-hkr/xor</a> Demo: <a href="https://sql-hkr.github.io/xor/" rel="nofollow">https://sql-hkr.github.io/xor/</a>Happy hacking!

Show HN: Proxmox-GitOps: Container Automation Metaframework (Recursive Monorepo)

Show HN: Proxmox-GitOps: Container Automation Metaframework (Recursive Monorepo) I'd like to share my open-source project Proxmox-GitOps, a Container Automation platform for provisioning and orchestrating Linux containers (LXC) on Proxmox VE - encapsulated as comprehensive Infrastructure as Code (IaC).TL;DR: By encapsulating infrastructure within an extensible monorepository - recursively resolved from Git submodules at runtime - Proxmox-GitOps provides a comprehensive Infrastructure-as-Code (IaC) abstraction for an entire, automated, container-based infrastructure.Originally, it was a personal attempt to bring industrial automation and cloud patterns to my Proxmox home server. It's designed as a platform architecture for a self-contained, bootstrappable system - a generic IaC abstraction (customize, extend, .. open standards, base package only, .. - you name it ;-)) that automates the entire infrastructure. It was initially driven by the question of what a Proxmox-based GitOps automation could look like and how it could be organized.Core Concepts:- Recursive Self-management: Control plane seeds itself by pushing its monorepository onto a locally bootstrapped instance, triggering a pipeline that recursively provisions the control plane onto PVE.- Monorepository: Centralizes infrastructure as comprehensive IaC artifact (for mirroring, like the project itself on Github) using submodules for modular composition.- Single Source of Truth: Git represents the desired infrastructure state.- Loose coupling: Containers are decoupled from the control plane, enabling runtime replacement and independent operation.It's a noncommercial, passion-driven project. I'm looking to collaborate with other engineers who share the excitement of building a self-contained, bootstrappable platform architecture that addresses the question: What should our home automation look like?I'd love to hear your thoughts!

Show HN: Nova: Open-source solution for CAD file conflicts

Show HN: Nova: Open-source solution for CAD file conflicts Hey HN,A friend at a hardware startup mentioned how their engineering team struggles with CAD file conflicts as PDM solutions are not affordable. Multiple engineers opening the same SolidWorks part = corrupted files and lost work.I was motivated and started building Nova. Nova is a open source file locking system, designed to support multiple CAD softwares with real time locking and live dashboard to keep design engineers in sync.Nova is built with python and Next.js.Get started with -<pre><code> git clone https://github.com/agg111/nova cd nova pip install -r requirements.txt nova start nova --help (for more commands) </code></pre> Open http://localhost:3000 in browserI am looking for early users to get some feedback and learn about more features or bottlenecks that mechanical design teams currently face.

Show HN: Osaurus – Ollama-Compatible Runtime for Apple Foundation Models

Show HN: Osaurus – Ollama-Compatible Runtime for Apple Foundation Models Osaurus is an open-source local inference runtime for macOS, written in Swift and optimized for Apple Silicon.It lets you run Apple Foundation Models locally — fully accelerated by the Neural Engine — while also exposing OpenAI- and Ollama-compatible endpoints, so you can connect your favorite apps, tools, or clients without any code changes.Key points:* Supports Apple Foundation Models natively* Compatible with OpenAI & Ollama APIs* ~7 MB binary, runs locally (no cloud, no telemetry)* MIT Licensed, open sourceProject: <a href="https://osaurus.ai" rel="nofollow">https://osaurus.ai</a>Source: <a href="https://github.com/dinoki-ai/osaurus" rel="nofollow">https://github.com/dinoki-ai/osaurus</a>We’re exploring what a local-first AI ecosystem could look like — where inference, privacy, and creativity all happen on your own hardware. Feedback and testing welcome!

Show HN: FFTN, faster than FFTW in 700 lines of C

Show HN: FFTN, faster than FFTW in 700 lines of C I am playing around with using arrays of arbitrary dimension as framework for designing FFT implementations, as opposed to the more classical approach of tensor products and butterflies (too complicated in my opinion).It turns out, that with a modern compiler, you do not need much complexity to make a really fast implementation. This implementation is for powers of 2, and optimized for arrays that do not fit in cache. I do think it would be better to use a higher-level language to implement other cases (e.g. n = 2^a * 3^b * 5^c, multiple small FFTs, higher-dimensional), so I am currently working on getting the SaC-compiler to generate this code.

Show HN: I made a calculator that works over disjoint sets of intervals

Show HN: I made a calculator that works over disjoint sets of intervals I've been studying interval arithmetic for the past few weeks and it's a really interesting field because while there is a ton of super interesting research published over the past decades, it has never really gotten the recognition that it deserves, IMO.One reason for this is that standard interval arithmetic has really poor handling of division by intervals containing zero. If you compute 1 / [-1, 2] in regular interval arithmetic, you get either [-∞, +∞], or you have to say that the operation is undefined. Both solutions are virtually useless. The real answer of course is [-∞, -1] U [0.5, +∞]: i.e. a union of two disjoint intervals.This is useful because you can confidently exclude a non empty set of the real numbers ([-1, 0.5]) from the set of possible values that you can get by dividing 1 by a number between -1 and 2.But this definition of interval division yields a value that is not an interval. This is a problem if you want to define a closed arithmetic system, where you can build and evaluate arbitrary expression over interval values.(This behavior extends to any non continuous function like tan() for example, which is implemented in my project - not without difficulties!)Well the obvious solution is to define your arithmetic over disjoint unions of intervals. This is the subject of a 2017 paper called "Interval Unions" by by Schichl, H., Domes, F., Montanher, T. and Kofler, K..This open-source project I made implements interval union arithmetic in TypeScript in the form of a simple interactive calculator, so you can try it out for yourself! The underlying TypeScript library is dependency free and implements interval union arithmetic over IEEE 754 double precision floats (JS native number type) with outward rounding. This guarantees accuracy of interval results in the presence of rounding issue inherent to floating point.

Show HN: Run PyTorch locally with a remote GPU backend

Show HN: Run PyTorch locally with a remote GPU backend I integrated a remote GPU execution backend into PyTorch through the same system that custom hardware accelerators get integrated into PyTorch. You can create a remote machine and obtain its CUDA device whenever you want to create or move tensors onto the remote GPU.<pre><code> machine = mycelya_torch.RemoteMachine("modal", "A100") cuda_device = machine.device("cuda") x = torch.randn(1000, 1000, device=cuda_device) y = torch.randn(1000, 1000).to(cuda_device) </code></pre> I made it reasonably performant by having most operations dispatch asynchronously whenever possible. For cases where slow performance is unavoidable such as uploading many GB of weights onto the GPU, I added a decorator that can be applied to functions to turn it into a remotely executed function. For the most part, the function should behave the same with or without the decorator; the main difference is whether the function code is executed locally or remotely.<pre><code> import mycelya_torch from transformers import AutoModelForCausalLM, AutoTokenizer @mycelya_torch.remote def load_model(model_name: str): tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype="auto", device_map="auto" ) return model, tokenizer </code></pre> You can only use it with Modal as the cloud provider right now, and it's free to use with their free monthly credits. I appreciate any feedback and bug reports :)

Show HN: Hyprvoice – Voice-Powered Typing for Wayland/Hyprland (No X11 Hacks)

Show HN: Hyprvoice – Voice-Powered Typing for Wayland/Hyprland (No X11 Hacks) I built Hyprvoice, a small tool that lets you type with your voice on Wayland — no X11, no kludgy bridges. Press a key, talk, and your words appear wherever your cursor is.It’s written in Go, uses PipeWire for audio, and talks directly to the compositor. The workflow is simple:press key → start recordingpress again → stop and inject textNotifications show recording/transcribing states, and it works with multiple backends — currently OpenAI Whisper, with whisper.cpp (local/offline) in progress.Everything runs through a lightweight daemon with IPC over a unix socket. Text injection uses wl-clipboard + wtype with clipboard restore fallback.Install (Arch/AUR):yay -S hyprvoice-bin systemctl --user enable --now hyprvoice.serviceThen add something like this to Hyprland:bind = SUPER, R, exec, hyprvoice toggleRepo: <a href="https://github.com/leonardotrapani/hyprvoice" rel="nofollow">https://github.com/leonardotrapani/hyprvoice</a>It’s beta but fully usable. I’d love feedback, especially from people running Wayland full-time or maintaining compositors.

Show HN: Vello's high-performance 2D GPU engine to .NET

Show HN: Vello's high-performance 2D GPU engine to .NET VelloSharp v0.5.0-alpha.1 is now available, delivering Vello’s high-performance 2D GPU engine to .NET atop the wgpu 3D backend. Integrates cleanly with Avalonia, WPF, and WinForms to modernize rendering pipelines without disruptive rewrites.

Show HN: Rebuilt Bible search app to run 100% client-side with Transformers.js

Show HN: Rebuilt Bible search app to run 100% client-side with Transformers.js I rebuilt Biblos, my semantic Bible search app, to run entirely in your browser. No more server costs. The main challenge was fitting an accurate text embedding model into browsers. Last year's version cost $20 monthly to host. The new version runs free on Vercel and searches 31k Bible verses without sending data to any server.I pre-compute embeddings for all 31,000 Bible verses offline using BGE-large-en-v1.5. Each verse becomes a 1024-dimensional vector stored as JSON, compressed into ZIP files by book. When you visit the site, your browser downloads Transformers.js and the BGE model.The model generates an embedding for your query, then finds similar verses using cosine similarity against the cached embeddings. Everything happens in your browser.The app is designed to search Bible verses by semantic meaning, not just keywords. There's a separate tab to read daily passages with church fathers commentary from 15+ sources, based on a read the bible in a year plan.Free to use, no sign-in features or anything like that. Try it out biblos.app. I'd appreciate feedback on the search experience, especially on mobile devices! Happy to discuss the technical details or help anyone building similar browser-based ML applications.

Show HN: Static builds of popular open source libraries on npmjs.org

Show HN: Rustacean AI – Tracking Rust's Expanding Role in AI

Show HN: Rustacean AI – Tracking Rust's Expanding Role in AI Rustacean AI, a weekly newsletter exploring how Rust is shaping the future of AI and Machine Learning. Issue #1: From Models to Data — Rust’s Expanding Role in AI Covers the growing Rust ecosystem around AI frameworks (Burn), data systems (Polars, Qdrant, Daft), and emerging tools that power safe, high-performance pipelines. The goal is to curate news, releases, and experiments from across the Rust + AI community — helping developers follow how the language is influencing the next generation of infrastructure. Read first issue here → <a href="https://rustacean.ai/p/issue-1-from-models-to-data-rust-s-expanding-role-in-ai" rel="nofollow">https://rustacean.ai/p/issue-1-from-models-to-data-rust-s-ex...</a>

Show HN: Twoway, a Go package for HPKE encrypted request-response flows

Show HN: Twoway, a Go package for HPKE encrypted request-response flows Hey HN,I'm Willem from Confident Security, we've built CONFSEC, a provably private AI inference engine. Today, we're excited to open-source twoway: <a href="https://github.com/confidentsecurity/twoway" rel="nofollow">https://github.com/confidentsecurity/twoway</a>twoway is a Go package that makes it easy to implement secure, encrypted request-response flows. It powers CONFSEC's blind prompt handling, ensuring no one, not even us, can see client requests.We built twoway on Cloudflare's circl/hpke, it uses Hybrid Public key Encryption to implement two flows: - A one-to-one flow where a sender communicates with a single receiver. This flow is fully compatible with RFC 9458 Oblivious HTTP (OHTTP), and the chunked OHTTP draft RFC. - A one-to-many flow where a sender communicates with one or more receivers. Similar to the Apple's PCC's request flow.Other features include: - Compatibility with any transport, twoway deals with just the messages. - Chunked messages. - Allows for custom HPKE implementations for specialized needs like cryptographic hardware modules.Our README has clear examples to get you started, all you need to do is go get and try an encrypted "Hello world" exchange.Our team will be popping in to answer questions, we'd love to hear your feedback.Cheers! Willem

Show HN: Agentic Design Patterns – Python Edition, from the Codex Codebase

Show HN: Agentic Design Patterns – Python Edition, from the Codex Codebase While reading Agentic Design Patterns by Antonio Gulli, I wanted to see how these patterns look in real code. I cloned the OpenAI Codex repo (the open-source AI coding assistant that recently trended on HN) — but it was in Rust.So, I used an Cursor to help me extract and translate 18+ agentic patterns from Codex’s codebase into Python. That small experiment turned into a full open-source guide: GitHub: Codex Agentic Patterns <a href="https://github.com/artvandelay/codex-agentic-patterns" rel="nofollow">https://github.com/artvandelay/codex-agentic-patterns</a>Each pattern comes with:A short explanation and code sampleA runnable exercise and agent snippetA summary of how Codex used the pattern (e.g., prompt chaining, tool orchestration, reflection loops, sandbox escalation)One full working Python agent that ties it all togetherIf you’ve read the agentic design patterns book or explored Codex, this is a bridge between theory and practice — focused on runnable, open examples instead of abstract diagrams.It’s completely free and open-source. Would love feedback, ideas, or even new patterns from your own agent experiments.

Show HN: Rethinking audit trails in Django (structured and database-free)

Show HN: Rethinking audit trails in Django (structured and database-free) We were using django-easy-audit to track CRUD and API events in Django. The problem: every action meant an extra database write, which slowed transactions, increased infra costs, and left us with audit tables that weren’t great for analytics.I built django-activity-audit (PyPI) to fix this: - Extends Django’s logging system with custom AUDIT and API levels. - Captures CRUD + API request/response events as structured JSON logs. - Vector tails the logs and ships them into ClickHouse. - Grafana makes them queryable and visual.This removes the extra DB writes, gives structured data ready for analysis, and keeps costs down.Curious — how are others handling audit logging in Django (or other frameworks)? Do you log it, write it to a DB, or something else entirely?

Show HN: We trained an MoE LLM built for developer tasks

Show HN: Kalendis – Scheduling API (keep your UI, we handle timezones/DST)

Show HN: Kalendis – Scheduling API (keep your UI, we handle timezones/DST) Kalendis is an API-first scheduling backend. You keep your UI; we handle the gnarly parts (recurrence, time zones, DST, conflict-safe bookings).What it does:• MCP tool: generates typed clients and API route handlers (Next.js/Express/Fastify/Nest) so you can scaffold calls straight from your IDE/agent tooling.• Availability engine: recurring rules + one-off exceptions/blackouts, returned in a clean, queryable shape.• Bookings: conflict-safe endpoints for creating/updating/canceling slots.Why we built it:We kept rebuilding the same "hard parts" of scheduling: time zones/DST edge cases, recurring availability, conflict-aware booking, etc. We wanted a boring, reliable backend so we could ship product features without adopting a hosted scheduling UI.How it's helped:We stopped re-implementing DST/recurrence math and shipped booking flows faster.One small team (just 2 developers) built a robust booking platform for their business using Kalendis—they kept full control of their UX without spending lots of cycles on scheduling infrastructure.The MCP generator cut the glue code: drop in a typed client or route, call the API, move on.Some tech details:• REST API with ISO-8601 timestamps and IANA time zones• Recurring availability + one-off exceptions (designed to compose cleanly)• Focused scope: users, availability, exceptions, bookings (not a monolithic suite)MCP integration:MCP server exposes tools like generate-frontend-client, generate-backend-client, generate-api-routes, and list-endpoints.Add to your MCP settings:{ "mcpServers": { "kalendis": { "command": "npx", "args": ["-y", "@kalendis/mcp"] } } }How to try it:Create a free account → get an API key. (<a href="https://kalendis.dev" rel="nofollow">https://kalendis.dev</a>)Hit an endpoint:curl -H "x-api-key: $KALENDIS_API_KEY" \ "https://api.kalendis.dev/v1/availability/getAvailability?userId=<user-id>&start=2025-10-07T00:00:00Z&end=2025-10-14T00:00:00Z&includeExceptions=true"What feedback would be most useful:Gaps in the endpoint surface (what's missing for your use case?).Features that would benefit this service integration in your app.MCP generator output—anything you'd want it to emit differently?Happy to answer questions and post example snippets in the thread. Thanks for taking a look!— Dave (Kalendis)

Show HN: FizzBee – Formal Model based autonomous testing

Show HN: FizzBee – Formal Model based autonomous testing GitHub: <a href="https://github.com/fizzbee-io/fizzbee-mbt-examples" rel="nofollow">https://github.com/fizzbee-io/fizzbee-mbt-examples</a> Quick Start: <a href="https://fizzbee.io/testing/tutorials/quick-start/" rel="nofollow">https://fizzbee.io/testing/tutorials/quick-start/</a>Most developers agree testing is important. At the same time, most developers don’t enjoy writing tests. With AI generating code faster than ever, testing is becoming even more crucial. But even AI-generated tests need review and maintenance, which makes them another burden.I'm introducing another form of autonomous testing - "model-based testing". Instead of writing test cases, you describe expected behavior in a Python-like specification language.The FizzBee model can be: - Verified exhaustively for design bugs (like formal methods). - Mapped to your actual system, automatically generating the tests.This gives you:- No hand-crafted test cases - Automatic testing of concurrent as well as sequential behavior - No cascading test rewrites when behavior changes - No cluttering the SUT with tracing codeWith FizzBee, you get both design validation (like in formal methods) and automatic test generation, saving time and effort.Currently, only Go is supported. Java and Rust are next and would love to hear which language you’d want supported next.I’d love your feedback!

Show HN: Mix – Open-source multimodal agents SDK

Show HN: Mix – Open-source multimodal agents SDK Why we built it: • Claude Code: great for coding, but no video/audio support, localhost only • OpenAI SDK: single-model, no native multimedia tools • Both: no integrated DevTools for debugging agent reasoningSo, we built Mix as an alternative for multimodal applications. • Native video/audio/PDF analysis tools (via Gemini for vision, Claude for reasoning) • Multi-model routing instead of single-provider lock-in • One-command Supabase setup for cloud deployment (vs localhost-only) • HTTP architecture that enables visual DevTools alongside agent workflows • Go backend: 50-80% lower memory footprint than Node.js—efficient for concurrent agent sessions. Python and typescript clients are availableExample use cases in the demo video: portfolio analyzer that reads Excel and generates charts, YouTube search agent that finds and edits video clips.GitHub: <a href="https://github.com/recreate-run/mix" rel="nofollow">https://github.com/recreate-run/mix</a> Demo video: <a href="https://youtu.be/IwgKt68wQSc" rel="nofollow">https://youtu.be/IwgKt68wQSc</a>Would appreciate feedback, especially from folks building multimodal agents.

Show HN: 1-Bit Pixel Art Font Editor

Show HN: 1-Bit Pixel Art Font Editor I like making small fonts for Arduino and ESP32 projects with those little SSD1306 OLED screens. So I made this browser-based tool to help design pixel art fonts for use in those embedded projects.It has a preview area that updates when you save your character. It can support fixed-width and variable-width fonts. And when you're done you can export the font in a few different formats.It comes with a bunch of example fonts built-in. Also it's fully client-side code so you can save the webpage to use it offline.If you want some inspiration for fonts, I made a bunch of really small fonts a few years ago: <a href="https://www.moonbench.xyz/projects/tiny-pixel-art-fonts/" rel="nofollow">https://www.moonbench.xyz/projects/tiny-pixel-art-fonts/</a>

Show HN: Envirobly – Efficient App Hosting

Show HN: Envirobly – Efficient App Hosting This is my, fully bootstrapped, take on an application hosting platform. I designed it primarily for myself, to meet the following goals:* Utilize the best parts of the cloud, leave expensive value added services behind. * Host anywhere in the world, close to your users. * Batteries included: backups, logging, monitoring, auto-scaling, containerization, databases. * Simple and user friendly.The journey was tough. It took me round about 3 years to get everything just right. This goes against the conventional wisdom of getting something simple out quick. With a hosting platform however, in my mind, reliability, stability and certain maturity are a must have from the start.I definitely need to work on the presentation, it's barely covering the basics. But you have to start somewhere :-)I'd love to hear some critique from the community. Thanks!

Show HN: A Node.js CLI tool to generate ai.txt, llms.txt, robots.txt, humans.txt

Show HN: RenderarXiv – Search ArXiv from terminal, HTML to read/paste into LLM

Show HN: RenderarXiv – Search ArXiv from terminal, HTML to read/paste into LLM Terminal tool to search arXiv papers and render them as beautiful HTML for humans and LLMs

Show HN: API for removing watermarks from Sora 2 videos

Show HN: API for removing watermarks from Sora 2 videos Computer vision for detection, advanced inpainting for removal, FFmpeg for audio handling. Simple REST endpoints with webhook callbacks for async processing.Built this after seeing developers struggle with building their own ML pipelines for video post-processing. The API handles the complexity—you just POST a video and get back a clean file

Show HN: Pluqqy – Terminal based context management tool for AI coding

Show HN: Pluqqy – Terminal based context management tool for AI coding I vibe-coded a terminal tool called Pluqqy (I had a dormant domain on hand) to help me keep LLM context organized while coding with AI. It’s my first time writing Go and my first terminal app, built almost entirely with Claude Code.• What it does: Pluqqy lets you manage prompts, rules, and context as small building blocks, then stitch them together into a single file (like AGENT.md or CLAUDE.md) that your coding agent can consume. It’s meant to reduce context drift and make iteration easier.• Why I built it: I was losing track of my agent context between sessions and wanted something lightweight, reproducible, and terminal-native.• Status: This is more of an experiment / thought-tool than a maintained project. It works on Mac; Windows/Linux haven’t been tested much.• Install: go install github.com/pluqqy/pluqqy-terminal/cmd/pluqqy@latest• Landing page: <a href="https://pluqqy.com" rel="nofollow">https://pluqqy.com</a> (just had fun with it)

Show HN: Gooey – Opinionated Go WebASM Framework

Show HN: Silobase – Firebase/Supabase alternative as NPM package

Show HN: Silobase – Firebase/Supabase alternative as NPM package I built Silobase , an open-source backend-as-a-service packaged as an npm module.With just a package.json and a .env file, you can deploy a REST API on top of your own database.

Show HN: Next.js-like Python web framework, built for Htmx with FastAPI

Show HN: Next.js-like Python web framework, built for Htmx with FastAPI It's very early days for the project, but I wanted to share it to see if there is interest.It is the final piece of the FastAPI server-side rendering stack I started building with FastHX and htmy (the two dependencies of this project besides FastAPI).Think of it as a more powerful and convenient alternative to tools like FastHTML, powered by FastAPI (without any modifications). I hope you'll like it.

Show HN: Glide, an extensible, keyboard-focused web browser

Show HN: I built an IDE for devs who live in the terminal

Show HN: Devbox – Containers for clean dev environments

Show HN: Devbox – Containers for clean dev environments I've been frustrated with dependency hell and clutter on my VPS from dev, so I built Devbox: a lightweight, open-source CLI tool that spins up isolated development environments using Docker. Each project runs in its own container, but your code stays in simple flat folders on the host machine—no messing with volumes or sync issues. Environments are disposable, so you can nuke and recreate them without losing your work. Key features:- Instant setup: `devbox init my-project` and you're in a fresh env with `devbox shell`.- Configurable via JSON: Define packages, services, and more in a `devbox.json` file. Share it in your repo for reproducible setups—teammates just run `devbox up`.- Docker-in-Docker by default: Build and run containers inside your env without extra config.- Host-friendly: Edit code directly on your machine; the container handles the runtime.- Templates for quick starts: Built-ins for Python, Node.js, Go, web dev, etc.- Advanced options: Port mapping, env vars, resource limits, and even mounting your dotfiles.It's FOSS (MIT license), Linux-focused (Debian/Ubuntu, or WSL2 on Windows), and super easy to install: `curl -fsSL <a href="https://devbox.ar0.eu/install.sh" rel="nofollow">https://devbox.ar0.eu/install.sh</a> | bash`.Check out the launch page and docs at <a href="https://devbox.ar0.eu" rel="nofollow">https://devbox.ar0.eu</a>, or the repo at <a href="https://github.com/itzCozi/devbox" rel="nofollow">https://github.com/itzCozi/devbox</a>. I'd love some feedback, stars, or contributions to help grow this into a solid community tool!

Show HN: WindowSill

Show HN: WindowSill Hey everyone! I'm excited to unveil WindowSill, a universal command bar for Windows 10 and 11 that brings AI-powered text assistance and a suite of productivity tools directly to wherever you're working.Why WindowSill? Inspired by the MacBook Touch Bar, StreamDeck, and Apple Intelligence, I wanted a tool that gives context-aware actions without interrupting my workflow. WindowSill is my take on that idea for Windows.What it can doAI text assistant Select any text in any app to summarize, rewrite, translate, or fix grammar instantly. No copy/paste needed. No switching apps needed.Short-Term Reminders Set reminders that can pop up as full-screen notifications, so you can't miss them. Perfect for ADHD brains, multitaskers, or anyone who needs a firm nudge to stay on track of things.Clipboard history Access your recent copies without switching apps.URL & text utilities Select any URL in any app to shorten it or generate a QR Code.Media & Meetings controls Manage playback, mute/unmute from Microsoft Teams, even when the app is in the background or minimized.Personalization Save custom prompts, dock the "sill" to the top, bottom, left, right, or change its size to reflect your style and needs.All from a single, universal command bar that stays out of your way — no friction, no app switching.Bonus: the app is extensible! It comes with an SDK allowing any app to integrate with WindowSill.Who is it for? Mainly Windows power users, but also anyone looking to boost their productivity with AI-powered text assistance and quick access to useful tools.Try it today for free! Visit <a href="https://getwindowsill.app" rel="nofollow">https://getwindowsill.app</a> Product Hunt launch: <a href="https://www.producthunt.com/products/windowsill-2" rel="nofollow">https://www.producthunt.com/products/windowsill-2</a>I'd love your feedback: what features would make WindowSill most useful for you? Or what would you like to see next?

Show HN: Tips to stay safe from NPM supply chain attacks

Show HN: Tips to stay safe from NPM supply chain attacks Hi everyone, given the recent increase of attacks on the NPM supply chain, I've put together a list of tips and tricks to help developers stay secure on this specific topic: <a href="https://github.com/bodadotsh/npm-security-best-practices" rel="nofollow">https://github.com/bodadotsh/npm-security-best-practices</a>I'd love for you to check it out, and contribute your own insights and best practices to make this a comprehensive resource for the community.Cheers!

Show HN: OS layer for running multiple Codex agents in parallel

Show HN: OS layer for running multiple Codex agents in parallel We built an open source layer to orchestrate multiple Codex agents in parallel. Found myself and some friends running Codex agents across multiple terminals. Thats why me and a friend built emdash. Each agent gets its own isolated workspace, making it easy to see who’s working, who’s stuck, and what’s changed.

Show HN: GPU Kill – A CLI tool to kill stuck GPU jobs without rebooting

Show HN: I made AquaShell, a scripting and automation environment for Windows

Show HN: I made AquaShell, a scripting and automation environment for Windows Being inspired by old third-party scripting environments such as AutoIt or AutoHotkey, I've developed my own scripting environment for Windows. I've always been fascinated by creating an own programming language and I made the syntax in a way it feels more like something that contains a personal flavor.The language matured over the years and I both use it for administration and automation tasks, but also for fully scripted applications as well.On the homepage, you'll find various production scripts as well as links to scripted applications.The scripting environment is free and open-source software, released under the MIT license.

Show HN: Made NZ's member of parliament financial disclosure data searchable

Show HN: Made NZ's member of parliament financial disclosure data searchable New Zealand Members of Parliament are required to annually disclose their financial interests (shareholdings, directorships, consultancies, etc.) but this gets published annually as an unwieldy 80+ page PDF that's hard to search effectively.I processed structured data out of the PDF and built a searchable interface: <a href="https://open-register-of-pecuniary-interests.joshmcarthur.com/" rel="nofollow">https://open-register-of-pecuniary-interests.joshmcarthur.co...</a>.You can search across all MPs' disclosed interests by name, company, or interest type. For example, you can quickly find which MPs have interests in specific sectors or companies, filter by category or political party.The data extraction was interesting - I found that a two-pass approach worked well with Gemini 2.5 Flash - one to pull out MP names and referenced page numbers, then I extracted the specific pages each MP appeared on and extracted structured data just from these pages.The approach could work for similar transparency registers in other countries - most seem to publish open data as PDF, which technically ticks the box, but isn't the most accessible format to work with. Even within NZ, I'm planning to expand the data I process to previous years, as well as processing data for local and regional councils (who have the same legal requirement to publish financial interests of council members).Open sourced at <a href="https://github.com/joshmcarthur/open-register-of-pecuniary-interests" rel="nofollow">https://github.com/joshmcarthur/open-register-of-pecuniary-i...</a>.Tech stack: Ruby on Rails, SQLite (FTS5), Tailwind/DaisyUI - keeping it lightweight since this is just a side project to make public data more accessible.

Show HN: Ghostpipe – Connect files in your codebase to user interfaces

Show HN: Ghostpipe – Connect files in your codebase to user interfaces Hey HN!I built Ghostpipe because:1. I like to keep data about my software in the codebase and under version control.2. I don’t like always working in raw text files with domain specific languages (eg Terraform, Openapi, er diagrams).Ghostpipe is an open source tool that creates a bridge between files in your codebase and applications using webrtc. This lets developers work with user interfaces where appropriate, while still having access to the underlying raw text files.A few side-benefits to this setup are:1. AI agents are good at working with local text files, so we can keep using those.2. Generally speaking, no signup or installation is needed to use Ghostpipe apps, because all relevant data is in the codebase.I built a few demo apps with Ghostpipe support (Excalidraw & Swagger UI), and I hope this proof of concept spurs some interest in taking this idea further.Thanks!

Show HN: I wrote a from-scratch OS to serve my blog

Show HN: I wrote a from-scratch OS to serve my blog Hey HN! This is a fun/educational project I built to learn OS programming. I started working on it right after graduating high school last year and have been working on it on and off during my first year of university. It features a TCP/IP stack, an HTTP server, a RAM file system, a BIOS bootloader, paging and memory management, and concurrent tasks based on cooperative scheduling, along with a custom library. It's written in a C programming style focused on safety (based on a custom library of core abstractions) that's inspired by the writing of Chris Wellons (nullprogram.com).There is a link to a test deployment in the README. The TCP/IP implementation is nowhere near perfect, of course, so there may be issues loading the page. I'm curious how the system holds up if this post gets any attention ;-)

Show HN: HN Term – browse HN using the terminal

Show HN: HN Term – browse HN using the terminal Hey HN! I've created a terminal interface to browse HN using only the keyboard.You can expand/hide replies, open external links, browse top, new, ask, show and jobs.All key bindings and theme colors are customizable :)It was built with React, OpenTUI, bun and HN API, had a lot of fun building this, excited to hear your feedback!

Show HN: Tsink – Embedded time-series database for Rust

Show HN: I built a tool to find trading signals that aren't just random luck

Show HN: I built a tool to find trading signals that aren't just random luck Hi HN,I'm a solo dev and for the last few months I've been building Hikaro, a tool to find statistically significant trading signals for [e.g., US equities, crypto, forex].I built this to solve my own problem: I was tired of backtests that looked great on paper but failed in practice. Simple metrics like "win rate" can be misleading, so I wanted a way to quickly tell if a signal's performance was genuine or just noise.Hikaro ingests daily market data and runs statistical analysis on various trading signals. The goal is to surface signals with strong properties, like:Low p-value: Evidence that the performance is not a random fluke. High Sharpe Ratio: Better risk-adjusted returns. Healthy 'Core Performance': The average return after removing the single best outlier trade, for a more conservative view. Other key metrics like Profit Factor and Max Drawdown that you can filter by.I'm looking for my first users and would love your feedback. I'm offering a 30-day free trial of the Pro plan (which includes Telegram alerts) with no credit card required.I'll be here all day to answer any questions. I'm especially keen to hear feedback on the concept and the metrics.Thanks, HN!

Show HN: Kafkatop, top-like CLI for Kafka

Show HN: Kafkatop, top-like CLI for Kafka Hey HN, for those of you tired of running kafka-consumer-groups.sh and similar tools, here's a small real-time monitoring CLI tool for Apache Kafka, that displays consumer lag and event rates in a clean, top-like interface. You can quickly assess which consumers are lagging and when they will catch up.I've made this to quickly assess the health of remote on-premises clusters which most of the time lack proper monitoring.The tool can be found here: <a href="https://github.com/sivann/kafkatop" rel="nofollow">https://github.com/sivann/kafkatop</a>I'd be very interested to hear your feedback or any features you think would add value to this tool!

Show HN: Llmswap – Universal AI SDK and Code Generation CLI

Show HN: Llmswap – Universal AI SDK and Code Generation CLI I was constantly switching between my terminal and ChatGPT/Claude/Gemini for code help. Built llmswap 4.1.1 to fix this.Now I just type: llmswap generate "command I need"Real examples that save hours:Site emergency - needed to debug compressed logs:llmswap generate "grep through gzipped nginx logs for errors"Got: zgrep -i "error\|fail" /var/log/nginx/*.gz | head -50That regex everyone googles:llmswap generate "extract all IP addresses from log file"Got: grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log | sort | uniq -cComplex configs? No problem:llmswap generate "docker compose for Prometheus Grafana monitoring" > stack.yml80 lines of production-ready YAML.The killer feature - works INSIDE vim::r !llmswap generate "MongoDB create user with read/write access"Got: db.createUser({user:"appuser",pwd:"password",roles:[{role:"readWrite",db:"myapp"}]})Code appears at cursor. No browser. No copy-paste.Supports 8 providers (OpenAI, Claude, Gemini, Groq, IBM Watson, Ollama, etc). Use whatever API keys you already have. No additional subscriptions.GitHub: <a href="https://github.com/sreenathmmenon/llmswap" rel="nofollow">https://github.com/sreenathmmenon/llmswap</a>PyPI: <a href="https://pypi.org/project/llmswap/" rel="nofollow">https://pypi.org/project/llmswap/</a>

Show HN: Run any GUI app in the terminal with term.everything

Show HN: Tablemd – canvas-based Markdown table editor

Show HN: Tablemd – canvas-based Markdown table editor I created a canvas-based Markdown table editor, which provides a novel (I think) editing experience. I'd love for people to try it out, or bookmark it for the next time they want to insert a one-off table into a Markdown-formatted comment. My design goals were 1) frictionless user input and 2) fast startup time.Some good-to-knows:- Can be used on mobile- Table data is saved locally to the browser (nothing is sent to a server)- I only tested this on a MacBook, so let me know if the trackpad calibration feels off

Show HN: Psq – CLI for Postgres Monitoring

Show HN: GitType – A typing game that uses your own Git repo as practice text

Show HN: GitType – A typing game that uses your own Git repo as practice text I built a small Rust CLI game called GitType.It’s a typing practice tool that takes your own Git repository and turns the code inside into typing material. Instead of random words, you type through real functions, comments, and code you’ve written — making practice feel closer to real-world programming.Features: - Works directly in the terminal (no GUI required) - Pulls text from any local Git repo - Tracks WPM and accuracy - Keeps a history of your past runs (so you can see progress over time) - Fun ranking titles based on your scoreSource and install instructions: <a href="https://github.com/unhappychoice/gittype" rel="nofollow">https://github.com/unhappychoice/gittype</a>Would love feedback from fellow devs — especially around the scoring system and ideas for new modes. :)

Show HN: Find the cheapest protein per gram across 3000 powders

Show HN: Find the cheapest protein per gram across 3000 powders I tracked protein powder prices in a spreadsheet for years and found that identical protein content can have wild price differences.I built PricePerProtein to automate it. It pulls real-time Amazon data (Keepa API) and uses Gemini 2.5 Flash to extract nutrition facts from product images/descriptions. Calculates actual protein per dollar, not just package price.Technical: FastAPI + Celery backend, Next.js frontend with virtual scrolling to handle 3000+ products. Deployed on a VPS (migrated from GCP - much simpler). The AI handles everything from blurry nutrition labels to understanding flavor categories.No signup, no ads, no affiliate links. Updates hourly.

Show HN: Evalyze – AI investor matching from your pitch deck (feedback welcome)

Show HN: Evalyze – AI investor matching from your pitch deck (feedback welcome) I used to work in VC and watched good teams lose months chasing the wrong investors. I’m building Evalyze to make the unglamorous parts faster and more precise.After sign-up (email only, no card) you can:- upload a deck or paste your site - get a ranked list of relevant VCs/angels with a short “why” for eachWhat’s different: instead of dumping a big list, we try to explain why an investor fits based on stage, sector, check size, and portfolio patterns. It’s far from perfect and we want blunt feedback before opening wider.Limits to know:- newer funds and emerging managers can be underrepresented - geo nuances are still rough - matching can over-weight buzzwords if the deck is vagueI’d love critique on the ranking logic, signals you’d add/remove, and any privacy concerns. If you don’t want to upload a deck, there’s a sample you can use to see the flow.I’ll be here replying and shipping fixes as comments come in.

Show HN: Inception: Automatic Rust Trait Implementation by Induction

Show HN: Inception: Automatic Rust Trait Implementation by Induction Hi HN,I thought this would be a good place to share a little puzzle I've been working on. Inception is a Rust library that helps you share behaviors in Rust using structural induction. Practically, this means that instead of having a derive macro for each behavior, a single derive can be used to enable any number of behaviors. It doesn't do this using runtime reflection, but rather type-level programming - so there is monomorphization across the substructures, and (at least in theory) no greater overhead than with macro expansion.While there are a lot of things missing still and the current implementation is very suboptimal, I'd say it proves the general concept for common structures. Examples of Clone/Eq/Hash/etc replicas implemented in this way are provided.The code is not idiomatic, which is my biggest reservation about continuing this work. It was fun to prove, but is not so fun to _improve_, as it feels a bit like swimming upstream. In any case I hope some of you find it interesting!

Show HN: PasteVault – An open-source, E2EE pastebin with a VS Code-like editor

Show HN: I built a deep research tool for local file system

Show HN: I built a deep research tool for local file system I was experimenting with building a local dataset generator with deep research workflow a while back and that got me thinking. what if the same workflow could run on my own files instead of the internet. being able to query pdfs, docs or notes and get back a structured report sounded useful.so I made a small terminal tool that does exactly that. I point it to local files like pdf, docx, txt or jpg. it extracts the text, splits it into chunks, runs semantic search, builds a structure from my query, and then writes out a markdown report section by section.it feels like having a lightweight research assistant for my local file system. I have been trying it on papers, long reports and even scanned files and it already works better than I expected. repo - <a href="https://github.com/Datalore-ai/deepdoc" rel="nofollow">https://github.com/Datalore-ai/deepdoc</a>Currently citations are not implemented yet since this version was mainly to test the concept, I will be adding them soon and expand it further if you guys find it interesting.

Show HN: Zyg – Stop Writing Status Updates

Show HN: Zyg – Stop Writing Status Updates Hi HN, I’m Tobi. For a couple of hours over the past few days I’ve been hacking on something to fix a pain point in my dev workflow: writing status updates.Progress is invisible by default. GitHub, Linear, Jira all track tickets and code, but they don’t do a good job of capturing the narrative between “ticket started” and “ticket done.”You start working on a feature, your PM asks “how’s it going?”, and even though you know exactly how it’s going - because you’ve been committing and making progress - you still struggle to answer. That usually means breaking your flow to piece together an update, or just saying “it’s going fine.” You could point them to the commits, but tbj they probably don’t want to wade through diffs.To solve this I built Zyg [pronounced zeig]. It tries to turn commits into human-readable progress updates. It’s a lightweight CLI + dashboard that wraps `git commit`. Running `zyg` will generate a detailed commit message from your changes, produce a project update from that commit or a set of commits you choose, and notify any stakeholders who are subscribed. If you’d rather not share updates automatically, you can just copy the generated summary and drop it in Slack or email.Zyg is free for September thanks to an API credit grant from Anthropic. After that I’ll figure out pricing, but you can also plug in your own key and keep using it for free. It’s still rough around the edges, but I’d appreciate you giving it a spin.

Show HN: StripeMeter – Open-Source Usage Metering for Stripe Billing

Show HN: StripeMeter – Open-Source Usage Metering for Stripe Billing We built StripeMeter, an open-source usage metering platform that plugs directly into Stripe. It solves the classic SaaS pain of “why is my bill higher than expected?” by giving both developers and customers real-time usage tracking with live cost projections. Why it matters:- Transparency: Customers see exactly what Stripe will bill them (within 0.5% parity).- Exactly-once guarantee: No double billing, ever.- Fast & scalable: Sub-minute freshness with Redis + Postgres counters.We’d love feedback from SaaS builders, especially if you’ve struggled with Stripe’s metered billing. Does this solve a real pain for you? What would you need before trusting it in production?

Show HN: Public chat rooms with ephemeral chat and anonymous signup

Show HN: Public chat rooms with ephemeral chat and anonymous signup Phispr is an ephemeral chat application designed for anonymous, temporary conversations that vanish without a trace. Built with Go, it offers both web and terminal user interfaces.A weekend project exploded into a two weeks project, and with a funny origin. <a href="https://github.com/bnkamalesh/phispr/blob/main/docs/genesis.md" rel="nofollow">https://github.com/bnkamalesh/phispr/blob/main/docs/genesis....</a>

Show HN: Pitaya – Orchestrate AI coding agents like Claude Code

Show HN: Pitaya – Orchestrate AI coding agents like Claude Code Pitaya is a local, open-source orchestrator for AI coding agents (Claude Code, Codex CLI). It runs many agents in parallel, isolates each in Docker with its own git branch, supports pluggable Python strategies, and persists state so runs are resumable. Quickstart + short demo are in the README.

Show HN: Q.js – Smaller than React/Vue, yet more powerful (40KB gzipped)

Show HN: Q.js – Smaller than React/Vue, yet more powerful (40KB gzipped) Q.js is a lightweight JS framework that I recently distilled from our in-house Qbix platform that I’ve been building since 2011. It powers many of our social apps, which have all the features of Facebook, LinkedIn, X, etc.We’re not a big company like Google or Meta, so we never released it publicly. Now I’d like to, and thought it would be a good idea to post it on HN and gather some feedback.Q.minimal.js was designed to be dropped into any website. It lazy-loads all your components only as they are needed and appear on the screen. The minimal file is meant as a starting point for developers, and if you later want more features from the Qbix platform, you can simply swap it out for the larger Q.js file instead.Here are some advantages of Q.minimal.js compared to React, Angular, Vue, or whatever you might be using now:40KB gzipped, smaller than React (without ReactDOM), smaller than Vue runtime, far smaller than AngularNo build step, just drop it in; works with plain .html <template> files or with JS/Handlebars templatesComponents & tools, like React components or Vue directives, but attachable as behaviors to any DOM elementFaster rendering with requestAnimationFrame and .rendering(), no giant virtual DOM reconciliationBuilt-in power: batching, caching, lazyloading, routing, slot-based page activation, all included in coreUniversal dev model: designers can use pure HTML, developers can use JS, both work interchangeablyIncremental: drop it into an existing site without rewriting or compiling anythingIf you have a free hour, give it a try! Play around with it, and let me know what you think. It's 100% free and open source under MIT license and I'm looking to polish up any rough edges before letting developers know about it.

Show HN: Captan – Open-Source Cap Table Management CLI

Show HN: Captan – Open-Source Cap Table Management CLI I built Captan (<a href="https://github.com/acossta/captan" rel="nofollow">https://github.com/acossta/captan</a>), a tiny open-source CLI tool for managing startup cap tables.Instead of juggling spreadsheets or paying for expensive SaaS cap table solutions, Captan stores everything in a simple JSON file that you can version-control in Git.It supports:- Stakeholders (founders, employees, investors)- Security classes (Common, Preferred, Option Pool)- Share issuances- Option grants with vesting schedules (monthly, cliff)- SAFEs (record + simulate conversion at a priced round)- Cap table math (Outstanding vs Fully Diluted)- CSV/JSON exports- Audit log ("the ship’s log")Overall a JSON in git will offer better auditability and version control than most commercial solutions out there.Modeling different scenarios is super easy, just create a git branch and model whatever you need.Quick taste:---------------------------------------npm install -g captan$captan init --name "Acme, Inc." --pool-pct 20$captan enlist stakeholder --name "Alice Founder"$captan issue --security sc_common --holder sh_alice --qty 5000000$captan chartExample output:Captan — Cap Table (as of today)Name Outstanding %Alice Founder 5000000 100.00%TotalsIssued equity: 5000000Vested options: 0Outstanding total: 5000000Fully diluted total: 7000000---------------------------------------Why I built it: early-stage founders (myself included) often don’t need Carta or Pulley yet — just a clean, hackable way to track ownership. I wanted something transparent, developer-friendly, and Git-native.Repo: <a href="https://github.com/acossta/captan" rel="nofollow">https://github.com/acossta/captan</a>npm: <a href="https://www.npmjs.com/package/captan" rel="nofollow">https://www.npmjs.com/package/captan</a>I’d love feedback on what features would make this more useful to you?Thanks!

Show HN: An AI coding tool for unserious projects

Show HN: An AI coding tool for unserious projects Crazy Context is a playful no-code tool to generate project prompts, then turn them into Javascript-based applications in one shot. It has robust version control and a unique approach while super easy to use, cheap and fast. It's perfect for any trial and error type approach.

Show HN: Sometimes GitHub is boring, so I made a CLI tool to fix it

Show HN: Sometimes GitHub is boring, so I made a CLI tool to fix it Just wanted to clone a repo from my gh account and visualize it. Pretty easy with gitact. You can check any gh account.It’s called { gitact }quickly navigate through a user’s repos instantly grab the right git clone URLFeedback, stars and PRs are welcome

Show HN: Yet another daily word game – wotd

Show HN: Yet another daily word game – wotd Howdy HN. I wanted an excuse to do some lightweight JS/TS development and to get reacquainted with the Cloudflare stack, so I put together a daily word game. It's partially inspired by NYT's Spelling Bee and Wordle. The main goal is to find a specific word each day that uses each provided letter at least once. There's a secondary goal of finding as many words as possible. Right now progress is all stored on-device, but in the future I might add leaderboards or other competitive elements. Hope y'all enjoy!

Show HN: Datacmd – Terminal-native dashboards from CSV/API in one command

Show HN: Datacmd – Terminal-native dashboards from CSV/API in one command Hi HN,I built Datacmd to eliminate bloated dashboards and browser UIs. It turns any CSV, JSON, API feed into live, terminal-native dashboards with one command. Fast. Minimal. Developer-centric. AND IT'S OPEN SOURCE <a href="https://github.com/VincenzoManto/datacmd" rel="nofollow">https://github.com/VincenzoManto/datacmd</a>What it does:* Generates dynamic dashboards in the terminal: tables, gauges, pie charts, line charts, radars, text boxes * Layout auto-generated or configurable via YAML * Supports CSV, JSON, REST APIs, live system metrics (CPU, memory, disk)Why this matters:* No GUI. Instant visuals where developers live * Zero setup. Download binary or use "go run", and dashboards appear * Great for sysadmins, devs, ops, data hackers working in terminal-first workflowsWhat I learned building it: Automating a clean layout via algorithm beats manual dashboard design for fast insights. Generating widgets in terminal forces clarity - no fluff, just signal.Looking for feedback on:* Performance with massive datasets (>100k rows) * UX: readability, layout transitions, color themes * Widget ideas: real-time alerts, sparkline ring charts, CLI-friendly drill-downsLive on GitHub. Let me know if you want a downloadable binary or CI build link. Open to contributions, bug reports, wild dashboard ideas.

Show HN: Kanto.ai – The soc2 ready infra agent

Show HN: Kanto.ai – The soc2 ready infra agent Hey HN,I am launching kanto.ai and looking for early beta users.This came out of my own experience. I was responsible for building and maintaining SOC-2 compliance for a Kubernetes application in GCP. The GCP Cloud Foundation Blueprints are a solid starting point, but they are difficult to set up and even harder to keep updated as requirements, policies, and cloud services evolve. Many aspects required for Soc2 are also not provided out of the box.kanto.ai is a GitHub bot that bootstraps an enterprise-grade, multi-repo, git-ops first GCP deployment and automates ongoing maintenance. It watches GitHub issues and generates Terraform pull requests with best practices built in. Under the hood it uses GCP’s Cloud Foundation Toolkit modules for projects, networking, org policies, IAM, and more. The goal is to keep infrastructure SOC-2 ready out of the box.Right now it is early with a landing page and working prototype. I would love feedback from anyone who has dealt with SOC-2, Kubernetes, or the Foundation Blueprints in GCP.Does this solve a real pain you have felt? What blockers did you run into with SOC-2 in GCP? If you used the GCP Cloud Foundation Toolkit, what worked and what did not?Thanks.

Show HN: Rebuilding GPT2 inference in ~500 lines of (commented) code

Show HN: brew-cleaner – CLI to bulk uninstall Homebrew formulae and free space

Show HN: AgentState – Lightweight state manager for multi-agent AI workflows

Show HN: AgentState – Lightweight state manager for multi-agent AI workflows AgentState to solve a problem I kept running into: managing state for multi-agent AI systems is surprisingly hard. When you have multiple AI agents that need to coordinate, persist their state, and query each other's status, you typically end up with a mess of Redis/Postgres setups, custom queuing, and manual synchronization code.The whole thing is ~3MB, written in Rust for performance and safety, runs in Docker, and handles 1000+ ops/sec. I've been running it in production for AI workflows and it's been rock solid.

Show HN: AICF – a tiny "what changed" feed for AI/RAG (v0.1 minimal core)

Show HN: AICF – a tiny "what changed" feed for AI/RAG (v0.1 minimal core) I’m proposing AICF (AI Changefeed) — a minimal, web-native way for sites to expose append-only change events. Instead of crawlers or RAG systems re-embedding everything, they can refresh only the sections that changed.Discovery: a /.well-known/ai-changefeed JSON points to a feed.Feed: an append-only NDJSON file with just 4 required fields (id, action, url, time) plus optional hints (anchor, checksum, note).Goal: cut wasted crawling/embedding while keeping docs/pricing/policy pages fresh for AI/agents.Spec & examples here: <a href="https://github.com/mnswdhw/AICF/blob/main/spec/AICF-v0.1.md" rel="nofollow">https://github.com/mnswdhw/AICF/blob/main/spec/AICF-v0.1.md</a>Would love feedback: is the minimal core (anchors only, no chunks/vectors/push yet) the right starting point? Would you use this in your docs/RAG stack?

Show HN: AIMless – a 10 KB single file P2P chat app with zero dependencies

Show HN: AIMless – a 10 KB single file P2P chat app with zero dependencies I built AIMless, a ridiculously minimalistic, browser native chat app that fits entirely into one HTML file (10 KB). It’s decentralized, P2P, and has no build tools, no server, and no frameworks. Just you, your browser, and a copy/pasted blob or two.

Show HN: Weam – open-source AI collaboration platform for teams

Show HN: Weam – open-source AI collaboration platform for teams We built Weam because we felt existing AI tools didn’t work well for teams. Everything was scattered across chats, prompts, and workflows — hard to share, harder to organize.Weam is an open-source platform that tries to fix that.Organize prompts, chats, and agents into “Brains” (team folders).Run agents and even Pro Agents for workflows.Bring your own LLM keys (works with OpenAI, Anthropic, Gemini, Llama, etc.).Self-hosted, so you keep control of your data.Includes RAG pipelines for document-based AI.It’s early but we’d love feedback. Repo here: <a href="https://github.com/weam-ai/weam" rel="nofollow">https://github.com/weam-ai/weam</a>Docs: <a href="https://weam.ai/" rel="nofollow">https://weam.ai/</a>Curious if anyone has run into the same pain of making AI tools “team-friendly.”

Show HN: MCP Server for PostgreSQL Monitoring/Operations (MCP-PostgreSQL-Ops)

Show HN: MCP Server for PostgreSQL Monitoring/Operations (MCP-PostgreSQL-Ops) MCP Server for PostgreSQL Monitoring/Operations (MCP-PostgreSQL-Ops)<Examples Queries> "Check PostgreSQL server status" "Check PostgreSQL server version and connection status" "Verify if extensions are installed" "Show current active connection count" "Show the shared_buffers configuration" "Show PostgreSQL configuration parameter for shared_buffers" "Find all memory-related configuration settings" "Show logging configuration parameters" "Display connection-related settings" "Find all timeout configurations" "Show all PostgreSQL configuration parameters" "Show top 10 slowest queries" "Show top 20 slowest queries" "Analyze slow queries in specific database" "Find unused indexes" "Analyze recent query activity" "Check index efficiency in specific database" "Check database sizes" "Find largest tables" "Show tables that need VACUUM" "Check table sizes in specific database schema" "List tables in specific database" "Check maintenance status in specific database"

Show HN: Because I Kanban

Show HN: Because I Kanban Just wanted to share my latest project Taskstax, it's just a simple Kanban kind of trello clone, built mainly for the learns, but it works too so it's online.Simple Kanban boards, easy login that takes you straight to it.It uses socket.io for data xfer after login which was fun to setup and also makes it work well.Totally free, any feedback would be cool or if you wanted some info on the tech just ask.

Show HN: Twick - React SDK for Timeline-Based Video Editing

Show HN: GiralNet – A Privacy Network for Your Team (Not the World)

Show HN: GiralNet – A Privacy Network for Your Team (Not the World) Hello, for some time I've been developing this project now that I am happy that it finally can see the light. I love Tor, but I believe the biggest thing with Tor is that the nodes are strangers which in itself requires some sort of level in just that, complete strangers.For this reason, I decided to build this private network inspired by the Onion router. Unlike other public networks, GiralNet is not for anonymous connections to strangers. It is built for small teams or groups who want privacy but also need a level of trust. It assumes that the people running the nodes in the network are known and verifiable. This provides a way for a group to create their own private and secure network, where the infrastructure is controlled and the people behind the nodes are accountable. The goal is to provide privacy without relying on a large, anonymous public network.In terms of technical details, it is a SOCKS5 proxy that routes internet traffic through a series of other computers. It does this by wrapping your data in multiple layers of encryption, just like the onion router does it. Each computer in the path unwraps one layer to find the next destination, but never knows the full path. This makes it difficult for any single party to see both where the traffic came from and where it is going.I will gladly answer any questions you might have, thank you.

Show HN: I've made an easy to extend and flexible JavaScript logger

Show HN: I've made an easy to extend and flexible JavaScript logger hi! I've made a logger for JS/TS. It's easily extendable, easy to use and configure.Would like to hear a feedback from you!

Show HN: I'm building a "work visa" API for AI agents

Show HN: I'm building a "work visa" API for AI agents Hey HN,I’m Chris, a solo dev in Melbourne AU. For the past month I've been spending my after work hours building AgentVisa. I'm both excited (and admittedly nervous) to be sharing it with you all today.I've been spending a lot of time thinking about the future of AI agents and the more I experimented, the more I realized I was building on a fragile foundation. How do we build trust into these systems? How do we know what our agents are doing, and who gave them permission?My long-term vision is to give developers an "Agent Atlas" - a clear map of their agentic workforce, showing where they're going and what they're authorized to do. The MVP I'm launching today is that first step.The core idea is simple: stop giving agents a permanent "passport" (a static API key) and start giving them a temporary "work visa" for each specific task. AgentVisa is a simple API that issues secure, short-lived credentials, linking an agent's task back to a specific user and a set of permissions.To make this more concrete, I've put together a demo you can run locally showing how an agentic customer service bot uses AgentVisa to access an internal API. You can see it here: <a href="https://github.com/AgentVisa/agentvisa-customer-support-demo" rel="nofollow">https://github.com/AgentVisa/agentvisa-customer-support-demo</a>Under the hood it’s JWTs for now. But the product isn't the token - it's the simple, secure workflow for delegating authority. It's a pattern I needed for my own projects and I'm hoping it's useful to you too.I know there's a "two-sided problem" here - this is most useful when the server an agent connects to can also verify the agent's authenticity. Right now it's ideal for securing your own internal services, which is where I started. My hope is that over time this can be built into a standard that more services adopt.I'm keen for feedback from fellow devs working with AI agents. Does this problem of agent identity and auditability resonate with you? Is the "visa vs. passport" concept clear? What would you want to see on that "Agent Atlas" I mentioned?The Python SDK is open and on GitHub, and there's a generous free tier so you can build with it right away. I'll be here to answer as best I can any questions you have. Thanks for checking it out!SDK: <a href="https://github.com/AgentVisa/agentvisa-python" rel="nofollow">https://github.com/AgentVisa/agentvisa-python</a> Demo: <a href="https://github.com/AgentVisa/agentvisa-customer-support-demo" rel="nofollow">https://github.com/AgentVisa/agentvisa-customer-support-demo</a>Note: for us down under it’s getting late! So if I miss your comment while asleep, I’ll reply first thing in the morning AEST.

Show HN: An Elisp tutorial made to run inside Emacs (constructed by Claude Code)

Show HN: Chatbang – Access ChatGPT from the terminal without an API key

Show HN: Chatbang – Access ChatGPT from the terminal without an API key How does it work? Chatbang works by scraping ChatGPT's website. It opens ChatGPT on a headless session when you execute Chatbang and take your prompt and paste it in ChatGPT's prompt area and execute that prompt, then it waits for the response and copies it as a markdown format and then render it in the terminal.

Show HN: Embedr – Agentic IDE for Arduino, ESP32, and More

Show HN: Embedr – Agentic IDE for Arduino, ESP32, and More Hi HN,I’m building an agentic IDE for hardware developers. It currently supports Arduino, ESP32, ESP8266, and a bunch of other boards (mostly hobbyist for now, but expanding to things like PlatformIO).It can already write and debug hardware projects end-to-end on its own. The goal is to have it also generate breadboard views (Fritzing-style), PCB layouts, and schematics. Basically a generative EDA tool.Right now, it’s already a better drop-in replacement for the Arduino IDE.Would love feedback from folks here.

Show HN: Kuvasz Uptime 2.4.0 – custom status, keyword and slow response checks

Show HN: Kuvasz Uptime 2.4.0 – custom status, keyword and slow response checks The most feature-rich version of Kuvasz since the 2.0.0 release has arrived. Custom status code and keyword matching, slow response checks, new translations, and a lot of smaller improvements and fixes are included in version 2.4.0!

Show HN: Ldns.com – fast DNS lookups from the URL bar

Show HN: Ldns.com – fast DNS lookups from the URL bar I built LDNS because I'm constantly curious about domain names - who owns them, which nameservers they use, how they're configured, and what their DNS records reveal. I wanted a fast, easy way to investigate domains right from my browser without juggling multiple tools.LDNS runs entirely client-side using Cloudflare's DNS over HTTPS. Just type a domain and instantly see:All DNS records with clickable filtering RDAP/WHOIS data with registrar info and expiration dates Email security configuration (SPF, DMARC, MTA-STS, BIMI) Export options (JSON, CSV, BIND zones, PDF reports)Try it at ldns.com - just append any domain like ldns.com/example.com to start investigating.Built with SvelteKit and deployed on Cloudflare Pages for that instant-load experience we all love.Comments, feedback, and feature requests welcome!

Show HN: langdiff – Stream valid JSON from LLMs with type-safe callbacks

Show HN: langdiff – Stream valid JSON from LLMs with type-safe callbacks Ever had json.loads() explode halfway through an LLM stream? langdiff fixes that with a schema + callback approach.Define your schema → attach callbacks → push streaming tokens → get structured events immediately.

Show HN: Turn your iPhone into a local OCR server using Vision Framework

Show HN: Turn your iPhone into a local OCR server using Vision Framework Built an iOS app that runs a local OCR server using Apple's Vision Framework.Creates a REST API endpoint accessible from any device on your network. No cloud services needed - everything processes locally on the phone.Available on App Store (searching "OCR Server").Would appreciate feedback on the architecture or similar mobile-as-server projects you've seen.

Show HN: Created 60 free useful tools in one place

Show HN: Created 60 free useful tools in one place Hey there, I'm a solo dev behind KewlTools.So I'm one of those people who like to build their own tools/utilities whenever they a) want to get something done, or b) want to learn something. c) don't want to spend ages finding a utilty and going through walls of ads.I gradually built 66 tools, all free, fast, ad-free, and zero login.I (and my family/friends) use these daily, so thought some of you will find it useful!Any suggestions, improving current tools or adding new ones, please let me know.

Show HN: Enter your domain and my open-source agent will hack it

Show HN: Enter your domain and my open-source agent will hack it I built an open-source AI agent for security testing to find and fix vulnerabilities in your code.I’ve noticed how bad security vulnerabilities have gotten with everyone shipping AI code slop, so I wanted to build something that allows for vibe-coding at full speed without compromising security.Traditional security tools aren’t effective, and manual pen-testing can’t keep up with the rapidly growing AI codeThis tool runs your code dynamically, finds vulnerabilities, and validates them through actual exploitation.You can either run it against your codebase or enter your (or someone else’s) domain to scan for vulnerabilities.Good luck, have fun, hack responsibly!

Show HN: ServerBuddy – GUI SSH client for managing Linux servers from macOS

Show HN: ServerBuddy – GUI SSH client for managing Linux servers from macOS Hi HN,I've built an app for macOS that allows performing common SSH operations on Linux servers using a native GUI.The problem:Managing multiple Linux servers usually means juggling terminal windows and copy-pasting snippets/scripts. After dealing with tens of production/staging VPSes at previous jobs, I realized there had to be a better way for common operations I did on a daily basis than my collection of bash snippets.Features:- Quickly switch between different servers. Tag servers with arbitrary key values for easy search.- Real-time dashboard with CPU/memory graphs, disk usage, and uptime.- Table based interface for processes (sortable/filterable), Docker containers, systemd services, network ports, and system logs etc.- Built-in file browser.- Full-featured terminal when you need to drop to the command line.You can check out the screenshots at <a href="https://serverbuddy.app/screenshots" rel="nofollow">https://serverbuddy.app/screenshots</a> for a quick overview of the features supported.All the above are done through SSH, there are no agents/scripts to install on your servers.From using the app for a few weeks(admittedly a short duration), I can say I much prefer the ServerBuddy based workflow to my previous workflows.Pricing:Free forever for one server, $59 one-time for unlimited servers (includes 1 year of updates).If you're a developer or sysadmin managing Linux servers from Mac, please do try out the app. I'd love your feedback regarding additional features/workflows etc.Thank you!

Show HN: An open-source email archiver with full-text search capabilities

Show HN: An open-source email archiver with full-text search capabilities Hey HN,I’d like to share an open-source project I’ve created. It is an email archiving tool that can back up your whole email system with full-text search capabilities.The project is called Open Archiver, and it is able to archive and index emails from cloud-based email inboxes, including Google Workspace, Microsoft 365, and any IMAP-enabled email inbox. You can connect it to your email provider, and it copies every single incoming and outgoing email into a secure archive that you control (Your local storage or S3-compatible storage).Some features:- Archive and index all emails and attachments- Import and sync the whole organization's emails: For Google Workspace and MS 365, Open Archiver can ingest all individual inboxes' emails- PST and .eml files import- Role-based access- Full-text search: All archived emails and attachments are indexed, so you can search the content of all emails and attachments- You can choose to store your files either on your local machine or on any S3-compatible storage provider- API accessIt's AGPL-3.0 licensed and free to use for personal and business purposes. I'd be happy if you could give it a try and give me some feedback.You can find the project on GitHub (with Demo site): <a href="https://github.com/LogicLabs-OU/OpenArchiver" rel="nofollow">https://github.com/LogicLabs-OU/OpenArchiver</a>

Show HN: Selfhostllm.org – Plan GPU capacity for self-hosting LLMs

Show HN: Selfhostllm.org – Plan GPU capacity for self-hosting LLMs A simple calculator that estimates how many concurrent requests your GPU can handle for a given LLM, with shareable results.

Show HN: BaaS to build agents as data, not code

Show HN: BaaS to build agents as data, not code Agents and workflows as data instead of code.Julep is a backend-as-a-service to build agents and workflows. Main features:1. Experimentation Velocity:With most agent frameworks, agents are code that need to be deployed. To iterate on the prompts or update the agent, you need to make changes to the code and deploy it to your server. This makes agents hard to iterate on quickly. But with agents and tasks declared as data, all that happens in the background is make an api call to update or make a new entry in the database. This increases the experimentation velocity.2. Scalability and long-running background tasks:Scaling is a hard software engineering problem and the solution is to define large scale systems to be distributed, stateful and scalable. Agents as data is a very helpful paradigm because you have to solve for this problem only once at the orchestrator level. Julep can handle 100s of thousands of executions paralely.3. Updating an agent / User Personalization:Tools such as create agent, update agent etc. can update the agent recursively. Let’s assume an agent is chatting with a user and mentions that they only like to communicate in a professional tone. The agent can call a tool to 'update the agent' and modify/update the instructions to include that the user only likes to communicate in a professional tone.This was the reason to create a backend when the market was flooded with agent frameworks. In Julep, you can declare a workflow in YAML, and it can automatically scale Millions of users.

Show HN: From Hacking a T480 to the Fastest Open-Hardware 75 Hz E-Ink Display

Show HN: From Hacking a T480 to the Fastest Open-Hardware 75 Hz E-Ink Display Three years ago, I posted here about hacking together a fast e-ink laptop from a T480 because I was tired of spending all day on LCDs. I liked e-ink’s comfort, but it was too slow for day-to-day use.<a href="https://news.ycombinator.com/item?id=26245563">https://news.ycombinator.com/item?id=26245563</a>That post drew in people, which grew into a community experimenting with ways to make e-ink usable for everyday computing. That project later turned into a company and a multi-year project to make e-ink fast and open.We built our own FPGA-based controller, Caster, and went through multiple iterations to push past e-ink’s usual limits, slow refresh, ghosting, and proprietary controllers.Now, after three years, we’ve launched the Modos Paper Developer Kit and Monitor: the fastest open-hardware e-ink display, with 75 Hz refresh and sub-100 ms latency.It works with 6" to 13.3" mono or color panels over HDMI or USB-C, supports multiple grayscale modes, and has a C API for low-level control.The hardware, firmware, and schematics are on our GitHub.<a href="https://github.com/Modos-Labs/Glider" rel="nofollow">https://github.com/Modos-Labs/Glider</a>Our goal is to make e-ink fast and open enough that anyone can build on it, for hacking, research, or daily use.Thanks, HN, for being part of the journey.

Show HN: HMPL – Small Template Language for Rendering UI from Server to Client

Show HN: HMPL – Small Template Language for Rendering UI from Server to Client Hi HN! Together with contributors, we've been making a small template language for a year now, which, in our opinion, can replace HTMX and Alpine.js. It is a mix between EJS and Handlebars, that is, you can make a request with a familiar syntax to the server in HTML right in the markup.Requests are made via fetch and are configured via javascript almost entirely, which is what is needed today to work with the server.The very essence of the template language comes down to minimizing the size of the bundle of the original web application by moving the components to the server and then storing them there. Thus, on the client we get a framework, where we insert components from the server brick by brick.We showed this template language a long time ago, but it was not so mature then, so people had a lot of questions: <a href="https://news.ycombinator.com/item?id=41204552">https://news.ycombinator.com/item?id=41204552</a>Thank you very much to everyone for your attention! Please tell me what you think about the project? It will be interesting to know!

Show HN: FFlags – Feature flags as code, served from the edge

Show HN: FFlags – Feature flags as code, served from the edge Hi HN,I'm the creator of FFlags. I built this because I wanted a feature flagging system that gave me the performance and reliability of an enterprise-scale solution without the months of dev time or the vendor lock-in.The core ideas are:1. Feature Flags as Code: You define your flag logic in TypeScript. This lets you write complex rules, which felt more natural as a developer myself than using a complex UI for logic.2. Open Standard: The platform is built on the OpenFeature standard (specifically the Remote Evaluation Protocol). The goal is to avoid vendor lock-in and the usual enterprise slop. You're not tied to my platform if you want to move.3. Performance: It uses an edge network to serve the flags, which keeps the wall-time latency low (sub-25ms) for globally distributed applications.I was trying to avoid the heavy cost and complexity of existing enterprise tools while still getting better performance than a simple self-hosted solution.There's a generous free tier ($39 per million requests after that, with no flag/user limits). I'm looking for feedback on the developer experience, the "flags-as-code" approach, and any technical questions you might have.Thanks for taking a look.

Show HN: Agentic AI Frameworks on AWS (LangGraph,Strands,CrewAI,Arize,Mem0)

Show HN: Agentic AI Frameworks on AWS (LangGraph,Strands,CrewAI,Arize,Mem0) We’ve published a set of open-source reference implementations on how to build production-grade Agentic AI applications on AWS.What’s in the repo: • Agentic RAG, memory, and planning workflows with LangGraph & CrewAI • Strands-based flows with observability using OTEL & Arize • Evaluation with LLM-as-judge and cost/performance regressions • Built with Bedrock, S3, Step Functions, and moreGitHub: <a href="https://github.com/aws-samples/sample-agentic-frameworks-on-aws">https://github.com/aws-samples/sample-agentic-frameworks-on-...</a>Would love your thoughts — feedback, issues, and stars welcome!

Show HN: Kanban-style Phase Board: plan → execute → verify → commit

Show HN: Kanban-style Phase Board: plan → execute → verify → commit After months of feedback from devs juggling multiple chat tools just to break big tasks into smaller steps, we re‑imagined our workflow as a Kanban‑style Phase Board right inside your favourite IDE. The new Phase mode turns any large task into a clean sequence of PR‑sized phases you can review and commit one by one.How it works1. Describe the goal (Task Query) – In Phase mode, type a concise description of what you want to build or change. Example: “Add rate‑limit middleware and expose a /metrics endpoint.” Traycer treats this as the parent task. 2. Clarify intent (AI follow‑up) – Traycer may ask one or two quick questions (constraints, coding style). Answer them so the scope is crystal‑clear. 3. Auto‑generate the Phase Board – Traycer breaks the task into a sequential list of PR‑sized phases you can reorder, edit, or delete. 4. Open a phase & generate its plan – get a detailed file‑level plan: which files, functions, symbols, and tests will be touched. 5. Handoff to your coding agent – Hit Execute to send that plan straight to Cursor, Claude Code, or any agent you prefer. 6. Verify the diff – When your agent finishes, Traycer compares the diff to the plan and checks compatibility with upcoming phases, flagging any mismatches. 7. Review & commit (or tweak) – Approve and commit the phase, or adjust the plan and rerun. Then move on to the next phase.Why it helps?* True PR checkpoints – every phase is small enough to reason about and ship. * No runaway prompts – only the active phase is in context, so tokens stay low and results stay focused. * Tool-agnostic – Traycer plans and verifies; your coding agent writes code. * Fast course-correction – if something feels off, just edit that phase and re-run.Try it out & share feedbackInstall the Traycer extension (<a href="https://traycer.ai/installation" rel="nofollow">https://traycer.ai/installation</a>), create a new task, and the Phase Board will appear. Add a few phases, run one through, and see how the PR‑sized checkpoints feel in practice. If you have suggestions that could make the flow smoother, drop them in the comments - every bit of feedback helps.

Show HN: Clauditate – Breathing exercises while Claude Code is thinking

Show HN: Clauditate – Breathing exercises while Claude Code is thinking Hello HN!I realized how often my mind wanders while waiting for Claude to finish "thinking". So I built Clauditate, a lightweight meditation menubar app that helps you with some breathing exercises.It uses Claude Code hooks and pops up with a breathing guide. I added some heuristics to make it less "annoying", for example if you dismiss it twice within 30 mins, it won't show up for another 2 hours. You can also tweak this behavior (and more) in the settings.It's early, but I'd love to hear your feedback!Github: <a href="https://github.com/ykumards/clauditate">https://github.com/ykumards/clauditate</a>

Show HN: Host Claude Artifacts on your own domain

Show HN: Host Claude Artifacts on your own domain Hi HN, I've been using Claude to generate landing pages and it's a huge time-saver.But, it's hard to go from Artifact -> Published website. That's where Artifact Ninja comes in.How it works: 1. Click "Copy" above your artifact in Claude.ai and paste into Artifact.Ninja 2. We'll generate a static webpage without any Claude branding 3. Use your registrar's "masked forwarding" feature to connect a custom domainArtifact Ninja is a quick utility I needed for my own purposes. It's cheap to host (Cloudflare worker + D1), so it's free! Hope it helps.

Show HN: We create visual codebase maps that scale (static analysis and LLMs)

Show HN: We create visual codebase maps that scale (static analysis and LLMs) Hi all, I'm Ivan, and together with Alex, we're building a diagram visualization tool for codebases.Alex and I are devs, and we've noticed that recently we've been super productive at writing code (prompting :D). But when it comes to understanding big systems, prompting doesn't work that well — for that, diagrams are best imo. Most tools out there don't scale to big projects (e.g. PyTorch), so we're building CodeBoarding — a recursive visualizer for codebases. It starts from the highest level of abstractions and lets you dive deeper. We use static analysis and LLM agents. The control-flow graph is our starting point, and we validate the LLM's analysis against the static analysis output. LLMs alone often hallucinate or apply familiar architectural patterns that don't actually exist in the code.Since this is a concise representation of a codebase, we also added an MCP-server to provide our docs for the libs your project depends on — reducing hallucinations and avoiding blowing up the context window. The vision: With agents writing more and more code, we think we also need a concise representation for it — diagrams. But for that to work, the diagrams have to be accurate, and that's why static analysis has to take part in the fun ;d.Would love to hear what you think about diagram representations for code, what problems you've run into with hallucinations while vibe-coding (even with tools like gitingest/context7), and any general feedback :)

Show HN: OpenAI Agents SDK demos made durable and scalable with Temporal

Show HN: OpenAI Agents SDK demos made durable and scalable with Temporal Steve from Temporal here. Temporal is an MIT open source project for reliable execution at scale. I adapted+extended some of OpenAI's Agents SDK samples to integrate with Temporal.These demo agents can survive process crashes, scale to millions of executions in parallel and have easy-to-implement human interactivity. Just add a couple of Python decorators to your OpenAI agent code, run Temporal workers and you're ready to go.Check the video I did with OpenAI showing this in action (it's linked in the repo).OpenAI actually use us for ChatGPT Images and also their Codex code writing agent so I figure this may be a viable path for others to code something easy that's also reliable at scale.Happy to answer questions.

Show HN: Universal Control" for Macintosh Classic

Show HN: Universal Control" for Macintosh Classic I made an app for controlling a vintage Macintosh from a modern Mac, using an Arduino to translate between the modern Mac and Apple Desktop Bus.

Show HN: Wush-Action – SSH into GitHub Actions over WireGuard

Show HN: Same prompt tested across Replit, Bolt, v0, Lovable and Raq.com

Show HN: Same prompt tested across Replit, Bolt, v0, Lovable and Raq.com Hi HN,I built Raq.com – a platform that uses Claude Code to build working internal tools directly in the browser.Claude Code is great at self correcting when given the right tools.I've found that the popular web-based AI coding tools look great in demos but fail on real API integrations or require a lot of error back and forth. They don't appear to do much research or self-correcting, likely to reduce spend. I wanted to see the current state of these tools, so I ran the same prompt on five platforms (Replit, Bolt, v0, Lovable, and Raq.com) to build a tool that requires 3 different APIs (Companies House, FinUK and OpenRouter) working together.Four platforms produced broken prototypes or needed manual fixes. Raq.com delivered a complete working solution from a single prompt (that can be deployed to live with one click).Full test with videos: <a href="https://raq.com/real-world-test" rel="nofollow">https://raq.com/real-world-test</a>We're in early access (requires Claude Pro/Max for free usage) - we're looking non-coders who would like to build internal tools for their team.Some technical info:- Raq.com provisions isolated dev and prod Docker environments for each company (companyname.raq.com and companyname-dev.raq.com).- The dev site includes a persistent terminal streamed to the browser, so the session continues even while tab is closed.- CLAUDE.md file provides best practices, known pitfalls, and coding patterns for the Laravel + Filament stack.- Self-Correction Loop: Claude can test and debug its own work. It has direct shell access to a custom script that bundles PHPUnit, syntax checks, and cache clearing. Plus a Playwright wrapper to check for errors and take screenshots.- A single click runs a script that rsync's the dev workspace to the prod container, runs migrations, and clears caches.

Show HN: Kiln – AI Boilerplate with Evals, Fine-Tuning, Synthetic Data, and Git

Show HN: Kiln – AI Boilerplate with Evals, Fine-Tuning, Synthetic Data, and Git I noticed there weren't boilerplates for AI projects like there were for web apps, so I built one. Same idea - everything you need to get a project up and running quickly. However, instead of web-framework/CSS/DB, it's tools for AI projects: evals, synthetic data gen, fine-tuning, and more.Kiln is a free, open tool that gives you everything most AI projects need in one integrated package:- Eval system: including LLM-as-judge evals, eval data generation, human baselines- Fine-tuning: proxy to many fine-tuning providers like Fireworks/Together/OpenAI/Unsloth- Synthetic data generation: deeply integrated into evals and fine-tuning- Model routing: 12 providers including Ollama, OpenRouter, and more- Git-based collaboration: projects are designed to be synced through your own git serverThe key insight is that these tools work much better when they're integrated. For example, the synthetic data generator knows whether you're creating data for evals vs. fine-tuning (which have very different data needs), and evals can automatically test different prompt/model/fine-tune combinations.It runs entirely locally - your project data stays in local files, and you control your own git repos. No external services required (though it integrates with them if you want).Main project GitHub: <a href="https://github.com/Kiln-AI/Kiln">https://github.com/Kiln-AI/Kiln</a>Demo GitHub where I use it to build a 'natural language to ffmpeg command' demo with evals, fine-tunes, and synthetic data (including demo video): <a href="https://github.com/Kiln-AI/demos/blob/main/end_to_end_project_demo/">https://github.com/Kiln-AI/demos/blob/main/end_to_end_projec...</a>

Show HN: I built a free tool to find valuable expired domains using AI

Show HN: I built a free tool to find valuable expired domains using AI Hi HN,I’ve been collecting and analyzing expired domains for years — especially those about to drop. Every day, tens of thousands expire. Most are junk, but a few still have traffic, backlinks, SEO value, or just great names. Finding them used to take hours.Last week I put my internal tools online: <a href="https://pendingdelete.domains" rel="nofollow">https://pendingdelete.domains</a> No login, no paywall Updated daily Combines domain history, traffic, SEO data and AI-driven insights to identify valuable expirations The goal: help spot valuable domains quickly and skip the noise.Still a work-in-progress — would love feedback: Is this useful? What signals or filters would you add? Any UI or speed improvements?Thanks!

Show HN: Open-source physical rack-mounted GUI for home lab

Show HN: Open-source physical rack-mounted GUI for home lab I have realized that a lot of people nowadays self-host services and set up home labs with mini racks.One major pain point I have come across personally is to quickly get health status from self-hosted services and machines, and have the ability to headlessly control my Raspberry Pi inside a mini rack.So It got me thinking about building a built-in GUI that users can easily add to their Raspberry Pi nodes in their (mini or full) racks or elsewhere.I have previously designed this GUI for an open source project I have been working on (called Ubo pod: github.com/ubopod) and decided to detach/decouple the GUI into its own standalone module for this use case.The GUI allows headless control of your Raspberry Pi, monitoring of system resources, and application status.I am designing a new PCB and enclosure as part of this re-design to allow for a new form factor that mounts on server racks.I am recording my journey of re-designing this and I would love to get early feedback from users to better understand what they may need or require from such a solution, specially on the hardware side.The software behind the GUI is quite mature (<a href="https://github.com/ubopod/ubo_app">https://github.com/ubopod/ubo_app</a>) and you can actually try it right now without the hardware inside the web browser as shown in the video:<a href="https://www.youtube.com/watch?v=9Ob_HDO66_8" rel="nofollow">https://www.youtube.com/watch?v=9Ob_HDO66_8</a>All PCB designs are available here:<a href="https://github.com/ubopod/ubo-pcb">https://github.com/ubopod/ubo-pcb</a>

Show HN: Flyde 1.0 – Like n8n, but in your codebase

Show HN: Flyde 1.0 – Like n8n, but in your codebase Hi HN!I'm excited to share Flyde 1.0. A big update to the open-source visual programming tool I launched here in March of last year (<a href="https://news.ycombinator.com/item?id=39628285">https://news.ycombinator.com/item?id=39628285</a>).Since Flyde’s launch, there's been a huge rise in demand for visual builders, especially for AI-heavy workflows. Visual-programming shines with async and concurrency-heavy logic, which describes most LLM chains perfectly.A few months ago, I tried to capitalize on this trend by launching a commercial version of Flyde called Flowcode (<a href="https://news.ycombinator.com/item?id=43830193">https://news.ycombinator.com/item?id=43830193</a>). It didn't go well. I learned the hard way that Flyde’s strength wasn't just about flexibility or performance compared to tools like n8n. The real value was always how Flyde fits inside your existing codebase. The launch also helped me understand that there's still a big gap: no tool really covers the full lifecycle, from rapid prototyping to deep integration, evaluation, and iteration inside your own projects.So, over the last few months, I worked hard to polish Flyde: - Cleaned up and simplified the nodes API - Made it possible to fork any node for maximum flexibility - Launched a new online playground for quick experimenting and sharing (<a href="https://www.flyde.dev/playground" rel="nofollow">https://www.flyde.dev/playground</a>) - Created a new CLI tool to speed up development and setup - Fixed a ton of bugs - Simplified the UI/UX to make it smoother and less confusingThere’s still a lot of missing stuff. Better templates, docs, and nodes, but I think it’s finally stable and useful enough to give it another shot.My plan is to first make sure that Flyde is usable and valuable as an OS project, and then try to provide additional value via “Flyde Studio” - a SaaS that will help non-engineers iterate on Flyde flows from a web-app. Changes become a PR in the host repo.I'd really love some honest feedback and hear whether Flyde resonates with an existing pain/problem.Check it out here: Playground: <a href="https://www.flyde.dev/playground" rel="nofollow">https://www.flyde.dev/playground</a>GitHub: <a href="https://github.com/flydelabs/flyde">https://github.com/flydelabs/flyde</a>Looking forward to hearing your thoughts! - Gabriel

Show HN: Convert from MIDI file to ASCII tablature (and more)

Show HN: Convert from MIDI file to ASCII tablature (and more) Hi folks,About seven months ago, via HN, I got nerdsniped into a silly guitar transcription problem and made a bunch of really senseless code but what came out of it was what I thought at the time could potentially be pretty useful - a guitar fretboard mapper and fingering scoring algorithm.So as of yesterday morning I've finally put those bits of code to "good" use, creating gtrsnipe to convert between MIDI files (.mid) and ASCII tab (as well as VexTab and ABC notation) and any combination/direction among the set of formats.gtrsnipe tries to intelligently find the best neck and fingering positions using a note to fretboard mapper and a scoring algorithm that is unavoidably shaped by my subjective opinions and skills as a player but it does its best to avoid objectively impossible fingerings.See the example tabs and usage in the README and please, try your own transcriptions from MIDI and if you love or hate the arrangement it gives you, I'd love to hear about it so I can further refine the scoring algorithm.Thanks!

Show HN: Zu – A minimalist key-value database engine for modern applications

Show HN: YouTubeTLDR – A lightweight, self-hosted YouTube summarizer in Rust

Show HN: YouTubeTLDR – A lightweight, self-hosted YouTube summarizer in Rust There are many commercial YouTube summarizers, but I couldn't find an open-source one that truly fit my needs. So, I built YouTubeTLDR: a simple, self-hostable solution that uses the Gemini API without much bloat.I went with a synchronous approach + threading which was a nice break from Tokio.It is Bring Your Own Key, but the key is sent to the server for each request, which is something I might revise in the future.There is a demo on <a href="https://youtubetldr.onrender.com/" rel="nofollow">https://youtubetldr.onrender.com/</a>

Show HN: Bskysrch – An Advanced Search for Bluesky

Show HN: Bskysrch – An Advanced Search for Bluesky Hi HN,I missed proper search on Bluesky, like Twitter used to have, so I built this. You can filter posts and profiles by keyword, handle, time and other search operators.Would love feedback or ideas for what to add next.

Show HN: Tool to discover bloggers, trending blog topics, and weekly summaries

Show HN: Go Command-streaming lib for distributed systems (3x faster than gRPC)

Show HN: Go Command-streaming lib for distributed systems (3x faster than gRPC) I created cmd-stream-go, a high-performance client-server library based on the Command Pattern, where Commands are first-class citizens.Why build around Commands? As serializable objects, they can be sent over the network and persisted. They also provide a clean way to model distributed transactions through composition, and naturally support features like Undo and Redo. These qualities make them a great fit for implementing consistency patterns like Saga in distributed systems.On the performance side, sending a Command involves minimal overhead — only its type and data need to be transmitted. In benchmarks focused on raw throughput (measured using 1, 2, 4, 8, and 16 clients in a simple request/response scenario), cmd-stream/MUS (cmd-stream/Protobuf) is about 3x (2.8x) faster than gRPC/Protobuf, where MUS is a serialization format optimized for low byte usage. This kind of speedup can make a real difference in high-throughput systems or when you're trying to squeeze more out of limited resources.By putting Commands at the transport layer, cmd-stream-go avoids the extra complexity of layering Command logic on top of generic RPC or REST.The trade-offs: it’s currently Go-only and maintained by a single developer.If you’re curious to explore more, you can check out the cmd-stream-go repository (<a href="https://github.com/cmd-stream/cmd-stream-go">https://github.com/cmd-stream/cmd-stream-go</a>), see performance benchmarks (<a href="https://github.com/ymz-ncnk/go-client-server-benchmarks">https://github.com/ymz-ncnk/go-client-server-benchmarks</a>), or read the series of posts on Command Pattern and how it can be applied over the network (<a href="https://medium.com/p/f9e53442c85d" rel="nofollow">https://medium.com/p/f9e53442c85d</a>).I’d love to hear your thoughts — especially where you think this model could shine, any production concerns, similar patterns or tools you’ve seen in practice.Feel free to reach me as ymz-ncnk on the Gophers Slack or follow <a href="https://x.com/cmdstream_lib" rel="nofollow">https://x.com/cmdstream_lib</a> for project updates.

Show HN: Giti – Natural Language to Git Commands with Local LLM

Show HN: Giti – Natural Language to Git Commands with Local LLM Hi HN,I built Giti, a command-line tool that converts plain English into actual Git commands using a fast, local language model (Qwen2.5-Coder, ~1 GB).Example:Input: giti "undo last commit"Output: git reset --soft HEAD~1No internet required after setup. No API keys. You can also run it in an interactive shell to chain commands naturally.Key features: - Natural language to Git translation - Local LLM powered by Qwen2.5-Coder in GGUF format - Works fully offline after model download - Dry-run mode to preview commands before running - Interactive shell mode for session-based workflows - Context file support to teach Giti your custom Git habitsQuick install: - Clone the repo - Install llama-cpp-python - Add giti to your PATH - Download the 1GB model from HuggingFace - Run giti "your query."You can also enhance its accuracy using context files in a simple Q&A format like:USER: How to start new feature? BOT: git checkout main && git pull && git checkout -b feature/<name>This lets Giti learn your workflow and generate project-specific Git commands.Thanks for checking it out.

Show HN: Dyad – build AI apps locally, no cloud

Show HN: An API for human-powered browser tasks

Show HN: An API for human-powered browser tasks At APM Help, we have a large team that performs repetitive, browser-based tasks. Years ago, to manage this work securely and get a clear audit trail, we built an internal platform we call "Hub." It's essentially a locked-down environment where our team works that records their sessions, tracks every interaction, and prevents data from being copied or shared. It's been our internal source of truth for years.More recently, like many companies, we've been building more automation. And like everyone else, we've seen our automations fail on edge cases—a weirdly formatted invoice our parser can't read, a website layout change that breaks a scraper, etc. Our team would have to manually step in to fix these.We realized other developers must have this exact same problem, but without a 250-person team on standby. So we connected our old, battle-tested Hub to a new, modern front door: a Human-in-the-Loop (HITL) API. We're calling it browser-work.com.The idea is simple: when you hit a task that needs a human, you can send it to our team through the API.Here's how it works:<pre><code> - You POST a request to our endpoint. The payload contains the context for the task (like a URL) and a set of instructions for the human on what to do. - The task appears in the Hub, where one of our trained operators can claim it. - They perform the task exactly as instructed, all within the secure Hub environment. - When they're done, we send a webhook to your system. The return payload includes the task's output, any notes left by the human, and a detailed log of their actions (e.g., DOM elements they interacted with). </code></pre> For example, if your automation for paying a utility bill fails, you can pass the task to us. A person will log in, navigate the portal, make the payment, and return a confirmation number.The product is live and we're looking for people with interesting use cases.I'm Robert, the CIO. If this sounds useful to you, send me a brief email about your use case at robert@apmhelp.com and we can get you started right away.Happy to answer any questions here.

Show HN: JavaScript-free imageboard in Lua, with CSS based widgets

Show HN: JavaScript-free imageboard in Lua, with CSS based widgets If you're a visual learner, one of the biggest instances can be seen at:<a href="http://lambdaplusjs35padjaiz4jw2fugdoeutse262phqr72uf634s2wdbqd.onion/" rel="nofollow">http://lambdaplusjs35padjaiz4jw2fugdoeutse262phqr72uf634s2wd...</a>It's usually SWF. Some features include:<pre><code> - No javascript of any type is used anywhere. In fact, CSP is used to block execution of any and all javascript, which makes XSS attacks impossible. - High security due to the use of pledge() and unveil() - Highly transparent moderation logs which include a reason for all moderation actions - advanced formatting, including LaTeX support - anyone can create their own board - multiple files per post - inline image expansion - per-board index and recent pages - paginated catalog pages and threads - extensive moderation tools</code></pre>

Show HN: Context42 – capture your coding style from across your projects

Show HN: Context42 – capture your coding style from across your projects Show HN: Context42 - AI-powered style guide generator for your codebaseHey HN,I've been building Context42 to solve a problem that's been bugging me: getting AI to write code like me, and helping disseminate coding best practices.The core insight is simple - your existing code is already your best style guide. Instead of debating tabs vs spaces or where to put your curly braces, Context42 analyzes your actual codebase and generates comprehensive style documentation using Google's Gemini AI.Here's what makes it special:1. *Language-aware analysis* - It groups files by language and generates specific style guides for each. Your TypeScript patterns won't bleed into your Python conventions.2. *Dependency-smart processing* - It analyzes child directories before parents, building up context as it goes. This means it understands your module structure and can identify patterns that emerge across your architecture.3. *Built for real codebases* - With configurable concurrency, resume capability, and automatic cleanup, it's designed to handle everything from small projects to massive monorepos. The terminal UI (built with Ink/React) gives you real-time progress on what's happening.4. *Pragmatic over prescriptive* - Instead of enforcing arbitrary rules, it documents what you're already doing. This makes it easier to onboard new developers and maintain consistency without religious debates.The technical approach is interesting too - it uses a worker pool pattern with abort controllers for graceful shutdown, SQLite for persistence (so you can resume failed runs), and a file registry system that guarantees cleanup even on crashes.I built this because I believe the best documentation is the kind that reflects reality, not aspirations. Your code style isn't what you think it should be - it's what it actually is. And that's worth documenting.You can check it out at: <a href="https://github.com/zenbase-ai/context42">https://github.com/zenbase-ai/context42</a>Would love to hear your thoughts, especially if you've tackled similar problems in your teams. What's worked for you in maintaining code consistency at scale?

Show HN: Fluent-state: a new fresh take on local React state

Show HN: Fluent-state: a new fresh take on local React state Hi HNI built *fluent-state*, a lightweight React hook that replaces useState, useReducer, useMemo, and useEffect.It gives you:- A fluent, proxy-based API: `state.user.name('Joe')` - Immutable updates without spread logic - Automatic dependency tracking - Built-in `compute` for reactive, memoized derived state (no useMemo needed) - Built-in `effect` for reactive side-effects with automatic dependency tracking (no useEffect needed) - Zero boilerplate, full controlDesigned for local state, nested structures, and clean, declarative code.Demo: <a href="https://stackblitz.com/edit/vitejs-vite-uh4kyzkf?file=src%2FApp.tsx" rel="nofollow">https://stackblitz.com/edit/vitejs-vite-uh4kyzkf?file=src%2F...</a> GitHub: <a href="https://github.com/marsbos/fluent-state">https://github.com/marsbos/fluent-state</a> NPM: <a href="https://www.npmjs.com/package/fluent-state" rel="nofollow">https://www.npmjs.com/package/fluent-state</a>Try it out plz.

Show HN: UML is dead – so I'm building the tool to revive it

Show HN: UML is dead – so I'm building the tool to revive it Hi HN,UML diagrams were meant to standardise system design, but they’ve become outdated — slow to build, hard to change, and rarely used in practice. Most tools feel clunky, and diagrams often go stale fast.I’m building RapidChart, a tool to bring diagramming back to life — fast, flexible, and developer-first.What makes it different:Cursor-style interface for rapid diagram creationFully customisable and exportableAI-assisted (works with GPT-4, Claude, etc.)100% freeThis began as part of my research at Imperial College London, and I’d really value your feedback.Here’s the link: <a href="https://www.rapidcharts.ai" rel="nofollow">https://www.rapidcharts.ai</a>Thanks!

Show HN: kiln – Git-native, decentralized secret management using age

Show HN: kiln – Git-native, decentralized secret management using age Hi HN, I've been building this tool for the past couple of weeks to solve a problem that seems universal across development teams: sharing environment variables securely.You know the drill - someone needs the staging database URL, so it gets shared over chat. Production API keys end up in plaintext files. Or you set up some complex secret management system that becomes a single point of failure during critical deployments.At Zerodha, we're a stock broker with strict regulatory requirements. Our infrastructure needs to be auditable, and our data must stay with us for instant recovery. But the deeper issue was that every solution we tried made deployments dependent on external services.We tried GitLab CI's built-in secrets, but they're stored unencrypted and only repository maintainers can access them. HashiCorp Vault was too complex to manage with painful ACL setup, plus it's now crippled by their BSL license change. AWS Secrets Manager would create the vendor lock-in we wanted to avoid.The breaking point came when we wanted to manage secrets through Terraform for idempotency and better infrastructure-as-code practices. But Terraform has no built-in way to encrypt secrets without relying on external providers. We could either store secrets in plaintext in our Terraform configs or add yet another external dependency to our deployment pipeline.That's when I had the idea: what if we could inject encrypted environment variables directly into Terraform, so anyone with the right key could deploy without hunting down secrets from different systems? As I iterated through this idea, I realized the same pattern would work for any application - from personal projects to team deployments.So I built kiln. It encrypts environment variables using age encryption into files that live alongside your code. No servers, no network calls, no external dependencies. Each team member gets their own key, and you control access per environment.Here's how it works:<pre><code> # Generate a new age key, or use your existing SSH keys kiln init key # Initialize with your team's public keys kiln init config --recipients "alice=$(curl https://gitlab.company/alice.keys)" --recipients "me=$(cat ~/.ssh/id_ed25519.pub)" # Set secrets (prompts securely, never shows in terminal) kiln set DATABASE_URL kiln set API_KEY # Run your app with decrypted environment kiln run npm start # These encrypted files are safe to commit git add .kiln.env kiln.toml </code></pre> Why not SOPS? SOPS is great for general file encryption, but kiln is built specifically for the environment variable workflow. It has commands like "run", "export", and built-in team management. Think "SOPS for .env files" with a focus on developer UX.Why not raw age encryption? Age is perfect for the crypto layer, but terrible for day-to-day team workflows. Try managing 20 team members across 5 environments with raw age commands - you'll go insane. kiln handles the orchestration.As for technical details, kiln:- Uses age encryption (modern, audited, simple)- Works with existing SSH keys or generates new age keys- Role-based access via TOML configuration- Single, cross-platform Go binary- Zero network dependencies - everything works offline- MIT licensedThe game-changer: secrets travel with code. No more "can someone send me the staging secrets?" in chat. No more broken deploys because the secret service is down. No more hoping your vendor doesn't change their pricing or licensing.Try it out - I'm confident it'll help improve your team's deployment workflows. Feel free to ask me any questions!GitHub: <a href="https://github.com/thunderbottom/kiln">https://github.com/thunderbottom/kiln</a>Docs: <a href="https://kiln.sh" rel="nofollow">https://kiln.sh</a>Or install now: go install github.com/thunderbottom/kiln@latest

Show HN: I built a tool to sync localStorage between devices

Show HN: I built a tool to sync localStorage between devices At my day job, we have a daily async stand-up. We have to message a slack bot how many hours we have worked on a given task that day and overall.The format is:> Task: "Task Name" | Worked: 5h Total: 16h > Description: Finished implementation of feature.I don't complain. Most fully remote jobs come with a version of this, but doing it manually got tedious. So, I needed a simple app that would track this.I am not usually a fan of "vibe coded" apps, but this was an ideal candidate for it, since it's not production code. Most LLMs solve the problem by creating a single HTML file with forms that save data to localStorage. This was perfect for me - no hosting, no DB, no backend. Just 15 mins of prompting.One day I was outside, just with my phone, and of course I couldn't use the app. I thought "how hard can it be to synchronize localStorage data across devices?". Turns out, it's not that hard, if you are ready to build a whole platform around it.<a href="https://htmlsync.io" rel="nofollow">https://htmlsync.io</a> does just that. You upload your HTML app that works with localStorage and get a subdomain for it. The tool automatically synchronizes your changes across devices. You can create private and public apps, can decide which keys to synchronize by using the "no_sync_" prefix. The "public-hidden" CSS class can be used to hide UI elements in public view. You also get a subdomain for your profile where all your apps are listed for easy access.I hope you find this as useful as I did.I'd also appreciate your feedback if you end up using it.

Show HN: Ruby on Rails tutorial running in the browser

Show HN: Ruby on Rails tutorial running in the browser Meet the Ruby on Rails Getting Started tutorial that runs fully in the browser: a web server, a console, a database—everything you need to explore the framework without dealing with local installation.Source code: <a href="https://github.com/evilmartians/rails-tutorial">https://github.com/evilmartians/rails-tutorial</a>This is the first step towards an in-browser development environment for Rails that could be used with AI app generators like Bolt among other things.

Show HN: Encode Base64

Show HN: Compare Speech APIs Live (OpenAI, Google, Deepgram, Soniox, etc.)

Show HN: Goliteql – A fast GraphQL executor and code generator in Go

Show HN: Goliteql – A fast GraphQL executor and code generator in Go Hi HN,I've built `goliteql`, a fast and lightweight GraphQL executor and code generator written in pure Go.It parses GraphQL schema and queries, validates them, and executes resolvers without using reflection. It also supports introspection and generates Go code from a GraphQL schema.Why I built it: - I wanted a fast, minimal alternative to gqlgen - Easy to embed in WASM or microservices - Focused on simplicity and performance (4x faster in benchmarks)

Show HN: A Lisp for code generation and metaprogramming in non-Lisp languages

Show HN: A Lisp for code generation and metaprogramming in non-Lisp languages Antilisp is a Lisp designed for code generation in non-lisp languages. The interpreter is written in RPython, and the language is designed for easy adoption by non-lispers. The project is still young, but the language can be played with if you don't mind missing some important features like modules and pattern matching.I have not published the source code yet, because I am not completely sure how to base a sustainable business on this project and I don't want to risk having to rugpull after raising expectations.

Show HN: We developed an AI tool to diagnose car problems

Show HN: We developed an AI tool to diagnose car problems Hey HN,We built AutoAI – an AI tool that tells you what's wrong with your car in plain English.Just enter:Your car’s make/model/yearThe OBD2 error codes (optional) (like P0420, P0171, etc.)Any symptoms you're noticing (e.g. “rough idle” or “weird sound when starting”)And we’ll tell you:The most likely issueHow to verify it yourselfWhether it’s a DIY fix or shop-worthyNo more endless Googling or forum-hopping. Built for car owners, tinkerers, and pros who want fast, reliable answers. Powered by a repair-trained AI using real-world automotive data.We’re trying to make diagnostics smarter, not replace your mechanic – just make you way more informed before spending money.Would love feedback or crazy edge-case inputs to improve it.

Show HN: FluidAudio – Swift Speaker Diarization on CoreML

Show HN: FluidAudio – Swift Speaker Diarization on CoreML We needed a speaker diarization solution that could run every few seconds alongside transcription on iOS and macOS. But native Swift support was either limited or locked behind paid licenses. Since diarization is a common need in speech-to-text workflows, we decided to open source our work and give back to the community.We initially tried sherpa-onnx, which works, but running both diarization and transcription models slowed down older devices. CPU-only inference just isn’t ideal for near real-time workloads, so we wanted the option to offload segmentation and speaker embedding to the GPU or ANE. Supporting M1 Macs in particular meant pushing more of the workload to the ANE.Instead of shoehorning the ONNX model into CoreML with C++, we converted the original PyTorch models directly to CoreML. This approach required some monkey-patching in the PyTorch and pyannote code, but the initial benchmarks look promising.We’d love feedback! We're currently working on adding VAD and integrating Parakeet for transcription, but still wrestling with CoreML model conversion.

Show HN: NodeLoop – Hub for electronics design knowledge and tools

Show HN: NodeLoop – Hub for electronics design knowledge and tools Building a free web toolbox for hardware engineers: harness cable diagram generator, connector pinout tools (M.2, JTAG...), microcontroller serial monitor, and various other small utilities.No sign-up required. Designed from my own needs. Feedback and feature suggestions are welcome.

Show HN: Pangolin – Open source alternative to Cloudflare Tunnels

Show HN: Pangolin – Open source alternative to Cloudflare Tunnels Pangolin is an open source self-hosted tunneled reverse proxy management server with identity and access control, designed to securely expose private resources through encrypted WireGuard tunnels running in user space.We made Pangolin so you retain full control over your infrastructure while providing a user-friendly and feature-rich solution for managing proxies, authentication, and access, all with a clean and simple dashboard web UI.GitHub: <a href="https://github.com/fosrl/pangolin">https://github.com/fosrl/pangolin</a>Deployment takes about 5 minutes on a VPS: <a href="https://docs.fossorial.io/Getting%20Started/quick-install" rel="nofollow">https://docs.fossorial.io/Getting%20Started/quick-install</a>Demo by Lawrence Systems (YouTube): <a href="https://youtu.be/g5qOpxhhS7M?si=M1XTWLGLUZW0WzTv&t=723" rel="nofollow">https://youtu.be/g5qOpxhhS7M?si=M1XTWLGLUZW0WzTv&t=723</a>Some use cases:<pre><code> - Grant users access to your apps from anywhere using just a web-browser - Proxy behind CGNAT - One application load balancer across multiple clouds and on-premises - Easily expose services on IoT and edge devices for field monitoring - Bring localhost online for easy access </code></pre> A few key features:<pre><code> - No port forwarding and hide your public IP for self-hosting - Create proxies to multiple different private networks - OAuth2/OIDC identity providers - Role-based access control - Raw TCP and UDP support - Resource-specific pin codes, passwords, email OTP - Self-destructing shareable links - API for automation - WAF with CrowdSec and Geoblocking</code></pre>

Show HN: Snub – A fast, lightweight file search CLI for Windows (written in C)

Show HN: Snub – A fast, lightweight file search CLI for Windows (written in C) built snub, a fast and lightweight recursive file search tool for Windows, written in modern C (C17). File Explorer and PowerShell often crawl on large codebases — so I wrote something that doesn’t.snub is: - Fully multithreaded - Avoids indexing entirely - Supports globbing, size/date filters, result limiting, and JSON output - Packaged as a single small executableNo dependencies. Just raw C and the WinAPI.GitHub: <a href="https://github.com/seeyebe/snub">https://github.com/seeyebe/snub</a>Would love feedback on C idioms, WinAPI practices, or ideas for portability and better build flow.

Show HN: Track the AI-generated code in your repo

Show HN: Dashboard tracking all GitHub PRs and analyzing Code Agent activity

Show HN: Dashboard tracking all GitHub PRs and analyzing Code Agent activity Hi HN,We are researchers from ETH Zurich interested in the real-world adoption and impact of Code Agents.To measure this, we built a dashboard, scraping all public PRs on GitHub, analyzing which are created by different code agents (Codex, Jules, Copilot, Devin, etc.), and measuring their merge rates, sliced by various repository and PR characteristics.<a href="https://insights.logicstar.ai" rel="nofollow">https://insights.logicstar.ai</a>Since mid-May, we've analyzed over 10 million PRs and already found some interesting trends:Usage is high, but shallow. Agents submit ~7% of all PRs overall, but only ~1–2% on popular repos. Most activity is in low-star or experimental projects.Merge rates vary drastically. On low-traffic repos, some agents get 90%+ of their PRs merged. On popular projects, that can drop to <25%.Pre-review helps. Agents that require human-in-the-loop review (e.g., Jules, Codex) have 30–50% higher merge rates than Copilot-style fire-and-forget PRs.Bias toward new code. Agent PRs mostly add code. Refactorings and deletions are rare.If you have ideas for what other characteristics we should look at let us know or play with the code yourself

Show HN: I built a single API to post on all social platforms

Show HN: I built a single API to post on all social platforms Building integrations for TikTok, X, Facebook, Instagram, YouTube, and LinkedIn got frustrating with how different every platform is with auth setup, rate limits, and media requirements. So we built Post for Me: one REST API that handles scheduling and publishing posts for TikTok, Facebook, Instagram, X, YouTube, LinkedIn, Pinterest, Bluesky, and Threads.It's built for developers. You bring your own app credentials from the social platform, so you're in control of your data. There's no limitations on account connections, and pricing is based on usage (not some arbitrary limitations). We wanted the API we wish we had when we first started.What it does - A single POST replaces a dozen different calls - Pay-per-post metered pricing (volume discounts) and a free tier (no seat fees) - Cascading configs: set captions/media globally, then override per platform or accountTry it at <a href="https://www.postform.dev" rel="nofollow">https://www.postform.dev</a>. Would love feedback, bug reports, or architecture questions!

Show HN: Interactive pinout for the Raspberry Pi Pico 2

Show HN: Interactive pinout for the Raspberry Pi Pico 2 I've been trying to make accessible and beautiful GPIO pinouts since I started one for the Raspberry Pi in 2013 [1]. I've since given the Raspberry Pi Pico [2] and Pico 2 [3] microcontrollers the same treatment when they launched.Recently I've updated these with a new "Upside-down" view to complement the rear view, giving a pinout in the right orientation to match your project.The Pico sites are all hand-coded single HTML pages with supporting CSS and minimal JS. They are set up to optionally install as a "Desktop" web app. They also degrade into a somewhat usable table in lieu of CSS and use vector graphics (for the board itself) to be viewable and printable at any size.Finally, hidden behind "Advanced" is a pinout of the test pads and special function pins![1] - <a href="https://web.archive.org/web/20130505194305/pi.gadgetoid.com/pinout" rel="nofollow">https://web.archive.org/web/20130505194305/pi.gadgetoid.com/...</a> [2] - <a href="https://pico.pinout.xyz" rel="nofollow">https://pico.pinout.xyz</a> [3] - <a href="https://pico2.pinout.xyz" rel="nofollow">https://pico2.pinout.xyz</a>

Show HN: I built a website to summarize Tech Twitter each day

Show HN: I built a website to summarize Tech Twitter each day Hey folks, I built this as a nightly job that pulls the tweets from a burner account I made, then passes it to GPT-4.1 to summarize alongside some recent headlines: <a href="https://github.com/neelsomani/tweet-insight-daily/blob/main/scripts/lambda_function.py">https://github.com/neelsomani/tweet-insight-daily/blob/main/...</a>

Show HN: Simple wrapper for Chrome's built-in local LLM (Gemini Nano)

Show HN: Simple wrapper for Chrome's built-in local LLM (Gemini Nano) Chrome now includes a native on-device LLM (Gemini Nano) starting in version 138. I've been building with it since it was in origin trials, it's powerful but the official Prompt API is still a bit awkward:- Enforces sessions even for basic usage- Requires user-triggered downloads- Lacks type safety or structured error handlingSo I open-sourced a small TypeScript wrapper I originally built for other projects to smooth over the rough edges:github: <a href="https://github.com/kstonekuan/simple-chromium-ai">https://github.com/kstonekuan/simple-chromium-ai</a>npm: <a href="https://www.npmjs.com/package/simple-chromium-ai" rel="nofollow">https://www.npmjs.com/package/simple-chromium-ai</a>- Stateless prompt() method inspired by Anthropic's SDK- Built-in error handling and Result-based .Safe.* variants with neverthrow- Token usage checks- Simple initialization that provides a helper to trigger downloads (must be triggered by user action)It’s intentionally minimal for hacking and prototyping. If you need fine-grained control (e.g. streaming, memory control), use the native API directly:<a href="https://developer.chrome.com/docs/ai/prompt-api" rel="nofollow">https://developer.chrome.com/docs/ai/prompt-api</a>Would love to hear what people build with it or any feedback!

Show HN: GraphFlow – A lightweight Rust framework for multi-agent orchestration

Show HN: GraphFlow – A lightweight Rust framework for multi-agent orchestration It all started with a conversation among friends about limitations in current multi-agent orchestration frameworks. We faced issues like limited control over agent memory and state, complicated persistence, scaling problems, and lack of type safety in Python-based tools. These challenges inspired us to try something different. The result was GraphFlow, a Rust-based lean framework for orchestrating multi-agent workflows that's simple, scalable, and robust. Its key features include: Graph-based orchestration: Easily define workflows using nodes and edges. Lean Execution Engine: A minimal and efficient graph executor / state machine implementation. Clear Memory Management: Direct and transparent handling of agent states. Simple DB Schema: Easy-to-understand schema for persistence and state tracking. High Performance: Native Rust performance with low overhead and easy scaling. Type Safety: Rust's type system reduces runtime errors. GraphFlow is open-source ofc and aims to solve real-world problems we've experienced firsthand. We'd love your feedback!

Show HN: ParsePoint – AI OCR that pipes any invoice straight into Excel

Show HN: ParsePoint – AI OCR that pipes any invoice straight into Excel Hi HN,I run a small ecommerce shop and, until recently, spent way too many evenings copy-pasting supplier invoices into Excel so my books stayed clean and my expense tracking was granular. It finally hit me that I’d rather invest that time in code than in Ctrl-C/Ctrl-V, so I built ParsePoint.app.Why I built it • Manual invoice entry was swallowing 4 hours every month. • Accounting software APIs felt heavyweight for my use-case; I really just wanted clean rows in a spreadsheet. • I love tinkering with AI models and needed an excuse to spin one up in production.What it does 1. Upload a PDF (or forward an email). 2. ParsePoint’s AI OCR extracts line-items, amounts, tax, dates, etc. 3. Download a ready-to-pivot Excel/CSV file or hit the API to drop the data wherever you like.Under the hood • Frontend: React • API: .NET 8, PostgreSQL • AI layer: an open-source VLLM model fine-tuned for document layoutsOutcome so far • My own workload: from 4 hours/month to less than 10 minutes. • Early beta testers (other solo-store owners) report similar time savings and fewer bookkeeping errors. • The pay-as-you-go credit system means no subscriptions or lock-ins—use it only when you need it.I’d love feedback on the tech approach, pricing model, or anything that looks off. All comments welcome, and I’m here to answer every question.Thanks for reading! Marcin – maker of ParsePoint.app

Show HN: Built email parsing for booking confirmations for my travel app – Aruko

Show HN: Built email parsing for booking confirmations for my travel app – Aruko <pre><code> A few months ago I shared my travel app here. Today I'm back with something that solved a real technical challenge I was facing. The problem: Parsing booking confirmation emails accurately. Built a parsing system that: - Distinguishes between connection hubs and actual destinations - Captures all segments (flights, hotels, trains) in the right order - Handles different booking site email formats - Creates complete itineraries automatically </code></pre> Happy to discuss more if anyone's interested :)

Show HN: Terminal in Browser

Show HN: Terminal in Browser I wrote a small golang project to render terminal on browser. It is a single binary that can be deployed on any server and you can access the terminal over web.

Show HN: A tool to benchmark LLM APIs (OpenAI, Claude, local/self-hosted)

Show HN: A tool to benchmark LLM APIs (OpenAI, Claude, local/self-hosted) I recently built a small open-source tool to benchmark different LLM API endpoints — including OpenAI, Claude, and self-hosted models (like llama.cpp).It runs a configurable number of test requests and reports two key metrics: • First-token latency (ms): How long it takes for the first token to appear • Output speed (tokens/sec): Overall output fluencyDemo: <a href="https://llmapitest.com/" rel="nofollow">https://llmapitest.com/</a> Code: <a href="https://github.com/qjr87/llm-api-test">https://github.com/qjr87/llm-api-test</a>The goal is to provide a simple, visual, and reproducible way to evaluate performance across different LLM providers, including the growing number of third-party “proxy” or “cheap LLM API” services.It supports: • OpenAI-compatible APIs (official + proxies) • Claude (via Anthropic) • Local endpoints (custom/self-hosted)You can also self-host it with docker-compose. Config is clean, adding a new provider only requires a simple plugin-style addition.Would love feedback, PRs, or even test reports from APIs you’re using. Especially interested in how some lesser-known services compare.

Show HN: Query your Rust codebase and generate types for anything

Show HN: Query your Rust codebase and generate types for anything Hello HN!As a long-time professional Rust developer. I've always been frustrated by the difficulty and "hackiness" of producing bindings to other languages, whether a frontend, an FFI library, etc.Not just in Rust but in any language.After many years of trying existing solutions and trying to make my own, I've finally developed a solution I'm very happy with.RTK (aka Rust Type Kit) allows you to write Lua scripts that perform queries on your code, such as method calls to Axum's `.route`, function definitions, and more, and then receive rich type information including all argument types, function paths, proc macro attributes, and more.Your Lua script can then read this information and emit an output file in any language of your choosing. Or, you can emit compiler errors and use it as a linter of sorts. You can even directly re-emit Rust code itself and use this as a richer proc macro solution!The code example is a bit verbose, so I encourage you to take a look at the repo's README. I look forward to hearing your thoughts, or any usecases you may come up with!

Show HN: Claude Code workflow: PRDs → GitHub Issues → parallel execution

Description

More from Show