value: theYipster

value:
I've long wanted to harness QEMU/KVM for my desktop virtual machines, but I'm 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!)

value: Show HN: VM-curator – a TUI alternative to libvirt and virt-manager

author: theYipster


value: sashimikun

value:
Hi HN — I’m Sheing, the original author of Deepwiki-Open.
I just open-sourced AsyncReview, a DevinReview-inspired code review tool that uses an RLM-style approach to review large PRs without trying to fit everything into a single prompt.
It treats the repo as external state and lets the model search and revisit files as needed. This is still early and experimental, but it’s been useful for reviewing PRs that other tools tend to skip.
Happy to hear feedback or criticism.

value: Show HN: AsyncReview – An OSS DevinReview Using RLMs

author: sashimikun


value: samwulol

value:
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

value: Show HN: EchoFluid – a video transcription without uploading full videos

author: samwulol


value: mjn

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

value: Show HN: Snowfall Progress

author: mjn

title: Show HN: Snowfall Progress


value: MGabrIbrah

value:
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: hackernews@podcost.io
Pass: hackernews@podcost.io
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!

value: Show HN: PodCost – Find wasted GPU and Kubernetes spend (with live demo)

author: MGabrIbrah


value:
Hi HN,
I built this library because I wanted a way to clean messy text data and extract PII without sending sensitive information to cloud APIs or dealing with brittle regex patterns.
The tool runs quantized models locally via llama.cpp and uses GBNF grammars generated from Pydantic models. This forces the LLM to output valid JSON strictly adhering to the schema, which solves the reliability issues common with small models. It currently supports Pandas and Polars dataframes and works with any GGUF model.
It is still an early alpha, so performance on older CPUs might be a bottleneck compared to standard string manipulation, but I found it useful for semantic extraction tasks where regex fails. I would appreciate any feedback on the implementation or suggestions for optimization.

value: Show HN: Structured data extraction using local quantized LLMs


value:
Hi HN,
I built a voice-to-text tool that runs entirely in your browser. No account required for the free tier, no data sent to my servers.
Try it: https://voicetotextonline.com
Why I built this:
- Existing tools require signups, have minute limits, or cost money
- Google Docs voice typing requires a Google account
- Dragon costs $150-500
- Otter.ai has free tier limits
(A) Free Features (no account required):
1/ Core Transcription:
- Real-time voice-to-text using Web Speech API
- 55+ languages supported
- Auto-punctuation & sentence case options
- Works offline after first load (PWA)
2/ AI Enhance (added based on user survey – 80% voted yes):
- Auto-fix grammar, punctuation & formatting
- One-click cleanup of transcripts
3/ My Projects (local storage):
- Save transcripts to browser localStorage
- Organize with folders (Notes, Work, Personal, etc.)
- Custom folders & tags
- Search across all transcripts
- Edit, copy, download as TXT
- 100% private – never leaves your device
- Export:
- Copy to clipboard
- Download as TXT or DOCX
(B) Pro Features ($10/month or $1/hour pay-per-use):
1/ File Upload & Transcription:
- Upload audio/video files (MP3, WAV, M4A, MP4, MOV, AVI, MKV)
- Up to 500MB per file
- Batch upload (10 files at once)
- Powered by AssemblyAI (95%+ accuracy)
- 150 hours/month transcription
2/ Advanced Features:
- Real-time progress with ETA
- Speaker labels
- In-browser audio recording (5 min with pause/resume)
- Translation to 25+ languages (GPT-4o)
3/ Export Formats:
- TXT, SRT, VTT, JSON with timestamps
- Segment-level timestamp precision
4/ Cloud Storage:
- Transcription history in the cloud
- 10 GB storage, 1,000 files/month
(C) Data & Privacy:
Free tier:
- All transcripts stored in browser localStorage only
- Never touches our servers
- 100% private
Pro tier:
- Audio files stored in Supabase (encrypted)
- Files retained for 30 days for re-download, then auto-deleted
- Transcripts stored permanently in your account
- You can delete any transcript or your entire account anytime
- We don't use your data for training
Tech stack:
- Next.js 14 (App Router)
- Web Speech API (free real-time transcription)
- AssemblyAI (Pro file transcription, 95%+ accuracy)
- OpenAI GPT-4o (AI Enhance & translation)
- Supabase (auth & storage)
- Stripe (payments)
- Tailwind CSS
- Hosted on Vercel
Limitations:
- Real-time transcription doesn't work in Firefox (Web Speech API not supported)
- Free tier accuracy depends on Chrome's speech engine
Would love feedback on UX, pricing, or feature ideas. Considering open-sourcing the core transcription component.

value: Show HN: Voice to Text– Free browser-based speech-to-text with local projects


value: liorcodev

value:
Hi HN,
I built trpc-docs-generator because I love the zero effort type safety of tRPC, but I found that as soon as a project grows, the source of truth stays locked in the TypeScript files.
Most existing solutions require you to implement trpc-openapi, which is great if you need a REST endpoint, but feels like a lot of boilerplate if you just want a way for team members (or yourself) to visualize the API, check Zod schemas, and see procedure trees.
How it works: It uses tRPC’s internal router introspection to map out your procedures. If you’re using Zod for validation, it pulls those schemas to show exactly what inputs/outputs are expected. The result is a static documentation site that's easy to host or run locally.
Why use this instead of OpenAPI? This is strictly for tRPC users who want to keep their DX pure TypeScript without adding the REST compatibility layer.
Repo: https://github.com/liorcodev/trpc-docs-generator
Thanks for checking it out!

value: Show HN: Document your tRPC API without mapping to OpenAPI

author: liorcodev


value: vassilbek

value: Show HN: Run world-class focus groups in minutes

author: vassilbek


value: iggycodexs

