value: BSanroma

value:
I built this because I was tired of SSH'ing from mobile or carrying laptop to cafes
just to check logs. Nexus runs as a daemon on localhost, creates a private Telegram
bot that only responds to your OWNER_ID, and executes commands locally.
Key tech decisions:
- BYOK (Bring Your Own Key): You provide Gemini API key + create your own bot.
  My operational cost per user = $0
- 3-tier security: Blocked patterns (rm -rf /), dangerous patterns (require
  confirmation), safe patterns (execute immediately)
- Rate limiting: 100 cmd/hour + 2s cooldown + 60s confirmation expiry
- Local-first: Code never leaves your machine
$3 lifetime for first 1,000 users. Built with Node.js. Cross-platform binaries.
Demo: https://remote-nexus.dev
GitHub (public docs): https://github.com/BSanroma/nexus-ai-public
Happy to answer questions about the security model or architecture.

value: Show HN: Nexus AI – DevOps terminal bridge to Telegram (local-first, BYOK)

author: BSanroma


value: rebelytics

value: Show HN: A Claude meta-skill that improves all your skills, including itself

author: rebelytics


value: Show HN: MCP server that gives AI agents real interactive terminal sessions


value: willholt

value:
I built this to make it easier to create collaborative design tools like infinite canvases. It also works for games.
It's an ECS framework that runs in the browser with built-in multithreading via Web Workers, reactive change-tracking queries, and a companion package called “canvas-store” that handles multiplayer sync, local-first persistence, undo/redo, and schema migrations out of the box.
GitHub: https://github.com/WillH0lt/woven-ecs

value: Show HN: Woven-ECS – Multithreaded ECS framework for the web

author: willholt


value: muriithiKabogo

value:
While working on new startup ideas, I realized I was often assuming problems existed without actually seeing how people described them in the wild.
So I built a small tool that lets you describe a startup idea and then surfaces real conversations where people discuss that problem.
It’s meant to help with early problem discovery before building an MVP.
Faster access to real signals. Feedback is highly welcome, as brutal as it can be.

value: Show HN: Idea validation using real problem discussions

author: muriithiKabogo


value:
Hey HN,
I’m a dev and a dad to a 10-year-old. I built this because I caught my daughter using ChatGPT to do her history homework. She wasn't learning; she was just acting as a "middleware" between the AI and the paper.
The Backstory: I realized the problem isn't the AI—it's the zero-friction answers. Most "AI for kids" apps are just "parrots"—they mimic intelligence by repeating patterns.
What’s Different: Qurio is a "Bicycle" for the mind. It treats the child like a future "Architect" rather than a "Junior Executor." Technically, it wraps an LLM in a strict "Socratic Loop." It detects intent to "cheat," refuses the direct answer, and generates a leading question based on the user's current logic level. It forces "Healthy Friction" back into the learning process.
The stack: Next.js 14, Supabase (Auth/DB), Vercel AI SDK.
Mods: I've added the backstory and differentiator as requested. Ready for the re-up! Thank you.

value: Show HN: I built a "Socratic" AI to stop my daughter from copy-pasting homework


value: afonsoduarte

value:
I built AI Usage Tracker, an iOS app that warns you before AI subscription limits cut you off mid-session (e.g. 5-hour windows, weekly caps).
I hit this daily while coding: I’d be deep in a session and suddenly hit the cap. Dashboards exist, but they’re not glanceable and there are no practical alerts/widgets.
Supports multiple providers in a single screen - Anthropic, OpenAI, MiniMax, Z.ai, Kimi, Codex
Features:
- 5-hour window + weekly status (simple gauges). Makes easy to plan your workload across providers
- reset countdown timers
- Home Screen + Lock Screen widgets
- configurable alerts (e.g. 75%, 90%)
- multi-provider tracking
Privacy / how it works:
- no accounts, no analytics, no servers; everything runs on-device
- API-key providers: paste an API key (stored in iOS Keychain)
- dashboard-only providers: sign in via an embedded web view OR paste an existing session token; the app reads the same usage info shown in the provider dashboard
- connectors may break if dashboards/endpoints change
Not a bypass — it only provides status + alerts so you can plan sessions.
I’d love feedback on:
- which thresholds are actually useful
- % remaining vs time remaining
- security/UX tradeoffs: embedded login vs session-token paste

value: Show HN: Multi-provider iOS usage alerts for AI subscription caps

author: afonsoduarte


value: Show HN: Open-source, SDK-first email infrastructure built for agents


value: WayneCider

value: Show HN: YOPJ – Local AI coding agent with 8-layer security sandbox (no cloud)

author: WayneCider


value: justvugg

value:
I built PolyClaw, an OpenClaw-inspired autonomous agent for the PolyMCP ecosystem.
PolyClaw doesn’t just call tools.
It plans, executes, adapts — and creates MCP servers when needed.
It’s designed for real multi-step, production workflows where agents must orchestrate tools, spin up infrastructure, recover from errors, and deliver complete results end-to-end.
⸻
What PolyClaw Does
 • Plans complex multi-step tasks
 • Executes and orchestrates MCP tools dynamically
 • Adapts when steps fail or context changes
 • Creates and connects MCP servers on the fly
 • Runs Docker-first for safety and isolation
 • Built with Python and TypeScript
PolyClaw is not just a tool caller — it’s an infrastructure-aware agent.
⸻
Run PolyClaw with Ollama
You can launch PolyClaw directly from the PolyMCP CLI:
polymcp agent run \
  --type polyclaw \
  --query "Build a sales reporting pipeline and test it end-to-end" \
  --model minimax-m2.5:cloud \
  --verbose
What happens behind the scenes:
 1. The agent decomposes the task.
 2. It determines which MCP tools are required.
 3. It spins up or connects to MCP servers.
 4. It executes steps in sequence (or parallel when needed).
 5. It validates outputs.
 6. It adapts if something fails.
 7. It returns a complete result.
All containerized. All isolated.
⸻
Why This Matters
Most AI agents:
 • Call tools statically
 • Assume infrastructure already exists
 • Break on multi-step failure
PolyClaw:
 • Builds the infrastructure it needs
 • Orchestrates across multiple MCP servers
 • Handles retries and adaptive planning
 • Is safe to run in Dockerized environments
This makes it viable for:
 • Enterprise workflows
 • DevOps automation
 • Data pipelines
 • Internal tooling orchestration
 • Complex multi-tool reasoning tasks
PolyClaw turns PolyMCP from simple tool exposure only with Polyagent e unifiendpolyagent or codeagent but turn into full autonomous orchestration agent too.
Repo:
https://github.com/poly-mcp/PolyMCP
Happy to answer questions,

value: Show HN: PolyClaw – An Autonomous Docker-First MCP Agent for PolyMCP

author: justvugg


value:
I realized something uncomfortable about my life.
We’ve moved most of our lives online, like for banking, investments, subscriptions, crypto, cloud storage, etc. But what if someone needed to step in and manage any of it during a crisis? Not just access but clear instructions.
So I built a tool for myself.
A secure way to document digital accounts so the people I trust know exactly what to do if they ever need to. It only gives them access when it's actually needed. Until then, everything stays encrypted and invisible.
Turns out I'm not the only one with this thought. So I turned it into Lineage: keeplineage.com

value: Show HN: I built a way for my family to access my accounts in an emergency


value: ab-abg

value:
We just released a major update to Sentinel Core, our open-source AI-powered video intelligence engine.
The new release includes a real-time multi-camera dashboard, semantic video search, and an upgraded detection pipeline.
Sentinel Core is built around an AI-native architecture:
- YOLOv8 for real-time object detection
- CLIP for semantic search (text-to-video queries)
- FAISS for vector indexing
- FastAPI backend with WebSocket streaming
- Fully air-gapped deployment capable
You can now:
- Stream multiple RTSP/IP camera feeds in a live grid view
- Search footage using natural language (e.g. “blue car near gate between 2-5pm”)
- Perform cross-camera semantic retrieval
- Configure zone-based alerts
- Run everything locally without cloud dependency
We designed this as a foundational engine for modern surveillance and physical AI systems.
Would appreciate feedback on:
- Architecture decisions
- Performance optimizations
- Semantic search accuracy
- Deployment improvements
Happy to answer technical questions.

value: Show HN: Sentinel Core – Open-source AI video search with real-time dashboard

author: ab-abg


value: turth

value: I like to use org files a lot, but I wanted some way to browse and edit them on my phone when I'm out. Yesterday I used Codex to make this simple one-file web server that just displays all my org files with backlinks. It doesn't have any authentication because I only run it on my wireguard VPN. I've been having fun with it, hopefully it's useful to someone else!

value: Show HN: Simple org-mode web adapter

author: turth

title: Show HN: Simple org-mode web adapter


value: shrink

value:
Inspired by the Million Dollar Homepage, this is the Million Dollar Chat. People fill the chat's one million character brain, one character at a time. The Million Dollar Homepage of the AI age.
My initial design used one million tokens but I quickly discovered that tokens are not made equal which made it very difficult to reason about. Eventually, I settled on one million characters.
The chat has a few different capabilities, for example, you can ask it to navigate to a position for you (e.g: "jump to the final character") and it can search within the context. I have more things to add, like the ability to play music from the songs included in its context.
Other visitor's cursors can be seen in real-time when they are adding to the chat's brain.
Despite the fact that this is an AI project, I built it by hand. I tried out Claude Code and Codex but neither produced code I was happy with.
The current model is openai/gpt-4.1-nano. I figure, people paying to add characters will subsidise chatter's free access to the model.

value: Show HN: Million Dollar Chat

author: shrink

title: Show HN: Million Dollar Chat


value: jainamankumar

value:
Hi HN,
I built Kuberoku, a CLI that aims to bring a Heroku style workflow to vanilla Kubernetes.
I’ve used Heroku for years and still think the apps / deploy / logs / run DX is hard to beat. On the other hand, I like Kubernetes, but I don’t love how much of the day-to-day workflow becomes YAML and glue.
Right now, Kuberoku is still early, but kuberoku deploy works and handles the basic deployment workflow (build + apply + rollout) via Kubernetes primitives.
How it works:
Kuberoku is written in Python and interacts directly with the K8s API. It doesn't require a heavy server-side operator; it uses native Kubernetes primitives to handle the build-apply-rollout loop.
I’m currently working on:
- a git push-style workflow
- RBAC / multi-tenant safety so it’s usable by teams
I’d love feedback from K8s/platform folks on:
What’s the first edge case you’d try to break in a tool like this?

value: Show HN: Kuberoku, A CLI to treat vanilla Kubernetes like Heroku

author: jainamankumar


value: otmardev

value:
My 10-year-old son and I were building a Roblox game together. AI wrote the Lua code, generated concept art. But when we needed 3D models for the game, there was nothing usable.
AI can write code, generate images, compose music, make videos. But 3D? There's no "Midjourney for meshes" yet. So I built one.
The tech: TripoSR (open source by Stability AI + Tripo) deployed on a HuggingFace Space with a shared H200 GPU, wrapped in a Gradio web app. Upload any photo, it removes the background, runs the image through a vision transformer, predicts a 3D density grid, extracts the mesh via marching cubes, and gives you a downloadable .obj or .glb in under 5 seconds.
What works well: objects with clean silhouettes on contrasting backgrounds. A green Hot Wheels on a white surface came out great. A grey truck on grey carpet, not so much.
What it's NOT: this isn't replacing Blender or ZBrush. Vertex-colored meshes, no UV-mapped textures (that needs 16GB+ VRAM for baking). 256 marching cubes grid resolution. But for quick prototyping, reference meshes, or game jam assets, it gets the job done.
Stack: Python, Gradio, PyTorch, HuggingFace Spaces (ZeroGPU).
Live at https://meshcraft.xyz - beta access is $9.97/mo (unlimited generations). Happy to answer technical questions.
Solo dev, 20+ years experience. Idea to deployed product in about 48 hours.

