2025年9月10日 的 Show HN

My elderly parents are behind a 5G connection in rural areas, and I help them manage their network from overseas. I found a reasonably priced 5G router that can do external antennas required for it to work, but the only reasonable ways to get access to it is either through OpenVPN or WireGuard, the latter of which is much more lightweight and preferred with the memory constraints of the device.

The problem with WireGuard is that it requires handling key management oneself, and configuring the keys to every device you want to access it from. It also doesn't play nicely together with other VPNs, meaning I ended up connecting and disconnecting VPNs whenever I wanted to use them. This is especially evident on my phone, which only allows one VPN app at a time.

I was already using Tailscale as an easy way to handle homelab access with SSO, even if some computers are behind ISP CGNAT, and came up with this idea of spinning up a Docker container to connect the two. I found some suggestions for it online, but nothing ready to use. It ended up being more work than I expected to fine tune the routing, IPv6, firewall settings, re-resolving the DNS of the router on IP address changes etc.

I got it very stable eventually though, and wanted to share with everyone else. I think it's cool to have the WireGuard router looking like any other Tailscale node in my tailnet now.

Hi HN!

We’re Akshay and Jake. We put together a tool called Haystack to make pull requests straightforward to read.

What Haystack does:

-- Builds a clear narrative. Changes in Haystack aren’t just arranged as unordered diffs. Instead, they unfold in a logical order, each paired with an explanation in plain, precise language

-- Focuses attention where it counts. Routine plumbing and refactors are put into skimmable sections so you can spend your time on design and correctness

-- Provides full cross-file context. Every new or changed function/variable is traced across the codebase, showing how it’s used beyond the immediate diff

Here’s a quick demo: https://youtu.be/w5Lq5wBUS-I

If you’d like to give it a spin, head over to haystackeditor.com/review! We set up some demo PRs that you should be able to understand and review even if you’ve never seen the repos before!

We used to work at big companies, where reviewing non-trivial pull requests felt like reading a book with its pages out of order. We would jump and scroll between files, trying to piece together the author’s intent before we could even start reviewing. And, as authors, we would spend time to restructure our own commits just to make them readable. AI has made this even trickier. Today it’s not uncommon for a pull request to contain code the author doesn’t fully understand themselves!

So, we built Haystack to help reviewers spend less time untangling code and more time giving meaningful feedback. We would love to hear about whether it gets the job done for you!

How we got here:

Haystack began as (yet another) VS Code fork where we experimented with visualizing code changes on a canvas. At first, it was a neat way to show how pieces of code worked together. But customers started laying out their entire codebase just to make sense of it. That’s when we realized the deeper problem: understanding a codebase is hard, and engineers need better ways to quickly understand unfamiliar code.

As we kept building, another insight emerged: with AI woven into workflows, engineers don’t always need to master every corner of a codebase to ship features. But in code review, deep and continuous context still matters, especially to separate what’s important to review from plumbing and follow-on changes.

So we pivoted. We took what we’d learned and worked closely with engineers to refine the idea. We started with simple code analysis (using language servers, tree-sitter, etc.) to show how changes relate. Then we added AI to explain and organize those changes and to trace how data moves through a pull request. Finally, we fused the two by empowering AI agents to use static analyses. Step by step, that became the Haystack we’re showing today.

We’d love to hear your thoughts, feedback, or suggestions!

I built HumanAlarm because I'm a heavy sleeper who's missed important things despite multiple phone alarms.

It's exactly what it sounds like - you book a wake-up time, we send someone to knock on your door for 2 minutes. If you don't answer, they wait 3-5 minutes and knock again. Simple as that.

We're live in select cities.

Would love feedback on the concept and execution!

We’ve open-sourced the Robot MCP Server, a tool that lets large language models (LLMs) talk directly to robots running ROS1 or ROS2.

What it does - Connects any LLM to existing ROS robots via the Model Context Protocol (MCP) - Natural language → ROS topics, services, and actions (And the ability to read any of them back) - Works without changing robot source code

Why it matters - Makes robots accessible from natural language interfaces - Opens the door to rapid prototyping of AI-robot applications - We are trying to create a common interface for safe AI ↔ robot communication

This is too big to develop alone — we’d love feedback, contributors, and partners from both the robotics and AI communities.