value:
Hey HN! I built Lumina – an open-source observability platform for AI/LLM applications. Self-host it in 5 minutes with Docker Compose, all features included.
The Problem:
I've been building LLM apps for the past year, and I kept running into the same issues:
- LLM responses would randomly change after prompt tweaks, breaking things
- Costs would spike unexpectedly (turns out a bug was hitting GPT-4 instead of 3.5)
- No easy way to compare "before vs after" when testing prompt changes
- Existing tools were either too expensive or missing features in free tiers
What I Built:
Lumina is OpenTelemetry-native, meaning:
- Works with your existing OTEL stack (Datadog, Grafana, etc.)
- No vendor lock-in – standard trace format
- Integrates in 3 lines of code
Key features:
- Cost & quality monitoring
– Automatic alerts when costs spike or responses degrade
- Replay testing
– Capture production traces, replay them after changes, see diffs
- Semantic comparison
– Not just string matching
– uses Claude to judge if responses are "better" or "worse"
- Self-hosted tier
– 50k traces/day, 7-day retention, ALL features included (alerts, replay, semantic scoring)
How it works:
Start Lumina
git clone https://github.com/use-lumina/Lumina
cd Lumina/infra/docker
docker-compose up -d
// Add to your app (no API key needed for self-hosted!)
import { Lumina } from '@uselumina/sdk';
const lumina = new Lumina({
  endpoint: 'http://localhost:8080/v1/traces',
});
// Wrap your LLM call
const response = await lumina.traceLLM(
  async () => await openai.chat.completions.create({...}),
  { provider: 'openai', model: 'gpt-4', prompt: '...' }
);
That's it. Every LLM call is now tracked with cost, latency, tokens, and quality scores.
What makes it different:
1. Free self-hosted with limits that work
– 50k traces/day and 7-day retention (resets daily at midnight UTC). All features included: alerts, replay testing, semantic scoring. Perfect for most development and small production workloads. Need more? Upgrade to managed cloud.
2. OpenTelemetry-native – Not another proprietary format. Use standard OTEL exporters, works with existing infra. Can send traces to both Lumina AND Datadog simultaneously.
3. Replay testing – The killer feature. Capture 100 production traces, change your prompt, replay them all, get a semantic diff report. Like snapshot testing for LLMs.
4. Fast
– Built with Bun, Postgres, Redis, NATS. Sub-500ms from trace to alert. Handles 10k+ traces/min on a single machine.
What I'm looking for:
- Feedback on the approach (is OTEL the right foundation?)
- Bug reports (tested on Mac/Linux/WSL2, but I'm sure there are issues)
- Ideas for what features matter most (alerts? replay? cost tracking?)
- Help with the semantic scorer (currently uses Claude, want to make it pluggable)
Why open source:
I want this to be the standard for LLM observability. That only works if it's:
- Free to use and modify (Apache 2.0)
- Easy to self-host (Docker Compose, no cloud dependencies)
- Open to contributions (good first issues tagged)
The business model is managed hosting for teams who don't want to run infrastructure. But the core product is and always will be free.
Try it:
- GitHub: https://github.com/use-lumina/Lumina
- Demo video: [YouTube link]
- Docs: https://docs.uselumina.io
- Quick start: 5 minutes from `git clone` to dashboard
I'd love to hear what you think! Especially interested in:
- What observability problems you're hitting with LLMs
- Missing features that would make this useful for you
- Any similar tools you're using (and what they do better)
Thanks for reading!

value: Show HN: Lumina – Open-source observability for LLM applications

author: iggycodexs


value: divyaprakash

value: Show HN: AutoShorts – Local, GPU-accelerated AI video pipeline for creators

author: divyaprakash


value: nineties

value: Show HN: Bootstrapping a compiler from raw machine code

author: nineties


value:
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

value: Show HN: Sightline – Shodan-style search for real-world infra using OSM Data


value: WolfOliver

value: Show HN: MonsterWriter – An Overleaf Alternative with a Better Free Plan [video]

author: WolfOliver


value: tas-blacktorch

value:
Hi HN — my wife and I built HouseTrak out of frustration.
Every time something broke or needed maintenance, the info was scattered: notes app, photos, emails, spreadsheets, reminders. There wasn’t one place to keep everything about our home.
So we built HouseTrak — a simple iOS app that keeps maintenance, projects, assets, and important home details in one place. One app for everything about your home.
It’s intentionally minimal and focused on being useful, not clever.
Would love feedback, especially from homeowners:
How do you currently track home maintenance?
What’s missing from tools you’ve tried?
App: https://apps.apple.com/app/id6757889785
Site: https://housetrak.app
Thanks for taking a look.

value: Show HN: HouseTrak – everything about your home in one app

author: tas-blacktorch


value: tylerdiaz

value: Show HN: Rack – A local data stack operated with Claude Code

author: tylerdiaz


value: iamvdev

value:
Hi HN,
I started a small newsletter to document what I’m learning while building projects — the decisions, mistakes, and experiments that usually stay behind the scenes.
It’s not a growth hack or a polished media thing. Just short write-ups about what worked, what didn’t, and how I’m thinking through problems as I go. I’ve only published a couple of posts so far, but it’s grown to 1,000+ readers, which surprised me.
Sharing here in case it’s useful to others who enjoy building in public or learning from real-world attempts rather than theory.
Happy to hear feedback or ideas on what would be most useful to write about next.

value: Show HN: Notes from building a startup, shared openly

author: iamvdev


value: Artzain

value:
Hey all!
Like many of you, I've been using Claude daily and kept having a hidden fear: when my limit will be reached? How much I have consumed in this session?
Im ending up going back and forth to settings > usage to check  Literally every 5mns
So I built ClaudeUsageBar, a minimal menu bar app that shows your Claude usage percentage at a glance.
What it does:
Shows your current session (5-hour) and weekly usage directly in the menu bar
Notifies you at 25%, 50%, 75%, and 90% thresholds so you can pace yourself
Displays exactly when your limits reset
Works with both Free and Pro plans
Privacy focused:
No data collection, no analytics, no telemetry
Your session cookie stays on your machine
Fully open source so you can inspect every line of code
Lightweight:
Under 5MB
Native for Apple Silicon and Intel
Minimal CPU/memory footprint
It's completely free and open source, feel free yo try out!
Would love to hear your feedback or feature suggestions

value: Show HN: I built a free macOS menu bar app to track Claude usage

author: Artzain


value: NeroWolfe

value:
I built an iOS app for taking photos of the same location from the same angle over extended periods.
The technical approach:
- First shot captures GPS + compass bearing + device tilt as the reference
- Frame Lock uses CoreLocation + CMMotionManager to guide return visits
- Ghost Overlay composites the previous shot for manual alignment
- Backend uses SuperPoint + SuperGlue for ML-powered sub-pixel alignment
- Async job system for alignment and timelapse generation
Offline-first architecture with SwiftData. Photos capture locally, sync when online.
Public stacks are collaborative—anyone can contribute shots to document a place together.
Landing page: https://stack.photos
TestFlight: https://testflight.apple.com/join/YfqCPu6w
API docs: https://api.stack.photos/docs

value: Show HN: Stack Photos – Capture the same place over time and create timelapses

author: NeroWolfe


value: angristan

value: Show HN: Fast-resume: a TUI to index and fuzzy search coding agent sessions

author: angristan


value: tomstig

value: Show HN: Volume Shader – Free online 3D GPU benchmark and stress test tool

author: tomstig


value: cledouarec

value:
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.

value: Show HN: Sara – Markdown-based requirements traceability tool written in Rust

author: cledouarec


value: viikka

value:
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

value: Show HN: Shopify app to block discount codes on discounted products

author: viikka


value:
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!

value: Show HN: I built a tool to stop my posts from getting shadowbanned


value: rcarmo

value: Show HN: A browser front-end for TUI coding agents

author: rcarmo


value: mitjafelicijan

value:
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.

value: Show HN: TUI for managing XDG default applications

author: mitjafelicijan


value: Show HN: SeedVR2 – One-step AI video upscaling to 4K, 10x faster


value: Show HN: Baby Dance AI – Turn baby photos into dance videos in 30 seconds


value: sgottit

value: Show HN: Bonsplit – Tabs and splits for native macOS apps

author: sgottit


value: 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!

value: Show HN: Crystal Upscaler – AI image upscaler built for portraits and faces


value: kaliades

value: Show HN: First Valkey-specific VS Code extension (open source Redis fork)

author: kaliades


value: PrismShadow

value:
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?

value: Show HN: AgentHub – A unified SDK for LLM APIs with faithful validation

author: PrismShadow


value: mekod

value: Show HN: Turning global news sentiment into a live market

author: mekod


value: obadakhalili

value:
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

value: Show HN: Mindwork – AI workspace for focused personal knowledge management

author: obadakhalili


value: llehouerou

value:
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.

value: Show HN: Waves – Terminal music player with download, tagging, and library

author: llehouerou


value: Generally fun fridays just mean playing pictionary. There was a lack of more interesting games, so I made "TEQ - That escalated quickly".<p>The premise is you're given a question and you have to write a funny answer. After everyone writes their answer, all players vote on the funniest answer.

value: Show HN: I made a webgame to make fun fridays entertaining


value:
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

value: Show HN: Gitmore – AI-powered Git reports that write themselves


value: Show HN: Can you draw an upside down pinepapple?


value: vforbackend

value:
I built Shorlabs out of personal frustration. Frontend deployment with Vercel felt effortless, but deploying and managing backend infrastructure was consistently painful. I wanted the same experience for backend services: connect a GitHub repository and have everything else handled automatically.
Shorlabs is a backend PaaS for Python and Node.js applications. It deploys, manages, and scales backend services on top of AWS Lambda, so developers don’t have to provision or maintain servers. The workflow is simple: connect GitHub, import a repository, configure, and deploy.
Most backend PaaS platforms assume that non-trivial applications require long-running servers or containers, treating Function-as-a-Service as suitable mainly for simple workloads. I think that assumption is increasingly outdated.
With modern cloud primitives, it’s now possible to run more sophisticated backend services on FaaS with strong reliability guarantees. The economic upside is significant: scale-to-zero, no idle cost, and far less operational overhead.
My goal is to make serverless a default choice for small teams, not a special case. I’d love feedback, especially from people who’ve hit limits with existing backend PaaS tools.

value: Show HN: Shorlabs – the Vercel for backend (open-source)

author: vforbackend


value: Show HN: TUI to track stock and cryptocurrencies in real-time


value: alabhyajindal

value: Show HN: Reminders to Stay in Touch with Friends

author: alabhyajindal


value: vansxxx

value:
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).