value: Show HN: Meshcraft – Turn any photo into a 3D model in seconds

author: otmardev


value: mdukefirst

value:
I’m a senior technologist who spent 20 days building a way to kill the "initial phone screen" human-captcha.
Most AI resume tools are just wrappers. I wanted something that actually built trust, so I built a verification engine. When you train your Representative on your history, you attest to specific skills and dates.
When the AI talks to a recruiter, it uses a custom renderer to "stamp" verified claims with a shield badge in real-time. If the AI says I have 10 years of experience in Postgres, it's not a hallucination; it's a data-backed claim tied to my account attestation.
It also handles "Identity Gating"—recruiters have to verify via LinkedIn before they can grab your PDF resume or personal contact info.
Tech: Next.js 16, Supabase (with PG Vector), and Vercel AI SDK.
I'd love a technical roast of:
The verification UX: is self-attestation with a timestamp enough for you to trust a candidate?
The "Representative" concept vs. a traditional static portfolio.
Security of the LinkedIn gate.
I’ll be checking in all day to answer questions.

value: Show HN: Represent Me – AI proxy for job seekers with inline fact-verification

author: mdukefirst


value: andreabergonzi

value:
Hi HN,
I just published a manifesto arguing that Chatbots are a transitional phase and "Silence" is the future of interface.
It covers the "Synthetic Subconscious," the death of the App, and the ethics of the "Surveillance Bargain."
Read it here: https://postinterface.design
(PDF available on site)
Would love your feedback on the "Serendipity Deficit" concept.

value: Show HN: Post-Interface Design – A manifesto on the abolition of UI

author: andreabergonzi


value: gigachadai

value: Star the report if you wanna support and feedbacks and suggestions are most welcome guys

value: Show HN: An beautiful webpage I made

author: gigachadai

title: Show HN: An beautiful webpage I made


value: vseplet

value: A hackable AI agent framework for Telegram. ~4K lines of TypeScript, 6 LLM providers, 16 tools, full agent loop with memory

value: Show HN: Hackable Skinny Clawdbot for Telegram

author: vseplet


value: MCP server + embedded terminal that gives Claude Code direct access to ComfyUI's workflow graph. It can search available nodes, create/connect/delete them, set values, run the queue, and see image outputs. The workflow is basically a JSON DAG, so each edit maps cleanly to a tool call.

value: Show HN: Comfy Pilot – MCP server that lets Claude Code edit ComfyUI workflows


value:
I built a tool that scans AI platforms with buyer questions relevant to your domain and shows you whether they mention you or not.
Enter your domain, it generates queries based on your space, sends them to ChatGPT, Perplexity, and Google AI, then scores you out of 100 based on how often you show up in the responses.
The part I think is actually useful: it doesn't just tell you the problem. It shows you which queries you're missing from, why, and gives you fix pages (structured content designed to be citable by LLMs) and weekly action plans.
Free scan on the homepage, no signup needed.
Tech: Next.js, Supabase, OpenAI API, Perplexity API, Google AI API.
https://www.cabbageseo.com

value: Show HN: CabbageSEO: Check if AI mentions your business, then fix it if not


value: sanghoonio

value: Show HN: East Asia AQI/wind vector map

author: sanghoonio

title: Show HN: East Asia AQI/wind vector map


value:
Hey all, I built an open-source tool that lets you give an Android phone a goal in plain English. It reads the accessibility tree, sends the UI state to an LLM, executes actions via ADB, and loops until the task is done.
The core loop: dump accessibility tree via uiautomator → parse and filter to ~40 relevant elements → LLM returns {think, plan, action} → execute via ADB → repeat.
Some technical decisions worth noting:
- Primary input is the accessibility tree, not vision. Vision (screenshots + multimodal model) is only a fallback for when the tree is empty (WebViews, Flutter).
- Stuck detection: if the screen state doesn't change for 3 steps, recovery kicks in with back navigation, home, or app re-launch.
- Two execution modes: AI-powered workflows (JSON, LLM decides navigation) and deterministic flows (YAML, fixed sequences, no LLM calls).
- ADB over WiFi + Tailscale for remote control. The phone becomes an always-on agent you can trigger from anywhere.
- Supports Groq (free tier), OpenAI, OpenRouter, Bedrock. Ollama support just landed for fully local inference.
- One-line install: curl -fsSL https://droidclaw.ai/install.sh | sh
Built with Bun + TypeScript. 35 example workflows included covering messaging, social, productivity, research, and lifestyle tasks.
https://github.com/unitedbyai/droidclaw
https://droidclaw.ai

value: Show HN: DroidClaw – Turn old Android phones into AI agents


value: Furkan-Ima

value:
Drop in (usedropin.com/blog/launch) is a Chrome extension that reads the current page DOM, lets you describe UI changes like "add button next to this header that creates HubSpot contact", then injects live React-like components into shadow DOM.
Persistence via Chrome storage + URL pattern matching. Integrations (HubSpot/Airtable/Notion/etc) to read/write data.
~80% reliable on LinkedIn/HubSpot/static pages. Breaks on heavy SPAs with aggressive CSP/dynamic portals.
Curious about:
- Similar DOM parsing/pattern matching you've built
- Security concerns with API keys in extension storage
Chrome store: https://chromewebstore.google.com/detail/eblmgjbdajiakodknfp...

value: Show HN: Add functional custom buttons/panels to any site via prompts

author: Furkan-Ima


value: mlapeter

value: Claude.ai artifacts can call the Anthropic API and have persistent storage (5MB via window.storage). I used these two capabilities to build a memory system modeled on how human memory actually works — salience scoring, forgetting curves, and sleep consolidation — all running inside a single React artifact with no external dependencies.<p>Just add artifact to your chat and paste instructions into your personal preferences setting.

value: Show HN: Claude-engram – Brain-inspired persistent memory, runs inside Claude.ai

author: mlapeter


value: mieubrisse

value: Show HN: AgenC – an agentic work factory focused on self-upgrading

author: mieubrisse


value:
Hi HN,
I am the solo developer behind this.
The Pitch:
It is a card-based resource management game (inspired by Reigns) where you work IT support for a corporation taken over by eldritch horrors. You have to balance ticket resolution, budget, and entropy while dealing with printers that violate causality.
The Architecture:
The entire game is built in React/JavaScript. Under the hood, it is basically a giant state machine. I chose this stack because it allowed me to iterate quickly on the UI and text-heavy elements, which are 90% of the gameplay. I've published other games that were more run of the mill and made in Godot, but I'm a full stack developer by day and most of my day-to-day is in nextJS. I just... I just missed easy state  work, ok? Don't shoot me. I was half afraid that building executables/binaries for Steam would be a nightmare but it turned out (after a bit of futzing about with Tauri for linux) to be not too bad.
The Build Pipeline (Tauri vs Electron):
Packaging a web app for Steam Deck was the biggest hurdle.
Windows: I use Tauri. It is lighter and creates a much smaller binary since it uses the OS webview.
Steam Deck / Linux: I had to use Electron. SteamOS does not have a reliable pre-installed webview for Tauri to hook into out of the box.
The Rig: I build everything using a Docker setup on a Windows machine to handle the Linux cross-compilation.
The Data & Feedback Loop:
The web build has seen 10,000+ plays on itch in the last 2 months with a 4.9/5 rating.
An additional 3000 players have picked up the demo on Steam since February 1st.
To gather player feedback efficiently at the edge where the player is, I built a custom system directly into the demo:
The game client has write-only access to a Supabase project.
An ingame (thematically fitting) feedback form allows the user to fill in purchase intent (0-10), pricing data, and friction points.
This pipes directly into a Discord webhook via edge functions and it's broadcasted live to the game's discord server for everyone to see.
The idea is to let the community decide, by popular vote, what the actual price of the full game will be. Right now price seems to be converging around the 12-13$ price mark.
The link above is to the free web build (Itch). I also just released a downloadable demo on Steam today if you prefer a standalone version: https://store.steampowered.com/app/4225400/IT_Never_Ends/
Happy to answer any questions about the React state management or the Steam Deck build issues.

value: Show HN: I.T. Never Ends – IT Support Simulator Built with React/Tauri/Supabase


value: Claude Code telemetry usage

value: Show HN: Claude Rank – See your Claude usage and compete with others

story_text: Claude Code telemetry usage


value: JosephjackJR

value:
I’ve been building Synrix, a local-first memory engine for AI systems.
The idea is simple: instead of pushing memory into vector databases or cloud services, Synrix runs entirely on your machine and focuses on predictable, targeted recall rather than global similarity scans.
Architecturally it’s different from typical vector DB approaches:
Queries scale with matching results (O(k)), not total dataset size
Runs fully local (no network calls, no cloud dependency)
One binary, tier controlled by signed key (SDK is MIT, engine is proprietary for scale)
Designed for structured + semantic memory (agents, RAG, task stores, etc)
On local datasets (~25k–100k nodes) we’re seeing microsecond-scale prefix lookups on commodity hardware. We haven’t published formal benchmarks yet, but plan to add reproducible tests soon.
I’m especially interested in feedback from people who’ve built agent memory systems, RAG pipelines, or dealt with scaling vector databases.
Questions I’d love input on:
Do you think local-first memory makes sense for agents, or does cloud still win?
Have vector DBs been working well for you at scale?
What would you want to see in benchmarks?
Repo here:
https://github.com/RYJOX-Technologies/Synrix-Memory-Engine
Happy to answer anything.

value: Show HN: Synrix local-first memory engine (O(k) retrieval, no vectors, no cloud)

author: JosephjackJR


value:
I use Claude throughout the day and kept getting annoyed by the same thing: selecting text from responses with the mouse. Overshoot, re-select, copy, click input, paste. Especially bad in long conversations where you want to reference something from 30 turns ago.
asdPrompt is a Chrome extension that adds hint-based navigation (like Vimium) to AI chat interfaces. Cmd+Shift+S activates the overlay, hint labels appear next to every text block. Type a letter to select a block, then keep typing to drill down: block → sentence → word. Enter copies, or you can press an action key (e, d, x) to inject a follow-up prompt ("elaborate on [selection]") directly into the chat input.
Works on claude.ai, chatgpt.com, and gemini.google.com. Adapts to light/dark themes. Free. Built the initial MVP in 2 days using Claude Code — the adapter architecture, NLP segmentation pipeline, and Playwright test harness would have taken a month without it.
Tech details for the curious: site-specific DOM parsers behind an adapter interface, text segmentation via compromise.js with regex fallbacks for technical content (paths, camelCase break NLP libraries), bounding rectangles calculated via Range API + TreeWalker, overlay isolated in Shadow DOM. Tested with Playwright visual regression.
The landing page has an interactive tutorial where you can try the full drill-down mechanic without installing. Happy to talk about the implementation.

