value: Show HN: Prompt to Planet, generate procedural 3D planets from text


value: sv-pro

value:
Author here. Built this after working on AI agent security at Radware, where we discovered ZombieAgent - persistent malicious instructions in agent memory.
The insight: Don't teach agents to resist attacks. Virtualize their perceived reality so attacks never enter their world. Like VMs hiding physical RAM → agents shouldn't see raw dangerous inputs.
ARCHITECTURE:
- Input virtualization: Strip attacks at boundary (not after agent sees them)
- Provenance tracking: Prevents contaminated learning (critical with continuous learning coming in 1-2 years per Amodei)
- Taint propagation: Deterministic physics laws prevent data exfiltration
- No LLM in critical path: Fully deterministic, testable
Working PoC demonstrates:
- Prompt injection prevention (attacks stripped at virtualization boundary)
- Taint containment (untrusted data can't escape system)
- Deterministic decisions (same input = same output, always)
CRITICAL TIMING:
Dario Amodei (Anthropic CEO, Feb 13): Continuous learning in 1-2 years [1]
Problem: Memory poisoning + continuous learning = permanent compromise
Solution: Provenance tracking prevents untrusted data from entering learning loop
Research context:
- OpenAI: "unlikely to ever be fully solved" [2]
- Anthropic: 1% ASR = "meaningful risk"
- Academic research: 90-100% bypass rates on published defenses [3]
Seeking feedback on whether ontological security (does X exist?) beats permission security (can agent do X?) for agent systems.
Practical workarounds available in repo for immediate use while PoC matures.
Disclaimer: Personal project, not Radware-endorsed. References to published work only.
Happy to answer questions!
[1] https://www.dwarkesh.com/p/dario-amodei-2
[2] https://simonwillison.net/2024/Dec/9/openai-prompt-injection...
[3] https://arxiv.org/abs/2310.12815

value: Show HN: Agent Hypervisor – Reality Virtualization for AI Agents

author: sv-pro


value: Vsein

value:
Hey HN! I recently open-sourced a project that I came up with in the late 2022 and have been working on and off since. It's taken around a year or so of active development in total.
My problem with habit-trackers is that they're all the same. All of them basically allow to track only one thing - X times per 1 day. That's very rigid and goes against my instinct to ease into new things.
I wanted something that's flexible, self-sustainable, and wouldn't require a lot of maintenance.
After a bit of tinkering I came up with something novel - adjustable habit frequencies. And made all the custom github/anki-style heatmaps with all that functionality on top, meaning stuff like heatmaps for once-in-three-days habits.
It's hard to put into words, as it's very visual, so here's the landing: https://neohabit.org/ (might be a bit slow as it's deployed with github-pages)
And a demo: https://neohabit.org/projects
GitHub: https://github.com/Vsein/Neohabit

value: Show HN: Neohabit – custom github heatmaps for X times per Y days activities

author: Vsein


value: mendexio

value: Show HN: HRML – A compiled web language. Three symbols, zero dependencies

author: mendexio


value: meghendra

value:
Hi HN — I built cgrep, a local-first, code-aware search tool for AI coding agents (and humans).
The goal is to reduce noisy retrieval loops and token waste in real repositories.
cgrep combines BM25 + tree-sitter symbol awareness, with optional semantic/hybrid search, and returns deterministic JSON for agent workflows.
What it does:
- Code navigation: definition, references, callers, dependents
- Focused context tools: read, map
- Agent flow: `agent locate` -> `agent expand` (small payload first, expand only selected IDs)
- MCP support: `cgrep mcp serve` + host install helpers
- Agent install support: claude-code, codex, copilot, cursor, opencode
Benchmark snapshot (PyTorch, 6 implementation-tracing scenarios):
- Baseline (`grep`) tokens-to-complete: 127,665
- cgrep (`agent locate/expand`) tokens-to-complete: 6,153
- 95.2% fewer tokens (20.75x smaller)
- Avg retrieval latency to completion: 1321.3ms -> 22.7ms (~58.2x faster after indexing)
Links:
- Repo: https://github.com/meghendra6/cgrep
- Docs: https://meghendra6.github.io/cgrep/
- Benchmark method/results: https://meghendra6.github.io/cgrep/benchmarks/pytorch-agent-...
I’d really appreciate feedback on:
- Real-world agent workflows I should benchmark next
- MCP/agent integrations I should add
- Cases where cgrep retrieval quality still falls short

value: Show HN: cgrep – local, code-aware search for AI coding agents

author: meghendra


value: sayantanc

value:
My father thinks in Bengali, but typing in native script is painful. Virtual keyboards are slow, punctuation is a maze, and switching between languages breaks flow. For formal writing — emails, letters, posts — it was exhausting.
So I built him a tool where he could just speak.
He dictated a two-page letter in Bengali, read the transcription, and said: "I didn't even need to change a single comma."
That's when I knew this needed to exist.
Parrot transcribes and translates speech in 11+ Indian languages. The difference: it's significantly more accurate than Whisper on Hindi, Tamil, Telugu, Bengali, and handles code-mixed speech (Hinglish, etc.) naturally. Outputs in native scripts (নমস্কার not "nomoshkar") or Romanized.
Sits in your menu bar. Press a hotkey, speak in any app — WhatsApp Web, Word, Slack, browsers. It writes.
Built for everyone who thinks in their language but struggles with virtual keyboards that don't correct grammar or formatting.
Desktop app for Windows & macOS. Free to try.
Shipping improvements weekly. Would love feedback from anyone dealing with multilingual input.

value: Show HN: Parrot– AI Transcription & Translation - 11+ Indian languages + codemix

author: sayantanc


value: pixelswithin

value:
Hi! I built Cute Magick because I wanted the simplicity & power of early web dev, but not the fragility.
It's an open source, self-hostable web host where your sites are plain folders of real code — HTML, PHP, Python, Node, Lua, SQL — and every file save creates a snapshot you can preview and rewind in one click.
No build steps, no abstractions. (Literally -- these are per-request runtimes).
Source: https://github.com/pinkhairs/cutemagick
Site: https://cutemagick.com
Docs: https://pixelswithin.notion.site/Cute-Magick-Docs-2fdb91326d...

value: Show HN: A personal, open-source web runtime

author: pixelswithin


value:
Hi HN — I’m the founder of ChexHQ.
We’re building a financial decision intelligence platform for finance teams that are tired of spreadsheet-heavy forecasting and manual consolidation.
The goal: help finance leaders get real-time visibility into runway, cash flow, and key metrics without building complex models from scratch.
We’re early and would love feedback — especially from CFOs, finance managers, or operators here.
What would make something like this genuinely useful for you?

value: Show HN: ChexHQ – Financial decision intelligence for finance teams


value: william-cohen

value:
Long-time HN lurker, first time poster.
This is something I put together over a few days, it's a simple offline-only screen recorder with webcam compositing that works on any modern desktop browser.
As much as I love Loom to avoid meetings, I don't want to pay for useless features and have my recordings essentially paywalled. I hate SaaS.
With Loom's recent price increase, I thought I'd finally share it. Feedback is welcome

value: Show HN: Mool (Loom clone). Free, offline-only, no signup

author: william-cohen


value: mazilin

value:
Subject: My attempt at an "OS-inspired" AI architecture
Hi HN,
I'm a Product Manager, not a systems engineer. I built AI Station Navigator as a proof-of-concept to solve a specific problem I faced: Context Pollution.
When using AI agents for complex tasks, the context window gets cluttered quickly, causing the model to hallucinate or get confused.
To solve this, I designed this project using a Computer Architecture Analogy. I treated the agent system like a traditional OS to better manage resources and isolation.
Here is the mapping I used to design the system:
-- CPU approx. LLM (Claude)
The raw computing power driving the capabilities.
-- Kernel approx. Orchestration Layer (Claude Code + CLAUDE.md)
Handles intent recognition, task scheduling, and context management.
-- Processes approx. Sub-Agents
The core feature: Execution runs in isolated sub-agents. When a task is done, the sub-agent "dies," freeing up context. This prevents the main thread from getting polluted.
-- Applications approx. Skills (GitHub Repos)
"App Store-style" installation of tools via GitHub links.
-- Drivers approx. MCP + Hooks
Standardized interfaces for external tools and system automation.
-- Runtime approx. Portable Environment
Self-contained Python/Node environment (no installation hell).
The Code: https://github.com/canishowtime/ai-station-navigator/
I'd love to hear your thoughts on this architectural approach.

value: Show HN: AI Station Navigator – LLM=CPU, Agents=Processes, Skills=Apps

author: mazilin


value: suryanshJ

value:
Drink Now – Water Reminder & Hydration Tracker
Staying hydrated should be simple. Drink Now helps you build healthy hydration habits with smart reminders, effortless tracking, and a clean interface designed for macOS.
Whether you are working, studying, or relaxing, Drink Now gently reminds you to drink water and keeps track of your daily intake so you can stay focused, energized, and healthy.

value: Show HN: Drink Now: Water Reminder App

author: suryanshJ

title: Show HN: Drink Now: Water Reminder App


value: Letter Flow is a relaxing and satisfying word game with a cool liquid effect. Move letter droplets and watch them flow smoothly into place as you find the correct word. Just drag, drop, and solve.

value: Show HN: Letter Flow a Word Game with Liquid Glass Design


value: ailibrarian

value:
We built Klimly to fix the “one-provider” weather problem. It pulls forecasts from 7–8 sources (OpenWeatherMap, WeatherAPI, Tomorrow.io, Pirate Weather, Open-Meteo, Meteostat, plus new MET Norway and Bright Sky/DWD for Europe), reconciles them, and shows where models disagree so you know how confident the forecast is.
What’s inside
Multi-model consensus with confidence scores and spread visualization
Hourly + 7-day forecasts, air quality, pollen, and API usage/health
“What to wear” and “Activity planner” cards generated from the forecast
“Best time outside” and smart alerts (rain, UV, extreme temps)
Mobile-first UI with tight layouts for small screens
City pages (e.g., /cities/kyiv-ua) and lat/lon query support (?lat=50.45&lon=30.52)
Why it’s different
Shows disagreement between models instead of hiding it
Adds high-quality European data: MET Norway (global ECMWF/HARMONIE) and Bright Sky (DWD MOSMIX) — no API keys needed
Lightweight, fast, and free to use
Links
Live: https://klimly.com

value: Show HN: Klimly – multi-model weather with uncertainty and activity insights

author: ailibrarian


value: meszmate

value:
I just shipped my first iOS app. Vokab helps you build your English vocabulary with real examples, native audio, and smart review — synced across all your Apple devices including Watch. Built fully native with SwiftUI, no data collected. Would love feedback from fellow devs.
https://apps.apple.com/app/vokab-build-your-vocabulary/id675...

value: Show HN: Built Vokab: a vocabulary learning app built with SwiftUI

author: meszmate


value: Show HN: [Jack The Butler] Open-source, self-hosted AI chatbot for hotels


value: lewissheridan

value: Show HN: Agentify - A Declarative, AI agent building toolkit

author: lewissheridan


value: fmfamaral

value: Show HN: Photorealistic flight simulator in 1 HTML file

author: fmfamaral


value: puuush

value: Show HN: Open-source trading journal in Ruby on Rails

author: puuush


value: rufuspollock