value: Show HN: HomeGenGuide – Calculator for home generator installation costs

author: vansxxx


value: choumei

value: Show HN: Local Masonry Video Player – Pinterest UI, Prompt Search, Mobile Stream

author: choumei


value: tai-kimura

value:
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.

value: Show HN: JsonUI – Constrain AI agents through code structure, not prompts

author: tai-kimura


value: jayseb

value: Show HN: Interactive "Zero to Hero" – Practice what you learn with live feedback

author: jayseb


value: Foilleuse

value: Show HN: Nyola – A daily Pareidolia tool (draw what you see in clouds)

author: Foilleuse


value: wanjus

value:
We built this because we were tired of    fighting with curl and formatting issues when importing data to CouchDB. It handles CSV and JSON and creates the DB
     automatically.

value: Show HN: CouchDB Importer – A pragmatic CSV/JSON import tool

author: wanjus


value: modinfo

value: Show HN: LLMNet – The Offline Internet, Search the web without the web

author: modinfo


value: dumebioruche

value:
I built Humynize because I realized that even with the best prompts, AI drafts still feel mechanical. I found myself spending hours fixing the "flow" rather than the content.
I used Next.js for the frontend and OpenAI for the core processing. The logic focuses on NLP structural re-architecture—essentially breaking down the robotic patterns in the sentence structure and restoring a human-like "burstiness" and rhythm.
Key Technical Focus:
Technical Integrity: It is designed to keep data, citations, and specific meaning 100% intact while changing the voice.
Structural Variety: It moves away from the predictable sentence lengths that AI detectors look for.
Speed: Using a clean stack for fast processing and high-precision output.
I am the founder, and I would love for this community to test it. I am specifically interested in feedback regarding the quality of the "Human-Voice Shield" and how it handles technical or academic text.
I am around to answer any questions about the build

value: Show HN: Humynize – A tool to fix the rhythmic stiffness of AI writing

author: dumebioruche


value: mtht

value: Show HN: Timer-wheel–based TTL cache for Node.js

author: mtht


value: Show HN: Vortex-[BitTorrent,CLI] – Fast io_uring BitTorrent lib and TUI


value:
Hi HN folks,
Deep here. I am a design engineer and I have been building Resurf for the past 4 months. Resurf is a local first Mac app for quickly capturing notes, thoughts, ideas, inspiration, links, and files like PDFs and images without switching context.
As a design engineer who cares a lot about craft, I built resurf because my “stuff I want to keep” was scattered across tabs, different apps, notes, screenshots, random folders, and I kept losing good references. A lot of tools exist, but I wanted something calm + polished that feels native on Mac (not another file manager).
with Resurf you can
- quickly capture with a global shortcut and a menu bar app
- capture notes, links, and media like images, videos, and PDFs
- save things without switching windows and breaking your flow
- lightweight organization with Inbox to spaces, tags, and notes so you can categorize later
- search across everything including keywords, type, tags, dates, and spaces
- spotlight style quick panel to find anything fast
- keep everything local on your file system with no cloud account
It also has an in-app web view and PDF viewer so you do not need to open multiple browser tabs.
we are still working on optional AI features (BYOK) to make this more powerful for people who wants AI.
The app is usable today but still beta. I am fixing bugs quickly as people report them. I am also exploring the best way to add AI and the resurfacing part based on early user feedback.
Would love to know what you think and any special use case you have.

value: Show HN: Resurf – a local-first quick capture and personal library for Mac


value: Enludus

value:
Hi HN! I'm the creator of Enludus Ego.
I built this because I was frustrated with traditional AI assistants that forget my context every time. I wanted something that understands my code (AGN), my learning (Vidnitive), and my emotions (Encura) as one integrated story.
What makes it different:
1. Runs locally on 8GB RAM (Rust + Python/MLX)
2. Monitors code and diary files simultaneously
3. Provides empathetic suggestions like "You're tired debugging calculate_score. Take a break?"
4. Transparent references (Humble UI principle)
Tech details:
- Hub: Rust with notify crate (50MB)
- Engine: Python with rule-based context fusion (1.2GB)
- Total: ~1.4GB, leaving room for actual work
This is Phase 1. Next steps:
- Phase 1.5: Terminal UI
- Phase 2: Flutter app + E2EE sync
- Phase 3: Full ecosystem integration
Open sourcing soon. Happy to answer questions!

value: Show HN: Personal AI that understands code and emotions on 8GB RAM

author: Enludus


value: david-minaya

