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

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: Claude Code workflow: PRDs → GitHub Issues → parallel execution

Show HN: Claude Code workflow: PRDs → GitHub Issues → parallel execution I built a lightweight project management workflow to keep AI-driven development organized.The problem was that context kept disappearing between tasks. With multiple Claude agents running in parallel, I’d lose track of specs, dependencies, and history. External PM tools didn’t help because syncing them with repos always created friction.The solution was to treat GitHub Issues as the database. The "system" is ~50 bash scripts and markdown configs that:- Brainstorm with you to create a markdown PRD, spins up an epic, and decomposes it into tasks and syncs them with GitHub issues - Track progress across parallel streams - Keep everything traceable back to the original spec - Run fast from the CLI (commands finish in seconds)We’ve been using it internally for a few months and it’s cut our shipping time roughly in half. Repo: <a href="https://github.com/automazeio/ccpm" rel="nofollow">https://github.com/automazeio/ccpm</a>It’s still early and rough around the edges, but has worked well for us. I’d love feedback from others experimenting with GitHub-centric project management or AI-driven workflows.

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: MCP Server for PostgreSQL Monitoring/Operations (MCP-PostgreSQL-Ops)

Description

More from Show