2026年1月25日 的 Show HN

Author here. I made this little TUI program for managing default applications on the Linux desktop.

Maybe some of you will find it useful.

Happy to answer any questions.

This is an interactive map of US navigational aids and lighthouses, which indicates their location, color, characteristic and any remarks the Coast Guard has attached.

I was sick at home with the flu this weekend, and went on a bit of a Wikipedia deep dive about active American lighthouses. Searching around a bit, it was very hard to find a single source or interactive map of active beacons, and a description of what the "characteristic" meant. The Coast Guard maintains a list of active lights though, that they publish annually (https://www.navcen.uscg.gov/light-list-annual-publication). With some help from Claude Code, it wasn't hard to extract the lat/long and put together a small webapp that shows a map of these light stations and illustrates their characteristic with an animated visualization..

Of course, this shouldn't be used as a navigational aid, merely for informational purposes! Though having lived in Seattle and San Francisco I thought it was quite interesting.

This is a hobby project of mine that I started a few years ago to learn about programming language implementation. It was created 95% without AI, although a few recent commits include code from Gemini CLI.

I started out following Crafting Interpreters, but gradually branched off that until I had almost nothing left in common.

Tech stack: Rust, Cranelift (JIT compilation), LALRPOP (parser).

Seven modules teaching C the way safety-critical systems are actually built: MATH → STRUCT → CODE → TEST.

Each module answers one question: Does it exist? (Pulse), Is it normal? (Baseline), Is it regular? (Timing), Is it trending? (Drift), Which sensor to trust? (Consensus), How to handle overflow? (Pressure), What do we do about it? (Mode).

Every module is closed (no dependencies), total (handles all inputs), deterministic, and O(1). 83 tests passing.

Built this after 30 years in UNIX systems. Wanted something that teaches the rigour behind certified systems without requiring a decade of on-the-job learning first.

MIT licensed. Feedback welcome.

To power the firewalling for our agents so that they couldn't contact arbitrary services, I build netfence. It's like Envoy but for eBPF filters.

It allows you to define different DNS-based rules that are resolved in a local daemon to IPs, then pushed to the eBPF filter to allow traffic. By doing it this way, we can still allow DNS-defined rules, but prevent contacting random IPs.

It also means you don't have to tamper with the base image, which the agent could potentially manipulate to remove rules (unless you prevent root maybe).

It automatically manages the lifecycle of eBPF filters on cgroups and interfaces, so it works well for both containers and micro VMs (like Firecracker).

You implement a control plane, just like Envoy xDS, which you can manage the rules of each cgroup/interface. You can even manage DNS through the control plane to dynamically resolve records (which is helpful as a normal DNS server doesn't know which interface/cgroup a request might be coming from).

We specifically use this to allow our agents to only contact S3, pip, apt, and npm.

I've long wanted to harness QEMU/KVM for my desktop virtual machines, but I've long been befuddled by virt-manager's lack of support for working nvidia 3D acceleration, dogmatic embrace of ugly XML, and the puzzling UI decision of having to click what seems like 15 buttons to attach an ISO to a VM image. When I further learned that NVIDIA's broken 3D acceleration is the fault of libvirt as opposed to QEMU's virtio driver, I had an idea...

Behold, vm-curator! A fast and friendly vm management TUI written in rust. You can create, configure, organize, and manage VMs directly with QEMU. No libvert. No XML. No wonky UI's. Just the right level of friendliness, customization, and speed to be really really useful.

The best part? 3D para-virtualization works with NVIDIA cards (via virtio-vga-gl!) No jumping through hoops to get GPU passthrough working!

(Disclaimer: This works great with other guest Linux VMs, but is not suitable for Windows gaming. If you want to game on Windows within a VM, passthrough is a must. vm-curator will have fast and friendly support soon.)

Looking for contributors (especially to help with the ascii art,) and donations are welcome. (Claude was a big help, but this was not a vibe-coded affair. We pair-programmed approx. 10,000 lines of code here. It was a great way to learn Rust, actually!)

Hi HN, I built Beni (https://thebeni.ai ), a web app for real-time video calls with an AI companion.

The idea started as a pretty simple question: text chatbots are everywhere, but they rarely feel present. I wanted something closer to a call, where the character actually reacts in real time (voice, timing, expressions), not just “type, wait, reply”.

Beni is basically:

A Live2D avatar that animates during the call (expressions + motion driven by the conversation)

Real-time voice conversation (streaming response, not “wait 10 seconds then speak”)

Long-term memory so the character can keep context across sessions

The hardest part wasn’t generating text, it was making the whole loop feel synchronized: mic input, model response, TTS audio, and Live2D animation all need to line up or it feels broken immediately. I ended up spending more time on state management, latency and buffering than on prompts.

Some implementation details (happy to share more if anyone’s curious):

Browser-based real-time calling, with audio streaming and client-side playback control

Live2D rendering on the front end, with animation hooks tied to speech / state

A memory layer that stores lightweight user facts/preferences and conversation summaries to keep continuity

Current limitation: sign-in is required today (to persist memory and prevent abuse). I’m adding a guest mode soon for faster try-out and working on mobile view now.

What I’d love feedback on:

Does the “real-time call” loop feel responsive enough, or still too laggy?

Any ideas for better lip sync / expression timing on 2D/3D avatars in the browser?

Thanks, and I’ll be around in the comments.

Hi HN,

I built *Sightline*, a Shodan-style search engine for *physical-world infrastructure*.

Shodan makes it easy to explore exposed internet services. Sightline applies the same idea to the real world, using OpenStreetMap as the data source.

You can search things like:

* “telecom towers in karnataka” * “power plants near mumbai” * “data centers in paris france”

or use structured queries:

* `type:telecom operator:airtel region:karnataka` * `type:data_center operator:google`

Sightline:

* uses Overpass API for querying OSM features * uses Nominatim for resolving countries, regions, and cities * avoids hardcoded geography * uses deterministic, rule-based parsing (no AI inference)

Repo: https://github.com/ni5arga/sightline Try it out: https://sightline-maps.vercel.app

Saw this repo: https://github.com/tldev/posturr and wanted to share my solution to avoid nail biting :)

I built this because I am perpetually drowning in file transfer hell.

As a systems engineer, I am constantly moving massive files. Whether it's getting new releases of custom ISOs to clients, downloading entire filesystems to spin up clones, or uploading massive support packages to L3.

I always have to get something to somebody. Usually, it's something large that lives on a headless server. I can't tell you how many times I've modified my 'clone' script to tar most of a filesystem over ssh ("hello --exclude, my old friend...") just to get 10GB that someone will need for two days.

Tedious is an understatement.

And the truth is, whatever I am sending, it is ephemeral. I download it, I upload it, I delete it. They download it only to delete soon after.

I kept wondering - why isn't there a simpler tool that works where I spend 90% of my time -- the terminal? I wanted something that I could install quickly on whatever server I was currently connected to, and run a simple command to push to the cloud.

Enter Bucket – a secure, encrypted file sharing platform that works the way I do. I upload from the CLI, share with a link and unique secret, done. No browser required (unless you want it). The people you're sharing with can simply click the link you share to download, no need for them to make an account (unless they want it).

What makes it different:

- CLI-first: Built for terminal workflows first, web UI second

- Encryption: End-to-end AES-256 encryption. We never see your files or your secrets. The secret generated during a push is required for the pull, keeping your data private even from us. If you lose the secret, you can't access the file.

- Simple scalability: Free tier for trying it out, plans up to 250GB for serious use, enterprise coming soon.

- File retention: Bucket is designed for ephemeral storage. Upload things that people need now. Free tier keeps files for 3 days (email notifications are sent to you before they are deleted, in case you need to upload again)

Colleagues I have introduced this to tell me they use it every day. I know that I do.

Free tier gives you 3 GB to try it out - enough for most one-off transfers.

Here's the workflow:

    $ bucket push api.bin
    Verifying upload...
     Upload complete!

    bID: bkdf1e848ea23e
    bURL: api.bucketlabs.org/d/bkdf1e848ea23e
    Secret: 9b1e15167403a88cadb7d0f4d2890856
    Expires: 2026-01-28T03:15:18.277988Z
 

Now you have a link for your browser-dwellers to simply click, paste the Secret and download. (go ahead, try on the link above to download the readme.md)

... but if the person you're sharing with has bucket installed they simply run:

    $ bucket pull bkdf1e848ea23e
    Enter secret: 
    ⠇ Downloading...
    Downloaded: api.bin

Check your file:

    $ bucket list 
    ID               Filename             Size         Expires
    ----------------------------------------------------------------------
    bkdf1e848ea23e api.bin              204.2 MB      2026-01-28T03:15:18.277988Z

    $ bucket account 
    Account Info
    ------------
    Subscription: free
    Used: 204.2 MB
    Quota: 3.00 GB

    To increase storage limits, visit:
    https://bucketlabs.org/auth

Everyone you needed to pull have the file? Go ahead and delete:

    $ bucket del bkdf1e848ea23e
    Deleted: bkdf1e848ea23e

Built in Go. Single static binary, works anywhere. Download at bucketlabs.org

Hey HN, I'm a solo developer from Nigeria. I built Quran Unlock - an app that blocks distracting apps (TikTok, Instagram, etc.) until you complete your daily Quran reading.

The idea came from my own struggle with phone addiction. I wanted to read Quran daily but kept getting distracted. So I built this for myself, then shared it.

Some stats after 2 months: - 123K+ users - 64.9% returning user rate - 31M events tracked

Tech stack: - React Native - Firebase (Auth, Firestore, Analytics, Cloud Messaging) - RevenueCat for subscriptions - iOS Screen Time API + Android UsageStats

App Store: https://apps.apple.com/app/quran-unlock/id6754449406

Play Store: https://play.google.com/store/apps/details?id=com.app.quranu...

Would love feedback from the HN community!

Hi HN,

We just open-sourced Lumina, an observability SDK for teams building LLM-powered applications.

We started building this after repeatedly running into the same problem: once LLMs are in production, failures are often silent. Prompts change, outputs degrade, costs spike, or responses break expectations — and it’s hard to understand why without proper traces and signals.

Lumina aims to make this easier by providing: • Lightweight tracing around LLM calls • Visibility into inputs, outputs, latency, and errors • A simple SDK you can integrate early, before things get complex

The project is still early, and we’re intentionally starting as open source so we can learn from real usage and feedback from teams actually running LLMs in production.

SDK (npm): https://www.npmjs.com/package/@uselumina/sdk

We’d really appreciate: • Feedback on the API • Thoughts on what signals are most useful in practice • Stories from anyone debugging LLM behavior at scale

Happy to answer questions and learn from the community. Thanks for taking a look.

— Ignatius

About a month ago, I shared the Day 1 prototype of this project (https://news.ycombinator.com/item?id=46448670). It has since evolved into a somewhat more polished "Slot-Machine Deckbuilder."

I also recently moved the project from qq-pwn.com to alt-qq.com. I did this mid-development specifically to see if I could migrate a live player base and session states without losing people.

The Design Challenge: The core of the game is a "One-Armed Bandit" dungeon crawler. The challenge is balancing the "house always wins" nature of slots with the player agency required for a good roguelike.

What I’d love your feedback on: The First 30 Seconds: Is it immediately obvious how to play? I’ve tried to keep the onboarding "invisible," but I worry the manipulation mechanics might be buried.

Skill vs. Luck: Does the game feel like a mindless gamble, or do you feel like you have agency over the outcome?

The "Cursed Seed" UX: I’ve added a way to share specific runs via a URL. Does the transition from "clicking a friend's link" to "playing the game" feel seamless?

Mobile/PWA Performance: It’s built to be a PWA. Does it feel like a "web page" or does it feel like a native app on your device?

I'm especially interested when and where exactly did you feel like quitting?

Technology: The project is built with React and Vite, hosted on a Cloudflare edge stack. The code is 100% augmented by AI, which allowed me to focus more on the architecture of the project and the design of the mechanics rather than implementation syntax.

Reel Rogue: The Bandit's Tale is playable here: https://alt-qq.com

Authoritarian regimes create crises to saturate our attention

AI can help us fight back by tracking and prioritizing threats to our freedom

250+ types of events tracked daily from national coverage

Completely automated and community funded

https://www.worstdaysofar.com/

Example Daily Situation Report:

SITREP - Authoritarian Consolidation (Last Update Jan 24, 7:11 PM)

New Today

Tactics: Scene access denial -- federal teams block state investigators after lethal force incidents (Minneapolis)

Violence/Detention: Border Patrol lethal force -- urban shooting escalates risk during routine immigration operations (Minneapolis) • Stun grenades and tear gas -- crowd control spikes after shootings, raising bystander injury risk (Minneapolis)

New Yesterday

Tactics: Generic POLICE vests -- misidentification enables federal teams to evade accountability during grabs (Minnesota)

Lawfare: Grant drawdown toggles -- federal health funding access paused to enforce priority compliance (US) • Sealing special-counsel report -- privilege claims used to suppress scrutiny of executive misconduct (US)

Disinformation: National parks passes with leader portrait -- voiding altered passes coerces visible loyalty (US) • Geofenced ICE recruitment memes -- wartime branding accelerates staffing for enforcement surges (US)

New This Week ... ...

We just released a fully computer-animated multivariable calculus course in six languages: English, Spanish, German, French, Italian, and Portuguese. Free and open to everyone. Half the course is live now; the rest is coming very soon.

We're an early-stage edtech startup. Our goal: use AI to build high-quality, computer-animated versions of every STEM course in the world, in every language, and bring them together on a platform like Coursera, but built for the AI age, with deep LLM integration. We want that literally. Every course. Every language.

This project simply couldn't exist without generative AI. We're two co-founders, and we don't speak five of the languages we just published in. There may be mistakes, but these courses wouldn't exist in those languages otherwise.

We produce lectures fast with AI. But once a lecture is done, adding another language is even faster, it's O(1). So we just made this in six languages. We could keep going.

These videos aren't static MP4s, they're open for improvement. If you have ideas, suggestions, or find mistakes, please open an issue on GitHub: https://github.com/academa-dev/multivariable-calculus

Would love your feedback. Happy to answer questions.

Join the waitlist for upcoming courses at https://academa.ai.

Tech stack: We forked 3Blue1Brown's Manim, synced TTS with animations using OpenAI Whisper, and used Inworld AI for text-to-speech.

The Project: I am building R3-Engine, a from-scratch, local AI inference engine for Microsoft's bitnet-b1.58-2B-4T. It is written in 100% Safe Rust, natively cross-compiles to Wasm SIMD128, and uses Zero heap allocations in the execution loop.

The Physics: By mapping a 64-byte aligned .r3 file directly from NVMe to CPU L3 Cache (Zero-Copy) and using AVX-512 VPOPCNTDQ for branchless math, the Ryzen 9950X3D achieves 117 Tokens/Second latency.

The Problem: The AI is mute (Outputting <unk>*)* The matrix multiplication pipeline is mathematically complete, but the output is stuck at Token ID 0 (<unk>). The issue lies in the transition between the quantized weights and the float-based non-linear activations.

Where I need expert input:

    Weight Tying in BitNet: Microsoft's 2B model ties Embeddings with the LM Head. I am cloning the embedding matrix for the output projection, but I suspect a scaling factor is missing.

    RMSNorm & SiLU in 1.58-bit: How should the raw integer accumulators (from the VPOPCNTDQ loop) be scaled before entering the SiLU activation and the subsequent layer?

GitHub Repo: https://github.com/r3-engine/r3-engine

If you know the physics of LLM Logit Sampling or ternary activation math, I would love your eyes on the codebase.

Client-side app that pulls NWS data to attempt to show progression when you're in the middle of a major snowfall event.

I kept running into the same problem: modern Python tooling, but deployments to air-gapped systems are a pain. Even with uv, moving a fully locked environment into a network-isolated machine was no fun.

uv-pack should make this task less frustrating. It bundles a locked uv environment into a single directory that installs fully offline—dependencies, local packages, and optionally a portable Python interpreter. Copy it over, run one script, and you get the exact same environment every time.

Just released, would love some feedback!

Hey HN! I built Gitmore to solve a problem I kept running into: spending hours compiling what my team did each week for stakeholders.

What it does: Gitmore connects to your GitHub/GitLab/Bitbucket repos (via webhooks, never touches your code) and uses AI to generate human-readable reports of your team's activity.

Example report: https://www.gitmore.io/example.html

Interactive demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po

EchoFluid is a privacy-first video and audio transcription tool I built to solve a problem I personally ran into: most transcription services require uploading the entire video file, which is slow, bandwidth-heavy, and sometimes not acceptable for sensitive content.

What’s different:

- Videos are processed locally in the browser to extract audio before upload

- Only the audio is sent for transcription, not the full video

This results in:

- Faster uploads

- Much lower bandwidth usage

- Support for much larger video files

- Better privacy by default

Hi HN, I'm an independent developer and programmer。

I built HomeGenGuide because I found it surprisingly difficult to get a clear estimate for home backup power installation costs without jumping through hoops with sales reps。

It’s a tool that calculates estimated costs based on generator type, fuel source, and potential labor rates。 On the tech side, it's built with Next.js and serves as a real-world case study for my interest in programmatic SEO (pSEO) and niche market analysis。

I'd love your feedback on:

The accuracy of the cost estimation logic.

The overall UX for a niche utility tool.

Any other variables I should consider (e.g., specific regional regulations).

Hi HN — I’m Maaz. I built Free PDF Editor by TechRex, a privacy-first PDF toolkit that runs entirely in the browser (client-side). No signup, no watermark.

Why: I was frustrated that many “free” PDF tools require uploads, add watermarks, or force accounts. I wanted a simple tool where files stay on-device by default.

What it includes: - Edit & annotate: type on PDF, highlight, draw/markup, add notes - Add images/branding: insert images/photos, add a logo to a PDF - Organize: merge, split, extract pages, delete pages - Compression: compress for email/WhatsApp/portal uploads + target sizes (100KB, 200KB, 500KB, 1MB, 2MB, 5MB, 10MB) - OCR: detect scanned PDFs, make PDFs searchable (Ctrl+F), improve copy/paste + conversion accuracy - Converters: PDF ↔ Word/Excel/PPTX, image ↔ PDF, HTML ↔ PDF, PDF ↔ text, image-to-text

I’d love feedback on: 1) UX: should the homepage focus on Edit vs Compress vs OCR? 2) Quality: which formats/conversions/OCR cases break most for you? 3) Trust: what privacy assurances would you want to see (copy, UI, technical notes)?

Thanks — I’ll respond to every comment and prioritize fixes/features based on feedback.

Throughout my career in embedded systems — automotive (ASPICE), medical, avionics, CMMI environments — I've seen teams struggle with the same problem: requirements traceability. The options were always frustrating:

Expensive, heavy tools like DOORS that don't fit modern dev workflows JIRA-based workarounds that slow everything down and integrate poorly with code

So I built SARA (Solution Architecture Requirements for Alignment): a CLI that treats architecture documents and requirements as a knowledge graph. The core idea: your requirements are too important to be locked in proprietary systems. SARA uses plain Markdown + YAML frontmatter, which means:

Full Git workflows (branching, code review, versioning) No vendor lock-in — switch tools anytime, your data stays readable AI/LLM-ready format for automated analysis

Features:

Multi-repo support Traceability queries (upstream/downstream) Validation (broken refs, cycles, duplicates, orphans) Coverage reports and traceability matrices

Coming soon: ADR support and MCP server for AI assistant integration. Written in Rust. Free and open-source. https://github.com/cledouarec/sara Would love feedback from anyone who's dealt with requirements management pain.

We’ve been working on a spinning ring that hides a true micro-bearing system inside a 2mm profile.

The main challenge was balancing tolerance, durability, and smooth rotation at this scale. We went through multiple prototypes dealing with ball size, raceway depth, and surface finishing before getting consistent 20s spins.

Would love feedback from anyone who’s worked on ultra-compact mechanical systems or precision manufacturing.

If you’re curious, the project is live on Kickstarter: https://www.kickstarter.com/projects/cooloze/spinitytm-beari...

Hi HN, I’m the creator of PodCost (https://podcost.io/).

I built this because as AI workloads move into production, GPU spend is becoming the largest line item on the cloud bill. Standard K8s cost tools often treat a node as a "black box," but when an A100 sits idle because of a misconfigured training job or a stuck inference server, you’re burning hundreds of dollars a day.

The Live Demo: I know how annoying it is to sign up just to see a dashboard. I’ve set up a demo cluster so you can see the ML-specific cost analysis and recommendations immediately:

URL: https://podcost.io/login

User: [email protected]

Pass: [email protected]

What’s inside:

ML Workload Analysis: It tracks costs per training job and inference request.

GPU Idle Detection: Automatically finds GPUs that are allocated but have low utilization.

Actionable Recommendations: It suggests specific rightsizing for pods and nodes based on actual historical usage.

Quick Setup: If you want to test it on your own cluster, it’s a single Helm command.

I’m particularly looking for feedback on our GPU recommendation engine. Is this a problem that you might pay for? also are those metrics shown in the demo cluster good enough? I am not building another observability tool. I am building AI cost saving tool that focuses on AI and GPU waste. your feedback will be really important for me.

I’ll be here to answer any technical questions!

- Added support for document metadata preservation - Bring your own LLM - No OS limitations

I built this browser tool which lets you quickly generate 3D printable boxes in your browser. It's pretty useful when you are rapidly iterating a design and need a box with specific parameters for internal capacity or external size without the effort of opening up CAD software.

It uses Three.js for rendering, and runs entirely in the browser (no server necessary).

It works in inches, mm, and also Gridfinity, which is a standard for making 3D printable storage units which stack nicely and fit along a 42 mm grid. It uses internal units of 10 nm, so that 100,000 are exactly one mm, and 2,540,000 are exactly one inch.

I have validated the numbers against the Gridfinity spec, but I don't have access to a 3D printer right now. I would love to hear what people think of it so far, or if one of you has a 3D printer nearby, I would love to know if it actually works.

I built an AI agent that searches the entire Cursor community forum (http://forum.cursor.com/) and answers questions grounded in real forum discussions.

The problem: Cursor's forum has tons of valuable content - feature discussions, troubleshooting threads, tips from power users - but it's hard to search. Traditional forum search is keyword-based and misses a lot of context.

The solution: I indexed the entire forum using Nia (a knowledge indexing service) and connected it to an AI agent with multiple search tools:

- Semantic search - finds relevant posts even when wording differs - Pattern search (grep) - exact matching for error messages, usernames, specific terms - Full thread reading - AI can dive deep into specific discussions - Web search fallback - for questions the forum doesn't cover

GitHub: https://github.com/nozomio-labs/nia-cursor-forum-search

Would love feedback on the approach!

I’m a computer engineering student at SPPU. While working on a project with React 19, I realized that the standard libraries we use for SEO (like React Helmet) are still doing things the "old" way.

The Problem: Older libraries use a trick called "side effects" to change your page title and meta tags after the page has already loaded. This can cause the title to flicker or make the site feel a bit slower because the browser has to do extra work.

The Solution: React 19 added a built-in feature that lets it move tags to the top of the page (the <head>) automatically. I built react-meta-seo to make this new feature easy to use for everyone.

Why it’s simpler for developers:

No "Provider" needed: You don't have to wrap your whole app in a special component. It just works wherever you drop it.

Tiny size: It’s under 4KB. For comparison, legacy options are usually 15KB or more.

No more broken Google data: It checks your Google Search data (JSON-LD) automatically to make sure it’s formatted correctly.

Built-in Preview: I added a tool so you can see what your site will look like on Twitter or Facebook while you're still coding.

Simple Sitemap Tool: It includes a command-line tool to make your sitemap.xml for you.

I wanted to build something that used the new React 19 features to make SEO faster and easier to set up. I’d love to get some feedback on the code!

GitHub: https://github.com/ATHARVA262005/react-meta

Managing a local music library used to mean juggling multiple apps: a Soulseek client to find music, MusicBrainz Picard for tagging, a file manager to organize folders, and finally a music player. Every new album meant switching between windows, waiting for apps to rescan, and hoping everything ended up in the right place.

I built Waves to collapse that entire workflow into a single keyboard-driven terminal app.

The workflow: - Press "f d" to search Soulseek directly from the player - Pick a release from MusicBrainz results, download matching files - Import with automatic tagging, album art fetching, and Picard-compatible renaming - Music lands in your library, ready to play

No window switching. No waiting for library rescans. No manual file shuffling.

But it's also just a solid music player: - Miller columns navigation (Artist > Album > Track) with vim bindings - Gapless playback, MP3/FLAC/Opus/M4A support - Radio mode: when your queue runs out, it uses Last.fm similar artists to keep playing from your own library - Last.fm scrobbling with offline queue - MPRIS support for desktop integration on Linux - Playlists with folders, favorites, queue with undo/redo - Full-text search across everything (SQLite FTS5) - State persistence: queue, position, everything survives restarts

Built with Go, Bubble Tea, and SQLite. Soulseek integration requires a running slskd instance (https://github.com/slskd/slskd).

  go install github.com/llehouerou/waves@latest
  # or on Arch
  yay -S waves-bin
  # or with Nix
  nix run github:llehouerou/waves

Press "?" for keybindings once you're in. Happy to answer questions about the architecture or take feature requests.

Description: Mindwork is an AI workspace for deep and focused personal knowledge management. Inspired by Cursor, notes are displayed like files and folders on the left, they can open as tabs in the middle, and on the right is an assistant that is your personal thought partner which you can brainstorm, plan, and learn with, using your knowledge in context, and that can write insights from your session back into your notes.

Inspiration: Integrating Cursor into my development workflow has been the biggest productivity boost in my career. Working with an all-knowing pair programmer that I can plan features and brainstorm ideas with in the context of my codebase, and then ask it to do changes based on decisions in a chat window is a huge performance unlock, and I believe personal knowledge management could benefit from the same experience.

Read our release blog to learn more about Mindwork and what makes it stand out: https://mindwork.it.com/blog/welcome-to-mindwork

Hey HN,

I’m Nikhil (https://nikhilp.online). I've been building projects for the past few years, and decided to build ShillGuard because I kept hitting a wall when trying to share them on platforms like reddit and facebook.

I’d spend weeks building something, write a post and get it instantly removed by Reddit’s AutoMod or flagged as spam in Gmail without knowing why.

ShillGuard is a Chrome extension that analyzes your draft text in real-time against the specific context of where you are posting/sending.

How it works under the hood:

Instead of just checking grammar or tone, the extension injects a content script (built with Plasmo) to scrape the DOM and fetch contextual metadata before you hit submit.

On Reddit: When you type in a text editor, it grabs the subreddit name from the URL and fetches the specific rules.json and about.json endpoints in parallel. It also checks your current account stats (Karma/Account Age) against the community's typical thresholds to predict if you'll be filtered by AutoMod. I plan to add examples of recently popularized posts as well, to provide good examples of how the content "should" look in an ideal world.

On Facebook: It scrapes group metadata and privacy settings to warn you if your post (e.g., containing external links) violates specific group norms.

On Gmail: It analyzes your subject line and body for spam-trigger words and checks for "attachment" inconsistencies (e.g., saying "attached" but forgetting the file). I am enjoying building this feature out the most, as there are so many ways to make it produce high quality emails! Currently, I'm integrating a blacklist and spam check using an external API to help highlight if your account is being hidden by email providers.

The Tech Stack:

Framework: Plasmo (for the browser extension runtime)

Frontend: React + Tailwind CSS

Intelligence: Google Gemini Flash (via the new Google Gen AI SDK)

Architecture: It’s strictly Local-First / BYOK (Bring Your Own Key).

I decided to go with a Bring Your Own Key model for the AI analysis. Your API keys are stored in chrome.storage.local and the analysis requests go directly from your browser to Google. This keeps the extension privacy-focused and avoids me having to act as a middleman for your data.

It’s currently a paid extension (with a lifetime deal) but I really wanted to solve the "black box" frustration of platform moderation for indie hackers.

This is my first time working on a Chrome Extension so I'd love to hear feedback on whether Plasmo is the best framework to use, or any ideas for additional features!

Hello Hacker News — greetings from South Korea I’m a backend engineer working primarily with Go, and I’d like to share a framework I’ve been building to solve a problem I’ve repeatedly encountered in production systems.

In my day-to-day work, our backend is built on top of Echo. Echo is fast and reliable as an HTTP transport, but its high level of freedom leaves architectural decisions almost entirely to individual developers. Over time, this led to a system where execution flow and responsibility boundaries varied depending on who last touched a feature. Maintenance became difficult not because the code was incorrect, but because how requests actually executed was no longer obvious.

I looked for a Go framework that could provide a clear execution model and structural constraints, similar to what Spring or NestJS offer. I couldn’t find one that fit. Moving to Spring or NestJS would also mean giving up some of Go’s strengths—simplicity, performance, and explicit control—so I decided to build one instead.

Spine is an execution-centric backend framework for Go. It aims to provide enterprise-grade structure while deliberately avoiding hidden magic.

What Spine provides • An IoC container with explicit, constructor-based dependency injection • Interceptors with well-defined execution phases (before, after, completion) • First-class support for both HTTP requests and event-driven execution • No annotations, no implicit behavior, no convention-driven wiring

The core idea: execution first

The key difference is Spine’s execution model.

Every request—HTTP or event—flows through a single, explicit Pipeline. The Pipeline is the only component that determines execution order. Actual method calls are handled by a separate Invoker, keeping execution control and invocation strictly separated.

Because of this structure: • Execution order is explainable by reading the code • Cross-cutting concerns live in the execution flow, not inside controllers • Controllers express use cases only, not orchestration logic • You can understand request handling by looking at main.go

This design trades some convenience for clarity. In return, it offers stronger control as the system grows in size and complexity.

My goal with Spine isn’t just to add another framework to the Go ecosystem, but to start a conversation: How much execution flow do modern web frameworks hide, and when does that become a maintenance cost?

The framework itself is currently written in Korean. If English support or internationalization is important to you, feel free to open an issue—I plan to prioritize it based on community interest.

You can find more details, a basic HTTP example, and a simple Kafka-based MSA demo here: Repository: https://github.com/NARUBROWN/spine

Thanks for reading. I’d really appreciate your feedback.

Got tired of constantly juggling files with find, ls, stat, grep, and sort just to locate or clean things up. So I built fdir - a simple CLI tool to find, filter, and organize files on your system.

I'm working on a tool that wraps Claude Code. In the process, I wanted to know some implementation details of the Claude Code CLI.

Claude Code is just a Bun CLI app, so I figured it could be decompiled.

This program will:

1. Decompile a Bun app

2. For each minified method, it will call an LLM (OpenAI, Anthropic, etc.) with the method and some context

3. The LLM will reply with suggested names for methods/variables/etc

4. Babel will apply those renames in a deterministic manner, so that functionality cannot be broken

I built GroqBash, a single‑file Bash client for the Groq API (OpenAI‑compatible). I wanted something fully auditable, with no dependencies, and that worked reliably on Termux, where /tmp isn’t writable. Everything lives inside a self‑created groqbash.d directory, and the core script avoids eval, avoids /tmp, and keeps permissions strict.

The project now includes optional extras: additional providers (including Gemini), extended documentation, small security tools, and a tiny test suite. The core stays minimal and portable; extras are opt‑in.

I’d love to get: - feedback on the design and Bash choices - visibility to see if others find this useful - testing on different environments (Linux distros, macOS, WSL, Termux)

Repo: https://github.com/kamaludu/groqbash

Note: I’m not a native English speaker. I read English fairly well, but I usually rely on automatic translators (and sometimes GroqBash itself) when writing. Happy to clarify anything if needed.

I built an ecosystem for AI-driven development where breaking architectural rules is structurally impossible.

*The problem:* AI coding assistants produce inconsistent code. Every session yields different implementations, and AI "forgets" rules mid-conversation. Prompt engineering helps, but quality still depends on how well you explain things each time.

*The insight:* Don't ask AI to follow rules—make it impossible to break them.

*The approach:*

1. *Specialized agents with strict boundaries* - Instead of one AI doing everything, split responsibilities. Layout agent creates JSON UI structure (never touches data types). Data agent defines bindings (never writes business logic). ViewModel agent implements logic (never edits JSON).

2. *JSON as single source of truth* - One JSON definition generates iOS native (SwiftUI/UIKit), Android native (Compose/XML), Web (React/Tailwind), tests, and docs. All in sync. Always.

3. *Cross-platform test runner* - Same test JSON runs on XCUITest, UIAutomator, and Playwright.

*Result:* Spec, implementation, and docs stay in sync because they're generated from the same source. AI agents are productive because they have clear, narrow scopes.

Still in development. Repos:

- Core: SwiftJsonUI, KotlinJsonUI, ReactJsonUI - Test runner: jsonui-test-runner (CLI + platform drivers) - Agents: JsonUI-Agents-for-claude

GitHub: https://github.com/Tai-Kimura

Would love feedback on the agent design approach.

*Show HN: SIS v1.0.0 – Static security scanner for rule engines and policy layers*

GitHub: [https://github.com/gopinath2866/sis-rules-engine](https://github.com/gopinath2866/sis-rules-engine)

I built *SIS (Security Inspection System)* to catch security issues in rule-based and policy-driven systems before they reach production.

While auditing systems using things like OPA/Rego, IAM policies, and custom RBAC logic, I kept seeing the same class of problems: overly permissive rules, missing deny paths, wildcard conditions, and logic that looked correct but created security risk.

SIS is a *static analyzer* (Go CLI) that lets you:

* Define security rules in YAML / JSON * Scan policy and configuration files * Catch common misconfigurations deterministically (no runtime access)

Key characteristics:

* Static analysis only (no credentials, no runtime hooks) * Extensible rule engine * Designed for CI/CD or pre-deployment checks * Explicitly scoped (not a vuln scanner, not runtime monitoring)

This is the *v1.0.0 stable release* — semver starts here, with documented guarantees and non-guarantees.

I’d especially appreciate feedback from people working with:

* OPA / Rego * Cloud IAM (AWS / GCP / Azure) * Custom RBAC / ABAC systems * Policy-as-code pipelines

I’m also offering a *free static audit* for a small number of teams using SIS, if you want real-world feedback.

Happy to answer technical questions or discuss design tradeoffs.

I built this because most image upscalers don't handle faces well - they blur skin and lose facial details. Crystal Upscaler focuses specifically on portraits, preserving natural skin texture and identity during 4x upscaling. Works in browser, free to try. Would love feedback from the HN community!

Hi HN, I built AgentHub because I was frustrated by the trade-offs required to build multi-model agents in 2026. When you try to support GPT, Claude, and Gemini 3 simultaneously, you usually hit a wall: you either write thousands of lines of boilerplate code or use a "standardizing" wrapper that strips away what makes each model special. While projects like Open Responses focus on creating vital standards for model transparency and evaluation, AgentHub provides a simple and light-weight interface to adopt those standards in production with zero code changes. AgentHub takes a different approach: We don’t want to "standardize" the models; we want to provide an intuitive yet faithful interface that keeps you 100% consistent with official API specifications. - Zero-Code Switching: You can transition your entire agent infrastructure from one provider to another via a simple configuration update. No refactoring, no logic changes—it’s a true zero-code conversion for your codebase. - Faithful Validation: Unlike simple API forwarders, we perform comprehensive validation to ensure your payloads perfectly match SOTA specifications. This maintains 100% consistency with official API SDKs, eliminating the "intelligence loss" often caused by fragile manual schema mapping. - Traceable Executions: We provide lightweight yet fine-grained tracing for debugging and auditing LLM executions, enabling deep post-mortem analysis of agent behavior. I’m curious to hear from the HN community: In your production workflows, do you prefer a "Universal Standard" like Open Responses, or do you value 100% official SDK consistency more when switching between frontier models?

My clients kept losing money during sales.

They’d use Compare at Price for a sale, and Shopify would still allow customers to apply discount codes on top. No native way to block this. Deleting codes or hiding the field doesn’t actually stop discounts.

So I built an app that blocks discount codes when products are already discounted, especially during sales.

It:

Prevents double discounts on Compare at Price products

Blocks codes at checkout logic level (not just UI)

Can be scheduled for sales like Black Friday

I built a UI language where you describe UI as JSON, and errors are caught at compile time—not runtime.

Why: When AI generates UI, JavaScript is too flexible. You get runtime errors, implicit behavior, hard-to-debug state. Constela constrains the surface area so output is deterministic and validatable.

Side effect: 5× faster builds, 5× smaller output than Next.js (same site, measured).

Live demo (this site is built with Constela): https://constela.dev

Try it yourself: https://constela.dev/playground

Source: https://github.com/yuuichieguchi/constela

I'd be interested in feedback from people working on compilers, UI frameworks, or AI-assisted development.

I've worn an Oura ring since 2020 and I've been that guy who cross references HRV with everything from supplements, late meals to quitting nicotine. I use the data to tell the difference between 'I feel off' and 'my resting heart rate is 8bpm higher than baseline'. And also for introspection, and to make better decisions in the future as Claude has access to 6 years of journal entries as well. (Yep privacy concern, but I find it worth it for me)

What bugged (lol) me is that I was spending too much time exporting data and manually correlating things. Earlier this year I tried feeding 5 years of data into a custom GPT, and the responses were actually (sort of) useful if it didn't choke.

So I built this as an MCP server, I had no idea how MCPs functioned so this was a good way to learn. It fetches fresh data on-demand rather than choking on a static dump, and the statistical analysis (correlation, outlier detection, trends) happens server-side before the LLM even sees it. When I ask "what predicts my best sleep?" it actually computes the answer instead of pattern-matching on vibes.

Works with Claude Desktop. Developed with Claude, see CLAUDE.MD TypeScript, ~600 tests, MIT licensed.

https://github.com/mitchhankins01/oura-ring-mcp