value:
I want to share Ask CLI, a tool I developed to get help with commands and coding directly from the terminal. It is a simple app designed to do one thing well: provide instant command assistance. This isn't a complex coding agent like Claude Code; it is built specifically to get short, fast answers without context switching.
As a developer, I’ve always struggled to remember every command and its specific options. Whenever I need to use tools like Docker, Git, or psql, I find myself leaving the terminal to check documentation or scrolling through verbose --help text just to recall a specific flag. I usually know what I want to do, but I forget the exact syntax. I didn't want to waste time switching to Google or ChatGPT just to find a one-line command.
I developed Ask CLI to solve this. It has been a game-changer for my workflow. Now, when I forget a command, I simply ask my terminal. It gives me a fast, precise answer—exactly what I need—without breaking my flow.
It is incredibly easy to use: just select an AI model, set your API key, and start chatting naturally with your terminal.
Examples:
$ ask how to run a docker container with env variables
$ ask how to setup my local git account
You can also use the "what" and "how" aliases for a more natural feel:
$ what is chmod
$ how to print all the env variables
You can use Ask CLI with popular hosted models (Gemini, Claude, ChatGPT) or with local models and external providers that support OpenAI-compatible APIs (Ollama, llama.cpp, LM Studio, etc.).
Ask CLI is free and open-source. Check it out here:
https://github.com/david-minaya/ask

value: Show HN: Ask CLI – A simple, open-source tool to get command-line help

author: david-minaya


value: locallyoptimal

value:
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
...
...

value: Show HN: AI powered daily tracker of the US slide into authoritarianism

author: locallyoptimal


value: Maaz-Sohail

value:
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.

value: Show HN: Free PDF Editor by TechRex – client-side PDF editing, OCR, compression

author: Maaz-Sohail


value: sinaatalay

value:
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.

value: Show HN: Open Computer-Animated Multivariable Calculus Course in 6 Languages

author: sinaatalay


value: dangoodmanUT

value:
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.
There's also no network performance penalty, since it's just DNS lookups and eBPF filters referencing memory.
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.

value: Show HN: Netfence – Like Envoy for eBPF Filters

author: dangoodmanUT


value:
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.

value: Show HN: Constela – JSON DSL for AI-generated UI with compile-time validation


value: relatedcode

value: Show HN: Generate the perfect kickoff prompt

author: relatedcode


value: mcavdar

value:
Hi HN,
I built a customizable context menu extension for Firefox that works well on both Desktop and Android.
I often found myself missing powerful context menu tools when browsing on mobile. Native context menus on Android are typically limited, so I built "Right Click", which lets you select text and run custom API calls on it directly.
How it works:
Desktop: Adds items to the standard right-click context menu and custom popup.
Android: Automatically displays a custom popup when you select text, giving you immediate access to tools without fighting the native UI.
It supports some default actions (such as translation and text-to-speech), but you can add more.
Thanks for all feedback, especially on how the text-selection popup feels on different Android devices.

value: Show HN: Right Click – Customizable Context Menu(Popup for Android) for Firefox

author: mcavdar


value: melonamin

value:
I built FlowScope because existing lineage tools either required uploading SQL to external servers or couldn't handle real-world query complexity. FlowScope does both: it's a  serious lineage engine that happens to run entirely client-side.
The engine is genuinely powerful:
- Full multi-statement analysis tracks lineage across CTEs, subqueries, temp tables, and cross-file references
- Column-level lineage with expression decomposition (not just "column A depends on table B")
- Backward inference — figures out SELECT * columns from downstream usage even without schema
- Type inference with dialect-aware compatibility checking
- Handles lateral column aliases, COPY/UNLOAD statements, table renames, and other edge cases that trip up simpler parsers
It's fast:
- Rust core compiled to WebAssembly — analyzes hundreds of files in milliseconds
- Graph layout runs in web workers so the UI never blocks
- Serve mode watches your SQL directory and re-analyzes on save with 100ms debounce
Multi-dialect, multi-format:
 - PostgreSQL, Snowflake, BigQuery, DuckDB, Redshift, MySQL, and more
- Native dbt/Jinja support with ref(), source(), config(), var() — not regex hacks
- Exports to Mermaid, JSON, Excel, CSV, HTML reports, or DuckDB for further analysis
Multiple interfaces:
- Web app at flowscope.pondpilot.io — interactive graphs, drag-and-drop
- CLI — flowscope -d snowflake -f mermaid *.sql for CI/CD pipelines
- Serve mode — flowscope --serve --watch ./models --open gives you a full local web UI in a single 15MB binary
- TypeScript/React packages — embed the engine or visualization   in your own tools
The CLI can introspect live databases (--metadata-url postgres://...) for accurate wildcard expansion against your actual schema.
Reusable Rust core and React components. Zero data egress. Apache-2.0 licensed.
VS Code extension in work.
GitHub: https://github.com/pondpilot/flowscope
Try it: https://flowscope.pondpilot.io
What SQL patterns does your lineage tooling struggle with? I'm curious what edge cases I should tackle next.

value: Show HN: FlowScope – Fast, sophisticated SQL lineage that runs in the browser

author: melonamin


value: venkada

value: Show HN: Fission – Offline Voice Notes with Local Llama Android (React Native)

author: venkada


value:
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

value: Show HN: Bucket – Encrypted file sharing for people who live in the terminal


value:
*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.

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


value: finktech

value:
Hi everyone! I'm the author.
A few months ago, a friend's MCP server accidentally deleted his database. That stuck
with me. We're building AI systems that can modify data and execute commands, but we
don't have practical tools to validate they're safe.
So I built mcp-security (security documentation with real code examples) and started
mcp-verify (an automated auditor).
What makes mcp-security different:
- 12 actionable rules mapped to OWASP Top 10
- Real vulnerable and secure code implementations (Node.js)
- Compliance mapping (SOC2, HIPAA, PCI DSS)
- Bilingual (English + Spanish)
- Free, MIT licensed
mcp-verify (still in development) will test MCP servers for security vulnerabilities,
load capacity, and protocol compliance. But the interesting part: it's also an MCP
server itself, so Claude can use it to audit other servers.
Happy to answer questions about MCP security or the roadmap!

value: Show HN: MCP Security Documentation with Code Examples

author: finktech


value: FounderSG

value: Show HN: RealXV6 – a faithful Unix V6 kernel port to 8086 real mode

author: FounderSG


value: spinity

value:
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...

value: Show HN: We built a hidden micro-bearing system inside a 2mm ring

author: spinity


value:
graft is a Rust CLI utility for easily creating self-executing GUI binary patches for any platform, with hash checking, rollback, etc. (The utility is written in Rust, and the patches it creates are themselves compiled in Rust.)
I created it to create game localization patches for old video games, but its more general than that.
This is a nice alternative to NSIS because: (a) it's easy to create patches from the command line or in CI/CD and (b) it compiles patch applications for Linux and Mac as well as Windows.

value: Show HN: Graft – binary file patcher in Rust


value: tariqshams

value:
Hi HN,
I am building TAUI (Terminal Agent UI), an open-source standard for autonomous agents in the terminal.
Most agents today interact with shells by directly writing raw text or ANSI escape codes. It’s brittle, prone to hallucinations, and breaks the second a terminal resizes.
Some developers are having agents write HTML, CSS, or Python scripts to create their own UIs. I believe this isn’t ideal. Having an agent generate executable code for a UI is dangerous because it opens up code injection vectors. It also wastes a massive amount of tokens on verbose boilerplate.
While projects like Google’s A2UI are making great strides in structured web/mobile blocks for agents, the terminal has unique constraints that require a specialized approach.
I’m building TAUI (Terminal Agent UI) to address this.
Instead of raw text or code, agents emit a structured TAUI-0001 document. A TAUI adapter handles the rendering in a trusted environment. This approach is inherently secure and significantly more token efficient than generating scripts.
The Ecosystem I have built:
* TAUI Specification: The core standard for Grid, Panel, Table, and Progress primitives.
* @taui-standard/validator: A strict Zod-powered engine that ensures the agent output is safe and compliant before it is rendered.
* @taui-standard/core: A unified state and event runtime.
* @taui-standard/ink-adapter: A high-fidelity React bridge that renders spec-compliant interfaces.
I believe we should move from "text buffers" to "structured state documents" for the next generation of autonomous tools.
I have included demos like a real-time htop dashboard and an interactive dashboard to show what is possible.  I’m the creator (Tariq Shams) and would love to hear your thoughts on why we haven’t standardized this yet, and if a declarative JSON approach for terminals is the right way forward.
Ecosystem Links:
* Official Specification
https://taui-standards.github.io/taui-site/TAUI-0001.html
* Ink Adapter and Demos(@taui-standard/ink-adapter)
https://github.com/TAUI-Standards/taui-ink-adpater
* @taui-standard/validator
https://github.com/TAUI-Standards/taui-validator
* @taui-standard/core
https://github.com/TAUI-Standards/taui-core

value: Show HN: TAUI – Structured Terminal Agent UI (Like Google A2UI)

author: tariqshams


value: PaulPlay

value:
Hey Hacker News!
The past few months I’ve been working on this open-source software stack that makes it easy to build your own privacy-first security camera. When searching for a security camera (e.g. Google Nest, Amazon Ring..) that guarantees privacy I was surprised to find out there’s no such option, apart from going the old-school route. Many of the big players also had major privacy scandals.
It has gotten even worse over the last couple of months with Amazon Ring now working together with Flock Safety, a company helping law enforcement with mass surveillance.
Using the ROOT software stack you can set up a feature-rich & remotely accessible security camera with on-device AI vision in no time. No need for a big NVR, home server, etc. All communication is fully end-to-end encrypted (with forward secrecy), and recordings are stored locally.
The linked guide walks you through the easy process, all you need is a Raspberry Pi Zero 2 + a camera module. I’m also currently working on a hardware prototype to make this even more accessible :-)
Happy to answer any questions!

