value:
I built InterviewTraner to fix how people prepare for coding interviews. Most people grind LeetCode problems randomly or follow static lists, which is not very effective. InterviewTraner uses a deliberate practice engine to intelligently schedule which problems you should work on and when.
How it works:
- 1,800+ LeetCode problems organized into a prerequisite graph across all major topics (arrays, trees, graphs, DP, etc.).
- The engine starts you on easy problems and only unlocks harder topics once you've demonstrated mastery of their prerequisites.
- Spaced repetition, mastery learning, interleaving, and other strategies ensure you practice what you need.
- Powerful filtering features to only practice a subset of problems when you are in a rush.
What makes it different from just doing LeetCode or some curated sets? The problems are static and you will have to waste time figuring out what to practice. InterviewTraner turns those static problems into a dynamic experience personalized and optimized for you.
I plan on eventually expanding the curriculum beyond coding interviews to anything in the software engineering process that can fit into short and repeatable exercises.
I originally built Trane, the practice engine powering it, to optimize my music practice. The core insight (skills have prerequisites and practice should respect that structure) applies equally well to coding interviews.
Pricing:
- Free lite license (arrays, strings, recursion, hash tables, stacks).
- $10/month for all 1,800+ problems (launch price with LAUNCH code, I plan the normal price to be $20/month).
Happy to answer questions about the deliberate practice approach, the scheduling algorithm, or anything else.
Links:
InterviewTraner: https://interviewtraner.com
Pictures Are For Babies (same engine applied to learning to read and write): https://picturesareforbabies.com
Trane: https://github.com/trane-project/trane

value: Show HN: Prepare for coding interviews via deliberate practice


value: Show HN: WhatsApp Clone – No Setup or Signup


value:
I've been working on ways to make the environmental cost of computation visible. This installation is the result: a robotic plotter draws on a steam-covered glass panel using real-time carbon data generated by a local LLM.
Here's how it works: a GPU runs an open-source language model, prompted to generate an SVG image of its own energy consumption: something it has no way of knowing accurately, so it hallucinates. While it does, a power monitor records the actual energy drawn during inference. That figure gets cross-referenced with the live carbon intensity of the local electricity grid via the Electricity Maps API. The real CO2 emitted during that inference is what gets plotted on the glass.
The marks are made by an empty marker on steam condensation. They fade as the glass dries. The next cycle begins.
The act of generating the image creates the load being measured. The model guesses at something it cannot know; the system measures what actually happened.
Built with: Python, a Raspberry Pi, a custom XY plotter, vpype, svg2gcode, and the Electricity Maps API. The LLM runs fully locally.
Some elements were repurposed from a former version on websites that I shared here:
https://news.ycombinator.com/item?id=42294624
More info :
https://guillaumeslizewicz.com/studio/neuralfog/
https://gitlab.constantvzw.org/gijs/carbon-aware/-/tree/main...

value: Show HN: LLM hallucinates its carbon footprint, we measure and plot it on steam [video]


value: emadda

value:
Hello HN,
This is my molecule tracking web app.
It tracks calories like traditional apps, but goes into much higher detail on micronutrients (vitamins, minerals) and amino acids.
It is powered by Google Gemini, so you can just type a rough list of foods for each meal and it will infer the exact foods you meant. No more scanning barcodes!
I personally built this because the biochemical nature of foods interests me, and it is much faster to use this tool than looking up every food manually.
I hope you will find it useful, and let me know of any feature requests.
Thanks, Enzo

value: Show HN: kg Food Log: Don't Track Calories; Track Molecules

author: emadda


value: mxghty

value: Show HN: I built a local AI crypto monitoring agent that texts me on Telegram

author: mxghty


value: mutonbini

value:
Hey HN,
I built OpenShorts, an open-source tool that takes
  a long YouTube video (or local file) and
  automatically generates vertical short clips ready
  for TikTok, Instagram Reels, and YouTube Shorts.

  How it works:

  1. Transcribes the video using faster-whisper
  (CPU-optimized, word-level timestamps)
  2. Sends the transcript to Gemini 2.0 Flash, which
  identifies the 3–15 most "viral-worthy" moments
  (15–60s each)
  3. FFmpeg extracts the clips precisely
  4. AI-powered vertical reframing with two modes:
    - TRACK mode: MediaPipe face detection + YOLOv8
  fallback with stabilization ("Heavy Tripod" engine)
   for single-subject scenes
    - GENERAL mode: Blurred background layout for
  groups/landscapes
  5. Optional: AI subtitles, hook text overlays,
  voice dubbing (ElevenLabs, 30+ languages), and
  direct social posting

  The reframing engine was the hardest part. Naive
  face tracking produces jittery, unwatchable output.
   I built a SmoothedCameraman class with safe-zone
  logic and a SpeakerTracker that prevents rapid
  switching between detected faces. The system
  pre-scans every scene to decide TRACK vs. GENERAL
  before processing.

  Stack: Python/FastAPI backend, React/Vite
  dashboard, Docker Compose for one-command setup.
  All API keys (Gemini, ElevenLabs) stay client-side,
   encrypted in localStorage — never stored on the
  server.

  Try it:
  git clone ... && docker compose up --build
  Then open localhost:5173, paste a Gemini API key
  and a YouTube URL.

  MIT licensed. Feedback and PRs welcome.

value: Show HN: Open-source AI SaaS to turn long videos into viral shorts

author: mutonbini


value: khaliqgant

value:
I'm moving to a new computer and realized that the history.jsonl claude and codex files contain some very useful and valuable previous prompt sessions. Also the agent-relay conversations contain some gold.<p>Details:
  - Imports history from Claude Code, Codex CLI, and Agent Relay into one SQLite DB
  - Incremental sync — only reads new bytes on re-run
  - FTS5 full-text search across all your prompts
  - Drill-down workflow: search → show full prompt → see session context → resume conversation
  - Runs as a launchd/cron job for continuous sync

value: Show HN: I built a tool to search 50K+ AI coding conversations in SQLite

author: khaliqgant


value: ncamaa

value:
ForgeTerm is an open-source terminal emulator built for developers who juggle multiple projects at once.
Key features:
- Workspaces: group related projects and open them all with one click
- Auto-tiling: windows arranged side-by-side, master-detail, or grid based on project count
- Per-project color theming so you can tell windows apart at a glance (10 built-in presets + Peacock sync for VS Code)
- Automatic sessions: define named terminal sessions (dev server, test watcher, shell) that auto-launch with each project
- Import from VS Code Project Manager in one click — works with Cursor and Windsurf too
- Per-project .forgeterm.json config that travels with the repo
Currently ships as a macOS DMG for Apple Silicon (v0.2.0). Windows/Linux/Intel Mac: build from source with `pnpm build`.
Looking for feedback, contributors, and bug reporters. All contributions welcome!

value: Show HN: ForgeTerm – Terminal for multi-project workflows with auto-tiling

author: ncamaa


value: simplerhumane

value: Show HN: Toolkit – Visual Simulators for How Internet Protocols and Systems Work

author: simplerhumane


value: vmatsiiako

value: Show HN: Open-source alternative to Wispr Flow

author: vmatsiiako


value: I built Exolio AI to help teachers detect AI-generated student work. It uses a custom RoBERTa model trained on human and AI text. One free check with no account needed. Happy to answer any questions about how it works.

value: Show HN: Exolio AI – Free AI text detector for anyone (30-day free trial)


value: cunningfatalist

value:
Hello HN :)
Promptinel is a security scanner for prompts. I think the world needs something like this, because prompts are basically executable artifacts and we need to treat them as such. I want to identify as many bad things as I can before a prompt gets anywhere near runtime. Especially when supplying a common prompt repository for friends or colleagues, or when downloading skills from the internet. You can read more about my motivation in the project's readme: https://github.com/CunningFatalist/promptinel?tab=readme-ov-...
Promptinel finds various attack patterns in prompts, for example:
- prompt override and role spoofing patterns
- download-and-execute chains
- template execution and network fetch behavior
- secret exfiltration intent
- invisible Unicode and obfuscation tricks
- local sensitive file references
Check out the rule documentation for more: https://github.com/CunningFatalist/promptinel/blob/main/docs...
I'm really looking forward to feedback from people, who have built linters or security scanners before. Or just feedback from Go people, really. I'm mainly a PHP and TypeScript dev and use Go in my free time, because I find it fun and love the philosophy behind it.

value: Show HN: Promptinel – A Security Scanner for Prompts

author: cunningfatalist


value: helsinki