I’ve just released Ark v0.5.0, a lightweight Entity Component System (ECS) library for Go, built with a focus on performance and simplicity.

If you're new to Ark: it's a high-performance Go ECS library with a clean API and zero dependencies. Beyond its core ECS functionality, Ark stands out for ultra-fast batch operations and first-class support for entity relationships.

This release brings notable performance improvements to queries via smarter indexing, plus new methods for sampling random entities. The documentation has been expanded with a chapter on design philosophy and limitations, along with new examples covering advanced topics like entity relations, world locking, spatial indexing, and parallel simulations.

If you’re exploring ECS patterns in Go or looking for a an ECS that delivers performance without sacrificing usability, I’d love to hear your feedback. Contributions are welcome.

Changelog: github.com/mlange-42/ark/blob/main/CHANGELOG.md

Hey Everyone! Ron here, part of the NixOS Foundation and building Flox. Just coming out of this years NixCon and pretty excited to show hn below :)

As of today, NVIDIA officially recognizes Canonical, SUSE, CIQ, and Nix—via Flox—as supported distributors for CUDA. Full blog - https://developer.nvidia.com/blog/developers-can-now-get-cud...

This is a huge win for the Nix community. For years, CUDA on Nix was possible but painful—builds could take hours, and redistributing prebuilt binaries was blocked by NVIDIA's licensing requirements.

NVIDIA's growing engagement with key Linux distributions reflects the company's evolution in working with open source communities. Now, for the first time, NVIDIA is allowing these vendors to package and serve the CUDA Toolkit and CUDA-accelerated packages directly from their package repositories.

That means Ubuntu users can get CUDA via `apt`, SUSE users via `zypper`, Rocky Linux users via `dnf`, and Nix users simply by declaring CUDA dependencies in their Nix expressions, `shell.nix` files, or flakes. Across all four platforms, developers can now pull in prebuilt, prepatched CUDA software—including huge packages like PyTorch, TensorFlow, TensorRT, OpenCV, ffmpeg, and more.

On Nix (my own bias showing), setup is straightforward: just add Flox's cache as an `extra-substituter` in your `nix.conf` or `configuration.nix`.