value: Show HN: Root – Privacy-preserving home security camera

author: PaulPlay


value: CodingForFun

value: Show HN: Kirin – Transparent AI Assistant, Real-Time OCR/AI Insight on Workflow

author: CodingForFun


value: yassershkeir

value:
django-safe-migrations is a Django library that statically analyzes your migrations to catch issues before deployment.
v0.4.0 adds:
- Custom rule plugin system for project-specific checks
- 8 new rules covering null=False without backfill, UNIQUE constraints, SQL injection, missing indexes, and more
- Configuration validation with typo suggestions
- SARIF output for GitHub Code Scanning integration
It's helped us catch several potential outages in CI before they hit production. Happy to answer questions about the implementation.
https://github.com/YasserShkeir/django-safe-migrations

value: Show HN: Django-safe-migrations v0.4.0 – Detect unsafe migrations

author: yassershkeir


value:
I tried to make the best CLI for interfacing with PyNaCl primitives, especially with KDF.
I don’t expect your trust; I focused on making the code readable for review. I haven’t reviewed the underlying libraries.
I included some silly examples in the README — I hope you enjoy them and have as much fun using it as I did while building it.
It’s focused on small files: not for large blobs, but great for keys, configs, and other secrets.
Thanks for your time. Please note that I’m not a security expert, and this is my first project in this space.
I actively use it myself and plan to maintain it long-term.

value: Show HN: rtty-soda – CLI frontend to NaCl (PyNaCl) for encrypting small files


value: Show HN: CertRadar – Find every certificate ever issued for your domain


value: rmqyeby

value: Show HN: TryStack – "try locally" portal and verified Docker Compose recipes

author: rmqyeby


value:
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.

value: Show HN: An interactive map of US lighthouses and navigational aids


value:
Hi HN,
I’m working on YouBankLab, a beta experiment around a simple idea:
What if people didn’t keep their money in a bank, but in a personal financial cloud they fully own?
YouBankLab is a non-custodial financial environment where:
users hold their own funds and identity
payments are peer-to-peer
the system has no custody over money
What’s new (and what I’m testing) is a local, privacy-first AI layer that:
observes transaction patterns
detects behavioral changes or anomalies
provides context and insights
never moves money or makes decisions
AI here is not a bot or advisor — it’s more like a private financial “observer” that helps you understand what’s happening inside your own financial cloud.
This is an early beta and very much a learning project.
I’m mostly interested in feedback on:
whether this framing makes sense
where it feels unclear or unrealistic
and if this solves a real problem for anyone here
Live beta: https://youbanklab.base44.app
Website: https://www.youbanklab.com
Happy to answer questions.
— Tomas

value: Show HN: YouBankLab – Personal financial cloud with a private AI layer


value: Sajarin

value: Show HN: Kreamsicle – Cmd+K command palette for Hacker News

author: Sajarin


value: quantdinger

value:
Hi HN,
QuantDinger is an open-source, local-first AI-powered quantitative trading platform that I’ve been building for about six months. It’s designed to cover the full quant workflow — from research and strategy development to backtesting and live execution — while keeping everything running locally.
Most existing quant tools are cloud-based, which means strategies, indicators, and API keys often need to be uploaded to third-party servers. QuantDinger takes a different approach: it is local-first by default, so strategy logic and credentials stay on your own machine.
The platform currently supports multiple markets, including US equities, A-shares, Hong Kong stocks, crypto, forex, and futures.
Key features:
- Local-first architecture with Docker-based deployment
- AI-assisted strategy and indicator generation
- Python-native strategy development
- Visual indicators and K-line (candlestick) execution
- Backtesting and live trading support
- Multi-user support for self-hosted setups
QuantDinger is fully open source under the Apache 2.0 license and can be used commercially.
Demo:
https://ai.quantdinger.com
GitHub:
https://github.com/brokermr810/QuantDinger
I’d really appreciate feedback from people who’ve built or used trading systems, especially around architecture, backtesting design, and practical usability.

value: Show HN: QuantDinger–An open-source, local AI quantitative trading platform

author: quantdinger


value: davnn

value:
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!

value: Show HN: Uv-pack – Pack a uv environment for later portable (offline) install

author: davnn


value: 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.

value: Show HN: Fdir – find and organize anything on your system


value: shepherdjerred

value:
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

value: Show HN: Decompile and deminify Bun using an LLM

author: shepherdjerred


value: Show HN: HyprKCS – A fast, native GTK4/Adwaita keybind manager for Hyprland