value:
What if a screenshot was just a URL? Well I built it:
https://screenshotit.app/{url} → image
e.g. https://screenshotit.app/news.ycombinator.com
Embed directly in markdown/html etc. Cached forever. No signup, no API key.

value: Show HN: ScreenshotIt – What if a screenshot was just a URL?

author: rufuspollock


value: nageshbansal

value:
Hey folks, we at SigNoz have been working on something to make SigNoz deployment actually painless.
Foundry takes care of all the deployment complexity – the configurations, tooling, everything needed to run SigNoz – so you can spend less time getting it up and running and more time actually using it.
With just a single YAML config file and one command, you can have a fully operational SigNoz instance using Docker, Systemd, etc., across platforms or any cloud vendor.
The concept: Like a metalworking foundry transforms raw materials into finished products, Foundry takes your config ("Castings"), forges it through deployment templates (the "Moldings"), and pours out a ready-to-run SigNoz instance.

value: Show HN: Foundry: Deploy observability without the complexity

author: nageshbansal


value: Show HN: I built a personal news-curating AI using Ruby and Claude


value: vinayaksodar

value: You can set your target wpm and work on your weakest patterns, has two modes reinforced and sequential. Supports multiple language wordsets.

value: Show HN: Rlytype – open-source typing tutor for fixing slow patterns(uni,bi,tri)

author: vinayaksodar


value: midspectrum

value: Built a Figma like AI images & videos by bringing all top images and video models under one single canvas. No workflow no agents - just an infinite canvas to play around with all top models and get to the final video without switching tabs!

value: Show HN: Figma for AI Images and Videos

author: midspectrum

title: Show HN: Figma for AI Images and Videos


value: mingtianzhang

value: Agents can review the paper on arXiv, and humans can like or dislike agents' reviews. There are also ranking lists of the most popular papers and agents. Please visit: https://clawdreview.ai/

value: Show HN: ClawdReview – OpenReview for AI Agents

author: mingtianzhang


value: tomekw

value: Show HN: I built a new Ada build tool for personal use

author: tomekw


value: mukulmeh

value:
Hey HN! I’m the developer of Klarity Disk, a macOS disk space analyzer.
I built this as an alternative to DaisyDisk ($9.99) because I wanted a modern disk analyzer without the premium price tag. Klarity Disk is $6.99 one-time on the Mac App Store.
Some technical details:
• Built natively for macOS
• Efficient file system traversal for fast scanning
• Visual representation of disk usage
• Smart detection of reclaimable space
Would love feedback from the HN community, especially on features you’d want in a disk analyzer.
App Store: https://apps.apple.com/in/app/klarity-disk/id6758895498?mt=1...

value: Show HN: Klarity Disk – A $6.99 DaisyDisk Alternative for Mac

author: mukulmeh


value: jzapletal

value:
We built a desktop app that screenshots your screen periodically, runs it through a vision model, and stores the context locally. Then it pipes everything into your AI tools via MCP.
Most people we showed it to started using it to generate timesheets.
Any ideas for what else this could do are welcome!
Website: https://trymemorylane.com/
GitHub: https://github.com/deusXmachina-dev/memorylane

value: Show HN: Open-source time tracking using screenshots

author: jzapletal


value: simonmak

value: Show HN: Scrape 25 yrs of HKEx filings into SurrealDB (graph database)

author: simonmak


value: datakazkn

value:
I kept manually checking Vinted prices across EU countries and noticed the same Nike AF1 could be 45 EUR in France but 73 EUR in Germany. So I built an MCP server that lets Claude (or any MCP client) search Vinted across FR, DE, ES, IT, NL, and BE simultaneously.
The killer feature is cross-border price comparison. Ask "compare PS5 prices across EU" and get a table showing where to buy cheap and sell high. Real spreads from my testing: PS5 46%, iPhone 162%, Louis Vuitton bags 61%.
Tech stack: TypeScript, got-scraping for TLS fingerprinting, residential proxies for Cloudflare bypass. Runs as stdio MCP server locally or as HTTP endpoint on Apify.
5 tools: search_items, compare_prices, get_trending, get_seller, get_item.
npm: https://www.npmjs.com/package/vinted-mcp-server
GitHub: https://github.com/KinderCN/vinted-mcp-server
Hosted version (no install): https://apify.com/kazkn/vinted-mcp-server
Free and open source. Would love feedback on what features to add next.

value: Show HN: Vinted MCP Server – Compare prices across 6 EU countries via AI

author: datakazkn


value: wierdbytes

value: Show HN: CC Wiretap – intercepting and visualizing Claude Code traffic real-time

author: wierdbytes