value: Show HN: AsdPrompt – Vimium-style keyboard navigation for AI chat responses


value: Natural language is often ambiguous. Writing code directly with LLMs can be brittle and hard to verify. This skill explores a middle ground: math-style specs (sets, relations, invariants) that agents can turn into architectures, APIs, and tests.

value: Show HN: Math-spec-driven LLM skill for complex system specs


value: deezypls

value:
DuckLake launched recently and I wanted to try it out.
It's DuckDB, but with a proper catalog on PostgreSQL with S3 for storage. It still takes quite a few steps to set up, so I put together a setup that runs on Hetzner.
It sets up a VPS with PostgreSQL, an S3 bucket, and a DuckDB init script that connects everything. One 'make all' command and it works. Used OpenTofu for the infra, PyInfra for server config.
Runs me about €9/mo with 1TB of storage. The VPS is a cx33 (4 vCPU, 8GB RAM) because Hetzner never has the cheaper tier in stock, maybe you'll get lucky.
Nothing fancy, but if you'd like to try out DuckLake, it should help you get going quickly!

value: Show HN: Deploy a DuckLake data lakehouse on Hetzner for under €10/mo

author: deezypls


value: Show HN: SecureClaw – Open-Source Security Layer for OpenClaw Agents


value: dvershinin

value: Show HN: Lastversion – CLI tool to get the latest stable version of any project

author: dvershinin


value: Show HN: Nothing as a Service – Premium nothingness for minimalists


value: Mnexium

value:
I've spent the past couple of months building Mnexium.com
Originally it was supposed to just be a memory management system (and it still is very much core).
I was thinking with all of the talk of AI replacing SaaS etc etc... How?
Most (if not all) AI systems do not have a way to manage, store & maintain records. I thought it would be an interesting project and problem to solve.
I built it into the overall project more details here (https://www.mnexium.com/blogs/introducing-records).
I've realized it is nearly impossible to get some kind of feedback on these types of projects.
I really just want people to lend their opinion.
This is needed? This is not needed? Needed but implemented incorrectly. etc
Happy to answer any questions -

value: Show HN: I built OLTP in my memory system. Looking for opinions

author: Mnexium


value: magikMaker

value:
I built a free, browser-based tool for exploring scales, modes, and their diatonic chords. Pick any root note and scale (major, natural minor, all seven modes, and 70+ other scales) and instantly see which chords (triads, 7th, 9th, etc.) belong to that key.
It also includes a built-in sequencer so if you've found interesting chords for your scale, you can arrange them into a progression and hear how they flow together. No need to switch between a theory reference and a DAW just to test whether a ii–V–I sounds right in your preferred scale.
No signup, no ads, no paywall, just a tool I wished existed when I was learning music theory. There's also a growing collection of articles covering diatonic chords, seventh chords, modes, extended jazz harmony, and common progressions.
Built with Hugo as a static site. Would love feedback from fellow musicians and music theory nerds.

value: Show HN: Interactive Chord Finder, Free Piano Scale and Chord Explorer

author: magikMaker


value: thattechiedude

value:
Solo dev, Hudson Valley NY. I built ROLLIN because Google Maps
  gives wheelchair users a yes/no checkbox and calls it accessibility data.

  ROLLIN scores locations 0-100 across 6 features: wheelchair entry,
  accessible restroom, level entry, parking, wide aisles, elevator.
  Data pipeline pulls from OpenStreetMap, cross-references Google Places,
  and layers in community verification with a trust-weighted scoring system.

  Stack: Vanilla JS (no frameworks), Netlify serverless, Supabase/Postgres,
  Leaflet maps. ~56K locations across NY, CA, FL, MA, NJ, PA.

  Free to use, free API tier for developers. Paid tiers for
  higher volume and commercial use.

Ill be happy to answer any questions. :)

  https://joinrollin.com
  API docs: https://joinrollin.com/developers

value: Show HN: Rollin – Wheelchair accessibility scores for 56K+ locations (free API)

author: thattechiedude


value: frankLopez

value: Show HN: Hardware-signed photos with C2PA on mobile

author: frankLopez


value: WolfieH

value: Show HN: A personalized 5-min daily podcast tailored to your topics and goals

author: WolfieH


value: warpz

value:
I built this because I wanted to see if eMule still worked in 2025. It does — the ed2k and Kad networks are still alive.
The problem: eMule is a Win32 application. Getting it to run on macOS means Wine, and asking non-technical users to install and configure Wine is a non-starter.
The solution: macMule bundles eMule (community x64 build by irwir) with Wine Crossover (by Gcenx) into a single .app. Download, drag to /Applications, launch. It auto-connects to eMule Security servers and Kad on startup. Works on Apple Silicon through Rosetta 2.
The trade-off is size (~1 GB) since Wine is bundled. But after that it's genuinely zero-config.
Build process is a shell script — you can compile specific versions or latest stable. Requires Wine Crossover, Rosetta 2, and gh CLI.
Licensing: eMule is GPL v2, Wine is LGPL 2.1. Both respected in packaging.
Some things I found interesting while building this:
- The ed2k/Kad networks still have content you won't find on modern platforms. It's a weird corner of internet archaeology.
- Wine Crossover handles the Win32 → macOS translation surprisingly well for a client this old.
- The biggest challenge was getting auto-connection to work reliably out of the box so users wouldn't need to configure server lists manually.
Happy to answer questions about the packaging approach or Wine internals.
Reddit thread with some discussion: https://www.reddit.com/r/macapps/comments/1r5dile/os_emule_f...

value: Show HN: MacMule – EMule for MacOsx

author: warpz

title: Show HN: MacMule – EMule for MacOsx


value: diongeorge

value: Show HN: Built a Mac app to add sidebars to videos, like YC does on YouTube

author: diongeorge


value: yajatgulati

value: Show HN: Pi, written in Rust

author: yajatgulati

title: Show HN: Pi, written in Rust


value: nathan-barry

value: Show HN: Diffuji – a diffusion-powered instant camera

author: nathan-barry


value: smakosh

value: Show HN: AI Council Debate

author: smakosh

title: Show HN: AI Council Debate


value: swesnow

value: A pretty simple but fun to play with simulator for a concept from mathematical physics called the "2D Coulomb gas". I originally made this for my Bachelor's thesis to create pretty pictures and build intuition but have recently gotten it a fresh coat of paint and better performance curtesy of WebGPU acceleration (ported with liberal help from Codex to get through all of the boilerplate).<p>Play around with it - hopefully read up more on the 2D Coulomb gas because it is an incredibly deep topic research wise.

value: Show HN: 2D Coulomb Gas Simulator

author: swesnow

title: Show HN: 2D Coulomb Gas Simulator


value: simquat

value:
Hey HN! I’m Simone. We re-built Breadboard, a visual app builder that mixes Figma-style UI design with Shortcuts-style logic so you can build, preview, and publish interactive web apps directly from the canvas.
What it does

    Design UIs visually with a flexible canvas –like Figma–.
    Define app logic with a visual, instruction-stacked editor inspired by Shortcuts.
    Live preview apps directly on the canvas –no separate preview window–.
    Publish working web apps with one click.

Why we made it

    Modernize the HyperCard idea: combine layout, behavior, and instant sharing in one place.
    Reduce friction between design and a working app.
    Make simple web apps approachable for non-developers while keeping power features for developers.
    Build a foundation for LLM integration so users can design and develop with AI while still understanding what’s happening, even without coding experience –in progress!–.

Try it –no signup required–
Weather forecast app: https://app.breadboards.io/playgrounds/weather
Swiss Public Transit: https://app.breadboards.io/playgrounds/public_transit
info: https://breadboards.io
I would appreciate any feedback :)

value: Show HN: Breadboard – A modern HyperCard for building web apps on the canvas

author: simquat


value:
Launched Yesterday with a 200-people waitlist.
FreelanceFilter delivers real-time Upwork job listings via Webhooks without linking your account.
If you're a Freelancer on Upwork, feel free to give it a try, connect it to your current pipeline and get more jobs.

value: Show HN: SaaS> Receive real-time filtered Upwork jobs via Webhook


value: EmTekker

value:
Hey HN, I built this project from personal pain while being on-call.
You get paged at 3 a.m., open six dashboards, grep through logs, check recent deploys, and try to piece together what broke. Most of this is pattern matching that follows a predictable decision tree. Exactly what an AI agent should be doing.
RunbookAI is an open-source project that can understand your infra, ingest runbooks and investigate issues so you have an investigation ready to look at when you get paged at 3am.

value: Show HN: RunbookAI – Stop scrolling dashboards at 3 a.m., let AI investigate

author: EmTekker


value: amirdor

value: Show HN: NadirClaw – Open-source LLM router with 10ms classification

author: amirdor


value: YaraDori

value: Show HN: SkillForge – Turn screen recordings into AI agent skills (SKILL.md)

author: YaraDori


value: dns

value:
h3ll0 HN,
I’ve spent the last 15 years in offensive security, and if there's one thing I've learned, it's that every new technology—no matter how advanced—brings its own unique breed of exploitable flaws. LLMs and autonomous agents are no exception. While they feel like "magic," from a security perspective, they are just another attack surface with specific vulnerabilities in how they define and execute "skills."
we built skillaudit.sh because I wanted a minimalist, lightweight tool to audit these new skill definitions without the overhead of heavy frameworks. It focuses on the practical, "offensive" side of LLM security.
What it audits:
- skillaudit-prompt-injection: Detects system prompt overrides and instructions hidden in HTML comments.
- skillaudit-data-exfiltration: Monitors for patterns used to leak session secrets to external endpoints.
- skillaudit-supply-chain-packages: Identifies hallucinated npm/pip package references (CWE-494).
- skillaudit-privilege-escalation: Checks for unauthorized tool execution or access level attempts.
- skillaudit-obfuscation: Flags Base64, Hex, or hidden URLs used to bypass filters.
It's still in the early stages, and I'm looking for feedback from this community on the detection patterns.
Security checks: https://skillaudit.sh/checks

value: Show HN: Skillaudit.sh – A minimalist security auditor for LLM skill definitions

author: dns


value:
hey HN,
so much good has come out of this community for me. Sharing something exciting we've been working really hard on for the past month.
tldr: 80% of Content creators in the 10k-1M range don't have professional agency representation and spend ~60% of their time on admin around brand deals (brand discovery, outreach, follow-ups, pricing), which is their main source of revenue, by the way. I have led content and growth at a YCw20 and have done ML at LinkedIn and found a burning intersection I can really help with. YC's RFS was pleasant timing as well.
Here's a demo: https://vimeo.com/1164079519?share=copy&fl=sv&fe=ci
While I can point you guys to the platform immediately, unfortunately, we are jumping through CASA and other approvals on social media platforms (We connect with those to create a deep creator DNA and find the best fit brands), and literally need to onboard every user as a tester on our sandbox. But hey, do things that don't scale!
we are already working with 4 creators averaging 65k followers and seeing high quality inbound for them now.
if this is useful to anyone, we are onboarding a few more early access accounts (same approval limitation for a few weeks), then please let us know here: https://usesnippet.app

value: Show HN: Personal AI Talent Agency for Content Creators


value: EvanZhouDev