I went down the rabbit hole on a side project and ended up building this: [Strange Attractors](https://blog.shashanktomar.com/posts/strange-attractors). It’s built with three.js. Working on it reminded me of the little "maths for fun" exercises I used to do while learning programming in early days. Just trying things out, getting fascinated and geeky, and being surprised by the results. I spent way too much time on this, but it was extreme fun.

All the parameters are configurable, so you can experiment and create your own shapes. My favorite part: someone pointed me to the Simone Attractor on Threads. It is a 2D attractor and I asked GPT to extrapolate it to 3D, not sure if it’s mathematically correct, but it’s the coolest by far. I have left all the params configurable, so give it a try. I called it Simone (Maybe).

If you like math-art experiments, check it out. Would love feedback, especially from folks who know more about the math side.

Nixite generates a bash script to automatically install all your Linux software unattendedly. Nixite prevents prompts and picks the best installation method. Nixite supports Ubuntu-based systems and Arch-based systems. Nixite installs a nixite-updater script to update all package managers and software at once.

Free PC Bottleneck Calculator - Check CPU & GPU bottleneck analysis. Find out if your processor will bottleneck your graphics card.

I was constantly switching between my terminal and ChatGPT/Claude/Gemini for code help. Built llmswap 4.1.1 to fix this.

Now I just type: llmswap generate "command I need"

Real examples that save hours:

Site emergency - needed to debug compressed logs:

llmswap generate "grep through gzipped nginx logs for errors"

Got: zgrep -i "error\|fail" /var/log/nginx/*.gz | head -50

That regex everyone googles:

llmswap generate "extract all IP addresses from log file"

Got: grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log | sort | uniq -c

Complex configs? No problem:

llmswap generate "docker compose for Prometheus Grafana monitoring" > stack.yml

80 lines of production-ready YAML.

The killer feature - works INSIDE vim:

:r !llmswap generate "MongoDB create user with read/write access"

Got: db.createUser({user:"appuser",pwd:"password",roles:[{role:"readWrite",db:"myapp"}]})

Code appears at cursor. No browser. No copy-paste.

Supports 8 providers (OpenAI, Claude, Gemini, Groq, IBM Watson, Ollama, etc). Use whatever API keys you already have. No additional subscriptions.

GitHub: https://github.com/sreenathmmenon/llmswap

PyPI: https://pypi.org/project/llmswap/

TimeCopilot is an open-source forecasting agent that combines the power of large language models with state-of-the-art time series foundation models (Amazon Chronos, Salesforce Moirai, Google TimesFM, Nixtla TimeGPT, etc.).

it automates and explains complex forecasting workflows: you can query data in natural language, compare across models, build ensembles, and ask why forecasts look the way they do. The goal is to make time series analysis more accessible while maintaining professional-grade accuracy.

we benchmarked it on Salesforce’s GIFT-Eval (144k series, 177M datapoints), where it ranked 1st overall (CRPS metric), and it’s already attracting early adopters in the open-source forecasting community.

repo: github.com/azulgarza/timecopilot docs: timecopilot.dev

would love feedback from the HN community, especially on use cases you’d like to see, and how we can make advanced forecasting more useful/usable.

After three years of development, my hardware project Mathpad is in its final 24 hours on Crowd Supply. I built this because I was tired of hunting for mathematical symbols every time I needed to type equations outside of specialized software.

What it is: A specialized USB-C keypad with 120+ mathematical symbols accessible via keypresses. Greek letters, calculus operators, set theory symbols, logic operators - everything you need for mathematical notation. Works anywhere you can type text.

Technical details: - QMK-based firmware (fully open source) - Unicode composition for universal compatibility - Multiple output modes (Unicode, LaTeX, Office equation codes) - Hot-swappable mechanical switches - Anodized aluminum case, custom UV-printed keycaps - Works on Windows, macOS, Linux

Why hardware vs software? Universal compatibility. Works in any text field - code editors, chat apps, documentation, even command lines. The development process was fascinating - from ugly $20 macropad prototype to custom PCB design to working with specialized keycap manufacturers. Weekly campaign updates document the entire journey if you're interested in the hardware development story.

Current status: 71 backers, final 24 hours remaining. All the hard engineering work is already done. This is just about getting enough orders to justify the production run.

Live demo video and complete technical documentation available on the campaign page. Would love feedback from the HN community on both the product and the development approach.

I just explored the Kokoro TTS model last week to generate audio for my needs. There are many cool projects already existing (Kokoro-FastAPI, kokoro-web), but they miss one of my needs (queuing audio generation) so I decided to build a simple one with queuing.

Link: https://github.com/kanthorlabs/sayathing

The most highlighted feature is async processing with a background task queue backed by SQLite.

The second feature is that audio will be saved as base64, and it’s very convenient for me to integrate with other systems in my homelab.

Let's try and enjoy it.

Hi HN, I built AegisClip, a minimalist clipboard manager for Mac.

Problem: I often needed to copy multiple items (code, text, links) but existing clipboard tools felt limited. Switching windows and pasting repeatedly was frustrating.

Solution: AegisClip tries to reduce context switching with: - Auto Paste after copying - Split copied text into multiple items - Batch or step-by-step paste - Inline previews (including color values), tags & search - 100% on-device, with privacy in mind

Would love to hear feedback from this community on how you use clipboard tools and what matters most. Demo & details: https://www.aegisclip.com

Hello HN, I'm Alex.

Today I'm launching updatify.io, a tool that delivers product updates and changelogs to your customers through embedded widgets, auto-generated blogs, or emails. It also collects feedback through an up/down vote mechanism (with comments coming eventually).

Similar tools exist, but I built my own for several reasons: some lack integrations, others lack features, and I needed one for my own projects. I run several open source projects for the self-hosted community, and it's a constant battle with users creating issues to request features that have already been implemented.

I've built similar functionality as part of paid projects at my day job, so it was a logical decision to create this as a standalone product given my knowledge and experience with previous implementations.

I'm already working on several improvements: integrations with GitHub/GitLab + Gitea/Forgejo releases, more customization options for blog pages (including SEO and UI enhancements), and better analytics for both widgets/blogs and emails.

Beyond the web version, I have a Flutter package almost ready for release(just need to QA it), which will make it easy to include in Flutter apps and eventually native iOS/Android packages.

I also want to provide free access to all open source maintainers, since they're most likely to benefit from this tool and I want to support their work. If you're an open source maintainer, sign up and contact me (you can find my contact email in the app) so I can grant you a free subscription.

And by the way - no AI involved, and not a single line of code written with it.

I built a little experiment called Internet Plays Chess.

It’s inspired by “Twitch Plays Pokémon,” but for chess. My goal was to see if the internet can collectively play a coherent game.

I leaned on Cursor (with Agent Mode) to speed up the build process, but I have a lot of experience with these types of apps/games, since I am also one of the creators of https://www.usdoku.com/ (another weird idea I had)

Hi HN,

I shared an early version of brainTerms (https://www.brainterms.ai) a while ago. It’s an AI platform I’m building to help product managers and any leaders explore and stress-test product and business strategies. Since then, I’ve made big improvements based on feedbacks I got.

What’s new ? - Multi-agent “experts” (market, finance, GTM, personas…) enhanced to meet our trademarked "SAFIR 5C" framework (Strategic Agentic Framework For Intelligent Reasoning) - Interactive scenario simulations and business digital twin analysis. We truly simulate your business dynamics before you spend $$$ in development. - Structured outputs (reports, slides, strategy notes) you can use in real meetings - Faster start: bring your idea as-is, or use the Biltz (quick) mode if you already have a pitch deck, strategic insights etc. - We have now a Demo Environnement (read only) accesible from the homepage

Why I’m building this ?

Strategy tools/skills today are either very manual (consulting, frameworks) or too generic (single LLM prompts). Costly or Toy. Brainterms.ai tries to bridge the gap: structured like a consultancy, but fast and adaptable like AI. Products needs better, faster and cheaper professional strategy.

Questions I often get - Who is this for? : Product Managers, Developers, Entrepreneurs, strategists, innovation managers, – Why not just ChatGPT with prompts? : You could, but brainTerms.ai orchestrate and chains specialized agents, enforces structure, and produces consistent, business-grade outputs. It's based on Academic research and Strategic Best Practice. - Hallucination : some Agents use hallucination as a feature and benefit from it. Others Agents have very strong guardrails to reduce it and benefit from specific tuning. - Security ? : we have security agreement with our provideds and encrypt our data. Enterprise users were happy to know that we can connect to they own corporate environnement (BYOOLM : Bring Your Own LLM). - Business model? : Free to try; subscriptions for advanced use.

What's next ? - We are finalising the first fine tuned LLM on Strategic Reasoning, that will be at the core of our product soon.

I’d love feedback again, especially from those who build products (tech or PM)

Thanks ! https://www.brainterms.ai

Hey there HN! My name is James, and I'm the developer of Nabla. The journey building this was a massive learning experience and I'm still learning things about this market as I go, but I wanted to tell you a little bit about Nabla that I think excite me about the future and why I chose firmware as opposed to the normal cloud path for GRC.

It actually went through a weird three step journey. What started off as a general BCA tool I wanted to build just to challenge myself because I saw Fossa advertise it on their website, turned into a weird snowball of trying out different things with binary composition analysis.

I ended up realizing the our typed Rust struct which standardized the composition opened up the door to a lot of things I was wanting to do, and beginning to over-engineer before I dug in and looked at what was being extracted better. What we ended up with was a pretty nice CLI that can scan firmware of multiple types and produce machine readable compliance artifacts.

The CLI uses:

- goblin for parsing ELF, Mach-O, and PE formats - capstone for lightweight disassembly where needed - A custom BinaryAnalysis struct to normalize metadata - The BinaryAnalsis structured results are fed into an LLM, which maps findings to OSCAL controls

Right now it covers 122+ controls, but the control set is expanding. The LLM isn’t a black box here — it’s grounded by the structured analysis, so it doesn’t just hallucinate.

I’d love feedback on:

- Usability, once I publish docs (install/run experience)

- Accuracy of the OSCAL mappings

- Ideas for handling edge cases (firmware blobs, weird file formats)

Thanks, and happy to answer questions!

Hi HN!

In every embedded job I’ve had, each company had its own way of handling application parameters. There was no standard approach, and everyone was reinventing the wheel. EPC aims to simplify this.

So, I built EPC, a small DSL and compiler to describe application-level configuration parameters for embedded firmware. The idea is inspired by Device Tree Compiler (DTC), but instead of hardware registers, EPC is focused on software parameters, like: constants, thresholds, default values, etc.

Cheers