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

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: 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: Fluent-state: a new fresh take on local React state

Description

More from Show