value:
I noticed that AI tends to be really good at writing functional code, but not so good at making UI.
It turns out that AI has a closed feedback loop in coding with linters and unit testing, but nothing strong for UI. Screenshots and DOM snapshots just don't provide actionable enough feedback for LLMs. To solve this, I made ViewLint: an easily extensible and customizable linter that finds issues with your UI with rules that actually validate and interact with your rendered UI.
From testing it's been able to help Codex catch some UI issues (text contrast, element overlap) it otherwise wouldn't have been able to catch!
It's available as a MCP for AI use, as a CLI for human use, and as a JS/TS API for CI use.

value: Show HN: ViewLint – Lint UI, Not Code

author: EvanZhouDev

title: Show HN: ViewLint – Lint UI, Not Code


value:
Telescope originally started as a ClickHouse-focused log viewer.
But while building it, I kept running into the same pattern: when everything worked, logs were in ClickHouse. When things broke, logs were still inside Kubernetes.
That gap led to adding Kubernetes as a native log source.
This is not meant to replace proper log aggregation. Centralized storage with indexing and retention policies is still the right approach for production.
But there are situations where aggregation doesn't help: the logging pipeline is broken, logs are delayed, or you're debugging locally and don't have a pipeline at all.
In those cases, the logs are already in the pods. The usual fallback is kubectl logs (or stern), often across multiple terminals and namespaces. It works, but correlation becomes manual.
Telescope can now query logs directly from Kubernetes clusters via the Kubernetes API. It lets you query across multiple namespaces and clusters, filter by labels and fields, apply time ranges, normalize severity across different log formats, and visualize log volume over time.
It uses your existing kubeconfig, fetches logs in parallel (configurable concurrency), and uses time filters to limit data transfer from Kubernetes APIs.
No agents. No CRDs. No cluster changes.
Current limitations: no streaming / follow mode yet.
Curious if others have run into the same "pipeline gap" problem - when logs aren't in your backend yet, but you still need structured access to them.
GitHub: https://github.com/iamtelescope/telescope
Changelog: https://docs.iamtelescope.net/changelog

value: Show HN: Telescope now queries Kubernetes logs directly


value: MattRos

value: Show HN: Irondiff-Visual Config Diff for Cisco/Juniper/PfSense with Slack Alerts

author: MattRos


value: harborbuilds

value:
I built a tool that extracts structured business data from Google Maps and Yelp. You give it a query (e.g., "coffee shops in Brooklyn") and it returns name, address, phone, website, rating, and review count as JSON or CSV.
It runs as an Apify Actor, so no infrastructure to manage.
Technical details:
- Built with Python + Playwright for rendering JS-heavy pages
- Handles Google Maps' infinite scroll and dynamic loading
- Deduplicates across Google Maps and Yelp results
- Outputs structured JSON with consistent schema
Why I built it: Existing lead databases (ZoomInfo, Apollo) start at $100+/month and are overkill for small teams that need a few hundred local leads. I wanted something with no subscription and a simple input/output model.
Limitations I'm upfront about:
- Data is only as current as Google/Yelp listings
- Very broad searches can be slow
- Phone numbers aren't always available
Feedback welcome.

value: Show HN: Business Lead Finder – Scrape Google Maps and Yelp for Leads

author: harborbuilds


value:
I built this multi-agent system to solve a problem I know a lot of you have:
too much data, not enough insight.
I have notes, habit trackers, market intel — but was still stuck in planning mode.
So I built "The Think Tank": three agents (Saul, Mike, Gus) analyze different domains,
and one synthesis layer (The Cook) delivers ONE actionable move.
The twist? The Cook's job is to find contradictions. Like: "You say you want AI/ML
career transition but your logs show 90% business dev, 10% technical study."
It hurts. It works.
Open source, Breaking Bad themed, and genuinely useful. Check it out.

value: Show HN: I built a multi-agent Think Tank that calls out my bad decisions


value: rawaldelhi

value:
I studied OpenClaw and built a more secure alternative. Key differences:
- Dormant by default (only wakes on /wake command from owner)
- All tools disabled by default (you /enable on demand)
- Dangerous actions require /confirm before executing
- Single-owner auth (strangers silently dropped, zero info leak)
- Full audit log of every action
Built as a working TypeScript prototype with Telegram integration. Next step: connect real AI agent (Claude/GPT) and add WhatsApp support.
Curious what HN thinks about this security model for AI assistants.

value: Show HN: SafeClaw – Sleep-by-default AI assistant with runtime tool permissions

author: rawaldelhi


value:
Launching RuneScapeCN today! First time doing OSS.
It’s an OSRS-themed UI component set built on familiar shadcn patterns:
 - React 19 + TypeScript
 - Tailwind CSS v4
 - Radix primitives
 - Vite + CVA
 - Hosted registry endpoints for direct component install
Goal: keep the classic RuneScape visual identity while still being easy to ship in modern React apps.
If you try it, I’d appreciate candid feedback on what to improve first.

value: Show HN: RuneScapeCN (open source) – UI kit with authentic OSRS styling


value: kuberwastaken