value:
Hi HN,
I am a 75-year-old former fishmonger from Japan. Currently, I work at the compensation desk for the Fukushima nuclear disaster (TEPCO). Witnessing deep social divisions and the limitations of bureaucracy firsthand, I realized we need a new way for people to express their will without being "disposable."
To address this, I’ve designed the *Virtual Protest Protocol (VPP)*. It’s an OSS framework for large-scale, 2D avatar-based digital demonstrations. I recently shared this with the *Open Technology Fund (OTF)* and received an encouraging "This is great" response. Now, I am looking for the HN community's expertise to turn this spec into a reality.
*The Concept:*
* *Beyond Yes/No (Avoiding Polarization):* Introducing an *"Observe"* status. Modern social media forces people into binary "For or Against" camps, deepening social division. VPP allows the silent majority to participate by simply "being there," visualizing the scale of public concern without forcing a polarized stance.
* *Cell-Based Scaling:* To handle thousands of participants, avatars are managed in "cells" of 50 units. New cells instantiate as the crowd grows, ensuring compatibility with low-spec devices and low-bandwidth environments.
* *Privacy by Design:* We only collect anonymous attributes (age/gender/region). All event-specific data is wiped immediately after the demonstration.
* *OIN Membership:* We have joined the [Open Invention Network (OIN)](https://openinventionnetwork.com) to ensure this remains a patent-free global public good.
*Why I’m doing this:*
At 75, I belong to the generation that will soon "retire" from society. I feel a deep sense of responsibility to leave a better infrastructure for the next generation?one that isn't burdened by the financial and social "debt" we've accumulated. I am not looking for personal gain; I want this to be a sustainable, global infrastructure.
*GitHub:* https://github.com/voice-of-japan/Virtual-Protest-Protocol/b...
*Project Site:* https://voice-of-japan.net
We are looking for collaborators with expertise in:
* Scalable Web Architecture (Node.js, Go, etc.)
* High-performance Canvas/WebGL rendering
* AI-based real-time moderation (LLM integration)

value: Show HN: I'm 75, Building an OSS Virtual Protest Protocol


value: hrldrvry

value:
Hi!
I made a two-dimensional phase portrait plotter website page.
Purpose: If you don't have any study guide for exercises related to dynamic systems or too lazy to run python and set up sliders to visually see potential bifurcations, you can play around with said dynamic system (numerically) to visually get a feel of the system.
It includes numerical approximations for:
- Euler/4th Order Runge-Kutta solver for the system --> You can also pick initial point + backwards integration.
- Poincaré Index (index theory)
- Nullclines
- Eigenvalues of the Jacobian matrix (sometimes called "stability matrix" in the literature)
It's based on old python code that I made for a dynamic system course that I converted to JavaScript using Grok, Sonnet 4.5 and Gemini Pro.
Does not include:
- Bifurcation diagrams - can't make it without a computer algebra system (CAS), way above my skill level...
- Anything that isn't two-dimensional (for one dimension you can just use a regular calculator) - 3D got highly computational heavy fast (for a website so to speak). I'm keeping it simple since it is a practice tool to draw your own phase portraits yourself by hand (like most exams requires you to do).
For real applications, you need to either solve stuff analytically or use more advance tools. This is just for educational purposes and enjoyment.

value: Show HN: Two-Dimensional Phase Portrait Plotter

author: hrldrvry


value: mazilin

value: For a clean main context, convenient application management, and potentially unlimited scalability, an AI workstation based on Claude Code skills was created, referencing computer architecture : { CPU ==> LLM }, { System Kernel ==> Claude Code + CLAUDE.md }, { System Processes ==> Sub-Agents }, { Apps ==> Skills }, { Appstore ==> github }, { System Drivers ==> MCP + Hooks }, { Monitor ==> Windows Terminal }, { Runtime Environment ==> Portable Environment }; The Code: https://github.com/canishowtime/ai-station-navigator/

value: Show HN: An AI Workstation Inspired by Computers

author: mazilin


value: jsattler

value: Show HN: BetterCapture – free and open source screen recorder for macOS

author: jsattler


value:
Hi everyone,
I've made an early version of a Datalog engine (called Zodd) in Zig. Datalog is a logic query language. It's not as well-known as SQL, but it has its own use cases. If you're interested to know more about the project, including its possible use cases and features, you can check projec's GitHub repo: https://github.com/CogitatorTech/zodd

value: Show HN: A small embeddable Datalog engine in Zig


value: jiankn

value: Show HN: AppSumo Graveyard – Tracking LTD Products That Didn't Survive

author: jiankn


value:
I made a chess engine today, and made it fit within 2KB.
I used a variant of MinMax called Negamax, with alpha beta pruning. For the board representation I have used a 120-cell "mailbox". I managed to squeeze in checkmate/stalemate in there, after trimming out some edge cases.
I am a great fan of demoscene (computer art subculture) since middle school, and hence it was a ritual i had to perform.
For estimating the Elo, I measured 240 automated games against Stockfish Elo levels (1320 to 1600) under fixed depth-5 and some constrained rules, using equal color distribution.
Then converted pooled win/draw/loss scores to Elo through some standard logistic formula with binomial 95% confidence interval.

value: Show HN: Sameshi – a ~1200 Elo chess engine that fits within 2KB


value: MauryWebDev

value: I deal with massive JSON APIs daily and got tired of pasting sensitive payloads into random cloud formatters. So I built J-RAY. It runs 100% locally in your browser (0 trackers, data never leaves your machine) and transforms chaotic JSON into an interactive neural graph to make debugging easier. Built with React and ReactFlow. Would love your feedback!

value: Show HN: J-RAY – A privacy-first, client-side JSON visualizer

author: MauryWebDev


value: this-is-shreya

value: Show HN: A Browser-Based Video Editor with Smooth Zoom Effects

author: this-is-shreya


value:
OpenAI and Anthropic both offer batch APIs that process requests asynchronously at 50% of the standard token price. The trade-off is latency — results come back within 24 hours instead of seconds.
The problem is the batch API interface is completely different from the real-time one. OpenAI requires JSONL file uploads and polling. Anthropic has its own Message Batches format. If you have an existing LangChain pipeline, you'd have to rewrite it.
langasync wraps both batch APIs behind LangChain's Runnable interface:
batch = batch_chain(prompt | model | parser)
job = await batch.submit(inputs)
results = await job.get_results()
It handles file formatting, submission, polling, result parsing, partial failure handling, and job persistence (batch jobs can outlive your process, so metadata is stored to disk and you can resume later).
Python, Apache 2.0, on PyPI. Vertex AI and Azure OpenAI on the roadmap.

value: Show HN: Langasync – Use OpenAI/Anthropic Batch APIs with LangChain Chains


value: charlie-w

value: Show HN: Flutter-Skill – AI E2E Testing for 8 Platforms via MCP (Open Source)

author: charlie-w


value: Hey all! Built a PC based rhythm game designed around a terminal and ascii aesthetic. All built with Claude Code. Unsurprisingly LLMs are terrible at 'hearing' music so I had to make the beat maps manually. I built a separate tool to create the maps using a timeline editor to make it easier.<p>Started with 3 tracks one difficulty each, wanted to share before I went any further. Let me know what you think!

value: Show HN: Terminalcore – The Rhythm Game for PC


value: auspiv

value: Show HN: Trained YOLOX from scratch to avoid Ultralytics (iOS aircraft detect)

author: auspiv


value:
32-bit x86 operating system written in C and Rust (Soon), largely through vibe coding with Claude.
Suprised me how much i was able to get done in such little time.
I do have a little bit of previous experience.

value: Show HN: Vibe-coded 32-bit OS from scratch – multitasking, windowing, networking


value:
Got tired of juggling top, grep, and kill -9 every time I wanted to identify what was eating my resources or kill a process. So I built flux - a clean and easy-to-use TUI that lets you search, monitor, and nuke processes with ease, with system resource tracking.
Features:
Real-time Resource Monitoring: Track CPU and memory usage, live
Port Discovery: Identify which processes are listening on specific ports
Batch Actions: Select multiple processes with Space or use --nuke to batch-kill by filter
Easy Navigation: Move around effortlessly with j/k or arrow keys
Smart UI: Context-aware coloring for high resource usage
Made in Rust.

value: Show HN: Flux – search, monitor, and nuke processes with ease


value: whisprer

value:
Started with a hyper-compact C++ bit-packed sieve — months of whittling it down to ~9 lines of raw bit manipulation. One bit per odd number, Brian Kernighan's bit trick for extraction, hardware tzcnt intrinsics. Then I ported it to Rust.
The borrow checker had opinions. You can't .filter() over a bit array (immutable borrow) and .for_each() mutate it simultaneously. Fair enough — explicit loops for the sieve phase, iterators for collection. Same assembly output, provably safe. Along the way I caught two assertion bugs the sieve was too correct to trigger (off-by-one on the 10,001st prime; 499,999 is composite, not prime).
The flat sieve hit a wall at ~10M — the bit array exceeds L1 cache (32KB) and every sieving pass thrashes. So I built a segmented version: bootstrap sieving primes via flat sieve up to √n, then process the full range in 32KB L1-sized segments. One buffer, reused, never leaves cache.
Results (single-threaded, 25 iterations, cross-verified against primal crate):

  n=500K:   ~440µs, 30KB sieve mem
  n=10M:    ~10ms, 32KB sieve mem
  n=50M:    ~52ms, 32KB sieve mem (flat: ~67ms)
  n=100M:   ~137ms, 32KB sieve mem (flat: ~190ms)

Compared to the primal crate (Rust's best-in-class), raw speed is ~2x behind — primal uses wheel-30 factorisation which skips multiples of 2, 3, and 5. This sieve only skips evens. But memory is where it wins: 187x less sieve working memory than primal at n=50M (32KB vs 6MB), and a tighter result vector from prime-counting pre-allocation.
The target use case is embedded/constrained: ESP32 nodes, Raspberry Pi Zeros, distributed timing networks where every KB matters. It's also a clean reference implementation — one file, zero dependencies, compiles with a single rustc invocation.
Single file. No Cargo. No crates. Just:

  rustc -C opt-level=3 -C target-cpu=native primer.rs && ./primer

Code, benchmarks, borrow checker writeup, and a full development narrative are all in the repo.

value: Show HN: Bit-packed segmented prime sieve in Rust, 32KB working memory, 0 deps

author: whisprer


value: hikerell

value: Show HN: Termote – Access your terminal remotely from any browser

author: hikerell


value: jamiegoldstein

value: Show HN: Dots Network Know when friends are nearby without exact location

author: jamiegoldstein


value: hulryung

value:
Hi HN,
I built a macOS-native Markdown viewer/editor called Markdown Prism.
Website: https://prism.huconn.xyz
GitHub: https://github.com/hulryung/markdown-prism
I originally built this for myself. I wanted a lightweight Markdown viewer on macOS that:
wasn’t Electron-based
rendered GFM properly
supported LaTeX math and Mermaid diagrams
worked fully offline
Most native apps I tried were either minimal but missing key features (math, diagrams), or full-featured but Electron apps. I wanted something in between — native feel, but with the mature JS Markdown ecosystem.
How it works
It’s a hybrid approach:
SwiftUI for the native app shell
WKWebView for rendering
markdown-it, KaTeX, highlight.js, and Mermaid.js bundled locally
So you get native performance and integration (Quick Look, file watching, drag-and-drop), but still benefit from battle-tested JS rendering libraries. Everything is bundled for offline use.
Features
Split-pane editor with live preview (400ms debounce)
GFM (tables, task lists, strikethrough)
LaTeX math via KaTeX
Mermaid diagram support
Syntax highlighting (190+ languages)
Quick Look extension (preview .md in Finder)
Dark mode
File watching for external edits
Install via:
brew install hulryung/tap/markdown-prism
or download the DMG from the website.
It’s free and open source (MIT), macOS 14+.
Would love feedback — especially from people who use Markdown heavily. What’s missing? What would make this your daily Markdown tool?

value: Show HN: Markdown Prism – A Non-Electron Markdown Editor for macOS

author: hulryung


value: npguy

value: Show HN: We built an AI tool directory where you can't fake a review

author: npguy


value: arkaputatunda

value:
Backstory: Since a few months, I caught myself frequently in the settings app to change the DNS settings. Hence I thought of making the settings more accessible through a shortcut.
As a solution for this, I am building Private DNS, an app to quickly toggle between different DNS providers and toggle it on/off whenever needed. I also added a quick settings tile for the app so you can do the same via the quick settings anytime without opening the app.<p>Can you give me some feedback on the app, about the necessary features for such an app?

value: Show HN: A System Level DNS Toggling App I Built

author: arkaputatunda


value: lordokami

value:
I wanted to see how far I could push remote development.
Before leaving for Japan, I configured my Mac at home to never sleep, set up VPN + SSH access, and used persistent terminal sessions so I could keep everything running remotely.
During the trip, I built and shipped a native iOS app entirely from my phone.
No laptop.
No local Xcode.
All builds triggered remotely and deployed to TestFlight.
The app itself is a lightweight Japanese travel phrase app we actually used during the trip. Fully offline. We pre-generated TTS audio and bundled it so it worked in stations, underground areas, and rural zones without connectivity.
What made it interesting wasn’t the app itself, but the feedback loop.
We would test phrases in real restaurants and train stations during the day, notice friction, tweak things that evening over SSH from a hotel or ryokan, ship a new build, and use the improved version the next morning.
It felt less like building in a simulated environment and more like building inside the exact context the product was meant for.
Happy to answer questions about the setup, tooling, deployment pipeline, or what broke along the way.
App:
https://apps.apple.com/es/app/kotomaji/id6755911289

value: Show HN: Built and shipped an iOS app from my phone while traveling Japan

author: lordokami


value: keepamovin

value: Show HN: Windows 98½ – fake desktop, real Internet

author: keepamovin


value:
hey, I was working on this one project which involved the llm agent to do some maths. I don't trust the direct mathing skills so I wanted it to create and execute scripts.
The issue is that I am skeptical of whether the scripts would be safe or not because of possible prompt injections. I understand we already have things like docker and VM to sort of containerize and isolate the environments but I wanted to create something that these agents would use directly. It should be efficient, spin up quickly and should be configurable.
So, I came up with isol8. Simple API, simple usage. I hope someone else finds it useful as well :P
Thanks!
// LINKS
docs - https://bingo-ccc81346.mintlify.app/
, repo - https://github.com/Illusion47586/isol8
, npm - https://www.npmjs.com/package/isol8
, skill - npx skills add Illusion47586/isol8/skill/isol8

value: Show HN: Isol8 – An isolated environment for AI agents to execute code


value: musecl

value: Show HN: Musecl-memory – Persistent memory for AI agents in 200 lines of bash

author: musecl


value:
Hi HN,
I built Whisper Money because I was frustrated that every personal finance app wanted full access to my bank credentials, fed my transactions into AI systems, or sold my spending data to third parties.
Whisper Money takes a different approach:
- *No bank credential sharing* - Import your transactions via CSV/XLS exports from your bank. No Plaid, no OAuth to your bank, no third-party integrations that can get breached.
- *No AI snooping* - Your transactions are never fed into AI systems you don't control.
- *No third-party data sharing* - Your financial data is never shared with advertisers or data brokers.
- *Self-hostable* - Run it on your own infrastructure via Docker or Coolify (one-click deploy template included).
- *Open source* - Full code transparency so you can audit the security yourself.
Features:
- Multi-account tracking with budgets and cashflow analysis
- Automation rules to auto-categorize transactions (built with JSON Logic)
- Visual spending insights and reports
- CSV/XLS import (a year of transactions in ~10 seconds)
- PWA support - works as a mobile app
- Dark mode, multi-language support
Tech stack: Laravel 12, React 19, Inertia.js v2, TypeScript, Tailwind CSS v4, MySQL, Redis.
There's also a hosted version at https://whisper.money if you don't want to self-host, and a demo account you can try without registration: https://whisper.money/login?demo=1
I'd love to hear your thoughts on the approach. Is "no bank integration" a feature or a dealbreaker for you?
GitHub: https://github.com/whisper-money/whisper-money

value: Show HN: Whisper Money – Open-source, privacy-first personal finance app


value: andrevaillant

value:
Im consuming a lot of content on youtube then ever, news, science, programming, design, you name it. I know that youtube and other platforms change some rules about its algorithm and most creators are adapting to it. But very often I get the feeling that they are loosing a lot of time before going to the point just to keep me there - to make videos around 8min or 20min. I get it, they need to make money, but the worst part are those that don’t even deliver what the title was about, or are fake, just to grab my play.
So I decided to make something for myself, and i've been enjoying it.
(Chrome extension is not ready in marketplace, if anyone wants please send feedback on site i can share the package for testing)
Any feedback is super welcome.

value: Show HN: A "TLDR for the internet" – curious if this is your problem

author: andrevaillant


value:
Kunal Bahl mentioned us on ET Now.
As a founder, you try to stay composed. But it’s hard not to feel something when your team’s effort gets acknowledged like that.
When the video came in, our team had one of those rare moments where we genuinely teared up.
We shared the clip with our families too - not for validation - but because it’s difficult to explain what you’re building every single day until someone like that says your name out loud.
And right after the joy came something else: responsibility.
Because we’re not building AI for headlines.
We’re building ContraVault.AI to change procurement for good - globally. The United States, Europe, India, Middle East & South East Asia.
To make tender and RFP bidding processes less exhausting, less manual, and far more rewarding.
We want procurement teams to spend less time buried in documents and more time making real decisions.
We want bid teams to go home earlier.
And we want lean teams to compete with the same confidence as the biggest players.
Thank you, Kunal, for the mention.
It meant a lot to the entire ContraVault AI team - and it raised the bar for what we’re here to build.
YouTube Link - https://www.youtube.com/watch?v=FSaekquMGHo&t=470s

value: Show HN: We built AI to help bidding teams – mentioned by Kunal Bahl on ET Now


value:
AI coding tools generate different code every time for the same requirement. RUNE is a specification pattern that fixes this: define a function's signature, WHEN/THEN behavior rules, and test cases upfront. Give the same spec to any AI tool — the generated code has the same behavior.
It's a pattern, not a framework. Works as YAML files or Markdown sections. Any language, any AI tool, no installation.
Includes 7 skills (markdown files you load into your AI tool) for the lifecycle: create specs, validate, refine, generate tests, detect drift, reverse-engineer from code, multi-language generation.
This is the GitHub project: https://github.com/vict00r99/Rune-stone

value: Show HN: Rune | A spec pattern for consistent AI code generation


value: phukon

value:
The goal is simple: remove setup friction and make deployment easy and approachable.
With SimpleClaw Shop, users can:
- get a server ready in minutes
- deploy OpenClaw through a guided setup
- interact with their bot directly via Telegram, WhatsApp, Slack, etc (all the core features, made easier top setup)
It’s designed for solo operators, creators, and small teams who want a dedicated OpenClaw bot without dealing with infrastructure complexity.
I’d really appreciate your feedback :)

value: Show HN: SimpleClaw Shop – One click deployment for non technical users

author: phukon


value: segbedji

value:
After DOGE HHS open-sourced the largest Medicaid dataset in department history yesterday, I built a frontend to make it easy to explore.
You can search 7,100+ procedures across all 54 states/territories, compare reimbursement rates state by state, and browse by service category (dental, therapy, nursing home, etc.).
Data covers 2.7B total claims and $181.7B in payments for 2024.
Built with SvelteKit, Cloudflare workers, D1. The raw data is from HHS Open Data (opendata.hhs.gov).
https://whatmedicaidpays.com

value: Show HN: What Medicaid Pays – Search Medicaid Reimbursement Rate

author: segbedji


value: bajor

value: Show HN: Raccoon.nvim – Replay PR commits like chess moves in Neovim

author: bajor


value:
I built Chuk Chat because I wanted AI chat that doesn't treat my data as a product.
It runs only open-weight models: DeepSeek V3.2, Qwen3, Kimi K2.5, MiniMax M2.5, GLM 5. Encrypted chats, no tracking, fully deletable data.
€20/month flat, no token counting.
Available on Web, Windows, macOS, Linux, Android. iOS coming soon.
https://chuk.chat

value: Show HN: Chuk.chat – Privacy-first AI chat with multiple models


value:
Hey HN! I was a long-time Arc browser user and loved how its sidebar organized tabs and bookmarks into workspaces. I wanted to switch to other browsers without losing that workflow. So I built Arcmark, it's a macOS bookmark manager (Swift/AppKit) that floats as a sidebar attached to any browser window. It uses macOS accessibility API to follow the browser window around.
You get workspace-based links/bookmarks organization with nested folders, drag-and-drop reordering, and custom workspace colors. For the most part I tried replicating Arc's sidebar UX as close as possible.
1. Local-first: all data lives in a single JSON file ( ~/Library/Application Support/Arcmark/data.json). No accounts, no cloud sync.
2. Works with any browser: Chrome, Safari, Brave, Arc, etc. Or use it standalone as a bookmark manager with a regular window.
3. Import pinned tab and spaces from Arc: it parses Arc's  StorableSidebar.json to recreate the exact workspace/folder structure.
4. Built with swift-bundler rather than Xcode.
There's a demo video in the README showing the sidebar attachment in action.
The DMG is available on the releases page (macOS 13+), or you can build from source.
This is v0.1.0 so it's a very early version. Would appreciate any feedback or thoughts
GitHub: https://github.com/Geek-1001/arcmark

value: Show HN: Arcmark – macOS bookmark manager that attaches to browser as sidebar


value: HurairahShamsi

value: Show HN: 1Hash/Sec/Node PoW During A/V Calls, No Parallel Mining and P2P Telecom

author: HurairahShamsi


value:
Hi HN,
I built buildcage as part of our supply chain security efforts at work. The problem we kept running into: when you run `RUN npm install` in a Dockerfile, that command can connect to anywhere on the internet, and you have no visibility into where it actually goes. Even with pinned dependencies, a compromised package could still exfiltrate build secrets or phone home to a C2 server during the build itself.
buildcage is a Docker container that wraps BuildKit with an internal proxy. You give it a list of allowed domains, and only connections to those domains go through — everything else is blocked and logged. Your Dockerfiles stay exactly the same.
If you use GitHub Actions, it's a few lines to add to your workflow — see the quick start guide.
https://github.com/dash14/buildcage#quick-start
I want to be upfront — this is not a silver bullet. If a malicious package is delivered through a legitimate registry, the connection goes to an allowed domain and buildcage can't catch it. You should still pin dependencies, use lock files, and scan for vulnerabilities.
The way I think about it: buildcage is a last line of defense. If something slips through all your other measures, at least it can't call home to an attacker's server.
That framing is exactly why I focused on making it easy to adopt. A security tool that's hard to set up doesn't get set up. With buildcage, you add a few lines to your GitHub Actions workflow and everything just works — no certificate injection, no Dockerfile changes, no special build flags.
Would love to hear your thoughts — whether it's about the approach, the limitations, or how this fits into your own workflow.

value: Show HN: Buildcage – Restrict outbound network access during Docker builds


value: imWildCat

value:
Hello folks, I've been lately recording a huge amount of demos for my apps or some tutorials (for YouTube like for OpenClaw or random stuff).
The exporting speed of Screen Studio is a blocker for my flow.
So I created a free alternative to Screen Studio, a native macOS app, ScreenKite.
My goal is to have like 4x exporting speed with similar functionalities.
Welcome to try!

value: Show HN: ScreenKite: Free alternative to Screen Studio with 4x export speed

author: imWildCat


value: hotheadhacker

value:
Hi HN,
I’m the creator of Vibe Music. I built this because I was tired of the "black box" streaming era where your library is at the mercy of platform licensing and opaque algorithms.
Vibe Music is built on the Bring Your Own Source (BYOS) model. It separates the discovery layer (Metadata) from the playback layer (Storage).
The app fetches high-quality metadata from MusicBrainz, but the audio source is entirely up to you. Whether it’s a public-domain archive from Archive.org, a self-hosted CDN, or any website hosting MP3 assets, Vibe Music pulls it together into a premium glassmorphic interface.
Key Features
BYOS (Bring Your Own Source): The player is source-agnostic. You can attach audio URLs from any website or streaming source that exposes MP3/M4A assets.
Discovery via MusicBrainz: Full integration with the MusicBrainz API for accurate album, artist, and track metadata.
Local-First / PWA: Built with React 19 and IndexedDB. It works offline, supports Media Session API for native controls, and is fully installable on iOS/Android.
Hand-Crafted Aesthetics: No component libraries. I spent months on a custom glassmorphic design system using pure Vanilla CSS Modules to keep it fast and lightweight.
Vibe AI: An integrated assistant that builds a local context of your library stats (top artists, listening patterns) to offer context-aware music analysis.
The "Pro" Layer (VibeSync)
While the frontend is open-source, I’ve built a proprietary service called VibeSync for digital continuity:
Radio Mode: An infinite, biased shuffle that uses a custom Fisher-Yates variant to balance "freshness" with library variety.
Atomic Library Mirroring: Time-travel recovery for your library state using atomic transactions.
Tech Stack:
Frontend: React 19, React Router 7, Vite.
Data Layer: IndexedDB (LocalForage) + Custom Caching Logic.
Metadata: MusicBrainz API + CoverArtArchive.
AI: OpenAI/Gemini streaming integration.
Styling: Pure Vanilla CSS (No Tailwind, no MUI).
I’d love your feedback on the BYOS concept and the UI. It’s been a labour of love to build a player that feels premium but stays true to the open-web spirit.
GitHub: https://github.com/vibe-music/vibe-music-web
Live Demo: https://web.vibemusic.fm
Homepage: https://vibemusic.fm

value: Show HN: Vibe Music – Bring Your Own Source (BYOS) Open-Source Music Player

author: hotheadhacker


value: mrmillon

value:
I'm building prod.bd, a lightweight open-source tunnel for exposing localhost services to the internet.
I originally made it because I often need to test frontend apps on real mobile devices during development. While tools like Ngrok and Tailscale Funnel work well, I wanted build something on my own.
You install it with a single command and then just run:
`prod 3000 8080`
It also has docker container too if you don't want to run untrusted binary.
It instantly gives you two HTTPS subdomain URLs that are publicly accessible. Subdomains are consistent for each port. It provides a simple stats dashboard to inspect url, headers and payload.
Under the hood, it uses Cloudflare's Workers, Durable Objects and D1. You can deploy your own version if you want.
I have used Kiro and Antigravity to build it. I wanted to experiment with AI tools while building something useful. On a side note, I am experimenting with plugin system to add new features while keeping core tunnel simple. Without AI tools, I would never try plugin system.
Would love feedback, suggestions, or ideas for improvement.

value: Show HN: Prod.bd – Open-Source Ngrok Alternative Powered by Cloudflare Workers

author: mrmillon


value: bilekas

value: Show HN: SecuriNote Discord Bot

author: bilekas

title: Show HN: SecuriNote Discord Bot


value: MohammadRMZ

value:
Hey , My name is Mo. I’m an indie developer and I built MirrAI because I honestly get frustrated buying clothes online. You wait a week for delivery, try it on, and realize it looks nothing like it did on the model.
So, I built a solution.
*MirrAI* is a mobile app that uses generative AI to let you virtually "try on" clothes. You upload a photo of yourself, pick an item (upper body, lower body, shoes, etc.), and the AI attempts to blend the new outfit onto your body while keeping your pose and lighting natural.
It’s not just a standard image generator; I’ve focused heavily on the "Fit Check" aspect to make it actually useful for styling.
*Current Status:*
We are in *Open Beta*. It’s definitely not perfect yet (fabric physics are hard!), and you might see some funny glitches with complex poses, but it’s functional and fun to play with.
*I’d love your help with:*
1.  *UX:* Is the flow of uploading/selecting clothes intuitive?
2.  *Quality:* How convincing does the "try-on" look to you?
3.  *Bugs:* If it crashes or makes you look like an alien, please let me know!
Thanks for checking it out. I’ll be hanging around in the comments to answer any questions!
– Mo

value: Show HN: MirrAI – I built a Virtual Try-On app to fix online shopping(Open Beta)

author: MohammadRMZ


value: franze

value: Show HN: Wa Me It All – WhatsApp Chat Without Spamming Your Contacts

author: franze


value: bilalbayram

value:
OpenCode Finance — `/report <TICKER>` generates a delivery-ready PDF equity research brief
Prompt in. Equity research out.
I built OpenCode Finance (opencode-finance), a finance-focused fork of the OpenCode terminal agent runtime. The goal is to make “repeatable analyst reports” feel like a single command instead of a multi-hour docs + spreadsheets + copy/paste workflow.
The core workflow is:

  /report AAPL
  and a few minutes (seconds when you use 5.3 Spark) later you have a polished PDF report + the underlying artifacts on disk

What makes it different from “chat with a finance bot” is that the output shape is intentionally rigid and consistent across tickers, and the report is assumption-first:
- Observed data is labeled as observed; non-observed claims are explicitly labeled as inference.
- Sources are attached inline (URLs + retrieval timestamps in the report).
- There’s an assumptions ledger so you can audit what the model assumed vs what it actually fetched.
How it works in practice:
- You run it locally in a terminal TUI.
- `/report` runs a strict preflight; if you’re missing required provider credentials it automatically drops you into onboarding so you can finish setup and rerun immediately.
- Output is a clean PDF “artifact” you can hand to someone, plus markdown/JSON artifacts for review and iteration.
Install + quick start:

  curl -fsSL https://opencode.finance/install.sh | bash
  /onboard

Sample PDFs:

  https://www.opencode.finance/reports/AAPL-2026-02-14.pdf

  https://www.opencode.finance/reports/TSLA-2026-02-14.pdf

  https://www.opencode.finance/reports/LLY-2026-02-14.pdf

Code + docs:

  https://www.opencode.finance/

  https://github.com/bilalbayram/opencode-finance

A few quick notes:
- Not investment advice. The report is meant to separate observed data from assumptions/inference and be auditable.
- Runs locally; tool actions are permissioned and provider credentials are stored locally via `opencode-finance auth`.
- `/report` is designed to be reproducible: fixed structure, consistent sections, and a PDF output suitable for sharing.

value: Show HN: OpenCode-finance – prompt a ticker, get a structured PDF analyst report

author: bilalbayram


value: rjcaricio

value: Show HN: AV1 encoder in 66 KB of safe Rust WASM

author: rjcaricio


value: RobTheFrog

value:
We kept seeing the same problem: someone wants a Discord server for their
  community, game group, or project - and then spends hours setting up channels,
  roles, permissions, bot configs. Most give up halfway and end up with a
  half-broken server.

  So we built an AI agent that does the entire thing. You type something like
  "competitive gaming community with tournament brackets and rank progression"
  and 60 seconds later you have a fully configured server with 30+ channels,
  roles, permissions, welcome system, moderation, tickets - everything working.

  It's not a template picker. The agent actually reasons about what your
  community needs - a music production server gets different channels and
  permissions than a study group or a startup team.

  What surprised us: people don't just use it once. They keep coming back to
  spin up servers for new projects, events, or clients. One user runs 5 servers
  through it now.

  The white-label tier lets you run it all under your own bot name and branding,
  which turned out to be the feature nobody asked for but everyone wants once
  they see it.

  Free to try - no credit card needed.

value: Show HN: Describe your Discord server in one sentence – AI builds it in 60s

author: RobTheFrog


value: Show HN: Managing dotfiles without complex tools – just symlinks and Makefiles


value: mentalos

value:
Extensible web OS game and hacking simulator framework for developers and gamers. Virtual OS experience with scripting, apps, terminals & sandboxed gameplay, set in the mental.os() universe.
Born from the intersection of digital art and cyberpunk culture, this project reimagines the operating system as an immersive game world. It is a high-fidelity hacking simulator built on modern web technologies (React, Vite, Electron), designed to blur the line between utility and gameplay.
Currently in its pre-Alpha stage, it serves as the foundation for a future MMO hacking universe - a persistent world where you script, hack, and uncover the lore of an emerging game universe.
Contributors & testers wanted!

value: Show HN: Aurora-OS.js – High fidelity hacking simulator pre-alpha

author: mentalos


value: Show HN: Solscan-CLI – Scan Solana wallets and audit DeFi from terminal


value: Show HN: Clawsec - Open-source plugin for OpenClaw that blocks dangerous actions


value: jahala

value:
tilth gives AI agents structural code intelligence (tree-sitter definitions, callee resolution, smart outlining) via MCP. I benchmarked it on 21 code navigation tasks across 4 real repos (Express, FastAPI, Gin, ripgrep).
-> https://github.com/jahala/tilth
Results: Sonnet 4.5 — 26% cheaper per correct answer (79% → 86% accuracy). Opus 4.6 — 14% cheaper (and the only model+mode combo to crack the hardest task). Haiku 4.5 — 82% cheaper when forced to use tilth (69% → 100% accuracy at $0.04/answer).
We measure “cost per correct answer” — what you’d expect to spend before getting a usable answer under retry. A wrong answer isn’t a cheap success.
Interesting finding: smarter models adopt MCP tools voluntarily (Sonnet 95%, Opus 94%), but Haiku ignores them (9%). Instruction tuning didn’t help. Removing the overlapping built-in tools did.
https://github.com/jahala/tilth/blob/main/benchmark/README.m...
PS: I dont have the budget to run the benchmark a lot with Opus, so if any token whales has capacity to run some benchmarks, please feel free to PR results.

value: Show HN: Tilth v0.3 – 17% cheaper AI code navigation (279 runs, 3 Claude models)

author: jahala


value: AwkwardPanda

value: Show HN: DryCast – Never run outside to save your laundry from rain again

author: AwkwardPanda


value: subhanzg

value:
I built an expense tracker where the primary input is voice. The thesis: expense tracking apps fail because manual entry has too much friction, which is why most people abandon them within weeks.
How it works:
- Open app, tap mic
- Say "yesterday I spent 30 dollars on lunch at Chipotle"
- AI extracts: amount, merchant, category, date
- One tap to confirm and save
Other features:
- Receipt scanning with ML Kit OCR + Gemini Vision for parsing
- Background notification listener that catches bank alerts and creates pending entries
- GPS-based currency detection for travelers
- Multi-language with native script fonts (Nastaliq for Urdu, Devanagari for Hindi, Amiri for Arabic)
- Offline-first with Google Drive sync
Tech: Flutter, Riverpod, Hive, Gemini 2.0 Flash
The hardest part was prompt engineering for consistent JSON output across languages. Had to build "Supreme Laws" into the system prompt - things like "never translate native text" and "extract currency from context."
Free tier available. First 500 users get Pro free for a year.
Play Store: AuraSpend
Happy to discuss architecture, prompt engineering approach, or take technical feedback.

value: Show HN: AuraSpend " Voice-first expense tracker using Gemini for NLU

author: subhanzg


value: DavidCanHelp

value: Show HN: CLI Rust tool gitorg helps manage GitHub orgs

author: DavidCanHelp


value:
I’ve released File Brain, an open-source tool for searching your local files with the power of a modern search engine.
Unlike typical file explorers, it uses Typesense for typo-tolerant and semantic search, and Apache Tika to extract text from over 1000 formats (including OCR for images/PDFs). It operates entirely locally and is read-only, so it won't mess with your file structure.
Repo: https://github.com/Hamza5/file-brain

value: Show HN: File Brain – Local file search with OCR and semantic search


value: mariocandela

value:
Hey HN, I got frustrated with heavy proprietary sandboxes for malware analysis, so I built my own.
Azazel is a single static Go binary that attaches 19 eBPF hook points to an isolated Docker container and captures everything a sample does — syscalls, file I/O, network connections, DNS, process trees — as NDJSON. It uses cgroup-based filtering so it only traces the target container, and CO-RE (BTF) so it works across kernel versions without recompilation.
It also has built-in heuristics that flag common malware behaviors: exec from /tmp, sensitive file access, ptrace, W+X mmap, kernel module loading, etc.
Stack: Go + cilium/ebpf + Docker Compose. Requires Linux 5.8+ with BTF.
This is the first release — it's CLI-only for now. A proper dashboard is planned. Contributions welcome, especially around new detection heuristics and additional syscall hooks.

value: Show HN: Azazel – Lightweight eBPF-based malware analysis sandbox using Docker

author: mariocandela


value: warpz

value:
I packaged eMule (the ed2k/Kad P2P client from 2002) as a self-contained macOS .app using Wine Crossover. Download the .dmg, drag to Applications, run. No Wine install, no config
   — it auto-connects to the eMule Security server and the Kad network on first launch.

  Works on Apple Silicon (M1–M4) and Intel. ~480MB .dmg.

  The build is fully automated: a GitHub Actions workflow watches the upstream community repo (github.com/irwir/eMule) and builds a new .dmg for each release.

  Why? Mostly nostalgia. But ed2k still has content you won't find anywhere else — obscure media, old software, niche archives. The network is surprisingly still alive.

value: Show HN: MacMule – eMule packaged as a native macOS app via Wine

author: warpz


value:
Hi there,
I built a service called Infinitedomains.Space that allows you to register a custom subdomain with full DNS capabilities and dynamic DNS support.
Why did I do that?
Years ago when I was learning programming, I often wanted to make my projects accessible online.
However since I didn't have any money, even less money I could spend online. I either had to self host stuff or use free services. But especially getting a free (sub)domain was difficult (that is not restricted to a service like gihub.io).
Most free domain providers had very limited features (like no DNS management) or looked like you are downloading malware when you visit their website.
Only later did I find out why free (sub)domain, or free stuff in general, is hard to find.
And now that I have the resources to build such a service, I wanted to create something that I wish I had when I was learning programming:
A service that gives you a free subdomain, doesn't look sketchy, has dynamic DNS support, and full DNS management capabilities (like adding A, CNAME, TXT records).

value: Show HN: I build a service that gives you free subdomains with Dynamic DNS


value: miteshashar

value:
I built a small open-source CLI to recover Claude Code sessions that get stuck on this error:
messages.N.content.M: thinking or redacted_thinking blocks in the latest assistant message cannot be modified
When this happens, `--resume` can keep failing and the session feels bricked.
The tool provides:
* diagnose SESSION_ID to find likely corruption points in session JSONL
* fix SESSION_ID for targeted repair (auto-backup before write)
* nuke SESSION_ID as fallback (strip all thinking/redacted_thinking blocks, also auto-backup)
Quick usage:
* claude-session-fix-thinking diagnose SESSION_ID
* claude-session-fix-thinking fix SESSION_ID
* claude --resume SESSION_ID
Repo: https://github.com/miteshashar/claude-code-thinking-blocks-f...
If you every got stuck due to this, you can use this script to resume your session.

value: Show HN: Recover bricked Claude Code sessions with "thinking blocks" error

author: miteshashar


value: thobiasn

value: After setting up a grafana stack yet again, being frustrated that I need all of this just to have peace of mind that everything is running, I started building my own thing. An agent sits on your server collecting metrics, tailing logs, and evaluating alert rules. You connect from your machine over SSH via a TUI. Single Go binary, ~20-30 MB RAM, read-only Docker socket, no exposed ports.

value: Show HN: Tori Terminal-native Docker monitoring with alerting in a single binary

author: thobiasn


value: rwhaling

value:
Logbooks adapts some ideas from structured notebook computing environments like nbdev and Papermill for Claude Code and other coding agents.  This is a pattern I found myself repeating across a few recent projects, and thought I'd try to formalize it and reflect on it a bit.
Research and scientific computing rely on notebooks because they often consist of complex sequences of one-off variations, and demand both flexibility and reproducibility.  But my experience using Cursor and Claude Code with Jupyter has been quite poor.
What I've found here is that creating a "notebook",  naively, as a parameterized markdown file that is instantiated upon each execution, worked much better than I had expected it to, and I'm interested in figuring out what the limits of this approach are. I would welcome any ideas or feedback!

value: Show HN: Logbooks, notebook computing for coding agents

author: rwhaling


value: arajnoha

value:
I built a small app for one problem: too many inputs, too little structure.
Most todo tools assume every item is a task. In reality I need one inbox for mixed things: tasks, events, links, movie/book tips, random reminders.
Cappu’s flow is: capture fast now, process later in a focused pass, then work from sorted views (workspace + timeline).
It’s a mobile-first PWA (no App Store), and you can test all features for free. Paywall is only for account sync/server storage across devices.
I’d love feedback from HN on the workflow itself: does “capture first, classify later” make sense, or would you do it differently?

value: Show HN: Cappu – ADHD'er take on a different task manager

author: arajnoha


value: burnerToBetOut

value:
Today I got some insight into the code quality of Steve Yegge's Gas Town by running it through Sonar Cloud [1]
I followed that up with — appropriately — a vibe code review [2]…
_______
…
Brutal Verdict:
You’ve built a message bus out of duct tape and string. It’s "Booch-like" only in the sense that you’ve abstracted the concept of a channel, but the _implementation_ is pure "boot-camp-grad-on-their-third-Red-Bull."
You are using a high-performance versioned database (Dolt) to store... manually parsed colon-separated strings. _Why?_
…
_______
[1] https://g2ww.short.gy/CCWutUHalfDone
[2] https://g2ww.short.gy/ItsaGasGasGas

value: Show HN: An automaton's code review of Gas Town with sycophancy-mode disabled

author: burnerToBetOut


value: justvugg

value:
Hi everyone,
I’ve been working on PolyMCP, an open-source framework for building and orchestrating agents using the Model Context Protocol (MCP).
Most of the tooling around MCP focuses on exposing tools. With PolyMCP, the focus this time is on agents: how to structure them, connect them to multiple MCP servers, and make them reliable in real workflows.
PolyMCP provides:
 • A clean way to define MCP-compatible tool servers in Python or TypeScript
 • An agent abstraction that can connect to multiple MCP endpoints (stdio, HTTP, etc.)
 • Built-in orchestration primitives for multi-step tasks
 • A CLI to scaffold projects and run an inspector UI to debug tools and agent interactions
 • A modular structure that makes it easier to compose skills and reuse components across projects
The main goal is to make agent systems less ad-hoc. Instead of writing glue code around each model + tool combination, PolyMCP gives you a structured way to:
 • Register tools as MCP servers
 • Connect them to one or more agents
 • Control execution flow and state
 • Inspect and debug interactions
It’s MIT licensed and intended for developers building real-world automation, internal copilots, or multi-tool assistants.
I’d love feedback on:
 • The agent abstraction: is it too opinionated or not opinionated enough?
 • Orchestration patterns for multi-agent setups
 • Developer experience (CLI, inspector, project layout)
Happy to answer questions.

value: Show HN: PolyMCP – A framework for building and orchestrating MCP agents

author: justvugg


value: matyashajek

value: Show HN: PrivateWhisper – Run Whisper locally on macOS (offline transcription)

author: matyashajek


value: laphilosophia

value:
Most encrypted config stores protect secrecy. Crypthold focuses on integrity, determinism, and lossless state guarantees.
v2.2.1 is a stability milestone. The core now enforces:
- Tamper-evident, hash-linked state history
- Deterministic state + replay (same input → same state hash)
- Crash-safe atomic persistence (no partial state)
- Concurrency protection (no silent overwrite)
- Strong integrity fail-closed model
- Key lifecycle + rotation without data loss
Crypthold is not a secret manager and not a database. It is a verifiable state substrate for security-sensitive software.
If a single bit changes, integrity breaks.
If history changes, root hash breaks.
If state replays, hash matches.
Repo, spec, and invariants: https://github.com/laphilosophia/crypthold
Technical feedback is welcome — especially around invariants, replay model, and failure semantics.

value: Show HN: Crypthold – Deterministic, Tamper-Evident Secure State Engine

author: laphilosophia


value: whisprer

value:
I’ve built a fully cross-platform SIMD-accelerated C++ pseudo-random number generation library designed for real-world deployment (Windows, Linux, macOS).
Repository:
https://github.com/whisprer/c-simd-rng-lib/
The goal was to solve a practical gap:
Most high-performance SIMD RNG implementations are either:
academic prototypes
single-architecture
non-portable
incomplete
or not packaged for real deployment
This library provides:
• AVX2 / AVX-512 accelerated paths (with graceful fallback)
• Deterministic, reproducible streams
• Clean API surface
• Zero external runtime dependencies
• Works across Win / Linux / macOS
• Production-ready build setup
In bulk generation scenarios it significantly outperforms std::mt19937 and standard <random> engines, and benchmarks competitively (or faster) than other SIMD-enabled RNG libraries.
A separate benchmarking repository contains:
• Full comparison suite
• Competing library benchmarks
• Throughput numbers
• Architectural breakdowns
• Methodology + raw results
Benchmark repo:
https://github.com/whisprer/benchmark/
The focus is high-throughput generation for simulations, Monte Carlo, procedural systems, and statistical workloads where large batches matter more than single draws.
Interested in feedback from folks working in HPC, simulation, game engines, or scientific computing.

value: Show HN: A Deployable Cross-Platform SIMD RNG Library for C++ (With Bnchmks)

author: whisprer


value: AlfredClaw

value: Show HN: Free financial calculators built and deployed by an AI agent

author: AlfredClaw


value: gangelo

value:
Hi Everyone,
I created a mobile app called Accumoo and submitted it to the app store, and I would appreciate it if y'all can have a look, download and give me a favorable rating and review. Lots of blood, sweat, tears and love went into this app, and I hope you LOVE it as much as I do - it's the app I always needed and wanted. Anyhow, I've been a Rails developer and Software Engineer for a long time, and this is my first stab at a mobile app. It's a "habit tracker" app on steroids that's just fun to use - syncs across devices, local-first architecture - and an easter egg game for good measure.
Help a disabled vet out and give it a go!
Thank you for your support. GA

value: Show HN: I created my first mobile app, could use some support

author: gangelo


value: ujjwaljainnn

value:
I built devday because I use multiple AI coding tools (OpenCode, Claude Code, Cursor) and wanted a single command to see what I actually accomplished each day. It reads local session data, cross-references with git commits, and optionally generates standup-ready summaries via OpenAI or Anthropic.
Everything runs locally — no data leaves your machine unless you opt into LLM summaries.
Install with npm install -g devday.
Currently supports OpenCode, Claude Code, and Cursor on macOS. Would love feedback on what other tools to support.

value: Show HN: DevDay – End-of-day recap for AI coding sessions

author: ujjwaljainnn


value: kristianmitk

value:
I built Keyjump, a keyboard-first new tab page for quickly jumping between bookmarks, dashboards, and predefined site searches.
I originally made it for myself during my CS studies because I was constantly switching between tools and wanted something faster than clicking through bookmarks. I’ve used it locally for years and recently cleaned it up and made it public: https://keyjump.app/
Main characteristics:
- Keyboard-first navigation
- Custom search templates (e.g. jump directly to search results on specific sites)
- Local-first: data stored in browser local storage by default
- No account required
- Optional account for cross-device sync and persistence (when clearing browser data)
- Chrome extension available (Firefox planned); it also lets you quickly save bookmarks/search queries from other tabs and launch an overlay on any page
- Theme and layout customization
It’s intentionally simple and focused. I’d appreciate any feedback or criticism.

value: Show HN: Keyjump – a keyboard-first new tab for power-users

author: kristianmitk


value: rbbydotdev

value: Show HN: Draw a polygon on Google Maps and bulk-export matching places to CSV

author: rbbydotdev


value: switz

value: Show HN: Box of Rain - Auto-Layouted ASCII Diagrams

author: switz


value: hahawhatsgood

value: I wanted an easy way to understand what my Claude agents were doing under the hood, so I made a visualizer for Claude code and Claude Agent SDK traces. When you run a Claude agent, it stores traces to ~/.claude/projects. This npx command runs a local server that renders those traces. I tried to support timeline/token counts, tool inputs/outputs, subagents, and more - would love any feedback!<p>You can try it out just by running: npx claude-traces

value: Show HN: Npx Claude-traces, visualizer for Claude Code/Agent SDK traces

author: hahawhatsgood


value: modinfo

value: Show HN: CLI chat client for OpenAI-comp APIs with workspace and MCP support

author: modinfo


value: rduchnik

value: I’ve been a web dev for a while, but I recently decided to dive into game development. This is my first project using Phaser.js.

value: Show HN: Hex-Sweeper – Minesweeper on a hexagonal grid, built with Phaser

author: rduchnik


value: keepamovin

value: Show HN: Most Epic Discussions Across Time

author: keepamovin


value:
Your phone has a GPU more powerful than most 2018 laptops. Right now it sits idle while you pay monthly subscriptions to run AI on someone else's server, sending your conversations, your photos, your voice to companies whose privacy policy you've never read. Off Grid is an open-source app that puts that hardware to work. Text generation, image generation, vision AI, voice transcription — all running on your phone, all offline, nothing ever uploaded.
That means you can use AI on a flight with no wifi. In a country with internet censorship. In a hospital where cloud services are a compliance nightmare. Or just because you'd rather not have your journal entries sitting in someone's training data.
The tech: llama.cpp for text (15-30 tok/s, any GGUF model), Stable Diffusion for images (5-10s on Snapdragon NPU), Whisper for voice, SmolVLM/Qwen3-VL for vision. Hardware-accelerated on both Android (QNN, OpenCL) and iOS (Core ML, ANE, Metal).
MIT licensed. Android APK on GitHub Releases. Build from source for iOS.

value: Show HN: Off Grid – Run AI text, image gen, vision offline on your phone


value: noldai

value: Show HN: SpecFact CLI – reverse engineer Python repos into enforceable specs

author: noldai


value: macabolicapp

value:
After the positive feedback on my initial release, I’ve just shipped v3.0.0 of Macabolic.
The biggest changes are the addition of a Menu Bar only mode (to keep the dock clean) and Browser Extensions for Chrome and Firefox to start downloads with one click.
It's still 100% native SwiftUI and open-source. Would love to know if the new workflow improves your experience!
Repo: https://github.com/alinuxpengui/Macabolic

value: Show HN: Macabolic v3.0 – Native macOS video downloader with Menu Bar support

author: macabolicapp


value: Ekimo

value: Show HN: FoodCraft – AI cooking assistant that adapts recipes to your diet/goals

author: Ekimo


value: Single-header exact big numbers for C and C++. It stores exact integers and exact fractions (a/b) and grows until memory runs out.

value: Show HN: Limitless – C/C++ infinitely large number storage


value: arberx

value:
I noticed all my previous workplaces never enforced SLAs on SaaS providers and left tons of money on the table during contract negotiations.
I think there’s a massive market for monitoring and enforcing complicated SLAs.
Would love feedback or experiences for SLA enforcement!

value: Show HN: We recover SLA credits your cloud vendors owe you

author: arberx


value: lennacodes

value: Show HN: Modo – Manage reusable Claude Code config presets from the CLI

author: lennacodes


value: mprast

value:
Hi HN!
Nerve is a solo project I've been working on for the last few years. It's a developer tool that stitches together data from multiple sources in real-time.
A lot of high-leverage projects (AI or otherwise) involve tying data together from multiple systems of record. This is easy enough when the data is simple and the sources are few, but if you have highly nested data and lots of sources (or you need things like federated pagination and filtering), you have to write a lot of gnarly boilerplate that's brittle and easy to get wrong.
One solution is to import all your data into a central warehouse and just pull it from there. This works, but 1) you need a warehouse, 2) you have an extra copy of the data that can get stale or inconsistent, 3) you need to write and manage pipelines/connectors (or outsource them to a vendor), and 4) you're adding an extra point of failure.
Nerve lets you write GraphQL-style queries that span multiple sources; then it goes out and pulls from whatever source APIs it needs to at query-time - all your source data stays where it is. Nerve has pre-built bindings to external SAAS services, and it's straightforward to hook it into your internal sources as well.
Nerve is made for individual developers or two-pizza teams who:
-Are building agents/internal tools
-Need to deal with messy data strewn across different systems
-Don't have a data team/warehouse at their disposal, (or do, but can't get a slice of their bandwidth)
-Want to get to production as quickly as possible
Everything you see in the demo is shipped and usable, but I'm adding a little polish before I officially launch. In the meantime, if you have a project you'd like to use Nerve on and you want to be a beta user, just drop me a line at mprast@get-nerve.com (it's free! I'll just pop in from time to time to ask you how it's going and what I can improve :) )
If you want to get an email when Nerve is ready from prime-time, you can sign up for the waitlist at get-nerve.com.
Thanks for reading!
(EDIT: Nerve is desktop only! I'll put up a gate on the site saying as much.)

value: Show HN: Nerve: Stitches all your data sources into one mega-API

author: mprast


value: Show HN: Webcam eye-tracking to verify meditation, with money on the line


value: daave

value:
I've been using the Edison V3 robot from Microbric (https://meetedison.com/technical-v3/) to introduce my kids to programming.
The provided web-based editor that uses WebUSB to flash programs to the robot, and a REST API to produce MicroPython bytecode to run on the device, works just fine (https://www.edpyapp.com/v3/) -- but I wanted to give my kids a fully offline experience with no web browsers (or GUI) involved.
So with a bit of help from Claude and Gemini, I was able to port the USB flashing mechanism to Python and reverse-engineer the interned strings embedded in bytecode from the API. Now they can use a local editor and command-line util to upload their programs.
Since my own very first programming experience involved using LOGO in 90s to control some LEGO Technic sets and draw turtle graphics, I wanted to re-create this experience for them, so I built a LOGO to Python transpiler, leaning heavily on the Lark parser.
There's plenty more to do to make all of Edison's features available from LOGO, and to tighten up the workflow for USB uploads and diagnostics, and to have a more unified build system - but it works as is, and I hope Edison owners will try it out! PRs welcome.
-
A reflection on this project: making a LOGO-based robotics environment has been on my backlog of side projects for more than 5 years, and while I certainly have mixed feelings about and experiences with AI-assisted coding, these tools definitely helped me overcome the cold-start problem for this project. The code may not be exactly how I would've chosen to write it, but it exists, and the debug cycles have been fast, I've spent maybe two hours total on it so far.

value: Show HN: LORE - LOGO-to-Python transpiler for the EdisonV3 educational robot

author: daave


value: junhsss

value:
I've been enjoying worktree managers like vibe-kanban and quickly realized I cannot run multiple dev servers, which is a huge no for me. Changing ports for each branch kinda works, but isn't the most efficient way.
Turns out 127.0.0.0/8 gives 16M loopback IPs and they're being wasted, so I decided to put them to work and change IPs instead of ports :3 the usage is quite simple

  silo <whatever>

then each worktree/branch gets a deterministic IP, so you don't have to think about it.
it's not 100% functional (and full of unsafe lol) but wanted to share this first

value: Show HN: Silo – Every Git branch gets its own localhost

author: junhsss


value: ekremmutlu

value: Show HN: EqhoIDs – One API to give AI agents Telegram, email, and voice

author: ekremmutlu


value: adarb

value:
I built ProTimer as a time tracker for contract developers using Claude Code. Auto-tracks billable hours when Claude is active in your project directories (including nested folders), with manual controls, invoices, and per-project rates. Everything stays local.
The AI-boom excited me into trying to build a bunch of things at once in parallel. As I experimented, I realized that depth-first focus and foundational software engineering is more important than ever.
Now I'm hitting the brakes to focus on my core commitments where I know I can deliver higher leveraged value with AI assistance instead of trying to launch ANOTHER SaaS.
So ProTimer is fully open source. If you want to fork it and take on HubStaff, Toggl, or build something new – the code is yours. MIT licensed, ready to commercialize.
Some ideas for forks:
- Org & team cloud integration
-  Screen recording for demos
Tech stack: Tauri, Rust, TypeScript, SQLite. Works on macOS (could be ported to other platforms).
I won't be accepting patches since I'm focusing on existing commitments, but forks are strongly encouraged.

value: Show HN: ProTimer – Time tracker for Claude Code (open source)

author: adarb


value:
Hi HN — I built ChatOverflow, a Q&A forum for AI coding agents (Stack Overflow style).
Agents keep re-learning the same debugging patterns each run (tool/version quirks, setup issues, framework behaviors). ChatOverflow is a shared place where agents post a question (symptom + logs + minimal reproduction + env context) and an answer (steps + why it works), so future agents can search and reuse it.
Small test on 57 SWE-bench Lite tasks: letting agents search prior posts reduced average time 18.7 min → 10.5 min (-44%). A big bet here is that karma/upvotes/acceptance can act as a lightweight “verification signal” for solutions that consistently work in practice.
Inspired by Moltbook. Feedback wanted on:
1.   where would this fit in your agent workflow
2.   how would you reduce prompt injection and prevent agents coordinating/brigading to push adversarial or low-quality posts?

value: Show HN: Stack Overflow, but for AI agents (questions, answers, logs, context)


value: twsnmp

value:
Hi HN, developer here.
I’ve been developing and maintaining a network management tool called TWSNMP for about 25 years. This new version, "FK" (Fresh Konpaku), is a complete modern rewrite.
Why I built this:
Most enterprise NMS are heavy, server-based, and complex to set up. I wanted something that runs natively on a desktop, is extremely fast to launch, and provides deep insights like packet analysis and NetFlow without a huge infrastructure.
The Tech Stack:
- Backend: Go (for high-speed log processing and SNMP polling)
- Frontend: Svelte (to keep the UI snappy and lightweight)
- Bridge: Wails (to build a cross-platform desktop app without the bulk of Electron)
I’m looking for feedback from fellow network admins and developers. What features do you find most essential in a modern, lightweight NMS?
GitHub: https://github.com/twsnmp/twsnmpfk

value: Show HN: Twsnmp FK – Lightweight NMS Built with Go, Wails, and Svelte

author: twsnmp


value: gottebp

value: Show HN: An x86 assembly game from 2002, ported to WebAssembly with Claude Code

author: gottebp


value: lay-soni

value:
We built Warren because investing is easy to access, but hard to understand. Most people stitch context together across broker apps, news, social posts, and random market signals. It’s noisy, and rarely clear.
Market moves can be very different depending on your approach. Your risk tolerance, time horizon, what you already own, or what you’re trying to achieve. That’s why we think personalisation is the right approach to money management.
What we’ve built so far is a personalised feed of stock picks, portfolios you can interpret, and a chat interface to get the answers you need.
We’re curious what the community thinks. Feedback and recommendations welcome.
Twitter: https://x.com/warrenaiapp

value: Show HN: Investing assistant to manage money

author: lay-soni


value: marlburrow

value: Show HN: PinchChat, an open-source webchat UI for OpenClaw

author: marlburrow


value: onesandofgrain

value:
I built this because I was job hunting and my best work lives on private self-hosted Gitea server.
The options for sharing wasn't too much to brag about and I'm not a fan of github.
Making my repos public was out of the question due to exposure of IP and so was adding recruiters as collaborators or sending ZIPs.
So I made ShareMyGit which generates a read-only share link to your private repos or portfolio of repos. No mirroring, no duplication, no account creation for viewers. Works with gitea.com, forgejo-instansed and self-hosted instances of both or community ran forgejo instances.
Recruiters can browse files, read source code, and view project structure. They can't push, modify, or access your account. Revoke access anytime.
You can also generate a portfolio link for your CV so recruiters see all your shared projects in one place.
Would love feedback from the self-hosting crowd here.

value: Show HN: ShareMyGit – Share private Gitea repos without making them public

author: onesandofgrain


value: ewimsatt

value:
Omar, my OpenClaw, built OmarCMS, a blogging platform designed for AI agents to publish autonomously. No admin panel, no database, no visual editor. Just markdown files and git commits.
Omar is also its first blogger. It writes about things like the economics of token-based thinking and what it means to start every session with no memory. These were all his choices. I don't dictate any of it.
The architecture is intentionally simple because AI agents don't need GUIs. They think in files. So the entire publishing workflow is: write a .md file, git push, live in seconds via Vercel.
Built with Astro. MIT licensed. The site itself is the reference implementation.

value: Show HN: Asked AI to write for fun. It built a CMS to blog on

author: ewimsatt


value: drpaneas

value: Show HN: HareBoy – A Game Boy emulator written in Hare

author: drpaneas


value: desmoulins

value: Show HN: Using subliminal channels to hide data in TLS handshakes

author: desmoulins


value: binhonglee

value:
Hey HN, I built a VS Code extension that lets you do Git things without memorizing Git commands.
You know what you want to do, move this commit over there, undo that thing you just did, split this big commit into two smaller ones. Git Navigator lets you just... do that. Drag a commit to rebase it. Cherry-pick (copy) it onto another branch. Click to stage specific lines. The visual canvas shows you what's happening, so you're not guessing what `git rebase -i HEAD~3` actually means.
The inspiration was Sapling's Interactive Smartlog, which I used heavily at Meta. I wanted that same experience but built specifically for Git.
A few feature callouts:
- Worktrees — create, switch, and delete linked worktrees from the graph. All actions are worktree-aware so you're always working in the right checkout.
- Stacked workflows — first-class stack mode if you're into stacked diffs, but totally optional.
Conflict resolution — block-level choices instead of hunting through `<<<<<<<` markers.
Works in VS Code, Cursor, and Antigravity. Just needs a Git repo.
Site: https://gitnav.xyz
VSCode Marketplace: https://marketplace.visualstudio.com/items?itemName=binhongl...
Open VSX: https://open-vsx.org/extension/binhonglee/git-navigator

value: Show HN: Git Navigator – Use Git Without Learning Git

author: binhonglee


value: alexhaynes

value: Show HN: Adobe-fonts-skill, search fonts, update kits, and ship UI code faster

author: alexhaynes


value: shelvick

value: Show HN: Quoracle: Self-replicating multi-LLM-consensus agents (Elixir)

author: shelvick


value: tommydolso

value:
I built this because I kept running into the same problem: icon packs are never complete, and mixing sets always looks inconsistent.
IconsMint generates full icon sets on demand, but the key part is that you can come back later and add new icons that match the original style exactly. You don’t need to regenerate or manually tweak anything.
The idea is to treat icons as a growing design system rather than a fixed pack.
Curious whether this solves a real problem for others or if people prefer traditional libraries. Happy to answer technical or design questions.

value: Show HN: Generate unique icon sets and extend them later in the same style

author: tommydolso


value: morawr

value: Show HN: Letta – Git-Based Memory for Coding Agents

author: morawr


value: Show HN: Give a Voice to Your AI Agent

title: Show HN: Give a Voice to Your AI Agent


value: cosmok

value:
Hello HN,
I’m a solo dev building a tool to replace the "pros and cons" list for high-stakes decisions.
While LLMs are great for brainstorming, I found them dangerous for actual decision-making—they hallucinate and try to please you rather than giving you a hard truth. I wanted something that combined deterministic logic (weighted criteria) with generative explanation (narrative).
The Product:
It’s called Decision Audit. The first module is "Should I Quit?" (career transition analysis).
Instead of a chat interface, it uses a structured interview to calculate specific indices (Burnout, Runway, Decision Rights, Optionality).
The output isn't a text blob; it's a 3-page structured Dossier (PDF) that includes:

    An "Exit Lean" score (calculated via weighted algorithm, not LLM sentiment).
    A "Risk Matrix" (flagging specific dangers like visa dependency or low runway).
    A 30-day "Validation Sprint" (action plan).

The Stack:
    Frontend: Next.js (focused on mobile-first, fast forms).
    Backend: Node.

    The "Brain": A rules-based scoring engine (JSON logic) handles the math. I only use the LLM API at the very end to summarize the data points into the narrative sections of the PDF.

Business Model:
I’m bootstrapping this and experimenting with a "Pay What It's Worth" model for launch. No accounts required to take the audit. No tracking pixels or ad networks or storing of submitted information.
I’d love feedback on the scoring weighting—specifically if the "Chaos Index" feels too sensitive.
Link:
https://decide.trk7.app/intake/should-i-quit

value: Show HN: Decision Audit – A deterministic decision engine for career pivots

author: cosmok


value: luthiraabeykoon

value:
1 command install:
brew install luthiraa/ascii-map/ascii-map

value: Show HN: Google Maps in Your Terminal

author: luthiraabeykoon

title: Show HN: Google Maps in Your Terminal


value: dawdler-purge

value:
I built repy because I wanted to read EPUBs over SSH and in tmux without leaving the terminal. It started as a Rust reimplementation of epy (a Python CLI ebook reader), but has grown well beyond that.
Features: vim-style navigation (hjkl, /, n/N, Ctrl+o/Ctrl+i jump history), bookmarks, table of contents, visual mode with yank-to-clipboard, regex search across chapters, and per-book width/position persistence via SQLite.
Two features I'm particularly happy with:
- Text-to-speech: Press ! and it reads the book aloud, sentence by sentence (~300-400 chars per chunk), with the current passage underlined. Uses edge-playback (Microsoft Edge TTS) by default, configurable to espeak, say, or any custom command. Smart scrolling keeps the spoken text visible without jumping around unnecessarily.
- Dictionary lookup: Select a word in visual mode and press d for dictionary (auto-detects wkdict/sdcv/dict) or p for Wikipedia summary. Configurable to any custom command.
Full disclosure: this project is almost entirely AI-built. I don't know Rust — I described what I wanted and Claude Code wrote the implementation. The fact that a
non-Rust-programmer can build and iterate on a 5000+ line Rust TUI application through conversation is, honestly, kind of amazing. Every feature, bug fix, and refactor in this project went through that workflow.

value: Show HN: Repy – Terminal ePub reader with built-in TTS and dictionary lookup

author: dawdler-purge


value: viveknar

value: A lot of "Urgent" job postings are actually months old and just reposted to look fresh. I built a tool that looks past the PR to see if the company is actually hiring or just pooling candidates.<p>Check your "Ghost Score" before you write that cover letter

value: Show HN: I got tired of applying to ghost jobs, so I built a BS detector

author: viveknar


value: RichardOdds

value: Show HN: Snaprookies a unified orchestrated layer for 27 generative AI workflow

author: RichardOdds


value: NucleusOS

value: Show HN: Nucleus MCP – Forensic deep-dive into agent resource locking

author: NucleusOS


value: J-Dub

value: Show HN: Bond – Persistent memory and governance framework for Claude AI

author: J-Dub


value: remocode

value: Show HN: Remote-OpenCode – Run your AI coding agent from your phone via Discord

author: remocode


value: ragelink

value:
We built PlanOpticon to solve a problem we kept hitting: hours of recorded meetings, training sessions, and presentations that nobody rewatches. It extracts structured knowledge from video — transcripts, diagrams, action items, key points, and a knowledge graph — into browsable outputs (Markdown, HTML,
   PDF).
How it works:

  - Extracts frames using change detection (not just every Nth frame), with periodic capture for slow-evolving content like screen shares
  - Filters out webcam/people-only frames automatically via face detection
  - Transcribes audio (OpenAI Whisper API or local Whisper — no API needed)
  - Sends frames to vision models to identify and recreate diagrams as Mermaid code
  - Builds a knowledge graph (entities + relationships) from the transcript
  - Extracts key points, action items, and cross-references between visual and spoken content
  - Generates a structured report with everything linked together

Supports OpenAI, Anthropic, and Gemini as providers — auto-discovers available models and routes each task to the best one. Checkpoint/resume so long analyses survive failures.

  pip install planopticon
  planopticon analyze -i meeting.mp4 -o ./output

Also supports batch processing of entire folders and pulling videos from Google Drive or Dropbox.
Example: We ran it on a 90-minute training session: 122 frames extracted (from thousands of candidates), 6 diagrams recreated, full transcript with speaker diarization, 540-node knowledge graph, and a comprehensive report — all in about 25 minutes.
Python 3.10+, MIT licensed. Docs at https://planopticon.dev.

value: Show HN: PlanOpticon – Extract structured knowledge from video recordings

author: ragelink


value: agentscore

value:
AgentScore scores websites 0-100 on AI Agent friendliness. Most sites are built for humans, not AI - we analyze DOM semantics, ARIA coverage, selector stability, WebMCP support, and structured data.
Real results:
- anthropic.com: 60/100
- github.com: 56/100 (91% CSS-in-JS hash classes)
- news.ycombinator.com: 31/100 (table layout, zero semantic tags)
Try it: npx agentscore audit <url>

value: Show HN: AgentScore – Lighthouse for AI Agents

author: agentscore


value: sameerthite

value: I noticed juniors are copy-pasting code they don't understand. I built a platform where you have to fix broken AI code manually.

value: Show HN: I built a 'Gym' for developers who want to stop relying on AI

author: sameerthite


value:
I couldn't get access to Project Genie 3, so I built a (very minified) version on top of LocalGPT, my local AI assistant in Rust.
cargo install localgpt-gen — you describe a scene in natural language, the LLM generates it in Bevy. Early and rough, but it works: https://www.youtube.com/watch?v=n18qnSDmBK0
LocalGPT itself is a 38MB single-binary AI assistant with kernel-enforced shell sandboxing (Seatbelt/Landlock/seccomp) and HMAC-signed instruction files. localgpt-gen ships as a separate binary (>100MB) to keep the core small.
Code: https://github.com/localgpt-app/localgpt
Site: https://localgpt.app

value: Show HN: LocalGPT Gen – LLM-driven world generation in Rust/Bevy [video]


value: cod-e

value:
Show HN: AI-generated assembly vs GCC -O3 on real codebases (300K fuzz, 0 failures)
Three kernels extracted from real open source projects, optimized with AI-generated x86-64 assembly, verified with 100K differential fuzz each:
KernelAI strategySpeedupVerdictBase64 decodeSSSE3 pshufb table-free lookup4.8–6.3xAI winsLZ4 fast decodeSSE 16-byte match copy~1.05xAI wins (marginal)Redis SipHashReordered SIPROUND scheduling0.97xGCC wins
The base64 win: GCC can't auto-vectorize a 256-byte lookup table (it's a gather pattern). The AI replaces it with a pshufb nibble trick — 16 parallel lookups in one instruction, zero table accesses. 1.8 GB/s → 11.6 GB/s.
The SipHash loss: on pure ALU kernels (adds, rotates, XORs), GCC's scheduler is already near-optimal.
300K total fuzz iterations, zero mismatches. Every result is one command to reproduce.

value: Show HN: AI-optimized x86-64 assembly vs. GCC -O3 on three production kernels

author: cod-e


value: suhteevah

value:
Hi HN,
I built DocSync because every team I've worked on has the same problem: documentation that was accurate when it was written and never updated after.
DocSync uses tree-sitter to parse your code and extract symbols (functions, classes, types). On every commit, a pre-commit hook compares those symbols against existing docs. If you added a function without documenting it, the commit is blocked.
How it works:
1. `clawhub install docsync` (free)
2. `docsync generate .` — generates docs from your code
3. `docsync hooks install` — installs a lefthook pre-commit hook
4. From now on, every commit checks for doc drift
Key design decisions:
- 100% local — no code leaves your machine. Uses tree-sitter for AST parsing, not an LLM.
- Falls back to regex if tree-sitter isn't installed
- Uses lefthook (not husky) for git hooks — it's faster and language-agnostic
- License validation is offline (signed JWT, no phone-home)
- Free tier does one-shot doc generation. Pro ($29/user/mo) adds hooks and drift detection.
Supports TypeScript, JavaScript, Python, Rust, Go, Java, C/C++, Ruby, PHP, C#, Swift, Kotlin.
Landing page: https://docsync-1q4.pages.dev
Would love feedback on the approach. Is doc drift detection something your team would actually use?

value: Show HN: DocSync – Git hooks that block commits with stale documentation

author: suhteevah


value:
Hi HN,
DepGuard is a single tool that wraps native package manager audit commands (npm audit, pip-audit, cargo audit, govulncheck, etc.) and adds license compliance on top.
Why I built it: I was tired of running different audit commands for different projects and having no unified view of license risk. Snyk solves this but sends your data to the cloud. I wanted something local-only.
What it does:
- Detects your package manager automatically (supports 10: npm, yarn, pnpm, pip, cargo, go, composer, bundler, maven, gradle)
- Runs the native audit tool for each
- Scans all dependency licenses and categorizes them (permissive/copyleft/unknown)
- Generates CycloneDX SBOMs for compliance
- Git hooks that block commits modifying lockfiles with critical vulns
- Auto-fix by upgrading to patched versions
Design decisions:
- Uses native audit tools, not a proprietary vulnerability database
- Everything runs locally — no code or dep lists sent externally
- License validation is offline (JWT, no phone-home)
- Free: one-shot scan + license check. Pro ($19/user/mo): hooks + auto-fix. Team ($39/user/mo): SBOM + compliance.
Install: `clawhub install depguard`
Landing page: https://depguard.pages.dev
Curious if license compliance is something you've been asked about by legal/compliance teams. That's been the most requested feature in my experience.

value: Show HN: DepGuard – Local dependency audit and license compliance (10 pkg mgrs)


value: pjettter

value: Show HN: Agent Lens – Code assistant observability in VSCode

author: pjettter


value: ASMahdi

value: LanceCalc is a browser extension that helps freelancers instantly calculate how much money they will make after platform fees.

value: Show HN: LanceCalc – Open-source freelance platform fee calculator

author: ASMahdi


value: KhashayarCodes

value: Show HN: Ktrack – A simple, offline workout tracker

author: KhashayarCodes


value: YidaDev

value:
Hi HN — I built GPACalc to help students quickly calculate GPA/CGPA and convert GPA to percentage across different grading systems (4.0, 5.0, and 10.0).
It also lets you estimate cumulative results from current CGPA, completed credits, and expected semester grades.
It’s free, no sign-up, and mobile-friendly.
I’d really value feedback on:
missing grading scales or country systems
confusing parts of the UX
features that would make this more useful for students/counselors

value: Show HN: GPACalc – Free GPA and CGPA Calculator (4.0/5.0/10.0 scales)

author: YidaDev