value: moshetanzer

value:
Google is killing POP3/Gmailify in January 2026, breaking workflows for fetching email into Gmail.
I built Forward My Inbox (https://forwardmyinbox.com) as a replacement: connects to your IMAP inbox and forwards new emails to Gmail while preserving threading, reply-to, and labels—no POP/Gmailify needed.
Credentials are encrypted, headers are preserved, forwarding is instant.
Looking for feedback from anyone affected by the shutdown or using similar workflows.

value: Show HN: Forward My Inbox – IMAP‑to‑Gmail Forwarding After Gmail Kills POP3

author: moshetanzer


value: lywald

value: Show HN: I used my book generator to generate a catalog of books it can generate

author: lywald


value: sashimikun

value: Show HN: A code reviewer that uses RLMs and a REPL to kill "context rot"

author: sashimikun


value: Plarsy

value: Show HN: Accurate Password Guessing with AI

author: Plarsy


value: anonyonoor

value:
Hi HN,
This is Bookface — a TypeScript wrapper for Meta's developer services, born from frustration at Meta's lack of easy developer integration.
The current API libraries you'll find for Meta's products are either very limited (and use hacky browser simulation) or unacceptably old/unmaintained. This is a library that aims to:
Interact with Meta's developer services the way Meta intended, although with way more ease.
Support all of Meta's platforms (e.g., Facebook, Instagram, Threads, WhatsApp, etc.).
Be consistently updated with Meta's latest API changes.
Overall, make things faster for people trying to use Meta services.
For background, I've been working on this library on and off for about a year and a half, slowly adding features as I needed them. I originally created this library for another project when I was seventeen. Two years later, I have been putting off release for too long, and this library desperately needs other experienced hands.
The reason for this post is to get some urgent feedback on what syntax feels good and what doesn't; to test that what's currently added is working as intended (I am the only tester); and, crucially, to find other maintainers. I want this to be a long-term project, and maintainers would help smooth out the rough edges of my mistakes and hopefully keep this project going for a while.
I should note that this is sort of a preliminary release post since this library is still in its very early stages (lacking features), and I'm really just looking to get things into motion. Please check it out!
https://facebook-js-sdk.vercel.app/
(The current, early-stage website. I’m working on getting a better domain.)
(Also forgive the name discrepancy with the website and repo — the name is still up in the air and I'm open to suggestions.

value: Show HN: Bookface – Modern TypeScript wrapper and MCP for Meta APIs

author: anonyonoor


value: dhilipsiva

value:
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.

value: Show HN: A Zero-Copy 1.58-bit LLM Engine hitting 117 Tokens/s on single CPU core

author: dhilipsiva


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

value: Show HN: AI-rganize – CLI tool for organizing your files


value: thedebuglife

value:
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

value: Show HN: Oura (Activity Tracker) MCP Server with Claude

author: thedebuglife


value: adamvhill

value: I run a newsletter tracking NYC startup jobs and built this Airtable database as a resource. Updated weekly with venture-backed companies hiring across all functions. Sharing in case it's helpful to the community.

value: Show HN: Free database of NYC startups hiring (updated weekly)

author: adamvhill


value: assetofbaskets

value:
Hi HN,
I built a small QR code editor after repeatedly running into the same problem: once a QR code is printed, the destination is frozen.
This tool supports both:
Static QR codes (generated entirely client-side)
Dynamic QR codes (editable destination after creation)
Dynamic QR codes come with a minimal dashboard where you can:
Update the QR destination without reprinting
See basic scan stats (count, device, time, approximate origin)
I intentionally kept the feature set small and avoided heavy analytics or tracking. The goal is something simple that works well for menus, flyers, events, and small businesses.
The app is live here:
https://qrcodeeditor.com/
I’d appreciate feedback on:
What’s missing for this to be useful day-to-day
Whether dynamic QR codes are something you actually need
What you’d expect before paying for a tool like this
Thanks for reading.

value: Show HN: QR Code Editor with static and dynamic QR codes (client-side first)

author: assetofbaskets


value: paco-gpu-empire

value: Show HN: GPU rental marketplace – RTX 4090s $15/HR (BTC payments)

author: paco-gpu-empire


value: vaneyckseme

value:
Hey everyone,
I built an app called SingTogether because I was tired of trying to get my bandmates to install complex DAWs just to practice over a demo. I wanted something that works instantly in the browser.
It’s designed to help bands and choirs practice and collaborate using their own multitracks.
The Main Use Cases:
1. Rehearsing a Song
The Problem: Sending MP3s back and forth is messy, and you can't isolate instruments.
The Solution: The band leader uploads multitracks to the app and sends a link. The team opens it (on phone or desktop) and can practice using standard tools like solo, mute, pan, and volume faders to isolate their specific part.
2. Asynchronous Jamming
The Problem: We want to experiment with ideas but can't meet up.
The Solution: A band member adds a base track (instrumental or vocal). They send the invite link, and other members can record a vocal or instrumental part straight from the browser. Everyone can listen to the layered contributions immediately.
I'd love for you to try it out and let me know what features would make your practice sessions easier.

value: Show HN: Helping my band rehearse remotely without installing a DAW

author: vaneyckseme


value: kaniksu

value:
I wanted to build my first CLI app and was inspired by terminal.shop (the coffee one). Figured if you can order coffee from your terminal, you should be able to order a t-shirt too.
how it works: you describe what you want, it generates ASCII art, shows you a mockup on an actual shirt, and you can check out right there.

  pip install ascii-tee

  ascii-tee "sunflower"

Stack:
- CLI: Typer + Rich for the interactive flow (prompts, spinners, panels)

  - ASCII generation: Claude API, with a system prompt tuned for a 40×30 character canvas that prints well

  - Preview: Pillow composites the ASCII (rendered with JetBrains Mono) onto a shirt mockup template

  - Terminal images: Detects iTerm2/Kitty/WezTerm for native inline images, falls back to timg or chafa, then browser

  - Backend: Cloudflare Workers handling API calls

  - Checkout: Stripe, with the preview image shown on the payment page

  - Fulfillment: Printful prints and ships (Bella+Canvas 3001)

First time building something like this so would appreciate any feedback.

value: Show HN: Make custom ASCII art t-shirts from your terminal

author: kaniksu


value: teugent

value:
We ran a 500-cycle benchmark to test long-horizon reasoning stability in large language models — not just output quality, but whether a model can maintain coherent identity and logic across hundreds of recursive reasoning steps.
This is part of our SIGMA Runtime project — a cognitive control layer that runs on top of any LLM and tracks drift, coherence, and identity persistence in real time.
---
Why we did this
Most LLM evals measure short reasoning spans — 1-10 turns.
But when a model is asked to sustain a line of reasoning over hundreds of steps, subtle feedback effects appear:
- Semantic drift: meaning slowly shifts as text compounds.
- Crystallization: the model locks into repeating its own phrasing or style.
- Identity loss: the “speaker” loses internal consistency.
We wanted to see whether it’s possible to prevent these effects at runtime, without retraining or prompt resets.
---
What’s new here
We replaced the older ACE anti-crystallization layer with a new system called
AEP (Adaptive Entropy Protocol) — a real-time regulator that injects controlled entropy into model outputs.
AEP tracks three internal metrics:
- TI — Terminological Isometry (consistency of key concepts)
- SDC — Semantic Drift Coefficient (meaning variation rate)
- L/N — Logic-to-Noise ratio (logical density vs surface variation)
When the model becomes too stable (repetition, rigid phrasing), AEP adds micro-perturbations to restore variation.
When it drifts too far, it dampens entropy back into equilibrium.
---
How we tested it
- 500 reasoning cycles per model (OpenAI GPT-5.2 & Gemini-3-Flash Preview)
- Every 50th cycle = a Rib Point that compresses and verifies the last 49 steps
- Continuous telemetry from the runtime (coherence, drift, entropy)
- Identity: same synthetic agent (“LEO”, AI architect/cognitive scientist)
---
What happened
Both models completed all 500 cycles without identity loss or semantic collapse.
Entropy modulation increased lexical variety, while keeping reasoning trajectories coherent.
When truncations occurred (Gemini API), the runtime reconstructed missing context using prior compression checkpoints.
---
Visual results
Drift & coherence evolution (500 cycles)
GPT-5.2: https://files.sigmastratum.net/Leo_OpenAI_D_summary_dashboar...
Gemini-3-Flash: https://files.sigmastratum.net/Leo_Gogle_D_summary_dashboard...
AEP metric dynamics (TI, SDC, L/N)
GPT-5.2: https://files.sigmastratum.net/Leo_OpenAI_E_metrics_timeline...
Gemini-3-Flash: https://files.sigmastratum.net/Leo_Gogle_E_metrics_timeline....
---
Takeaway
- Entropy can be regulated, not just randomized.
- LLMs can maintain self-consistent reasoning over hundreds of cycles when given runtime feedback.
- Structural stability (coherence, terminology, logic) doesn’t require retraining — only a dynamic control layer.
---
Report (DOI): https://doi.org/10.5281/zenodo.18271591
Code & appendix: https://github.com/sigmastratum/documentation
---
We’d love technical feedback on:
- Runtime-level coherence control
- Measuring “identity persistence”
- Long-horizon reasoning tests (100+ turns)

value: Show HN: 500-cycle runtime test for long-horizon LLM coherence

author: teugent


value: rexfuzzle

value: Show HN: Lochle, a Wordle clone for Scottish Lochs

author: rexfuzzle


value: azdhril

value:
Hi HN,
I’m a software engineer and I’ve been building agentic workflows lately. Like many of you, I got concerned about giving LLMs "write access" to tools. Whether it's a payment API, a database deletion, or a simple email send, the risk of a hallucination causing a $5k mistake is real.
I wanted a way to keep a human in the loop without rewriting my entire agent logic every time. So I built Sentinel.
It’s a lightweight Python layer that wraps any tool/function. The key principles I focused on:
Fail-secure by default: If the rules engine or the network fails, the action is blocked. Most systems fail-open, which is a nightmare for security.
Zero-trust Decorator: You just add @protect to your functions. It’s agnostic to the framework (works with LangChain, CrewAI, or raw OpenAI calls).
Semantic Anomaly Detection: Beyond static JSON rules (like "max $100"), it uses a Z-score analysis of historical audit logs to flag unusual behavior—like an agent suddenly trying to call a function 100 times in a minute.
Context-Aware Approvals: The approver sees exactly what the AI saw (the state before the action) to make an informed decision.
It’s open source (MIT) and just launched on PyPI: pip install agentic-sentinel
I’d love to hear your thoughts on the "Fail-secure" approach and how you guys are currently handling AI tool governance in production. I'm here to answer any questions!
Repo: https://github.com/azdhril/Sentinel

value: Show HN: Sentinel – Zero-trust governance for AI Agents

author: azdhril


value: indest

value: Show HN: Promo/offer code sharing and discovery for apps

author: indest


value: gorkemcetin

value: Show HN: A lightweight, native macOS menubar app for monitoring with mini graphs

author: gorkemcetin


value: LeoPanthera

value: Show HN: Computer Chronicles

author: LeoPanthera

title: Show HN: Computer Chronicles


value: nicoritschel

value:
With agents, I have I found myself using worktrees more and more. First manually, then with conductor.build, then with worktrunk.dev.
I prefer using coding CLIs instead of UI wrappers as the terminal tends to be more performant (depending on the agent you choose) and you get access to new features immediately.
Ghostty is a bit challening to automate today— I considered building a complementary app to Ghostty at first. But since I have been building native mac apps on the side lately (as well as tools for agents, consuming their logs etc) I figured I would just modify Ghostty to have native worktree management.
You can download with homebrew via: brew install sidequery/tap/ghostree

value: Show HN: Ghostree is a Ghostty fork with worktree management built in

author: nicoritschel


value: hiddenarchitect

value: I started with making a cognitive architecture and wanted to attempt a system that heavily resembles autopoiesis. An A.I that builds itself entirely.

value: Show HN: Protogen Beta

author: hiddenarchitect

title: Show HN: Protogen Beta


value: univrsal

value:
For a while I've been looking for a tool that can monitor network connections down to individual sockets and with the ability to block or throttle traffic.
Since the existing tools I found weren't able to do that I gave it a shot and tried to make my own.
Wächter (or waechter) is divided up into a demon using eBPF and tc for monitoring and controlling traffic and client using imgui for a simple GUI to control the demon.
The demon can be connected to both via a unix socket or a web socket if you want to run it on a server and control it remotely.
Eventually the goal is to also collect and visualize long term traffic statistics.
So far I was able to test it on Arch Linux with 6.18.3 and Ubuntu 24.04 LTS with 6.8.0.
Since eBPF is a bit picky about whether or not it'll load a program depending on the kernel version people are welcome to test it on other setups and report bugs or request features.

value: Show HN: Wächter – Traffic shaping and monitoring for Linux

author: univrsal


value: karanSF

value:
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.

value: Show HN: Box3d – Generate 3D-printable Gridfinity boxes in the browser

author: karanSF


value: hhossain

value:
I've been working on a video editor where you can edit by typing commands in plain English instead of using traditional timeline tools. The idea came from making tutorial videos and getting frustrated with how many clicks it takes to do simple things.
Right now it handles commands like:
"Zoom into this area smoothly"
"Speed up the next 5 seconds by 2x"
"Highlight this button for 3 seconds"
"Remove the zoom at 10 seconds"
You can render videos locally for free (single-threaded on your CPU), or use cloud rendering for faster processing.
I'm trying to figure out if this approach actually saves time for people or if it's just a novelty. My main questions:
For folks who make tutorial/demo videos - what editing tasks eat up most of your time? What features would actually make you switch tools?
Would you trust AI to correctly interpret your editing commands, or does that feel too unpredictable?
What types of effects or edits would be most handy to control with natural language?
Curious to hear what would make this genuinely useful for your workflow vs just an interesting demo.

value: Show HN: AI-powered natural language video editor – seeking feedback

author: hhossain


value: vrdev

value:
Hey HN,
Launching an AI coding assistant built specifically for VR/AR/XR development: https://vr.dev
The problem: Generic LLMs give confidently wrong answers about XR development. The APIs change constantly (Meta ships SDK updates monthly), training data is stale, and XR knowledge is sparse in general-purpose models. Developers end up with deprecated method signatures and patterns that broke two versions ago.
The solution: RAG over actual XR documentation, updated regularly.
Free to use during beta. Looking for feedback from anyone building XR applications.
What's the XR development question that AI has never gotten right for you? Drop it in the comments or email chat@vr.dev and I’ll post some bake-off comparison shots.
What it doesn't do (yet): index your own codebase/docs, IDE plugin, MCP tool set. Those are on the roadmap.
Feedback welcome here or at chat@vr.dev — especially on answer quality, missing doc sources, or features that would make this useful for XR workflows.

value: Show HN: vr.dev – AI coding assistant beta for XR/VR

author: vrdev


value: iamasuperuser

value:
I create a free mobile-first tool to help you close better deals; Zopamind.com .  It can be used both to help you understand your boundaries (ZOPA, BATNA) and as a tool during negotiations (Monte Carlo Decision Tree).
More details:
It uses 200+ signals to calculate your actual odds of winning a deal, helping you spot risks before you walk into the room.
Why use it?
 Data-Driven: Analyzes your deal across 10 dimensions.
 100% Private: Data lives in your browser, not my servers.
 100% Free: No paywall.
Perfect for prep, in-session management, and debriefing.
Try it here: https://zopamind.com

value: Show HN: Zopamind. A B2B Negotiation Sidekick

author: iamasuperuser


value: steffenbilde

value:
I built an MCP server that gives AI coding tools (Claude Code, Cursor) direct access to UntitledUI's component library.
The problem: AI tools can generate functional UI, but it often lacks the polish of professionally designed systems. Instead of generating a modal from patterns, why not fetch the actual UntitledUI modal?
How it works:
- AI says "add a settings modal"
- MCP fetches the real component + all base dependencies (buttons, inputs, etc.)
- Files are placed in your project with correct imports
Tools available:
- search_components: Find by name/description
- get_component_with_deps: Fetch with all dependencies
- get_example: Fetch complete page templates (dashboards, landing pages)
Requires UntitledUI Pro license for premium components. Base components are free.
GitHub: https://github.com/sbilde/untitledui-mcp
npm: npx untitledui-mcp
Would love feedback on the DX and any edge cases I've missed.

value: Show HN: MCP server that lets AI agents fetch real UntitledUI components

author: steffenbilde


value: Cloudef

value: I was disappointed with the current archive formats, either they were too complex, were kitchen sink, or did not support random access (tape formats), or had weird limitations (ar archives), so I NIH'd a simple random access archive format.

value: Show HN: Simple random access archive format with no compression

author: Cloudef


value: kalyfacloud

value:
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!

value: Show HN: I built an app that blocks social media until you read Quran daily

author: kalyfacloud


value: akulasairohit

value:
Hi HN, I've spent the last few weeks building an experimental AI Operating System called Meru OS, based on the idea that intelligence should be verifiable, not probabilistic.
Most LLMs are "Black Boxes". I wanted to build a "Glass Box" where every output traces back to a certified source.
The Architecture:
The Kernel: Instead of vectors, state is represented as Integers. We use the Fundamental Theorem of Arithmetic (Unique Prime Factorization) to encode concepts.
Example: If Time = 3 and Space = 5, then Spacetime = 15. This allows for reversible "time-travel debugging" by just dividing integers.
The Hypervisor (Bija): It doesn't just run cycles; it runs "Frequency Modulations".
The kernel itself is coded in specific Prime Frequencies (Hz).
Execution is effectively a "Resonance" state between the Instruction and the Data, rather than a fetch-decode-execute pipeline.
The Data (< 2MB): We compressed the entire Constitution of India, the IPC, and an Indo-European Etymology Dictionary into a <2MB bundle using a custom schema-based compression (Pingala).
Why?
Sovereignty: The logic and data are locally owned. No API calls.
Green AI: It runs on my MacBook's CPU with negligible heat/power.
Vedic Logic: It implements Panini's Grammar rules (Ashtadhyayi) as a graph traversal algorithm rather than just statistical attention.
It's definitely experimental, but it questions the "Scale is All You Need" dogma. Would love feedback on the reversible prime state machine logic.
Links:
Code: https://github.com/akulasairohit/meru-os
Live Demo: https://huggingface.co/spaces/akulasairohit/panini-demo
The Manifesto: https://www.linkedin.com/pulse/introducing-meru-os-worlds-fi...
Thanks, Rohit

value: Show HN: Meru OS – The First Sovereign AI Stack (<2MB, CPU-Native)

author: akulasairohit


value: jcparkyn

value:
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).
Original title: "A small programming language where everything is a value" (edited based on comments)

value: Show HN: A small programming language where everything is pass-by-value

author: jcparkyn


value:
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.

value: Show HN: FaceTime-style calls with an AI Companion (Live2D and long-term memory)


value: ihlamury

value: Show HN: Design constraints from Top Companies as AI agent skills

author: ihlamury


value: cacoos

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

value: Show HN: A desktop app that blocks work when you bite your nails

author: cacoos


value: baristaGeek

value: Show HN: Approval workflows for AI agents using OAuth

author: baristaGeek


value: justvugg

value:
PolyMCP now lets you expose Python MCP (Model Context Protocol) tools in two ways from the same code:
 1. Server-based MCP deployments (HTTP endpoints)
 2. WebAssembly bundles that run directly in the browser
This means you can reuse the same Python functions for server workflows or client-side experiments without any code changes.
⸻
Why it matters
 • Plug-and-play: one Python function, multiple deployment options.
 • Instant testing: run your tools locally in the browser or via HTTP.
 • Enterprise-ready: leverage internal libraries, scripts, and APIs immediately.
 • Unified interface: MCP agents call your tools the same way, regardless of server or WASM.
⸻
Example
# Python function
def calculate_stats(numbers):
    """Return basic statistics for a list of numbers"""
    return {
        "count": len(numbers),
        "sum": sum(numbers),
        "mean": sum(numbers)/len(numbers)
    }
# === WebAssembly MCP ===
from polymcp import expose_tools_wasm
compiler = expose_tools_wasm([calculate_stats])
compiler.compile("./wasm_output")
The same function can also be exposed via HTTP MCP endpoints without modification.
# === HTTP MCP ===
from polymcp.polymcp_toolkit import expose_tools
app = expose_tools([calculate_stats], title="Stats Tools")
# Run with: uvicorn server_mcp:app --reload
⸻
Repo: https://github.com/poly-mcp/Polymcp
We’d love to hear how you’re using PolyMCP and feature ideas for future releases.

value: Show HN:PolyMCP – from Server to WebAssembly from the Same Python Code

author: justvugg


value: narubrown

value:
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.

value: Show HN: Spine – an execution-centric backend framework for Go

author: narubrown