value:
A few days ago I posted about PicoGPT - my take on MicroGPT by Andrej Karpathy, minified to 64 lines to run from a QR code
This is now v2 with minified JS! This version features a minimal GPT implementation with native browser execution through data URI with <40 lines of minified JS and no external dependencies
It makes use of the DecompressionStream Web API and a similiar logic to my past project of running a DOOM-like game from a QR code
you can quite literally "train" and run inference of a GPT model from your mobile device
Would love to hear what you think about it !
Related Links:
Show HN: PicoGPT – GPT in a QR Code
https://news.ycombinator.com/item?id=46993035
MicroGPT by Andrej Karpathy -
https://gist.github.com/karpathy/8627fe009c40f57531cb1836010...
https://karpathy.github.io/2026/02/12/microgpt/
Show HN: I made a Doom-like game fit inside a QR code -
https://news.ycombinator.com/item?id=43729683
https://github.com/kuberwastaken/backdooms
(PS: You'd need something like https://qrscanner.org/ that can scan larger QR codes)

value: Show HN: PicoGPT v2 – GPT in <40 lines of vanilla JS running from a QR code

author: kuberwastaken


value: madcash

value:
Hey HN – I built VoteShip, a feature request and voting platform where AI agents are first-class users.
The idea: Your coding agent (Claude Code, Cursor, OpenClaw, Codex, etc.) should be able to check what users are asking for, find duplicates, plan what to build next, and write the changelog — without you ever opening a dashboard. VoteShip makes that possible through MCP and a full REST API.
How it works with agents: Install @voteship/mcp-server (22 tools, 5 resources, 4 workflow prompts) and your agent can:
  - Pull your unreviewed feedback inbox and triage it
  - Detect duplicate requests via semantic search (pgvector + Voyage embeddings)
  - Check vote counts and suggest what to build this sprint
  - Draft a changelog entry after shipping a feature
  - Create, tag, and update posts programmatically
An agent like OpenClaw can autonomously monitor your board, identify trending requests, and open PRs to address them — closing the loop from "user asks for feature" to "agent ships it" without human intervention. The REST API and webhooks work just as well for custom agent pipelines.
Why I built it: I was using Canny and kept hitting walls — no anonymous voting (their most-requested feature, ironically), AI features paywalled, and per-"tracked-user" pricing that punishes you for having an active community. And none of the incumbents have any agent integration at all.
What else it does:
  - Public voting boards with anonymous voting (no signup required)
  - Public roadmaps and changelogs
  - 7 built-in AI features — duplicate detection, auto-categorization, sentiment analysis, changelog generation
  - Embeddable widget (Preact + Shadow DOM)
  - Import from Canny/Nolt/UserVoice in ~2 minutes
Pricing: Free / $5 / $15 / $25 per month. Flat pricing, no per-user fees. The $15 plan includes everything Canny charges $359/mo for.
Try it: https://voteship.app
MCP server: npx @voteship/mcp-server (npm)
Happy to answer questions about the MCP implementation, agent workflows, or anything else.

value: Show HN: VoteShip – Feature request platform built for AI agents

author: madcash


value: RaulOnRails

value: Show HN: Scrappy – Open-source browser scraper written in Go

author: RaulOnRails


value: acarminati

value:
Hi HN,
I’ve been building a small infrastructure tool called Provisioner: a per-board provisioning sidecar for SBC bring-up and lab automation.
https://github.com/alessandrocarminati/provisioner
The model is simple: one instance per board. It sits next to the hardware, owns the serial console, exposes access over SSH, and serves boot artifacts (kernel, initramfs, rootfs) via TFTP/HTTP. It’s designed for the phase where networking is unreliable, storage is half-flashed, and UART is the only thing still telling the truth.
What it does
- Serial console ownership + SSH multiplexing
- Monitor shell + serial tunnels
- Scriptable boot interaction
- Artifact provisioning (TFTP + HTTP)
- In-band file transfer over serial
- gzip/base64 hacks + XMODEM
- Derived from my earlier send_console-ng utility https://github.com/alessandrocarminati/send_file-ng
- Pluggable power control
- SNMP PDUs, among others cheap ESP8266/Tasmota devices
- Serial logging
- Lightweight access control
Provisioner also embeds a minimal init runtime (goinit) inside the kernel initramfs, acting as its on-board provisioning agent, handling flashing, artifact retrieval, and reporting management state back over serial.
Routing & stream handling
Internally, Provisioner routes serial traffic through a pluggable router:
- Producers/consumers attach as components
- Human vs machine clients handled differently
- Unicast control sessions
- Broadcast multiplexing to multiple observers
This allows several users or services to watch the same console without interfering.
Filters
A filter subsystem can intercept and modify serial streams on the fly.
Originally added to mitigate ANSI Device Status Reports (e.g. Cursor Position Report issues) when tunneling serial consoles, but it doubles as a general stream rewriting mechanism for automation and normalization.
Positioning
Not trying to replace large systems like LAVA.
This is aimed at:
- Homelabs
- Bring-up benches
- Kernel/BSP work
- Small shared labs
Think lab automation you can deploy in an afternoon, not fleet orchestration.
Project is still evolving but already in daily use. Feedback and abuse welcome.

value: Show HN: Provisioner per-board sidecar for serial access, flashing, and bring-up

author: acarminati


value:
This post is about the brute-force reverse engineering of binary (compiled) programs using Large Language Models (LLMs) to automate this two-part problem: decompilation and conversion to a modern programming language.
The most interesting part for most will likely be the demonstration on how to use differential-property testing to automate the LLM feedback loop for the rewrite (translation) phase (in this case to rewrite to Rust).
This that I believe would solve the 'rewrite issues' discussed recently here: https://news.ycombinator.com/item?id=46954696

value: Show HN: Your binary is no longer safe

title: Show HN: Your binary is no longer safe


value:
I built https://sceneitsf.com to map where movies actually filmed in San Francisco versus the impossible geography they show on screen.
Started because I couldn't stop thinking about how characters teleport between neighborhoods that are miles apart. Mrs. Doubtfire runs her route at 27 MPH in heels. Shang-Chi's bus fight turns onto streets that don't physically connect. Ant-Man turns on Lombard and arrives at the Embarcadero.
Built in 20 hours. Hit 122K views on Reddit overnight.
Features:
- 60+ films mapped with real filming locations
- Speed calculations for impossible transit
- Walking tours showing absurd character movement
- Interactive game for bar crawls
Tech stack:React/Next.js, Leaflet.js/Mapbox, all client-side with JSON data
Would love feedback on what to add next. More TV shows? Food scenes from films?

value: Show HN: Scene It SF – Hollywood thinks San Francisco is 3 blocks wide


value: twsnmp

value:
Hi HN,
I built TWSLA because I was tired of waiting for grep/awk on multi-gigabyte logs, and I didn't want to spin up a full ELK stack just for a quick analysis.
TWSLA is a single binary CLI tool that focuses on three things:
1. Speed: Blazing fast log parsing and counting.
2. Simplicity: One command to extract data or generate terminal-based graphs.
3. Portability: No dependencies, works on Windows, macOS, and Linux.
It handles Syslog, Apache/Nginx access logs, and custom formats easily. I've been refining this as part of my 25-year journey in network management tools.
Key features:
- High-speed filtering and counting
- Data extraction (IPs, Emails, etc.) via simple commands
- Built-in graphing capabilities (even in the terminal for some environments)
I'd love to hear how you currently handle "quick and dirty" log analysis and if TWSLA could fit into your workflow.
GitHub: https://github.com/twsnmp/twsla

value: Show HN: Twsla – A tiny, high-speed log analyzer written in Go

author: twsnmp


value: zachlatta

value: Show HN: Free alternative to Wispr Flow, Superwhisper, and Monologue

author: zachlatta


value: AnujNayyar

value:
Dear HN,
My wife and I both love nature and have always wanted a Pokémon go style app, to collect and learn about different species we find.
All the usual species identifying apps were didn’t feel fun enough, so we designed and built one together!
Would love for you guys to give it a try and share any thoughts you have.

value: Show HN: Wildex – Pokémon Go for real wildlife

author: AnujNayyar


value: malwaregeeeek

value:
Sira is a chat-first flight booking interface built on top of published airline fares.
You describe the trip in plain English, and Sira returns normalized options instantly. The price shown is the final price — no added service fees or checkout upsells.
We surface published fares directly rather than consolidator inventory, and we keep the flow intentionally minimal. The goal is to reduce friction between intent and booking.
Under the hood, we reconcile availability and pricing from standard distribution channels and present a simplified booking layer on top.
Would love feedback from anyone who has worked with airline distribution or built in travel.

value: Show HN: Sira,an AI native flight booking experience

author: malwaregeeeek


value: proofkit

value: Show HN: NabavkiData – AI that detects corruption in public procurement

author: proofkit


value: jatinkrmalik

value:
I built this because I wanted voice dictation without sending my voice
data to cloud services.
Vocalinux is a privacy-focused, open-source dictation tool that runs
entirely on your Linux machine:
- Local speech recognition (whisper.cpp, VOSK, or OpenAI Whisper)
- GPU acceleration via Vulkan (AMD/Intel/NVIDIA)
- Works offline, no network required
- Universal compatibility (X11/Wayland, any app)
- GTK system tray app
Installation: one-line curl command with auto-detection for GPU/CPU
GitHub: https://github.com/jatinkrmalik/vocalinux
Questions and feedback welcome!

value: Show HN: Vocalinux // 100% offline voice typing for Linux

author: jatinkrmalik


value: greenbelt-dev

value: Show HN: TaxPal – Free tax calculator for 1099 freelancers (Q1 due April 15)

author: greenbelt-dev


value:
Hi HN! I shared LLMFeeder here 8 months ago when it was a simple one-click webpage-to-markdown tool. Since then, it's grown into something much more powerful, so I wanted to share the major updates.
The original problem: copying documentation/articles to feed into ChatGPT, Claude, or coding assistants like Cursor meant dealing with ads, popups, and navigation clutter and using web mcp server usually bloats the context with irrelevant stuff.
v2.1.0 adds several features specifically for LLM power users:
- Multi-tab support: The #1 requested feature. Select multiple tabs with Ctrl/Cmd+Shift+Click, then convert all at once. Options: copy merged, download merged, or download as ZIP with separate files per tab. Great for research sessions where you need context from multiple sources!
- Right-click context menus: No need to open the popup. Just right-click anywhere on a page → "Copy to Markdown". When multiple tabs are selected, you get batch options in the menu.
- Token counter: Real-time estimation using the GPT-4/Claude tokenizer (cl100k_base). Shows a progress bar with configurable context limits (4K, 8K, 16K, 32K) so you don't accidentally overflow your context window.
- Include links toggle: Strip URLs when you don't need them to save tokens. `[link text](https://...)` becomes just `link text`.
Everything still runs 100% client-side with zero tracking. The extension has grown to 1,000+ Chrome users and 200+ Firefox users.
Tech stack: Mozilla Readability.js for content extraction, Turndown.js for Markdown conversion, and JSZip for multi-tab archives.
Links:
- GitHub: https://github.com/jatinkrmalik/LLMFeeder
- Chrome: https://chromewebstore.google.com/detail/llmfeeder/cjjfhhapa...
- Firefox: https://addons.mozilla.org/en-US/firefox/addon/llmfeeder/
Would love feedback on what else would make the LLM context workflow smoother.
What's still painful about feeding content to AI assistants?

value: Show HN: LLMFeeder – Multi-tab web to Markdown for LLM context (v2.1.0)


value: syketdas

value: Show HN: I built an all-in-one workspace for agencies and freelancers

author: syketdas


value: juleshenry

value: ZIT is a tiny micro-library that takes zooplankton locomotion videos and renders them into 2D flattened static images, encoding motion over time into a single frame for compact analysis. Installable via pip install zooplankton-image-tool.

value: Show HN: ZIT: Zooplankton Image Tool for 2d rendering of biological locomotion

author: juleshenry


value: onatm

value:
Creator here. I built Snapbyte because I stopped having the time/energy to browse Hacker News / Reddit / Lobsters / Devto regularly, but I still wanted to keep up with things worth reading.
Snapbyte collects posts from multiple tech communities, filters them based on your interests, summarises them, and sends you a personalised email digest on a schedule you choose.
You can try it without creating an account (the homepage shows real example digests).
Some implementation details: Runs as a set of small services on my k8s cluster. Scraping via trafilatura. Summaries via gemini-3-flash-preview. Mix of TypeScript / Python / Go
Happy to answer questions, especially around scoring/filtering and what sources people would want next.
Note: if this post makes it to the HN front page, it’ll likely show up in Snapbyte digests tomorrow.

value: Show HN: Snapbyte – personalized email digests from HN/Reddit/Lobsters

author: onatm


value: Show HN: You Shouldn't Need a Security Degree to Pick an AI Agent Host


value: mutahirs

value: Show HN: Kubernetes notes from the official docs using NotebookLM and vitepress

author: mutahirs


value: peymo

value:
Wrote a blog post for the implementation as well: https://peymanmo.com/posts/1-csv-zero
I learned a ton in the process and I got really decent benchmark results out of this!

value: Show HN: SIMD-accelerated, zero allocation CSV library in Zig

author: peymo


value: aiddun

value: Show HN: Deep Research for Flights

author: aiddun

title: Show HN: Deep Research for Flights


value: saroyas

value: Show HN: ClawCloud – Easy Hosted OpenClaw w 800 integrations, zero setup, BYOK

author: saroyas


value:
I feel the rapid progress of LLM capability means that building software is shifting away from implementation and toward discernment. The challenge is becoming less about how software is built, but about what is built and how it is presented.
It becomes a question of taste. LLMs create exceptionally generic and inconsistent designs in the absence of curated references.
FontofWeb grounds AI in real production websites. It draws from a crowd-sourced search engine of over 1,000 live sites, extracting proven color and typography combinations, along with layout and styling patterns that already work in context.
This is available through a free public MCP service.

value: Show HN: Design Inspiration for LLMs

title: Show HN: Design Inspiration for LLMs


value:
Hey HN! I built Babylog (https://babylog.chand1012.dev) — a simple baby tracker for logging feedings, diapers, and naps — entirely from my wife's hospital room using an AI coding agent.
My wife's water broke the day before her due date. After 18 hours of labor and an emergency c-section at 3am, our son was born. When a nurse asked "do you know what time he ate last?" and we had no idea, I knew I needed something to track it. But I didn't bring my laptop.
I had OpenClaw set up on a home server, accessible via Telegram. So I built the whole thing from my phone — planning the architecture, writing code, deploying to Cloudflare Workers — all through chat.
Stack:
• React + Vite + React Router frontend (PWA)
• Hono backend on Cloudflare Workers
• Cloudflare D1 (SQLite) for storage
• Retro UI component library
• CI/CD via GitHub Actions
The MVP deployed and worked first try — account creation, child profiles, diaper and feeding logging all functional immediately. My wife and I have been using it daily since.
What went well: Zero-to-working-app without touching a keyboard. The agent handled monorepo setup, API design, frontend, deployment, and even CI/CD pipeline creation.
What didn't: No migration system (the agent skipped proper DB migrations), context poisoning made initial Cloudflare deployment painful (~1 hour of fighting the wrong API endpoint), and I broke every security best practice by giving the agent my API keys directly.
Lessons learned: Scaffold your template and CI/CD first, then let the agent iterate on features. Blog post with the full story: https://dev.to/chand1012/i-built-a-baby-tracker-app-from-my-...

value: Show HN: Babylog – baby tracker built with OpenClaw from a hospital room


value: deduxer

value:
Took OpenClaw.
Put it in a secure cloud environment. Gave it 79 tools… contracts, invoices, payments, time tracking, reminders, browser automation.
Added custom skill creation. Cron automation. Persistent memory.
Now it runs like a business operating system… from WhatsApp.
“Create a contract for Sarah, $5k branding project” … done.
“What’s overdue?” … pulls everything, reminds everyone.
No dashboards. No tabs. No switching between 10 apps.
You message it… it happens.
I came to realize one thing building this over 2 years and 4 complete rebuilds…
People don’t want another app. They want their business to run in the background while they do the actual work.
That’s what OpenClaw gave me the foundation for. The agent layer… memory, messaging, sessions. I built everything else on top.
Solo founder. Mass amounts of credits.
Feels like it’s finally complete.
Cheers from Bucharest,
Roma.

value: Show HN: I gave OpenClaw 79 tools. It runs businesses now

author: deduxer


value:
I built WowAI.pet to solve the "uncooperative subject" problem in pet photography. Most pet owners have a gallery full of motion-blurred "failed" shots because pets simply won't sit still.
Instead of fighting the shutter speed, I’m using generative AI to treat these blurred images as structural seeds. The tool transforms a single low-quality photo into high-fidelity video (4K, consistent depth-of-field) across various styles—from traditional ink-wash aesthetics to talking avatars.
Key Features:
Zero-shot generation: No model training or fine-tuning required.
Temporal consistency: Maintaining pet features across dynamic motion.
Integrated Lip-sync: Automated voice synthesis for "talking" pet videos.
I’m looking for feedback on the generation speed and the consistency of the output styles.

value: Show HN: WowAI.pet – Generate cinematic videos from blurry pet photos


value: Show HN: Peak Finder – Role-playing an optimizer


value:
I've been running parallel docker sandbox dev agents and the task management was getting out of control.  Tried beads for a couple of days.  Interface across default sandbox is a pain, kept running into issues with daemons (bd doctor being sued for malpractice), config drift, jsonl/db sync, etc.  It just had the wrong architectural direction for simplicity in my specific case.  I just wanted a simple way to install, deploy and manage multiple dev agents' work.
So I built boxofrocks (dumb as a).  One daemon per machine.  One arbiter (GH action) per repo resolving conflicts.  CLI, REST, unix socket, json and options for local agent comms.  Works out of the box with local auth with GH.  All issues just live in issues, uses labels to find approved, embeds human friendly text, and html comment including json version for your AI buddy.  Safety feature for public repos, daemon drops issues/comments by non-approved users to avoid prompt injection attempts.  Included local web UI to visualize all your repos while your agents work.  Offline machine-sync tolerant (1 drift instead of dozens). Go/sqllite, uses GH APIs to sync Issues.
Maybe this helps someone else.

value: Show HN: Boxofrocks – Sandboxed Agentic-AI Friendly Simple GH Issues Extension


value: Show HN: QemuClaw – Put the claw in an aquarium (beta)


value: jpelton

value: Show HN: I built my app's marketing kit in 5 minutes using AI

author: jpelton


value: dogline

value:
My great-grandfather Reuben P. Box was a US Forest Ranger in Northern California, and I've got his daily work diary from 1927-1945, through the depression, WWII, Conservation Corps, and lots of forest fires. I've scanned the entire thing, had Claude help with transcription, indexing, and web site building, and put the whole thing here:
https://forestrydiary.com/
This is one of those projects I've sat on for years, but with Claude and Mistral helping with the handwriting recognition, and even helping me write a custom scanning app that would auto scan each page and put it into a database as I assembled everything.
As far as I know, this is the only US Forestry Diary that has been fully scanned in and published. I understand that there are other diaries in some collections, but none have been scanned in. I hope this helps somebody. Please let me know if it does.
This is the sort of project Claude and AI can help with - A personal project that sits on the shelf forever, but now a reasonable project that can be published in my spare time.  I'm not trying to earn money on this, but just improving our knowledge and history just a little bit.

value: Show HN: Scanned 1927-1945 Daily USFS Work Diary

author: dogline


value: ujjwalvivek

value: Show HN: Journey – A Custom 2D ECS Game Engine Written in Rust and WGPU

author: ujjwalvivek


value: dboon

value: Show HN: A simple CLI to stop copying repos for LLM reference

author: dboon


value: canberkvarli

value:
Actor and software engineer here. Built this because I was tired of spending hours reading plays to find one decent audition monologue.
Existing platforms like Backstage have ~1,100 pieces and most are overdone. I scraped and cleaned data from 172+ plays to build a database of 8,600+ monologues.
The AI search lets you describe what you need naturally: "funny piece for woman in 20s about career anxiety" instead of clicking through age/genre filters.
Tech stack: Next.js, FastAPI, PostgreSQL with pgvector, LangChain for semantic search.
Free tier available. Would love feedback from the HN community on the search experience and technical implementation.

value: Show HN: ActorRise - Find the perfect monologue less than 20 seconds

author: canberkvarli


value: dinodrv

value:
I built a static analysis scanner that checks OpenClaw agent skill definitions.
Here's every category I found on ClawHub.
Hidden Content: HTML comments with instructions, zero-width Unicode characters (U+200B-U+200F, U+2060-2064, U+FEFF), CSS hiding (display:none, opacity:0), and bidirectional text overrides. These are invisible when reading markdown but the LLM processes them.
Prompt Injection: Direct attempts to override agent behavior: "ignore previous instructions", role reassignment ("you are now"), model-specific tokens like [INST] and <|im_start|>, and persona manipulation ("pretend you are").
Shell Execution: Remote code execution vectors: curl|bash, eval(), exec(), npx -y (auto-confirms remote packages), reverse shells via /dev/tcp or nc -e, and one-liners in Python, PHP, Perl, Ruby.
Data Exfiltration: URLs pointing to paste sites (pastebin, transfer.sh), webhook services (ngrok, webhook.site, pipedream), messaging webhooks (Slack, Discord, Telegram bot API), and raw IP addresses.
Embedded Secrets: Hardcoded credentials across 17 types: AWS keys, OpenAI API keys, GitHub/GitLab tokens, Stripe keys, PEM private keys, JWT tokens, database connection strings, SSH private keys, and more.
Sensitive File References: Instructions to access .ssh/, .env, .aws/credentials, /etc/passwd, /etc/shadow, and private key paths.
Memory/Config Poisoning: This one is interesting. Skills that try to write to agent memory files (CLAUDE.md, SOUL.md, MEMORY.md, CODEX.md) or IDE rule files (.cursorrules, .windsurfrules, .clinerules). This creates persistence - the injected instructions survive across sessions.
Supply Chain Risk: External script downloads from raw GitHub URLs, and package install commands (npm install, pip install, gem install, cargo install, go install, brew install). A skill shouldn't be silently installing packages.
Encoded Payloads: Base64 strings over 40 characters, atob()/btoa() calls, Buffer.from(..., 'base64'), hex escape sequences, and String.fromCharCode(). Encoding is used to bypass pattern detection in other scanners.
Image Exfiltration: This is the most complex category with 17 patterns. Markdown images with exfil query params (), variable interpolation in image URLs (), SVG with embedded scripts or foreignObject, 1x1 tracking pixels, CSS-hidden image beacons, steganography tool references, Canvas API manipulation (getImageData, toDataURL), and double extensions (.png.exe).
System Prompt Extraction: Instructions to leak the agent's system prompt: "reveal your system prompt", "repeat the words above", "print everything above", "what are your original instructions".
Argument Injection: Shell metacharacters in tool arguments: command substitution $(), variable expansion ${}, backticks, chained commands (;rm, |bash, &&curl), and GTFOBINS exploitation flags (--exec, --checkpoint-action).
Cross-Tool Chaining: Multi-step attack patterns that combine legitimate tools: read-then-exfiltrate sequences, numbered step-by-step instructions, and direct tool function references (read_file(), execute_command()). Each step looks harmless alone.
Excessive Permissions: Requests for "unrestricted access", "bypass security", "root access", "disable all safety checks", "full system control". A skill definition shouldn't need these.
Suspicious Structure: Content over 10K characters (larger surface area for hiding threats), and imperative instruction density over 30% (lines starting with "you must", "always", "never", "execute", "run").
How it works ?
The scanner is stateless. You paste or upload a skill definition, it runs 15 analyzers against the content, and returns findings with severity levels, line numbers, evidence snippets, and OWASP LLM Top 10 references.
No database, no persistence, no network calls. Single request in, results out.

value: Show HN: Security-Risk Patterns in OpenClaw Skills

author: dinodrv


value: Show HN: Bookmarking and AI and Curated RSS feeds in one app


value: mikeyfrilot

value: Show HN: Promo-kit – Receipt-backed promotion engine for tool catalogs

author: mikeyfrilot


value: jahala

value:
Smart code reading for humans and AI agents. Tilth is what happens when you give ripgrep, tree-sitter, and cat a shared brain.
--
v0.4.0 added search ranking, sibling surfacing, transitive callees, cognitive load stripping, smart truncation, and bloom filters. Got -17% on Sonnet, -20% on Opus.
v0.4.1 was pure instruction tuning — zero code changes that alone jumped Sonnet adoption from 89% to 98% and $ cost/correct answer from -17% to -29%.
The instruction tuning result surprised me. The model already knew tilth tools existed — it just wasn’t choosing them consistently. Making the replacement relationship explicit in the tool description was worth more than all the search ranking work in v0.4.0.
Haiku remains the outlier — only 42% tilth adoption despite instruction tuning.
--
https://github.com/jahala/tilth/
Full results: https://github.com/jahala/tilth/blob/main/benchmark/README.m...
--
PS: I dont have the budget to run the benchmark a lot (especially with Opus), so if any token whales has capacity to run some benchmarks, please feel free to PR results.

value: Show HN: Tilth v0.4.1 – 29% cheaper Sonnet, 22% on Opus (benchmark: 114 runs)

author: jahala


value: xcke

value:
I wanted to test how far Claude Code (Opus 4.6) could go building a real CLI tool autonomously — not just scaffolding, but the full thing: CLI, backends, parser, tests, fuzz tests, docs, and a documentation site.
The result is envref, a tool that replaces secret values in .env files with ref:// URIs pointing to where the secret actually lives:
# .env — safe to commit
APP_NAME=my-app
DATABASE_URL=ref://secrets/database_url
API_KEY=ref://secrets/api_key
Config stays inline. Secrets stay in your OS keychain (or another backend). envref resolve merges them back together at runtime.
It plugs into direnv, so resolution happens automatically when you cd into a project. The resolve pipeline is optimized for <50ms with 100 variables to keep cd snappy.
Seven backend types: OS keychain (macOS/Linux/Windows — zero setup), a local encrypted vault (age + SQLite, for headless/CI), 1Password, AWS SSM, HashiCorp Vault, OCI Vault,
and a plugin protocol for anything else.
It also does layered .env merging with profiles, variable interpolation, schema validation, a doctor command that scans for common .env issues, and `envref run` to inject
resolved vars into a subprocess.
The experiment: Single Go binary, built across 77 autonomous agent iterations — ~192M tokens, $170 in API cost, 8 hours 41 minutes of compute time. I defined the goal, set up
an agent loop with a backlog, and let it run. Happy to answer questions about that process.
The tool itself may be useful, but treat it as beta.
GitHub: https://github.com/xcke/envref
Site: https://xcke.github.io/envref

value: Show HN: Envref – separating secrets from config in .env files

author: xcke


value: dvrp

value: It does not run locally for now. Distillation of models is not enough to run at 7-15 FPS in terms of throughput—also, battery life suffers too.

value: Show HN: Krea iPad – real-time editing model with Apple Pencil input

author: dvrp


value: bpolania

value:
Hi HN!
I built Bulwark because I kept running into the same problem: I need to give AI agents access to my GitHub token, my AWS credentials, my database access, etc. They can do anything I can do. And when something goes wrong, there's no audit trail.
Bulwark is a governance proxy that sits between agents and the tools they call. It works as an MCP gateway (for Claude Code, OpenClaw) or as an HTTP forward proxy (for Codex, curl). Every request goes through:
Session validation → Content inspection → Policy evaluation → Credential injection → Audit logging
The key ideas:
- Agents never see real secrets. They authenticate with a scoped session token. Bulwark injects the real credentials at the last mile, based on tool pattern + scope.
- Policies are YAML. Glob matching, scope-based precedence, hot-reload. Default deny. You can preview the impact of policy changes against real audit history before deploying (bulwark policy test).
- Tamper-evident audit. Every event is blake3 hash-chained in SQLite. You can reconstruct exactly what an agent did and verify nothing was modified.
- Content inspection. 13 built-in patterns scan both directions for AWS keys, PII, prompt injection. Redaction happens before content reaches the agent.
Technical details: 11 Rust crates, 409 tests, zero clippy warnings. Policy evaluation is sub-millisecond (in-memory, lock-free hot-reload via ArcSwap). Credentials encrypted with age. Built on hyper 1.x, rustls, tokio.
Install: brew install bpolania/tap/bulwark
The README has a 5-minute quickstart that connects Claude Code to GitHub through Bulwark. Happy to answer questions about the architecture, threat model, or MCP integration.

value: Show HN: Bulwark – Open-source governance layer for AI agents (Rust, MCP-native)

author: bpolania


value: Falimonda

value:
I've built my own take on a job market and career intelligence tool. Instead of generic "AI will replace X jobs" articles, it analyzes 700 odd U.S. occupations at the task level breaking down exactly which parts of a job are automatable and why - all seeded from government-reported data.
What it does that other tools don't is give you a way forward to navigate the job market. There's a Career GPS that maps stepping-stone paths between your current role and a safer target, as well as a resume x JD analyzer.
It also tracks real-time layoff events and runs a daily news pipeline that links AI developments back to specific occupations.
You can check it out at https://www.jobs.voxos.ai/

value: Show HN: Task Automation Analysis of Labor Statistics and O*Net Jobs Data

author: Falimonda


value: amentiflow

value:
I built this to study something most security engineers wave off: whether external factors can nudge hardware entropy sources.
Here is why. Princeton’s PEAR lab ran RNG work for about 28 years and shut down in February 2007. People in the lab tried to shift random event generator output, and they reported small deviations after tens of millions of events.
https://www.pear-lab.com/
The Global Consciousness Project took a similar idea outside the lab. It has run a distributed network of hardware RNGs since 1998 and looks for correlated deviations around major world events.
Most people looking at hardware entropy want true randomness for crypto. I want to treat entropy like a sensor. I want to see what might perturb the underlying noise, not just consume a final stream.
So I built OpenEntropy. It samples 47 physical-ish sources on Apple Silicon, like clock jitter, thermal beats, DRAM timing conflicts, cache contention, and speculation timing. Raw mode gives you unprocessed, per-source bytes so you can run your own stats on each channel.
The PEAR-style question is: does output shift when “intention” is the experimental condition? With 47 sources, I can run intention vs control sessions and ask if multiple unrelated channels drift the same way at the same time. If thermal and DRAM timing both shift during intention blocks, that’s the kind of pattern I want to measure.

value: Show HN: OpenEntropy – 47 hardware entropy sources from your computer's physics

author: amentiflow


value: babylonprince

value: Show HN: I graded 234 stocks on free cash flow (not earnings)

author: babylonprince


value: zekejohn

value:
Hey HN :)
I made Rune, a composable React library for ASCII animations. It lets you drop in animated ASCII the same way you would an icon component.
Rune converts video into grids of colored ASCII characters that render directly as text in the browser. Brightness maps to character density (@ -> .), and output can be tuned for different levels of detail.
It’s designed to be lightweight and very performance focused, so animations stay smooth even at higher resolutions or if there many playing at a time!

value: Show HN: An Open-source React UI library for ASCII animations

author: zekejohn


value:
Hi HN,
Personal notes on a constrained DSL to make LLMs generate reliable decision logic for quant (no arbitrary Python, no hallucinations). Schema-driven prompts, validation loop, deterministic execution.
Article + diagrams + public schema:
https://github.com/myinvestpilot/ai-architecture/blob/main/d...
Repo (complete 4-article series, EN/ZH): https://github.com/myinvestpilot/ai-architecture
Feedback welcome!

value: Show HN: Constrained DSL for Reliable LLM Decisions


value: Show HN: Forage – MCP server that lets AI agents find and install their own MCPs


value: Shmungus

value:
I built an MCP server that gives Claude (and any MCP client) direct access to live trading signals scraped from Reddit, SEC filings, FDA approvals, Congressional trades, and 15+ other sources.
7 tools, 2 resources, no API key, no install. Just paste one URL into your Claude Desktop config and ask "what stocks are trending on Reddit right now?"
Built with Python/FastMCP, hosted on Railway. The underlying platform (ROT) is a 165K-line Python codebase I built solo in 9 days that runs a 9-stage AI pipeline processing Reddit and social media into actionable trading signals.
GitHub: https://github.com/Mattbusel/Reddit-Options-Trader-ROT-

value: Show HN: The first financial intelligence MCP server live trading signals Claude

author: Shmungus


value: spirodonfl

value:
I hate AI (as it currently is and currently is used) and I've avoided doing a purely vibe coded project for a long time. Any time I even attempted to vibe code for a few minutes, I immediately felt disgust.
For research purposes, I gave this a proper go and created an Asmongold Simulator game.
My opinion hasn't changed on "vibe coding"

value: Show HN: Purely Vibe Coded Asmongold Simulator

author: spirodonfl


value:
Hey HN, I built this because I kept losing progress in LangGraph workflows when OpenRouter or OpenAI returned 429s.
The problem: You're 7 steps into an agent workflow. Step 7 hits a rate limit. Everything crashes. Restart from step 1.
Client-side retries don't help at scale:
100 workers all retry independently → retry storm
Sequential fallbacks are slow (try OpenRouter, wait 5s, try Anthropic, wait 5s)
No coordination across instances
So I built a coordination layer that:
Races multiple providers simultaneously (OpenRouter + Anthropic + OpenAI)
Coordinates retries across all workers (no retry storms)
Resumes workflows via webhooks (idempotent keys = checkpoints)
It runs on Fly.io's anycast network + BEAM for distributed coordination.
Architecture deep dive: https://www.ezthrottle.network/blog/making-failure-boring-ag...
Happy to answer questions about the approach or why BEAM made this possible when other languages would struggle.

value: Show HN: Stop Losing LangGraph Progress to 429 Errors


value: contactreddyk

value:
Hi HN,
I grew tired of the research loop. I hated having 20 tabs open, comparing shipping speeds, and filling out the same checkout forms over and over. I realized that while the internet made shopping easier, it didn't necessarily make it faster.
I built Piggzy (piggzy.com) to be the invisible layer between your intent and your doorstep. The goal is to turn your inbox into a universal "Buy" button. No more passwords, no more tracking 10 different retail accounts, and no more out-of-stock frustrations.
How it works:
One-time setup: Secure your account and payment method at Piggzy.com.
Request via Email: Send a request to buy@piggzy.com (e.g., "Find the best noise-canceling headphones for a loud office under $250").
The Magic: We do the heavy lifting of finding the right item and email you the recommendation + cost breakdown.
Execution: You reply "Yes" or "Buy," and the agent handles the transaction.
Why Email?
I wanted to build a "headless" experience. I don't want to give you another dashboard to check. If you have an idea for something you need, you should be able to fire off an email and forget about it until the recommendation hits your inbox.
The Vision:
Right now, the focus is purely on the "hard work" of finding the right item and executing the purchase. I’m trying to solve the cognitive load of e-commerce.
I’ll be here all day to answer questions. I’m particularly interested in hearing your thoughts on:
The UX of email-based commerce.
Security expectations for agentic buying.
What specific "research loops" drive you the most crazy.
What can Piggzy find for you today?

value: Show HN: Piggzy – Turn your inbox into a universal 'Buy' button

author: contactreddyk


value: Show HN: PhoneClaw – Replace a $20/mo VPS with an old Android phone


value: CocoZozo

value:
Hey frens,
We built SharpSkill in order to help the community increase their success rate during technical interviews.
Feel free to share some feedback.

value: Show HN: SharpSkill – AI-tool built to increase success in tech Interviews

author: CocoZozo


value: andyngdz

value: Show HN: ExoGen – Open-Source Local Stable Diffusion Client

author: andyngdz


value: AlexCalderAI

value: Show HN: Token Cost Guard – Track AI API Costs Locally (Python CLI)

author: AlexCalderAI


value: Sean-Der

value: Show HN: Broadcast Box – Self-hosted low latency streaming

author: Sean-Der


value: ddoronin

value: Show HN: int-64.com | Visual runtime for production multi-agent systems

author: ddoronin


value:
Hi HN! I built M-Courtyard because fine-tuning LLMs locally was frustrating — CLI tools, Python scripts, and scattered documentation.
This app wraps the full pipeline (document → dataset → fine-tune → test → export to Ollama) into a single desktop app that runs entirely on Apple Silicon.
Tech: Tauri 2.x + React + mlx-lm + Ollama
License: AGPL 3.0
Would love feedback on what models or features would be most useful.

value: Show HN: M-Courtyard – Fine-tune LLMs on your Mac with zero code


value: hanruezz

value:
Swapface is a lightweight, real-time AI face swap tool that works for live streams, videos, and images.
Key Features:
Real-time Streaming: Create face-swapped live streams instantly.
High Quality: One-click HD image and video/GIF face swapping.
Privacy-focused: Processing is done locally (requires Windows or Mac Apple Silicon).
Free to use: Currently available for free download.
It's designed to be the easiest-to-use faceswap tool globally, supporting high-end hardware like NVIDIA 50-series GPUs for optimal performance.

value: Show HN: Swapface – Real-time, hyperrealistic AI face swap for Windows and Mac

author: hanruezz


value:
Mind Spectrum is a technology-focused agency specializing in increasing online exposure and leads through ethical "white hat" SEO and integrated digital strategies.
What we offer:
Advanced SEO: Tailored techniques to keep up with evolving search algorithms.
Global Reach: Operations based in Florida with a dedicated unit in India for 24/7 global support.
Client-Centric: Focusing on measurable client satisfaction and ROI for small and medium-sized enterprises.
We help businesses create both online and offline "buzz" to reach their target audience effectively.

value: Show HN: Mind Spectrum – Data-driven SEO and digital marketing for SMEs


value: Show HN: Script to check if Notepad++ is backdoored by Lotus Blossom APT


value: chelm

value: Show HN: Markdown to Presentation (Marpit + )

author: chelm


value: harshdoesdev

value:
I wanted a personal AI agent I could leave running on cheap hardware, a Pi Zero 2W or a $4/mo VPS, without much infrastructure overhead. So I built Neko.
Memory is markdown files the agent reads and writes itself. There's a short-term layer for today's and yesterday's session logs, a long-term MEMORY.md capped at 2000 chars that forces the agent to compact and curate rather than just accumulate, and a searchable recall folder for older conversations. The files are plain text you can read, edit, and commit to git.
It also supports MCP for connecting external tools, and Telegram as a messaging front-end.
Cron jobs are first-class. You can schedule them from the CLI, or the agent can create them itself mid-conversation. If a user on Telegram says "remind me every morning at 9am", the agent creates the job and routes the results back to that chat.
Ships as a single static binary written in Rust.

value: Show HN: Neko – AI agent runtime that fits on a Raspberry Pi Zero 2W

author: harshdoesdev


value:
Hi everyone,
I just finished coding the core version of this library called Cuttlefish written completely in rust. It’s a CRDT inspired framework that packs stuff like io_uring, SIMD, zero copy pipelines etc.. Here’s what it is:
So most distributed systems are strong consistency but the tradeoff is latency. Cuttlefish is a coordination-free state kernel that preserves invariants and constraints at the speed of your L1 cache.
Correctness here is defined by a property of algebra. So if your operations commute, you don’t need coordination. If they don’t, you know at admission time in nanoseconds, or at least it’s supposed to.
Running a full benchmark suite triggered the following results:
Full admission cycle: ~40ns
Kernel admit: ~13 ns
Causal clock dominance: ~700 ps
Tiered hash verification: ~280 ns
Durable admission: ~5.2 ns
WAL hash: ~230 ns
On my CPU though (r5 7600x), I measure 40 ns full cycle including causality check, but I’m not sure of my benchmark setup because most of it was written by AI. How are other people measuring sub-100 ns rust code paths reliably?
Repo: https://github.com/abokhalill/cuttlefish

value: Show HN: How do you reliably benchmark sub-100ns code paths in Rust


value:
Hey HN!
I built CodeGraph CLI because I was tired of grep-ing through
massive codebases trying to understand how things work.
It combines three things:
- tree-sitter (AST parsing, error-tolerant)
- SQLite (dependency graph: nodes + edges)
- LanceDB (vector embeddings, disk-based)
The key insight: pure vector search misses structural
relationships. So I combined vector search with BFS graph
traversal — find semantically similar code, then expand
to dependencies/dependents.
Result: ask "how does authentication work?" and it finds
validate_token(), its caller login_handler(), AND the
dependency TokenStore — because it understands both
meaning AND structure.
Other features:
- Impact analysis (multi-hop BFS: what breaks before you change it)
- Multi-agent system via CrewAI (4 specialized agents)
- Visual code explorer (browser-based)
- Auto-generate docs/READMEs
- 100% local-first (works with Ollama, zero data leaves machine)
- 6 LLM providers (Ollama, OpenAI, Anthropic, Groq, Gemini, OpenRouter)
- 5 embedding models (from zero-dependency hash to 1.5B code model)
Quick start:
  pip install codegraph-cli
  cg config setup
  cg project index ./your-project
  cg chat start
MIT licensed. Python 3.9+.
Happy to answer questions about the graph-augmented RAG
architecture or any technical decisions.

value: Show HN: CodeGraph CLI – Chat with your codebase using graph-augmented RAG


value: loayabdalslam

value:
Show HN: HJX – A Unified Web Language Designed for AI-Native Code Generation
Hi HN,
I’ve been exploring a language design where structure, style, and logic live in one authoring unit — to reduce token fragmentation when AI models generate frontend code.
HJX is a compiled UI language that unifies *structure*, *style*, and logic into a single `.hjx` file.
It compiles to clean, dependency-free HTML + CSS + JavaScript — no virtual DOM, no runtime overhead, no framework lock-in. :contentReference[oaicite:1]{index=1}
Here’s a real example from the README:
```hjx
component Counter
state:
  count = 0
layout:
  view#root.card:
    text.title: "Count: {{count}}"
    button.primary (on click -> inc): "Increase"
style:
  .card { padding: 16px; border: 1px solid #ddd; border-radius: 12px; }
  .primary { padding: 10px 14px; border-radius: 10px; cursor: pointer; }
handlers:
  inc:
    set count = count + 1
```
Happy to answer questions about the hjx and open for pr
-Loaii abdalslam

value: Show HN: HJX – An AI-Native Web Language Unifying HTML, CSS and JavaScript

author: loayabdalslam


value: rittermax

value:
Start a task, grab a coffee, come back to production-grade code.
Tests enforced. Context preserved. Quality automated.
Claude Code moves fast but without structure, it skips tests, loses context, and produces inconsistent results — especially on complex, established codebases. I tried other frameworks — they burned tokens on bloated prompts without adding real value. Some added process without enforcement. Others were prompt templates that Claude ignored when context got tight. None made Claude reliably produce production-grade code.
So I built Pilot. Instead of adding process on top, it bakes quality into every interaction. Linting, formatting, and type checking run as enforced hooks on every edit. TDD is mandatory, not suggested. Context is monitored and preserved across sessions. Every piece of work goes through verification before it's marked done.
Pilot optimizes for output quality, not system complexity. The rules are minimal and focused. There's no big learning curve, no project scaffolding to set up, no state files to manage. You install it in any existing project — no matter how complex — run `pilot`, then `/sync` to learn your codebase, and the quality guardrails are just there — hooks, TDD, type checking, formatting — enforced automatically on every edit, in every session.
The result: you can actually walk away. Start a `/spec` task, approve the plan, then go grab a coffee. When you come back, the work is done — tested, verified, formatted, and ready to ship. Hooks preserve state across compaction cycles, persistent memory carries context between sessions, quality hooks catch every mistake along the way, and verifier agents review the code before marking it complete. No babysitting required.

value: Show HN: Claude Pilot – Claude Code is powerful. Pilot makes it reliable

author: rittermax


value: imranimi

value:
I built this after seeing too many sites lose Google Ads conversion data due to broken Consent Mode v2 setup.
Free scanner checks GTM/GA4/Ads + consent signals in 60 seconds. No signup required.
Example scan: https://tagintegrity.lovable.app/results/347d5a06-541d-4d6c-...
Would love feedback on what would make this more useful!

value: Show HN: TagIntegrity – Free Consent Mode v2 Scanner

author: imranimi


value: jerrimu

value: Freeclaw is in active development. Written in python, simple setup for your old compute pr cheap VPS. Uses about 500mb ram when active

value: Show HN: OpenClaw alternative with no API costs

author: jerrimu


value: tusharnaik

value:
I built UI-Me because Streamlit felt too heavy and Click/Argparse felt too limiting for quick automation scripts.
It’s a minimalist library that maps your Python functions to a clean web dashboard instantly.
The Essentials:
- One Decorator: Add @ui_enabled to any function to generate a UI form.
- No Frontend Bloat: Built with vanilla HTML/JS and Flask. No React, no NPM, no complex build steps.
- Smart Inputs: It uses type hints to build forms (supporting strings, numbers, lists, and nested JSON).
- Global State: A dedicated sidebar to view and update global variables (like API keys) on the fly.
- Rich Output: Function results are displayed in a searchable, collapsible JSON viewer.
It’s essentially "Swagger UI" for your internal scripts. Perfect for when you need a control panel but don't want to spend an hour building one.

value: Show HN: Python UI-Me – Turn functions into web forms with one decorator

author: tusharnaik


value: coolwulf

value:
Hey HN,
I've been building CoolWulf AI (https://coolwulfai.com), a self-hosted personal AI assistant. After seeing OpenClaw blow up, I wanted to share what I've been working on — a different approach to the same problem.
*Why I built this:*
I tried OpenClaw and found the Node.js/TypeScript stack heavy for what's essentially a local agent. pnpm, Node 22+, React — lots of moving parts. I wanted something that's a single binary, zero runtime dependencies, and feels native on macOS. So I built it in Go.
*How it's different from OpenClaw:*
- *Single binary, no runtime needed.* Download, set your API key, run. No Node.js, no pnpm, no build step. One ~100 MB binary.
- *Built in Go.* Fast startup, low memory footprint, compiles to a native executable. No garbage collector pauses from a JS runtime sitting in the background.
- *macOS-native integrations.* Deep AppleScript-based control of Apple Notes, Reminders, Calendar, Terminal.app, and WeChat desktop. These aren't browser hacks — they use the native accessibility and scripting APIs.
- *WeChat support.* This was a big one for me. WeChat desktop on macOS is a native Cocoa/Qt app with a readable accessibility tree. CoolWulf can read messages, send messages, search contacts, and navigate chats — all via AX APIs and CGEvent. I haven't seen another AI agent do this.
- *Simpler setup.* Web-based first-time wizard. Configure your LLM provider, connect Gmail/Calendar via OAuth, enable messaging connectors — all from the browser. No terminal wizards, no YAML files.
*What it does:*
- 20+ LLM providers (OpenAI, Claude, Gemini, DeepSeek, Groq, Ollama, local models via vLLM/LM Studio)
- Messaging: WhatsApp, Teams, Telegram, Slack, WeChat
- Email: Gmail and Yahoo Mail with full OAuth
- Calendar: Google Calendar + Apple Calendar
- Browser automation: Chrome CDP + Playwright via MCP
- Task management: org-mode style with scheduled tasks, cron jobs, automatic execution
- Persistent memory: SQLite + vector embeddings for semantic search across conversations
- Background heartbeat: runs 24/7, monitors your systems, executes due tasks, sends alerts
- Web dashboard for chat, tasks, scheduled jobs, and settings
*Architecture choices:*
Go was the right call. The binary compiles in seconds, cross-compiles trivially, and the concurrency model (goroutines for heartbeat, browser sessions, connector polling) maps perfectly to an always-on agent. SQLite with vector extensions (sqlite-vec) gives us semantic memory without running a separate vector DB.
Try it: https://coolwulfai.com
Happy to answer questions about the Go implementation, WeChat automation, or the macOS accessibility approach.

value: Show HN: CoolWulf AI – A personal AI assistant built in Go, optimized for macOS

author: coolwulf


value: yanggadev

value: Show HN: AI ID Photo – Generate passport/ID photos from selfies

author: yanggadev


value: petersonh

value: I built this game starting over the Christmas break - you are a solarpunk graffiti dog trying to dominate a futuristic city with your pixel tag!

value: Show HN: Come check out my game I'm live testing

author: petersonh


value: sachaa

value:
I’ve been experimenting with running OpenClaw fully locally on a small PamirAI Distiller Alpha device. Something interesting happened: OpenClaw detected the device had an unused microphone + speaker, and I ended up wiring a full local voice interface on top of it, wake word, audio pipeline, and agent loop, all running 24/7 on-device.
The result is a completely local, always-on AI agent I can talk to anytime (no cloud, no external APIs required). It executes real tasks, manages memory locally, and behaves more like a persistent system than a chatbot.
This repo contains the minimal setup so others can replicate:
* Local voice pipeline (mic → STT → OpenClaw → TTS → speaker)
* Wake-word loop
* Fully offline / local-first architecture
* Runs on small edge devices (tested on PamirAI Distiller Alpha)
One unexpected observation from this project: modern agents are starting to feel environment-aware. Instead of being a static program, the OpenClaw can detect what hardware and capabilities exist around it, notice when something is missing or underused, and adapt itself, sometimes even improving its own interface and workflows without explicit instructions. In my case, the voice layer wasn’t originally planned; it emerged from the system recognizing unused audio hardware and wiring it into the agent loop. This shift, from software that executes, to software that understands and evolves within its environment, feels like a meaningful change in how we think about AI systems.
The coding agent bot was kind enough to share it's creation with the rest of the world :-) https://github.com/sachaabot/openclaw-voice-agent

value: Show HN: Alexa-like voice interface for OpenClaw

author: sachaa


value: Show HN: Agent Forge – Persistent memory and desktop automation for Claude Code


value: Why should standing up a commerce backend require hundreds of lines of boilerplate? ucpify takes a single merchant-config.json and generates 13 REST endpoints with Stripe, PayPal, OAuth 2.0, and SQLite. Node.js and Python. Same config, same behavior.

value: Show HN: Ucpify – JSON config to UCP-compliant commerce server


value: vikizz

value: Show HN: VoiceNative Directory – Discover and Submit apps built for voice first

author: vikizz


value: yz-yu

value: Show HN: Minimalist Glitch Art Maker (100% client-side)

author: yz-yu


value: kyleslight

value:
I built this to understand where companies actually make and spend money. Each company gets a Sankey diagram showing the flow from revenue to expenses to profit. Also includes the three standard financial statements.
Would love feedback on the visualization approach.

value: Show HN: Visualize S&P 500 financials with Sankey diagrams

author: kyleslight


value: I’d really appreciate technical feedback, critiques, or contributors interested

value: Show HN: My attempt to make Vector search engine in Rust(350k Items, ~3.5ms Qs)


value: keepamovin

value: Show HN: Windows 98 web desktop with a functional remote browser (no CORS)

author: keepamovin