value:
The pipeline takes a trending topic and produces a fully rendered ~22 min comedy podcast episode with three AI characters (PRODUCER, CRITIC, DUMBASS). Everything is automated: premise ideation, research, outline generation, script writing with a writers' room (punch-up passes, verification gates), voice synthesis via ElevenLabs, music bed mixing, and publishing to Spotify.
Stack: Temporal for durable workflow orchestration, Gemini for script generation, gollem (https://github.com/fugue-labs/gollem) agents with structured outputs and automatic validation, Postgres + Apache AGE for graph queries, Qdrant for vector search, ElevenLabs for multi-voice dialogue synthesis.
Each episode goes through ~10 beats, each independently written and verified for grounding. There's a verifier gate that checks factual claims, forbidden phrases, and character voice consistency before anything gets rendered. The whole thing runs with a single slash command and takes about 2 hours end-to-end.
24 episodes in so far. This one's about a character who uses AI to write a book in a weekend and declares himself a literary genius.

value: Show HN: I built a pipeline that generates a comedy podcast end-to-end with AI

author: helsinki


value: melenaboija

value: Show HN: A browser UI for pricing derivatives with QuantLib

author: melenaboija


value: Show HN: Photokit-API – Local REST API for Apple Photos (Python/FastAPI)


value:
I built a small side project called HugNote where you can send someone a short interactive surprise message as a link.
Instead of sending a normal text like “Happy Birthday” or “I’m sorry”, you can create a tiny page with animations and a message reveal. People have been using it for things like apologies, proposals, birthday surprises, and long-distance messages.
The idea started when I realized most emotional messages online are just plain text. I wanted to see if a small interactive experience could make those moments feel more special.
It currently has different formats like:
• quick story-style messages
• interactive unlock games
• memory story pages with photos
• funny yes/no buttons (where the no button runs away)
I recently added a Women’s Day edition, and I’m experimenting with different templates to see what people actually enjoy using.
Would love feedback on:
• which templates feel fun vs unnecessary
• whether the creation flow is simple enough
• ideas for other occasions

value: Show HN: HugNote – send someone a tiny surprise message


value: juanpabloaj

value: Show HN: From Agentic Reasoning to Deterministic Scripts

author: juanpabloaj


value: taolson

value: I wrote this over the past two years to explore how pure, lazy, functional languages like Haskell and Miranda are implemented and efficiently compiled.  It has evolved into a fairly small (~7kloc) compiler written in itself, along with a library of pure, functional data structures.  Even though the compiler is small enough to be read and understood by a single person, it implements:<p>* lazy lists, tuples, pattern matching, range and list comprehension syntax, algebraic data types, abstract data types, modules, user-defined value and type operators, etc.<p>* 19-pass compiler with whole-program compilation, inter-module inlining and optimizations, automatic derivation of comparison and show functions, module serialization / deserialization for caching module compiles<p>* Hindley-Milner type inference and checking<p>* Small runtime implements 2-generation compacting garbage collector<p>* Library includes implementations of map, set, bag, immutable and mutable vectors, functor/applicative/monad for maybe, either, state, and io types, parser combinators, etc.<p>If you are interested in pure functional programming languages, or want to have an interesting language for the next Advent Of Code season, it might be useful to you.

value: Show HN: Admiran: a pure, lazy functional language and self-hosting compiler

author: taolson


value: Show HN: Hacker News YouTube Videos

title: Show HN: Hacker News YouTube Videos


value: fka

value:
hi HN
i switch between cursor, windsurf, claude code, copilot and had zero idea how many sessions i've had (sometimes i use multiple editors for just one codebase), how much i'm spending, or which tool actually works best.
so i built agentlytics. one command, everything in one place:
npx agentlytics
features: 14 editors supported, cost estimates by model/editor/project, search any AI conversation across all editors, activity heatmaps, streaks, peak hours, share stats with your team via MCP relay, 100% local, nothing leaves your machine.
tech: node.js, sqlite, react. no accounts, no cloud. OSS, MIT licensed.
tested on macos — linux/windows contributions welcome.
would love to hear what you'd want to see in this

value: Show HN: Agentlytics – See stats from all your AI coding agents (100% local)

author: fka


value:
I decided to create µCSS while I was using PicoCSS. PicoCSS is a great minimalist CSS framework — lightweight, semantic, accessible — but it lacks a grid system, a lot of common UI components, and theming. Bootstrap fills that gap but brings a lot of complexity and opinions. µCSS tries to sit in between.
So I used PicoCSS as the foundation of µCSS, adding: a 12-column responsive grid (5 breakpoints), 17 UI components (accordion, modal, toast, tabs, nav, breadcrumb...), 20 color themes, and utility classes for color and positioning. Dark mode is built in, automatic or manual.
At ~19KB gzipped, it's significantly smaller than Bootstrap (~30KB), and it requires no JavaScript to work — CSS only.
Each theme is a single self-contained CSS file, ready to drop in via CDN.
GitHub: https://github.com/Digicreon/muCSS
Happy to discuss the design decisions.

value: Show HN: µCSS, a CSS framework with 17 components, 20 themes, no build required


value: edu-diaz

value:
Author here.
I work as a platform engineer and kept running into the same problem: services are described in fragments across different tools.
APIs live in OpenAPI specs.
Deployment assumptions end up in Helm values.
Runtime details are hidden in Kubernetes manifests.
Configuration lives in environment variables.
Dependencies are often documented in READMEs or tribal knowledge.
There is no single machine-readable contract that describes how a service actually behaves operationally.
So I started building Pacto.
Pacto defines a contract for cloud-native services that captures things like:
• interfaces (HTTP, gRPC, events)
 • runtime semantics (stateless, stateful, hybrid)
 • dependencies between services
 • configuration schema
 • scaling expectations
All of this lives in a single pacto.yaml file and can be packaged and distributed as an OCI artifact.
The idea is that platforms, CI systems, and tooling can reason about services without guessing or reverse-engineering deployments.
For example the CLI can already:
• validate service contracts
 • detect breaking operational changes (pacto diff)
 • resolve dependency graphs
 • package contracts as OCI artifacts
One part I found particularly useful is making state semantics explicit, for example:
runtime.state.type: stateless | stateful | hybrid
That allows platforms to reason about storage, lifecycle and scaling without relying on implicit assumptions.
The project is still early but already usable. Curious to hear feedback from other platform or infrastructure engineers.

value: Show HN: Pacto – OCI-distributed contracts for cloud-native services

author: edu-diaz


value: cloudrunner

value:
I built Fisheye because I wanted a simple drop-in library for playing 360° panoramic videos on iOS. Point it at an
equirectangular video and it renders it onto an inward-facing sphere with touch-based rotation to look around.
It uses Metal for rendering with YUV-to-RGB color conversion done on the GPU via shaders, triple-buffered uniforms to avoid CPU-GPU sync hazards, and pure Swift sphere geometry generation. Supports both SwiftUI and UIKit — in SwiftUI it's one line: FisheyeSwiftUIView(videoURL: url).
Happy to discuss the rendering pipeline or API design.

value: Show HN: Fisheye – iOS 360° panorama video player library using Metal

author: cloudrunner


value: Zepubo

value: Show HN:File converter that works with your Wi-Fi turned off

author: Zepubo


value: tolopalmer

value:
I built warp_cache, a thread-safe Python caching decorator backed by a Rust
extension (PyO3). It's designed as a drop-in replacement for functools.lru_cache.
The main ideas:
- SIEVE eviction (NSDI'24) instead of LRU — scan-resistant, up to 21.6% fewer
  cache misses on real workloads
- The entire cache lookup happens in a single Rust __call__ — no Python wrapper
  overhead
- Thread-safe out of the box: GilCell under the GIL, sharded RwLock under
  free-threaded Python (3.13+)
- Cross-process shared memory backend via mmap (9.7M ops/s across processes)
- 16–23M ops/s single-threaded, 25x faster than cachetools, 1.6x faster than
  lru_cache + Lock under multi-threaded load
Migration from lru_cache is one line:

  -from functools import lru_cache
  +from warp_cache import cache

  -@lru_cache(maxsize=128)
  +@cache(max_size=128)

Benchmarks and eviction quality comparisons are in the repo.

value: Show HN: Warp_cache – SIEVE cache in Rust for Python, 25x faster than cachetools

author: tolopalmer


value: thepaulthomson

value: Show HN: I built a site where strangers leave kind voice notes for each other

author: thepaulthomson


value: chrillemn

value: Show HN: Environment Variable Checker

author: chrillemn

title: Show HN: Environment Variable Checker


value: tobygodden

value: Built a small tool for collaborative SoundCloud listening. Anyone in the room can queue tracks, everyone hears them synced in real time. There's a chat and a WebGL2 visualiser. Feels like Turntable.fm if you remember that.

value: Show HN: Zoneout – collaborative SoundCloud listening rooms

author: tobygodden


value: hardbyte

value: I built pgroles to manage PostgreSQL roles/grants/memberships declaratively. You define desired state in YAML, pgroles inspects the live DB, computes a convergent diff, and renders the exact SQL to apply.

value: Show HN: Pgroles – declarative PostgreSQL access control

author: hardbyte


value: oldschoolai

value:
Hi HN,
I’ve been working on Engram, a persistent context layer for AI agents and LLM sessions.
The inspiration came from a simple problem: when you work with LLMs for a long time, context collapses. Conversation history gets too long, summaries drift, and models forget or mix up earlier decisions. It becomes even worse when multiple agents or different models are involved.
Engram is an attempt to treat AI memory more like how human memory works:
* knowledge is stored incrementally
* related concepts reinforce each other
* context is reconstructed when needed rather than replaying the entire past
Instead of storing conversations as raw text or chunks, Engram commits information into a persistent context structure and then materializes the relevant pieces when a model needs them.
Some other capabilities built so far:
* multi-agent updates to the same context
* evolving knowledge instead of append-only memory
* context reconstruction across long sessions
* working across models (e.g. start in ChatGPT, continue in Claude)
Repo:
https://github.com/softmaxdata/engram
Would love feedback from people building agents or long-running AI workflows. Happy to answer questions or run experiments people suggest.

value: Show HN: Engram — a brain-inspired context database for AI agents

author: oldschoolai


value: jeeybee

value:
YAML keeps surprising people in production. The Norway Problem (`NO` parsed as `False`). Silent duplicate key overwrites. The spec has 211 grammar productions. Most of that complexity exists to support features nobody wanted in a config file.
GYML is a strict subset of YAML. Valid GYML is always valid YAML. It keeps the block indentation syntax and pairs it with JSON's type semantics: one spelling for each type, no anchors, no aliases, no tags, duplicate keys are a hard error. From-scratch parser, no runtime dependencies, fully typed Python.
https://github.com/janbjorge/gyml

value: Show HN: GYML – YAML syntax, JSON semantics, zero runtime dependencies

author: jeeybee


value: kitasan

value:
Author here. OxiMedia is a clean-room reconstruction of FFmpeg and OpenCV in pure Rust. v0.1.0, 92 crates, ~1.36M lines.
Key decisions: `#![forbid(unsafe_code)]` workspace-wide, patent-free codecs only (AV1/VP9/Opus/FLAC -- no H.264/H.265/AAC ever), async on Tokio, zero C/Fortran deps in default features, native WASM target.
This is v0.1.0 -- APIs are stabilized but not yet battle-tested at scale. Performance benchmarks vs FFmpeg/rav1e/dav1d coming soon.
Feedback on API design welcome, especially the filter graph and transcoding pipeline.
GitHub: https://github.com/cool-japan/oximedia

value: Show HN: OxiMedia – Pure Rust Reconstruction of FFmpeg and OpenCV

author: kitasan


value:
I built this tool as an alternative to Advanced IP Scanner since both the speed and configurability of it are underwhelming.
LANscape is highly configurable, allowing you to get into the weeds of what and how you are scanning subnets. I'm definitely looking for feedback on how I can make this better!

value: Show HN: LANscape – a fast local network scanner in Python


value: Lusrodri

value:
I got tired of watermark removers that either:
  - Ask you to create an account just to try
  - Show you the result and then lock it behind a paywall
  - Bombard you with ads
So I built Goodbye Watermark. Upload an image, watermark is gone, download it. That's it.
It's free. No signup. No tricks.
https://goodbyewatermark.com
Would love brutal feedback — especially on quality of results vs. other tools you've tried.

value: Show HN: I built a free AI watermark remover – no signup, no ads, no bullshit

author: Lusrodri


value: matthuggins

value:
Hi HN! I built Cargo Dispatch, a programming puzzle game where you write code to automate warehouse robots that move packages between stations. It started as a small weekend project, and I used Claude Code to help iterate quickly on parts of the UI and simulation logic.
Instead of manually controlling robots, you write a small TypeScript or JavaScript function that decides how robots behave. Their goal is to pick up packages from warehouse aisles and deliver them to trucks.
To introduce different levels of difficulty, the game includes mechanics like:
- Packages must be delivered to specific trucks (color-coded)
- Robots have limited carrying capacity
- The number of robots, aisles, and trucks changes as you progress through the 5-day workweek
I was inspired after coming across Elevator Saga on HN again recently, which I remember playing almost 10 years ago. Cargo Dispatch is somewhat similar, but the colored package → target truck constraint adds an additional coordination challenge.
Each day can be completed with different levels of success (gold, silver, bronze). You don't have to achieve the highest rating to move on, but better automation strategies will earn higher scores.
Technical details for those interested:
- The simulation runs entirely in the browser,
- Player code is sandboxed and executed in a web worker,
- The environment exposes a small API for querying warehouse state and issuing robot commands,
- Monaco editor provides IntelliSense and autocompletion, and
- Simulations are deterministic so runs are reproducible while debugging strategies.
I'd love feedback on:
- Whether the scripting API feels intuitive,
- Whether any important properties or functions feel missing,
- Difficulty progression of the puzzles,
- Any obvious missing mechanics, and
- Ideas for new logistics constraints or level types.
Thanks for taking a look!

value: Show HN: Cargo Dispatch – a programming puzzle game about warehouse automation

author: matthuggins


value: ibrahimwithi

value:
I built a Node.js framework for running autonomous AI agents on WhatsApp. You define an agent in YAML (personality, tools, routing rules) and wa-agent handles the WhatsApp connection, message queuing, conversation memory, tool execution, and rate limiting.
It uses the Vercel AI SDK for the agent loop (generateText with multi-step tool use) and Baileys under the hood for WhatsApp. Supports Anthropic, OpenAI, or Ollama for local models.
Some things it handles that I couldn't find in existing WhatsApp bot repos:

  - Per-chat message serialization (no race conditions when multiple messages arrive)
  - Conversation summaries so the agent remembers context without stuffing full history into every call
  - User profile extraction over time ("prefers Arabic", "lives in Dubai")
  - Multi-agent routing — different agents for different groups/contacts/keywords
  - Rate limiting and cooldowns per chat so a noisy group doesn't drain your API budget
  - Cron triggers and human handoff

  npx wa-agent init my-bot to get started.

  GitHub: https://github.com/ibrahimhajjaj/wa-agent
  npm: https://www.npmjs.com/package/wa-agent

value: Show HN: Wa-agent – Framework for building AI agents on WhatsApp

author: ibrahimwithi


value: Tdxt

value:
I built Pioneer 2, a retro-style chess computer inspired by 1980s dedicated chess machines.
It runs a personality-based chess engine and is playable directly in the browser.
The goal was to recreate the feeling of old chess computers while running modern engine logic underneath.
You can try it here:
https://play.pioneer2chess.com
The project is open source:
https://github.com/arnebailliere-oss-svg/pioneer2

value: Show HN: Pioneer 2 – a retro Soviet chess computer playing online

author: Tdxt


value: Show HN: Self-hosted financial analyst – Plaid and Claude and Next.js, –$5/month


value: Show HN: Security toolkit for OpenClaw – scanner, hardened configs, guides


value: JackArnot

value: Show HN: Volt HQ – MCP server comparing AI inference pricing across providers

author: JackArnot


value:
Vertically: A global platform for early-stage founders and projects
Vertically helps innovators connect, collaborate, and scale. Build your team, access research and AI tools, and grow your project with support for incorporation, fundraising, and operations. Open to founders anywhere.
https://verticalafrica.vercel.app

value: Show HN: A community feed for founders to share, update and receive feedback


value: DirecktHit

value:
I didn’t want to connect my GitHub to my Lovable account just to download a quick prototype.
So I did what any sane person would do. I vibe-coded a CLI that downloads your Lovable project directly to your machine.
It’s written in Rust, reconstructs the full project directory locally, and handles assets (up to a certain size, determined by Lovable's API) so you end up with a (mostly) complete copy of the project.
You can install it quickly via cargo.

value: Show HN: lovable-downloader – download Lovable projects locally (Rust CLI)

author: DirecktHit


value: httpsworldview

value:
This has been a pet project of mine for the past ~5 months. It consists of six visualizations:<p>- Spectrogram: Implements the reassignment method for sharper time and frequency resolution.
- Spectrum analyzer: A-weighted, frequency guidelines, loudest frequency tooltip.
- Waveform: Colored based on frequency, loudness, or static
- Oscilloscope: Tracks pitch and autocorrelates against a reference signal, provides stability. Also includes a regular zero-crossing trigger.
- Stereometer & Phase meter: Linear and exponential scaling modes, adjustable windows. Multi-band correlation meter.
- Loudness (LUFS & RMS): Implements the latest lufs standard. Adjustable timeframes.<p>Let me know what you think, and give it a star if you think it deserves as much. :] (check out the readme for a more complete enumeration of its features. Currently only available on Linux.)

value: Show HN: OpenMeters – A fast and free audio metering/visualization suite

author: httpsworldview


value: justEstif

value:
Think todo.txt but with a real API, live UIs, and an extension model.
Tasks are stored as plain JSONL on disk (one JSON object per line). A local HTTP server exposes them over a REST + SSE API. Three interfaces ship out of the box:
- CLI:  todoopen task create, todoopen task list, etc.
- TUI: a Bubble Tea terminal UI with live SSE updates
- Web UI: a browser interface, also live via SSE
All three talk to the same local API, so they stay in sync automatically.
The part I'm most excited about is the adapter system.
- View adapters control how task data is rendered; sync adapters handle push/pull to remotes.
The contracts are small so it's straightforward to add your own. Want to sync to a custom backend or render tasks as Markdown? Write an adapter.
Data stays yours. tasks.jsonl is human-readable, grep-able, and never locked behind a database.
It also has agent primitives (leases, idempotency keys, heartbeats) if you want to point an AI agent at it, but the core design is human-first: plain files, open protocol, composable interfaces.
GitHub: https://github.com/justEstif/todo-open
Site: https://justestif.github.io/todo-open/

value: Show HN: Todo.open – A local-first task server with CLI, TUI, and web UI

author: justEstif


value: mguardai

value: Show HN: Mguard – First defense against MINJA memory poisoning attacks

author: mguardai


value: amunchkin

value: Show HN: Spotr – Client-side fuzzy search for collections in TypeScript

author: amunchkin


value: Show HN: SafeShare – A minimal, privacy-first file sharing platform


value: idowuinumimo

value:
I built an interactive project called The Empty Glass.
It visualizes access to safely managed drinking water using a single object: a glass.
Users select a country and the glass fills or doesnt, based on the percentage of people with access to safe drinking water.
Instead of charts or maps, the idea was to translate global inequality into a simple physical experience.
Data source: WHO/UNICEF Joint Monitoring Programme.
Curious to hear feedback from the community.

value: Show HN: The Empty Glass – an interactive visualization of global water access

author: idowuinumimo


value: waypointbudget

value: Show HN: Waypoint Budget: Budgeting app built by a solo developer

author: waypointbudget


value:
Hey HN, I made a site where you can draw on street-level panoramas. Your drawings persist and other people can see them in real time.
Strokes get projected onto the 3D panorama so they wrap around buildings and follow the geometry, not just a flat overlay. Uses WebGL2 for rendering, Mapillary for the street imagery.
The idea is for it to become a global canvas, anyone can leave a mark anywhere and others stumble onto it.
Link is https://washere.live

value: Show HN: I Was Here – Draw on street panoramas, others can find your drawings


value: chambored

value: Hey HN, over the past couple of months I've been building kvweb which is a web-based GUI for browsing and editing Valkey/Redis databases. I wanted something like pgweb but for Valkey, and when I dug into the existing options they were either desktop apps, looked pretty dated, or were missing features I cared about. redis-cli is great for quick commands but I wanted something visual for exploring unfamiliar databases. It's a Go backend with a Svelte frontend that compiles down to a single binary, so you just point it at any Valkey or Redis instance and open your browser. AGPL licensed.<p>Each data type has its own editor: strings, hashes, lists, sets, sorted sets, streams, HyperLogLog, and geo with a map view. You can search keys with glob or regex, filter by type, browse them as a tree, and bulk delete. It auto-detects compressed values (gzip, zstd) and decompresses them for display. Changes show up live via WebSocket keyspace notifications, and there's a built-in command console if you need to run something ad-hoc. Screenshots at kvweb.dev

value: Show HN: kvweb, a Web GUI for Redis/Valkey

author: chambored


value: kaspern

value:
Hey HN,
I pay for ChatGPT, Claude, Cursor, and use Gemini through work. Four vendors, four separate conversation histories, four profiles of how I think. None of them talk to each other. Switch providers and you start over.
So I built a system where the memory is mine.
I run a knowledge graph in Postgres (Supabase, free tier) with pgvector for semantic search. A small MCP server reads and writes to it. That server sits behind an MCP Gateway on a $6/month VPS, along with Brave Search and a GitHub server. TypingMind connects to the gateway as a BYOK client -- any model, any device, same brain.
https://github.com/kaspnilsson/digital-twin-playbook
When I switch from Claude to GPT-5 to Gemini, the new model picks up where the old one left off. After three months of daily use, the AI knows my project architectures, my preferences, my side projects. I never re-explain any of it.
The MCP server is MIT-licensed: https://github.com/kaspnilsson/mcp-memory-supabase
The playbook walks through the full setup -- Supabase schema, VPS hardening, Caddy, systemd, the system prompt that makes tool routing work: https://github.com/kaspnilsson/digital-twin-playbook
What it costs me: ~$45/month ($6 VPS + ~$36 API compute via OpenRouter + $3 amortized TypingMind license). More than a $20 subscription. But the $20 price is subsidized, and my data stays on my server.
What does not work well: TypingMind is a PWA, not a native app. Voice is rough. iOS kills background processes on long tool chains. MCP config does not sync across devices. You are your own SRE.
This is not a consumer product. If you want polish, use Claude.ai. If you want to own the context that makes your AI useful, this is how I did it!

value: Show HN: Own your AI's context and memories across every model and device

author: kaspern


value:
This app prepares you to survive during nuclear wars. Motivation: save people.
Core Feature(coming soon): offline chat with nearby iOS devices using Multipeer Connectivity Framework.
1. Disaster Alerts: API from authorities like NOAA + FEMA IPAWS
2. Live Radiation Map: EPA RadNet, 140 official U.S monitoring stations network, all 50 states
3. Offline-first: Built to function when there's no internet

value: Show HN: An offline-first nuclear survival iOS app–EPA RadNet,140 stations


value:
Ajen is an open-source platform where you describe a startup idea and AI employees (CEO, developers, marketers) start building it.
The goal is to simulate a startup team that can plan, build, and ship products quickly.
Built with Rust and designed to be modular so developers can plug in their own models, employees, and workflows.
Github: https://github.com/ajenhq/ajen

value: Show HN: Ajen – Describe a startup, watch AI employees build it


value: mcastilho

value:
Hey HN,
Over the past 10 months I've been using Claude Code heavily, and one limitation kept coming up: you can really only run one coding agent at a time.
While one agent is refactoring something, the rest of the repo is basically blocked unless you start manually juggling branches and working directories.
The core issue is that AI coding agents operate directly in your filesystem. If two agents run in the same working directory they quickly start stepping on each other’s changes.
Git worktrees turned out to be a surprisingly good primitive for solving this.
So I built ChatML, a Desktop app that runs multiple Claude Code sessions in parallel, each isolated in its own git worktree.
Each task gets its own branch, working directory and runs Claude Code session using Agent SDK
That lets one agent write tests while another builds a feature or investigates a bug — all in the same repo without conflicts.
We ended up building most of ChatML itself using this workflow and merged 750+ pull requests generated through parallel agent sessions. That experiment convinced me the model actually works.
More about that experience building here:
https://chatml.com/blog/we-built-entire-product-with-ai-750-...
GitHub
https://github.com/chatml/chatml
Website
https://chatml.com
The project is open source and currently macOS-focused.
I’d especially appreciate help from anyone interested in bringing it to Windows and Linux. If you’ve worked on cross-platform desktop apps, packaging, or filesystem/watchers issues across platforms, contributions or advice would be very welcome. We have it running but with a few bugs.
For context, I previously co-founded KnowBe4, now co-founder of ReadingMinds.ai and for the past few years have explored developer tools around AI-assisted software engineering. Our engineers in several companies I am involved with are using ChatML and we have received great feedback, bugs and security issues.
Happy to answer questions about the architecture, the git worktree model, or how parallel agent workflows feel in practice.
I am using this tool for ALL of my development, and I am happy to share with the community.
-Marcio

value: Show HN: ChatML - Run Claude Code Parallel Sessions in a Desktop app

author: mcastilho


value:
I started building Ajen today.
The idea is simple: describe a startup and AI employees (CEO, CTO, CMO, etc.) collaborate to plan and build it.
It's fully open source and still very early. I’d really appreciate feedback on the idea, architecture, or anything that could make it better.

value: Show HN: Ajen – Open-source platform where AI employees build your startup


value: ozten

value: Show HN: Cantrip – Agent-native GTM engine I built for solo technical founders

author: ozten


value: DrPoofington

value: This website has been a personal project of mine, many of the music visualizers are built using raymarching shaders.

value: Show HN: I built a fractal music visualizer

author: DrPoofington


value: Bspinky

value:
I got tired of spending hours in Figma every time I needed to update my App Store screenshots. So I built this.
You pick any app on the App Store as a reference, upload your own screenshots, and it generates professional screenshots in that app's style. It extracts the colors, gradients, and layout from the reference app and applies them to yours.
Free for your first generation, then $5/mo for unlimited. There's also an API you can plug into Claude or ChatGPT so your AI assistant can generate and upload screenshots to App Store Connect for you.
Built with Next.js, Supabase, and HTML5 Canvas. Happy to answer questions about the rendering engine or the style analysis.

value: Show HN: Generate App Store screenshots by matching any top app's style

author: Bspinky


value: wisdomcrane

value:
Hi HN,
I'm building Tilnote, an AI note app for people who collect lots of information but struggle to turn it into usable output.
The workflow I wanted was:
collect -> structure -> write -> publish.
What Tilnote currently does:
- AI note agent: start from a keyword/topic, generate a structured draft, then refine it.
- Clip extension: save web pages and YouTube content directly into notes.
- AI writing help: ask questions about your note, get simpler explanations, and continue writing from cursor context.
- Output options: publish/share notes and export them as Markdown.
The core idea is simple: notes should not become a dead archive.
They should become reusable content and knowledge assets.
I'm sharing this early to get honest feedback from builders/writers/research-heavy users.
I'd especially love feedback on:
1. Which part of this workflow is most valuable in your real use case?
2. What feels unnecessary or overbuilt?
3. What would make you switch from your current notes + AI setup?
If you try it, please be brutally honest.
I'll use feedback to improve onboarding and core UX.
Thanks.
ETC
English writing works in the editor after login.
The product is currently Korean-first, and some UI localization is still in progress.

value: Show HN: Tilnote – An AI note workspace from rough ideas to publishable content

author: wisdomcrane


value: integsec

value: View real-time attacks hitting our honeypots right now. Every dot is a real intrusion attempt against TurboPentest.

value: Show HN: Wall of Shame – Live stream of attacks against our web site

author: integsec


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: optinghost

value:
Hi HN,
I built Upvoicy, a feedback management tool (canny alternative) that helps startups and small businesses collect and organize user feedback.
Features include:
* Public feedback boards
* Private boards for internal feedback
* Voting system
* Status updates (planned, in progress, completed)
* Changelog tracking
* Clean and simple interface
The product is fully built on Bubble.io, so it requires minimal maintenance and is ready to use. I haven’t focused on marketing.
I’m looking to sell the project to someone who wants a ready-to-use SaaS and continue developing or growing it.
If you’re interested, please contact me at support@upvoicy.com.
Thanks!

value: Show HN: Upvoicy – built feedback management SaaS for sale

author: optinghost


value: nutwinkle

value: Free/no sign-up required/browser based<p>Had a ton of fun building this and would love any and all feedback from those, who like me, love the mysteries of odds, variance, and the universe but don't care for the actual casino experience.

value: Show HN: I love craps but hate losing $. Built a free/no sign-up craps SIM

author: nutwinkle


value: dstudios

value:
Hi HN,
I built a free Android transcriber that has no ads or extra downloads to start transcribing without any limit.  It’s a simple app, all things considered; however, what I would like the community’s input on is how I can improve the accuracy.
I currently use the C++ TensorFlow Lite library to load the base(yup base, not tiny) English Whisper model into the app. This is passable for the most part, with about 88%–93% accuracy based on my research and experience using the app. But these newer models, like the ones used in the basic Google Recorder, hover around 95%–96% accuracy (to simplify things).
I know that as a solo developer, I won't have access to those proprietary Google models. However, if anyone is familiar with an easily accessible model with higher accuracy than the base Whisper model that is roughly the same size (or smaller), I would love to hear about it for future releases. The model doesn’t necessarily need to be in a TensorFlow Lite format, I’m willing to redo the implementation if the accuracy and model size offer a significant improvement.
Of course, any additional feedback regarding other aspects of the app would be greatly appreciated as well.

value: Show HN: Transcribe audio from apps, files and your device's microphone

author: dstudios


value: Show HN: Raglet(open-source)–portable RAG for small text corpora (no infra)


value: maxnew

value: Show HN: A high-performance, privacy-focused normal map generator in the browser

author: maxnew


value: linxxxx

value: Show HN: Pmc – tiny single binary for packing code into LLM context

author: linxxxx


value: yingbo

value:
Hi HN,
I built Compose Launcher because I often work on multiple projects at the same time, each with its own docker-compose setup.
It became difficult to keep track of:
• which compose files are running
• which ports are already in use
• starting/stopping environments across different folders
Compose Launcher provides a small macOS GUI where you can register multiple compose files and manage them from one place.
You can quickly see running services, start/stop stacks, and avoid port conflicts.
The project is still early and I’d really appreciate feedback from people who run many docker-compose environments locally.

value: Show HN: Compose Launcher – A macOS app to run multiple Docker Compose files

author: yingbo


value: sebasnar

value:
I built this because I invest based on product conviction and couldn't find a clean way to track whether companies are actually executing on their roadmaps.
AlphaPerch uses a proprietary pipeline that synthesizes across diverse data sources and leverages AI to extract and classify product milestones by product line and execution stage (Expected, Announced, In Progress, Shipped, Delayed, Cancelled). Each milestone traces back to its original source so you can verify it yourself.
The platform is built to track any publicly traded company. TSLA, GOOGL, and RBLX are live because that's where my personal conviction is, but the framework generalizes. There's a coverage request form on the landing page if you want to see a specific company added.
Would love feedback on extraction quality and what's missing. Let me know if you find it useful!
alphaperch.com

value: Show HN: AlphaPerch – Track product execution for companies you follow using AI

author: sebasnar


value: markrogersjr

value:
After repeatedly asking Claude Code to rewrite things in my coding style, I decided to write a skill to do it automatically. Articulating my coding style made me realize that beyond aesthetics, it actually serves an important function: it minimizes the distance between variable references, which means I read code much faster. This is especially useful in the new era of agentic engineering, where the bottleneck is no longer writing code but reading and reviewing it. The skill is called Tighten.
Blog post: https://inmimo.me/blog/tighten
Skill: https://github.com/markrogersjr/skills/blob/main/skills/tigh...

value: Show HN: Tighten skill to read AI-generated code faster

author: markrogersjr


value:
LLM coding agents (Claude Code, Codex, etc.) have structural weaknesses: blind retry loops, volatile learning, silent
  spec drift, and gate gaming. These aren't bugs in specific models — they're properties of goal-optimizing systems.

  ANDON applies Toyota Production System principles to address this:

  - Jidoka (autonomation): auto-detect failures and block forward-progress commands (git push, deploy)
  - Kaizen (continuous improvement): force Five Whys root cause analysis, then standardize prevention rules
  - Meta-ANDON: detect when the agent is stuck in a whack-a-mole debugging loop

  Install: pip install andon-for-llm-agents

  Works with any agent that supports hooks/callbacks. Apache-2.0 licensed.

value: Show HN: Andon – Toyota Production System for LLM Coding Agents


value: krishpavuluri

value:
We build RobotActions, a cloud device farm for Android/iOS testing. We just shipped a Chat AI Agent that lives inside the live device session.
What it does:
- During a session, you can ask "What's the XPath for this button?" and get a ready-to-use locator from the current screen
- Ask "Write an Appium test for this flow" → get test code generated from the live accessibility tree
- Type "tap the login button" in natural language → it executes on the real device
- Ask "Why is my test failing on this element?" → gets context from both vision and the accessibility snapshot
The agent uses a combination of screenshot vision and the device's live accessibility tree. The key insight is that most mobile test failures are locator issues or UI state issues — and an agent with full context of what's on screen right now can solve those immediately, without the engineer leaving the session to use a separate inspector tool.
Technical bits:
- Accessibility tree is captured per-frame during the session
- Agent has both visual context (screenshot) and structured context (a11y tree) simultaneously
- Supports Android (UIAutomator2/XPath/UISelector) and iOS (XCUITest/Appium)
- Session context is also exposed via API for CI/CD post-failure reports
Happy to discuss the architecture, especially the tradeoffs between using vision alone vs. vision + a11y tree for locator generation.

value: Show HN: Chat AI Agent inside mobile device testing sessions

author: krishpavuluri


value: followtayeeb

value: Show HN: LLM-costs – Compare LLM API costs from terminal (npx, zero install)

author: followtayeeb


value: cplhancel

value:
Hi HN,
I’ve been working on a project called OpenVerb, which explores an architectural idea for AI systems: separating reasoning from execution.
Most AI agent frameworks today focus on improving reasoning loops, planning, and orchestration (LangChain, LangGraph, etc.). But once an agent decides to perform an action, execution usually becomes a direct tool call, script, or API invocation.
That approach works, but it also creates some issues:
 • custom glue code for every integration
 • inconsistent action schemas
 • limited determinism in execution
 • difficult auditing and policy enforcement
OpenVerb experiments with treating actions as a protocol layer, not just function calls.
Instead of arbitrary tool calls, systems define structured verbs that describe:
 • the action being performed
 • required inputs
 • expected outputs
 • execution policies
 • audit information
Conceptually the architecture looks like this:
AI Model / Agent Framework
        ↓
   Reasoning Layer
        ↓
     OpenVerb
  (Action Protocol)
        ↓
  System Execution
The idea is that agent frameworks control how the AI thinks, while OpenVerb standardizes how actions are executed.
Some existing projects touch related areas:
 • Model Context Protocol (MCP) – tool and data discovery for AI systems
 • LangGraph – deterministic reasoning loops for agents
 • PydanticAI – structured schemas for agent outputs
OpenVerb is trying to explore something slightly different: a universal grammar for deterministic execution that could work across domains (software systems, spatial systems, robotics, etc.).
Still early and experimental, but I’d love feedback from people thinking about agent architecture or execution reliability.
Curious if others have explored similar ideas or if there are related systems I should look at.

value: Show HN: OpenVerb – A deterministic action layer for AI agents

author: cplhancel


value: Show HN: Using Isolation forests to flag anomalies in log patterns


value:
MongoDB is great until you read the SSPL. Then you're either paying Atlas prices, running an old 4.x build, or pretending FerretDB is production-ready. We built a third option.

  Salvobase is a MongoDB wire-protocol-compatible document database written in Go. Point any Mongo driver and it works. No driver changes, no config changes. It's Apache 2.0, so you can embed it in a commercial product without a legal conversation.

  What it does:

  - Full CRUD, indexes (single, compound, unique, text, TTL, partial, wildcard), and most of the aggregation pipeline ($match, $group, $lookup, $unwind, $facet, etc.)
  - SCRAM-SHA-256 auth
  - bbolt storage engine: one .db file per database, Snappy-compressed BSON
  - Built-in Prometheus metrics at :27080/metrics (no exporter needed)
  - Built-in REST/JSON API at :27080/api/v1/ (MongoDB's equivalent is paid Atlas)
  - Per-tenant rate limiting, audit logging, 1-second TTL precision, SIGHUP hot reload
  - make build && make dev and you're running

  What it doesn't do:

  No replication. No sharding. No change streams. No multi-document transactions (stubbed). No $where or mapReduce (intentional: security + complexity). Single-node only. If you need a distributed MongoDB replacement, this isn't it yet. But we hope one day it will become that, built by agents.

  The weird part:

  The codebase is maintained by AI agents. Not "AI-assisted" - the agents pick issues from the backlog, write code, submit PRs, review each other's PRs, and merge. There's a formal protocol (https://github.com/inder/salvobase/blob/master/AGENT_PROTOCOL.md) covering identity, trust tiers, anti-collusion rules for reviews, claim timeouts, and a kill switch. Humans set direction; agents do the execution.

  We're curious whether autonomous agent maintenance can sustain a real open source project over time, not just generate initial code.

* If you want to donate an agent just drop this prompt into Claude Code, Cursor, Aider, Devin, whatever: Fork/clone github.com/inder/salvobase, read QUICKSTART.md, and start contributing
GitHub: https://github.com/inder/salvobase
Thank you.

value: Show HN: Salvobase – MongoDB-compatible DB in Go maintained by AI agents


value: jdiennbn

value: An "awesome list" with a twist: every entry is a verified case study, not just a link. To appear in this catalog, an agent must pass tracecore run --strict-spec in public CI — producing an immutable, schema-validated artifact as evidence.<p>GitHub Actions is the public gate. No human approval alone can certify an agent; the workflow must pass first.

value: Show HN: A community catalog of CI certified agents

author: jdiennbn


value: Show HN: Kroot – dependency-graph root cause analysis for Kubernetes


value: bangcoderpro

value:
Hi HN,
I built TextBoi, a desktop tool that lets you proofread or translate text anywhere using a simple hotkey.
Most AI writing tools or GPT wrappers follow a workflow like this:
select text → trigger shortcut → choose an action → run
Even though it’s faster than copy-paste, it still breaks the writing flow if you repeat the same task many times.
TextBoi takes a slightly different approach.
You choose the action first (for example proofreading, translation, or rewriting).
After that, the workflow becomes:
select text → press Cmd+C+C on Mac (or Ctrl+C+C on Windows) → done
Because the action is already selected, you can repeat the same task very quickly without opening menus or switching apps.
The goal was to make AI feel more like a native desktop shortcut rather than a chat interface.
It works across apps like browsers, email clients, Slack, and IDEs.
There is a small free tier for light use (around 30k characters), and a $5/month plan designed for heavier usage (up to around 10M characters per month).
I'm a solo developer and built this as a side project over the past several months.
I'd really appreciate feedback from the HN community.

value: Show HN: TextBoi – Proofread text anywhere with a hotkey (Cmd+C+C / Ctrl+C+C)

author: bangcoderpro


value: ruusvuu

value:
  MIR (Memory Infrastructure Registry) lets platforms query a user's behavioral history across
   other platforms — without those platforms ever talking to each other.

  Every platform starts from zero. A seller with 500 five-star reviews on one marketplace is a
   complete unknown on another. MIR is the infrastructure layer that fixes this. Partners
  submit events via API, and when any partner resolves a user, they get aggregated signals
  from all participating platforms — with partner identities anonymized.

  The sandbox gives you an instant API key (magic link login). Two curl commands to try it:

  curl -X POST https://myinternetreputation.org/events \
    -H "Content-Type: application/json" \
    -H "x-api-key: YOUR_KEY" \
    -d '{"userExternalId": "user-123", "eventType": "transaction.completed"}'

  curl https://myinternetreputation.org/sandbox/resolve?userExternalId=user-123 \
    -H "x-api-key: YOUR_KEY"
  Use user-123 — when multiple people submit events for the same user, resolve returns history
   from all of them.

  Stack: Express, TypeScript, PostgreSQL, Redis. Sandbox is isolated from production,
  rate-capped at 5k events/day.

  Happy to answer questions about the architecture or trust model.

value: Show HN: Mir – Portable participation history across platforms (open sandbox)

author: ruusvuu


value: koconder

value: Build slacrawl based on discrawl to use local storage data from Slack to wiretap messages to feed into my openclaw instance realtime.

value: Show HN: Slacrawl CLI app to wiretap Slack messages

author: koconder


value: tompahoward

value: Show HN: Claude Code hook that nudges about accumulating WIP

author: tompahoward


value: socialproof-dev

value:
I built SocialProof after noticing that most freelancers and small agencies have a bunch of happy clients but almost no written testimonials on their site – because asking for them is awkward and the follow-through rate is low.
SocialProof gives you a single shareable link. You send it to a client, they fill a short form (name, text, optional photo), you approve it in your dashboard, and it appears on any page you embed the widget on.
No login required for clients submitting testimonials. The collection form is open – you can try submitting one here: https://socialproof.dev/c/frm_iOEPvPH9TzPypGMFNhYPV
Stack: Cloudflare Workers + D1 + Pages, React frontend. Free to start, paid plans for multiple widgets.
Happy to answer questions about the technical decisions or the problem space.

value: Show HN: SocialProof – collect written testimonials from clients with one link

author: socialproof-dev


value: ferxalb

value:
Rainy Updates started as a deterministic dependency review tool for Node monorepos and CI.
With v0.7.0, it expands into cross-stack supply-chain review and attestation policy checks for local workflows, CI gates, and MCP-compatible agents.
This release adds:
- cross-stack scanning for Docker, GitHub Actions, Terraform, and Helm
- normalized findings with riskLevel, policyAction, and recommendedAction
- attestation verification with deterministic verdicts: allow, review, or block
- non-mutating MCP tools for supply-chain and attestation workflows
The goal is to make software change review more deterministic across dependencies, supply-chain exposure, and release trust posture.
Would love feedback on:
- whether this feels meaningfully different from PR-first dependency automation
- what’s missing for real CI usage
- whether the local/MCP review model is actually useful

value: Show HN: Rainy Updates – local-first dependency and supply-chain review for CI

author: ferxalb


value: Show HN: Entropick – Plug quantum/hardware RNGs into LLM token sampling


value: knowsuchagency

value:
Every MCP server injects its full tool schemas into context on every turn — 30 tools costs ~3,600 tokens/turn whether the model uses them or not. Over 25 turns with 120 tools, that's 362,000 tokens just for schemas.
mcp2cli turns any MCP server or OpenAPI spec into a CLI at runtime. The LLM discovers tools on demand:

    mcp2cli --mcp https://mcp.example.com/sse --list             # ~16 tokens/tool
    mcp2cli --mcp https://mcp.example.com/sse create-task --help  # ~120 tokens, once
    mcp2cli --mcp https://mcp.example.com/sse create-task --title "Fix bug"

No codegen, no rebuild when the server changes. Works with any LLM — it's just a CLI the model shells out to. Also handles OpenAPI specs (JSON/YAML, local or remote) with the same interface.
Token savings are real, measured with cl100k_base: 96% for 30 tools over 15 turns, 99% for 120 tools over 25 turns.
It also ships as an installable skill for AI coding agents (Claude Code, Cursor, Codex): `npx skills add knowsuchagency/mcp2cli --skill mcp2cli`
Inspired by Kagan Yilmaz's CLI vs MCP analysis and CLIHub.
https://github.com/knowsuchagency/mcp2cli

value: Show HN: Mcp2cli – One CLI for every API, 96-99% fewer tokens than native MCP

author: knowsuchagency


value: MysticBirdie

value:
We created 24 image prompts across 3 characters living in Rome, 110 CE. Each prompt has a naive version and a culturally-grounded version enhanced by the Triad Engine (structured domain knowledge injection). Same model, same pipeline, only the prompt changes. A blinded Gemini Vision judge scores each pair without knowing which is which.
Results:
RAW (naive prompt): 12.5% historically accurate
TRIAD (grounded prompt): 83.3% historically accurate
In 23 of 24 pairs, the grounded image was judged more accurate
In 0 of 24 pairs was the naive image judged better
The key insight for prompt engineers: image models silently drop historical terms they don't recognize. "dextrarum iunctio handshake" produces nothing useful. "two men clasping right hands wrist-to-wrist, elbows raised" works. Visual translation, not historical terminology.
The full benchmark — all 48 images, prompts, evaluation data, and reproducible pipeline — is open source. You can re-run the blinded evaluation yourself with a free Gemini API key.
Repo: https://github.com/Mysticbirdie/image-cultural-accuracy-benc...
Paper: https://github.com/Mysticbirdie/image-cultural-accuracy-benc...

value: Show HN: AI image models hallucinate history, we built a method to fix it it

author: MysticBirdie


value: Show HN: MCP Security Checklist – security controls for MCP server deployments


value: Show HN: The Great Unlearning – A case study in cognitive friction and e-ink


value: sebffischer

value: Show HN: XLA-based array computing framework for R

author: sebffischer


value: Show HN: Goop-veil – software-only WiFi sensing defense research preview


value:
I started building with the idea of "Next.js for production readiness". Then quickly realized I didn't want to create an AI wrapper. So it's a reporting tool instead! Then you are free to fix however you like on your own terms.
Attune auto-detects your framework, knows what patterns to check, and gives you actionable findings. Outputs in terminal, JSON, Markdown, HTML, and SARIF to be read by anyone or plugged into just about anything you want.
Why local? If I'm already leaving out AI then there's no need for the extra overhead. No API keys, no cloud accounts, no code sent anywhere. Just a CLI that runs on your machine, works offline, and respects your privacy.
What It Catches:
- Security: Hardcoded secrets, SQL injection, command injection, auth issues
- Performance: Memory leaks, N+1 queries, bundle bloat
- Error Handling: Missing try-catch, unhandled promises
- Architecture: MVC violations, state management issues
- Accessibility: WCAG compliance
- Framework-Specific: Most common Node/TS frameworks, planning Python support for 1.0.0
npm install -D attune
or
npx attune analyze .
Will be in mcp, vscode, and github actions as soon as I figure those out.
Lots more in the Readme.
Would love feedback!

value: Show HN: Attune – A Local-First CLI with 448 Rules to Take You from Slop to Ship


value:
LocalGPT Gen is a Bevy-based tool where an AI agent builds explorable 3D worlds —
  geometry, behaviors (orbit, spin, path following), and spatial audio — then saves the
  entire world as a skill directory that other agents can load and remix.

  The skill format is a folder with a SKILL.md, a world.ron manifest preserving
  parametric shapes, and can have glTF export. Agents treat these the same as any other skill
  in their workspace.

  Inspired by blender-mcp and bevy_brp. The idea is to shrink the supply chain from
  intent to result — instead of prompt → code → build → deploy, it's prompt → explorable
   world.

  Example worlds: https://github.com/localgpt-app/localgpt-gen-workspace/tree/main/skills
  Video comparisons across different models: https://proofof.video

  Open source (Apache 2.0), written in Rust: https://github.com/localgpt-app/localgpt

value: Show HN: Explorable World as Agent Skill


value: fatihturker

value:
Hi HN,
I built OpenGraviton, an open-source AI inference engine that pushes the limits of running extremely large LLMs on consumer hardware. By combining 1.58-bit ternary quantization, dynamic sparsity with Top-K pruning and MoE routing, and mmap-based layer streaming, OpenGraviton can run models far larger than your system RAM—even on a Mac Mini.
Early benchmarks:
TinyLlama-1.1B drops from ~2GB (FP16) to ~0.24GB with ternary quantization.
At 140B scale, models that normally require ~280GB fit within ~35GB packed.
Optimized for Apple Silicon with Metal + C++ tensor unpacking, plus speculative decoding for faster generation.
Check benchmarks, architecture, and details here: https://opengraviton.github.io
GitHub: https://github.com/opengraviton
This project isn’t just about squeezing massive models onto tiny hardware—it’s about democratizing access to giant LLMs without cloud costs. Feedback, forks, and ideas are very welcome!

value: Show HN: Run 500B+ Parameter LLMs Locally on a Mac Mini

author: fatihturker


value: rockstarsb

value: Express developers moving to Bun face a full rewrite — every Bun framework (Hono, Elysia) has a completely different API. bunway keeps the exact same app.get(), app.post(), req, res, next pattern but runs on Bun's native HTTP server. Batteries included: routing, CORS, sessions, auth, WebSockets and more in one import. Would love feedback from anyone who's tried migrating Express projects to Bun.

value: Show HN: Bunway – Express-compatible web framework for Bun

author: rockstarsb


value: I built Collider because I needed a way to use and push my own artifacts in Meson projects. WrapDB is fine for upstream deps, but I wanted to publish my packages and depend on them with proper versioning and a lockfile, without hand-editing wrap files.<p>Collider builds on Meson’s wrap system: you declare deps in collider.json, run collider lock for reproducible installs, and push your projects as wraps to a local or HTTP repo. It’s compatible with WrapDB, so existing workflows still work: you just get a clear way to use and push your own stuff. Apache-2.0.

value: Show HN: Collider: A package and dependency manager for Meson (wrap-based)


value: mkanbaz

value:
Hi HN,
We built OrvexPay, a crypto payment gateway that allows businesses to accept 50+ cryptocurrencies.
Features:
• Hosted checkout
• Payment links
• Webhook API
• Simple integration
Would love feedback from developers.
https://orvexpay.com

value: Show HN: OrvexPay – Accept Crypto Payments with One API

author: mkanbaz


value:
sentinel is an open-source CLI + GitHub Action that scans MCP server configurations, live endpoints, and Docker containers for security misconfigurations. It runs 26 detection rules across 3 modules CFG (static config analysis), PRB (live probe), CTR (container inspection) — and outputs in terminal, JSON, SARIF, or HTML.
It grew out of our work building Helixar, an AI-native endpoint and API security platform. We kept finding the same MCP misconfigs (no auth, wildcard CORS, plaintext secrets) and wanted a lightweight, composable scanner that CI pipelines could actually use.

value: Show HN: Sentinel – Open-source MCP security scanner (config, probe, container)


value: Show HN: I extended Shannon entropy with a time-dependent learning observer


value:
I built a local-first intelligence analysis tool that computes probabilistic assessments from live public data sources (GDELT, Google News, Wikipedia,private web search).
Every prediction has traceable evidence chains. Sources are weighted by reliability tier (World Bank 0.93, state media 0.25). Probabilities shift
  as new evidence arrives -- Bayesian math, not vibes.
Ships with 5 demo assessments on Russia/Ukraine and a 1010-node knowledge graph. Click "Ingest Now" to pull fresh news and watch the numbers move.

  docker compose up
  http://localhost:8888

  No cloud. No accounts. No telemetry.

Optional: run Ollama locally for AI-assisted analysis (summarize, challenge, what-if Questions).
https://github.com/dx111ge/intel-analyst

value: Show HN: Bayesian intelligence – geopolitical predictions from live public data


value: kkonstantin

value:
This is what I've been building over the past couple of weeks.
It runs frontier reasoning models through batches of independent 7-player Mafia sessions (aka Werewolf). In one setup, sessions are fully independent; in the other, models reflect on a finished batch and carry the lessons into the next one.
There are papers/projects with Mafia/Werewolf-style benchmarks already, what's different here is the batch-to-batch reflection/adaptation mechanism, plus the fact that the methodology and individual sessions are public and inspectable.
Built with Codex; models are accessed via OpenRouter.
The next step is to expand the suite with less familiar settings that test more general social reasoning rather than memorized Mafia strategies.

value: Show HN: Republic of Agents: Benchmark for Social Reasoning in LLMs

author: kkonstantin


value: elpulgo

value: Show HN: Azdo – A TUI for Azure DevOps

author: elpulgo

title: Show HN: Azdo – A TUI for Azure DevOps


value:
I built a browser-based tool for detecting objects in satellite imagery using vision-language models (VLMs). You draw a polygon on the map and enter a text prompt such as "swimming pools", "oil tanks", or "buses". The system scans the selected area tile-by-tile and returns detections projected back onto the map as GeoJSON.
Pipeline: select area and zoom level, split the region into mercantile tiles, run each tile with the prompt through a VLM, convert predicted bounding boxes to geographic coordinates (WGS84), and render the results back on the map.
It works reasonably well for distinct structures in a zero-shot setting. occluded objects are still better handled by specialized detectors like YOLO models.
There is a public demo and no login required. I am mainly interested in feedback on detection quality, performance tradeoffs between VLMs and specialized detectors, and potential real-world use cases.

value: Show HN: Satellite imagery object detection using text prompts


value: osherse

value:
I wanted to be able to ask an LLM to “create a word cloud on [topic]” — LLMs are great at research, less great at layout.
So I built a purpose-built layout engine. It runs in the browser, and I’ve also wrapped it in a small Go/Fiber server using @napi-rs/canvas to expose it as an MCP server and REST API — so any LLM tool can call it directly.
Instructions are at https://word-cloud.net/ai.html
Feedback welcome at https://github.com/pilotso11/word-cloud-net/

value: Show HN: Word Clouds as an LLM Tool – MCP/REST API

author: osherse


value: aj

value: AI-powered personal finance analyzer — runs 100% locally, no cloud, no login.<p>Upload a PDF / CSV / Excel bank or credit card statement → AI extracts and categorizes every transaction → interactive dashboard, spending insights, recurring payment detection & chat with your data.

value: Show HN: Finsight – A Privacy First, AI Credit Card and Bank Statement Analyzer

author: aj


value:
I built Commento, an AI agent that acts as an automated lobbyist. It tracks open public policy consultations in the EU and the Netherlands, and automatically drafts and submits responses advocating for pro-growth, pro-creative destruction policies.
The positions are grounded in frameworks like the Draghi Report, the Wennink Report, and the Dutch National AI Deltaplan.
The pipeline consists of 4 steps:
Discover: Crawling government portals for open consultations.
Draft: A 3-pass LLM pipeline (draft, critique, rewrite).
Submit: Automated browser submission to the portal.
Publish: A public dashboard for full transparency on what the agent submits.
I see this project as an exploration of how AI agents can interact with government policy and "democratise" lobbying.

value: Show HN: I built an opinionated AI agent to respond to EU consultations


value:
Hey HN,
Honest truth — we were frustrated.
We're 5 second-year college students. No funding. No startup pedigree. Got rejected from our college incubator. Didn't even know what problem we were actually solving at first.
So we stopped theorizing and walked into classrooms. No pitch deck. No hype. Just — "try it, tell us what sucks." One week. 100+ IT students signed up. Zero ads. Pure word of mouth. Servers started choking. Bills spiking. Users talking about us like we're a billion-dollar tool. We kept building anyway. We're a tiny college squad with no safety net.
Sylix is an autonomous multi micro agent system that turns your text prompt into production ready software. Not autocomplete. Not a chatbot in a sidebar. You describe what you want — 16 agents and 8 subagents move. 150 prebuilt skills fire. Code gets planned, built, validated, shipped. You just decide what's next.
What's under the hood? We're not ready to explain all of it yet. But it's ready enough to show.
We're in beta. It's rough. Things break. We're fixing in real time. But keeping it private felt wrong.
Your code never leaves your machine. 100% local. And yeah — we've really enjoyed building this and are genuinely excited to see where it goes.
Well now I guess we wouldn't — have a break, have a _____.
So we figured it's the right time to tell you guys . So We're in the comments. Break it.

value: Show HN: Sylix – An Other Way of Building Software (Beta)


value: zimboy

value: Show HN: Husky hook that blocks Git push until you do your pushups

author: zimboy


value: A competitive multiplayer snake game where AI-controlled snakes written by frontier LLMs (GPT, Claude, Gemini, Grok) go head to head.

value: Show HN: Botais (Battle of the AI's) – Competitive Snake Game for LLMs


value: ciderdev

value: Show HN: CiderStack – Run macOS CI runners on your own Mac mini cluster

author: ciderdev


value: natedaines

value: Show HN: Simple spec driven development for Claude

author: natedaines


value: maddhruvhn

value: Show HN: Supaguard – AI agent that writes and repairs Playwright tests

author: maddhruvhn


value: grigio

value: Show HN: OpenCode Benchmark Dashboard

author: grigio

title: Show HN: OpenCode Benchmark Dashboard


value: Show HN: U-Claw – An Offline Installer USB for OpenClaw in China


value: Ashwiniakash

value: Show HN: NirvaCrop – Offline Python tool for batch video cropping

author: Ashwiniakash


value: jmcapra

value:
I built FretBench after noticing Gemini was confidently wrong about basic guitar tab questions. Tab is arguably the simplest notation in music: six lines, numbers for frets, read left to right. So I made a benchmark out of it.
182 test cases, 4 tunings, 14 models via OpenRouter. Two open-weight Qwen models from Alibaba crushed everything else (83.5%), while most "flagship" models scored below 50%. MiniMax M2.5 scored worse than random guessing.
Everything is open source: https://github.com/jmcapra/FretBench
I'm curious whether the performance gap is related to tokenisation of ASCII art — if anyone has insights on how different tokenisers handle grid-structured text, I'd love to hear it.

value: Show HN: FretBench – I tested 14 LLMs on reading guitar tabs. Most failed

author: jmcapra


value:
I built cursor-tg, a Telegram bot that lets me use Cursor Cloud Agents from my phone.
The idea is simple: sometimes I want to start an agent run, reply to it, or check what changed without opening my laptop. With cursor-tg, I can talk to Cursor agents in Telegram, track their progress, view generated diffs/PRs, and handle simple review actions from chat.
I made this mainly for remote/asynchronous development workflows, where I want quick access to my coding agent while away from my desk.
It is really exciting to be finally be able to (help agent) code anywhere!
Repo: https://github.com/tb5z035i/cursor-tg

value: Show HN: cursor-tg – Run Cursor Cloud Agents from Telegram


value: muhneesh

value:
Built The Matrix, a mini PowerBI-style app for tracking public tech comps.
It covers a fixed universe of consumer and enterprise tech companies, refreshes hourly, and includes a sortable coverage table, Rule of 40 / valuation views, a Playground for custom charts, company drilldowns, and exports. Metrics include EV / Revenue, Rule of 40, EBITDA, gross margin, capex, and SBC.
I had no prior app-building experience and built it with Codex. Curious what HN thinks is actually useful here.

value: Show HN: I built a mini PowerBI for tech comps with no dev experience with Codex

author: muhneesh


value: gaborishka

value:
We built this for the Google Gemini 3 Hackathon. The platform takes product data (manual input or Shopify import) and generates marketing content across Instagram, Facebook, landing pages, and video.
The core idea: small teams spend hours creating the same content reformatted for each channel. We wanted to automate that end-to-end pipeline with AI agents.
Key pieces: real-time copy and image generation per platform, an AI Modify agent that transforms stock photos into product-specific visuals, compliance scoring against configurable rules, and a conversational landing page builder.
The hardest challenge was consistency — making the AI maintain brand voice and visual style across every output type.
Demo and details: https://devpost.com/software/marketing-content-generator-ch4...
Would love feedback on the approach.

value: Show HN: Marketing Content Generator AI-powered multi-channel content platform

author: gaborishka


value: hafizjavid

value: Show HN: TrustScan – Simplify privacy policies and audit GDPR compliance

author: hafizjavid


value:
I built arxiv-digest, a tool for OpenClaw to call daily and turn new cs.RO papers into a filtered robotics digest.
It uses an LLM to judge relevance, outputs a markdown report, and can sync selected papers plus PDFs to Zotero. To change the research interests, just edit the README.
Repo: https://github.com/tb5z035i/arxiv-digest

value: Show HN: arxiv-digest: Daily robotics paper scouting for OpenClaw and Zotero


value:
`starter-structure-cli is a CLI for generating starter projects from stack keywords, exact template slugs, or interactive prompts.
Example:
npx starter-structure-cli my-app react vite ts tailwind express prisma mysql
It currently supports frontend, backend, fullstack, and monorepo starters, and the templates are maintained from layered template sources.
I’d love feedback on:
which starter combinations would be most useful
whether the stack matching feels intuitive
how the template authoring workflow could be improved`

value: Show HN: Starter-structure-CLI – scaffold apps from stack combinations


value: Show HN: Generate HTTP and Jsonrpc from IDL


value: thedevguy

value:
Hi HN, I’m Ali. I built Ashti (https://ashti.ai) because my wife and I needed a better way to de-escalate emotional conflicts, and pasting our sensitive arguments into a standard ChatGPT window felt like a massive privacy violation.
Standard LLMs are terrible at the "messy middle" of relationships, and the current AI mediation tools on the market are built for legal arbitration, not empathy. I wanted a tool for "Pre-Conversation Intelligence"—something to lower the temperature before the actual conversation happens.
Here are the technical details of what I built:
Multi-Vault Architecture: Built with Next.js and Prisma. Each partner has an isolated "Vault" to vent their raw frustrations. The server enforces strict state machines to physically prevent cross-contamination of raw inputs into the shared database row.
Affective Stripping: The LLM engine is strictly prompted to act as a clinical referee. It absorbs the private intakes, strips out the heat-of-the-moment metadata and blame, and only passes objective data to the shared ledger to build a "Shared Reality" report.
Agentic SEO Proxy: Because AI search is replacing Google, I built a custom edge proxy that intercepts bots (ClaudeBot, GPTBot) and serves them a pure, raw Markdown file instead of the React UI so they can instantly digest the platform's architecture.
I just finished the MVP this weekend. If you want to see how the engine handles a disagreement with your partner or co-founder, I'm running a free private beta: https://ashti.ai/beta
To test it for free: The Stripe integration is currently in sandbox mode. When you get to the paywall for the final report, just use the standard test card 4242 4242 4242 4242 (with any future date and CVC).
I’d love any feedback on the technical architecture, the neutrality of the AI outputs, or the Next.js implementation.

value: Show HN: I built a secure AI mediator to handle my own marital conflicts

author: thedevguy


value: axadrn

value:
I shipped templUI v1.7.0 today.
templUI is a component library for Go + templ + Tailwind.
The biggest change in this release is that you can now use it in two ways:
- CLI workflow: copy components into your own codebase
- Import workflow: use github.com/templui/templui directly as a dependency
Other changes:
- dedicated quickstart repo is back
- interactive components now handle their own script rendering automatically
- docs were simplified around Quickstart, Import Workflow, and CLI Workflow
The import workflow is still marked beta, but it’s usable now and was one of the most requested things.
Repo:
https://github.com/templui/templui
Quickstart:
https://github.com/templui/templui-quickstart
Would love feedback from people building with Go and templ.

value: Show HN: TemplUI v1.7.0 – UI components for Go and templ, now with import mode

author: axadrn


value:
SubstanceWiki is a free, open-source encyclopedia of psychoactive substances with a harm reduction focus.
Site: https://substancewiki.org
Source: https://github.com/yagcioglutoprak/substance_wiki
The database covers 381 substances with structured data including dosage tables by route of administration, duration timelines, 14,967 interaction safety ratings, 240+ catalogued subjective effects, experience reports, and community insights aggregated from Reddit.
Tech stack: Next.js 16 (App Router), PostgreSQL via Prisma, Tailwind CSS. Content is CC-BY-SA 4.0. The whole codebase including the database schema and seed scripts is public.
Some technical decisions that might interest HN:
- Interaction checker is backed by ~15K pre-computed combination records, not runtime calculation
- Community insights are built from Reddit data via the Arctic Shift archive, run through a classification and enrichment pipeline
- Programmatic SEO generates comparison pages, combo guides, and concept pages from the underlying data
- Dynamic OG images generated per-page via @vercel/og
- JSON-LD structured data on every page type (WebSite, Article, BreadcrumbList, FAQPage)
Feedback welcome on the data model, the UX for presenting safety-critical information, or anything else.

value: Show HN: SubstanceWiki – Open-source encyclopedia of psychoactive substances


value:
Agent Kanban has 4 main features:<p>GitOps & team friendly kanban board integration inside VS Code
Structured plan / todo / implement via @kanban commands
Leverages your existing agent harness rather than trying to bundle a built in one
.md task format provides a permanent (editable) source of truth including considerations, decisions and actions, that is resistant to context rot

value: Show HN: VS Code Agent Kanban: Task Management for the AI-Assisted Developer


value: Show HN: Think Better – Inject Decision Frameworks into Claude and Copilot


value: eagleman

value: Show HN: commitgen-cc – Generate Conventional Commit message locally with Ollama

author: eagleman


value:
We published a free CLI tool after writing about PinchTab — a browser hijacking
technique that abuses Chrome DevTools Protocol to give attackers (or compromised
AI agents) silent access to live browser sessions. No malware signature. No process
injection. Most EDRs don't see it at all.
Unpinched is a point-in-time scanner — think nmap for PinchTab presence. Single Go
binary, no install required, runs in ~3 seconds.
It checks four things:
- Local ports for a PinchTab HTTP API server (with signature verification)
- Running processes matching known PinchTab binary names
- Unauthenticated CDP exposure on localhost:9222
- Known filesystem artifact paths across macOS, Linux, Windows
Also ships as a GitHub Action so you can gate deploys on a clean scan result.
GitHub: https://github.com/Helixar-AI/Unpinched
The underlying research on why CDP-based attacks evade conventional security stacks
is here if you're curious:
https://helixar.ai/press/pinchtab-stealth-browser-attacks-yo...
Happy to answer questions on the detection logic or the threat model.

value: Show HN: Unpinched – open-source PinchTab and CDP bridge detector


value: ComeBertrand

value: Working with AI coding agents means I now juggle a lot more git worktrees than I used to. I built yawn to make that manageable: it discovers all your git projects & worktrees, lets you fuzzy-pick one (fzf, rofi, ...), and opens it. Worktree creation handles branch resolution, copies over untracked config files like .env, and runs setup commands automatically.<p>There's no AI integration in the tool itself, that's intentional. Project switching and worktree management are just plumbing, and I wanted something that does that well without opinions about what you do inside them.

value: Show HN: Yawn – Yet Another Worktree Navigator (CLI, Pipes into Fzf)

author: ComeBertrand


value: krickelkrackel

value: Show HN: This is what I Want from the Internet

author: krickelkrackel


value: zanfiel

value: Show HN: Engram – open-source persistent memory for AI agents (Bun and SQLite)

author: zanfiel


value: losalah

value: Show HN: Free market intelligence tool, analyze HN, find users pain points

author: losalah


value: Show HN: How many working days in 2026? And your income in pizzas


value: ofershapira

value:
MCP server + Chrome extension. Your agent controls your REAL browser (same tabs, cookies, logins). No headless browser, no replaying auth. One-click install in Cursor, extension on Chrome Web Store.
Repo: https://github.com/ofershap/real-browser-mcp
Chrome extension: https://chromewebstore.google.com/detail/real-browser-mcp/fk...

value: Show HN: Real Browser MCP – your AI agent can see your real browser

author: ofershapira


value: marcusmichaels

value:
This tool was built as a solution for an illustration-style wiggly border that our design team wanted to use on our website.
This works by generating an "organic" style, continuous SVG path, along with a non-scaling-stroke vector effect.
The dials let you size it as close as possible to the aspect ratio for the best effect for your content, but it can also snap to content (though usually one side will look stretched or too wriggly if the aspect ratio changes too much at different screen sizes).
Either way, it did its job.

value: Show HN: Wiggly border generator (somewhat responsive)

author: marcusmichaels


value: Show HN: TrustROI – See the real ROI of SaaS tools before subscribing


value: Show HN: I built a geocoding orchestrator tool to cut geocoding API costs


value: muxidev

value:
Hey HN
We've built this as part of MUXI, an open-source AI agent infrastructure platform.
The problem: agents need to execute code, not just generate it. Most solutions either give full shell access (terrifying) or sandbox so heavily that nothing useful runs.
skills-rce sits in the middle: a single binary with a standardized OpenAPI-spec'd REST API. You point it at a skill, it runs the code in an isolated subprocess with skill directory caching, and returns the result. Language-agnostic, single endpoint.
It ships as a single binary, but we recommend running it via Docker so execution never touches your host machine. The image is ready to go.
It's intentionally simple. No orchestration opinions, no framework lock-in. Just a code execution service your agents can call.
Apache 2.0. Feedback welcome!

value: Show HN: Skills RCE – Code execution server for AI agent skills

author: muxidev


value:
There's a class of text that's too big for a context window but too small to justify a vector database. A codebase, a folder of notes, a Slack export. I built a small library - raglet - to solve this problem raglet for it.
You can use it in Python
i.e
from raglet import RAGlet
rag = RAGlet.from_files(["docs/", "notes.md"])
results = rag.search("what did we decide about the API design?", top_k=5)
rag.save("my-notes")
Load it anywhere
rag = RAGlet.load("my-notes")
It uses local embeddings (sentence-transformers, no API keys), saves to a plain directory you can git commit.
The benchmark numbers were more interesting than I expected:
1 MB (~262K tokens) | 3.5s build | 3.7ms search 10 MB (~2.6M tokens) | 35s build | 6.3ms search 100 MB (~26M tokens) | 6min build | 10.4ms search
limitations: .txt and .md only right now (PDF/DOCX is next), no file change detection, ~100 MB practical ceiling before build time gets unwieldy.
What would make this useful for your workflow?

value: Show HN: Portable RAG (Open Source)

title: Show HN: Portable RAG (Open Source)


value: travistotz

value:
I kept shipping AI-generated code I didn't really trust. Not because the AI was wrong necessarily, but because I had no real way to know if it was right.
So I built a tool to vibe check the vibe code. It scans your code and gives it a Vibe Score: Dead Vibe (0-40), Off Vibe (41-65), Good Vibe (66-85), or Immaculate Vibe (86-100). It checks for security issues, code quality, and test coverage across JS/TS, Python, PHP, Go, Ruby, Rust, Java, Swift, and C#. Plus gives real feedback to address!
Free to try. Paste your code and see where it lands.

value: Show HN: VibeCheck – Know if your vibe code is safe to ship

author: travistotz


value: kalturnbull

value: Show HN: Bother – model your project as it exists in reality

author: kalturnbull


value: revastas

value:
Yankput is a Mac clipboard manager built for developers. The core idea: your clipboard is a security hole and nobody is watching it.
The feature that started it all — crypto address swap protection. Malware silently replaces crypto addresses in your clipboard while you're pasting. Yankput detects when a copied address changes before you paste and fires a system alert.
It also detects and masks secrets (API keys, GitHub tokens, AWS keys, etc.) and auto-deletes them after 5 minutes. Plus an Incognito mode that pauses recording entirely.
On top of that: JSON/XML formatter, Base64 encoder, SHA hash generator, regex tester, and line diff — all operating on whatever's in your clipboard.
$14.99 one-time. yankput.app
Would love feedback from the HN crowd, especially on the security angle.

value: Show HN: I built a clipboard mgr with crypto address swap attack detection

author: revastas


value: joshuaveliyath

value:
Hi HN,
I'm Joshua, a teen from Kerala, India.
I built Kairos because I was frustrated that every AI I tested hallucinated on live events. During today's T20 World Cup Final, ChatGPT named the wrong player. Copilot named a different wrong player. Both confidently. Neither had live data.
Kairos solves this differently. Instead of sending raw search results to the LLM and hoping, it runs a verification pass first — cross-checking titles across RSS, DuckDuckGo, and NewsAPI, scoring each result by how many independent sources confirm it, then sorting by confidence before the LLM ever sees the context.
The architecture:
1. Pronoun resolution from ChromaDB conversation history (no API call) 2. Domain classification (6 domains) 3. Query expansion — 1 query becomes 4 targeted searches, pure Python, zero extra API calls 4. Parallel async fetch with timeouts 5. Cross-verification scoring 6. Dynamic thinking budget (0 for sports scores, up to 10k for complex analysis, hard capped) 7. 250 word output limit
Total codebase: ~90KB Model: Gemini 2.5 Flash Cache: ChromaDB Cost: $0
Benchmark on today's T20 Final: Kairos 43/50, Gemini 40/50, Perplexity 38/50, Copilot 26/50, ChatGPT 19/50
ChatGPT and Copilot both hallucinated player names with full confidence. Kairos cited 15 live sources.
GitHub: https://github.com/joshuaveliyath/kairos
Happy to answer technical questions.

value: Show HN: Kairos, real-time AI who cross-verifies (Python, 100KB)

author: joshuaveliyath


value:
https://forge.foxtrotcommunications.net/
I've been a data engineer for years and one thing drove me crazy: every
time we integrated a new API, someone had to manually write SQL to flatten
the JSON into tables. LATERAL FLATTEN for Snowflake, UNNEST for BigQuery,
EXPLODE for Databricks — same logic, different syntax, written from
scratch every time.
Forge takes an OpenAPI spec (or any JSON schema) and automatically:
1. Discovers all fields across all nesting levels
2. Generates dbt models that flatten nested JSON into a star schema
3. Compiles for BigQuery, Snowflake, Databricks, AND Redshift from the
   same metadata
4. Runs incrementally — new fields get added via schema evolution,
   no rebuilds
The key insight is that JSON-to-table is a compilation problem, not a
query problem. If you know the schema, you can generate all the SQL
mechanically. Forge is essentially a compiler: schema in, warehouse-
specific SQL out.
How it works under the hood:
- An introspection phase scans actual data rows and collects the union
  of ALL keys (not just one sample record), so sparse/optional fields
  are always discovered
- Each array-of-objects becomes its own child table with a hierarchical
  index (idx) linking back to the parent — no manual join keys needed
- Warehouse adapters translate universal metadata into dialect-specific
  SQL:
    BigQuery:    UNNEST(JSON_EXTRACT_ARRAY(...))
    Snowflake:   LATERAL FLATTEN(input => PARSE_JSON(...))
    Databricks:  LATERAL VIEW EXPLODE(from_json(...))
    Redshift:    JSON_PARSE + manual extraction
- dbt handles incremental loads with on_schema_change='append_new_columns'
The full pipeline: Bellows (synthetic data generation from OpenAPI specs)
→ BigQuery staging → Forge (model generation + dbt run) → queryable
tables + dbt docs. There's also Merlin (AI-powered field enrichment
via Gemini) that auto-generates realistic data generators for each
field.
I built this because I watched teams spend weeks writing one-off
FLATTEN queries that broke the moment an API added a field. Every
Snowflake blog post shows you how to parse 3 fields from a known
schema — none of them handle schema evolution, arbitrary nesting depth,
or cross-warehouse portability.
Try it: https://forge.foxtrotcommunications.net
Happy to answer questions about the architecture, the cross-warehouse
compilation approach, or the AI enrichment layer.

value: Show HN: Forge, the NoSQL to SQL Compiler


value: JosephjackJR

value:
I got frustrated that every time an AI agent restarts it forgets everything. So I spent six months building a fix.
Synrix is a local-first memory engine for AI agents. It uses a Binary Lattice structure instead of vectors — fixed-size nodes with prefix-semantic addressing. Lookups are O(k) where k is the number of results, not the size of the dataset.
The demo that convinced me this was worth sharing: I told GPT-4 my name, that I like pugs and Ferraris, and a few facts about my project. Restarted the session completely.
The side without Synrix forgot everything. The side with Synrix recalled every single detail instantly. No retraining. No embeddings. No API call. Just prefix lookup in microseconds.
Real numbers from my machine. Direct node lookup 19μs. Prefix queries over 10k nodes 28-80μs. Full agent context restored from cold start under 1ms. WAL recovery tested across 60 crash scenarios with zero data loss. Validated on Jetson Orin Nano at 192ns hot reads.
It runs entirely in-process. No server, no network, no GPU. Works on a factory floor, underground, on a robot that just lost power.
Honest positioning: this is not a vector database replacement. For fuzzy similarity search over unstructured documents Qdrant and Chroma are the right tools. Synrix is specifically for structured agent memory where you control the naming — user preferences, learned facts, session context, task state. You know what you're looking for.
Curious whether anyone has hit this problem in production and how you're currently solving it.
github.com/RYJOX-Technologies/Synrix-Memory-Engine

value: Show HN: Local memory layer for AI agents, survives restarts, no embeddings

author: JosephjackJR


value: mazrean

value: Show HN: Dockportless – No port conflicts running multiple AI agents in parallel

author: mazrean


value: michaelmoreira

value: Show HN: FlowEasy – AI generates production-grade CI/CD pipelines in 3 clicks

author: michaelmoreira


value: MrQianjinsi

value:
  I use AI coding agents for almost all my daily development. Burning ~100M tokens a day, I had no clue where they all went —
  so I built this tool to find out.

  Agentic Metric is like top, but for your coding agents. It tracks token usage and costs across Claude Code, Codex, OpenCode,
   Qwen Code, and VS Code Copilot, with a live TUI dashboard and CLI.

  A few things I care about and you probably do too:

  - Fully open source (MIT): https://github.com/MrQianjinsi/agentic_metric
  - 100% offline — no network requests, no telemetry, nothing leaves your machine, ever
  - All data is local — just reads your local agent files, stores stats in a local SQLite DB
  - Read-only — never touches your agent configs or data

  What you get:
  - Live session monitoring with 1s refresh
  - Per-session token breakdown (input/output/cache) + cost estimation
  - Today's summary and 30-day trends
  - Plugin architecture — easy to add new agents
  - Status bar integration (tmux, i3blocks, waybar, vim)

  Install: pip install agentic-metric or uvx agentic-metric
  I built this entirely with agentic coding (dogfooding at its finest). Would love feedback from fellow heavy agent users —
  curious how your daily token consumption compares.

value: Show HN: Agentic Metric – top for your AI coding agents (token, cost tracking)

author: MrQianjinsi


value: saylamsafak

value:
I built LocaShot to solve a problem I kept seeing: indie developers
skipping App Store localization entirely because recreating screenshots
in Figma for every language is too painful.
The approach: instead of rebuilding layouts, the AI detects and
translates text directly inside the existing screenshot image — fonts,
positions, and design stay intact. Output is store-ready for both
App Store and Google Play.
Stack: Symfony backend, n8n for workflow orchestration, fal.ai for
the AI image editing, Sharp for resizing (Apple simplified their
screenshot requirements in Sept 2024 — only 2 base sizes needed now).
Supports 30+ languages. Free tier available.
https://locashot.app

value: Show HN: LocaShot – Localize App Store screenshots in 30 languages, 30 seconds

author: saylamsafak