value:
Built Resona (https://useresona.com) to solve a recurring frustration: you save something, think "this relates to something I read before" — and never find what.
Those connections are where the aha moments live. Same underlying idea, different domain, months apart.
What it does:
- Save anything (Chrome extension or forward emails) — no folders, no organizing
- Weekly digest surfaces connections across months of reading
- Interactive graph ("Overtones") shows how ideas relate over time
- Chat with your library — "What have I saved about scaling teams?"
Tech: TypeScript monorepo, React SPA, Supabase (Postgres + Auth), OpenAI for embeddings and semantic search, Chrome extension.
Would love feedback: Do the surfaced connections make you want to revisit what you saved?

value: Show HN: Resona – Finds connections across what you save


value: santiviquez

value: Show HN: Soda 4.0 – Data contracts engine for the modern data stack

author: santiviquez


value:
Hi HN,
I’m one of the founders of Gling https://gling.ai
We’ve been working on AI video editing for a while (mostly helping YouTubers remove silences and bad takes), but we just released a new feature that I wanted to share with you: converting text links directly into talking head videos.
The Problem: Repurposing text content (blogs, Twitter threads, LinkedIn posts) into video is tedious. You usually have to summarize the text, write a script, set up a camera/teleprompter, record, and edit. We wanted to collapse that entire stack into one click.
How it works: You paste a URL (e.g., a TechCrunch article, blog post, or an X thread), and Gling does the following:

    Content Extraction: We scrape the meaningful content from the page.

    Script Generation: We use llm to summarize the content and rewrite it into a natural-sounding video script.

    Video Synthesis: This is the core update. We generate the visual and audio using elevenlabs and veed fabric, you can either upload your avatar and voice, or select an AI generated one.

The Tech Stack:

    Backend: Node.js on google cloud.

    Video/Audio: Elevenlabs for audio, Veed fabirc for video, and mediabunny for handling the media files

Why we built this: We noticed many of our users were manually reading their own blog posts to camera. We figured we could automate the "talking head" part so creators can test video versions of their written content without the production friction.
The Ask: We are looking for feedback on:

    The "Uncanny Valley": How natural does the movement/voice feel to you?

    Script Quality: Does the summarization miss key technical context from your links?

    Use Cases: Would you use this for docs? Marketing? Internal updates?

You can try it here: https://app.gling.ai – no login required for the first video.
Thanks!

value: Show HN: Turn blog posts and X threads into talking head videos


value: grrajan

value:
Hey HN,
I’ve been obsessed with the idea that while LLMs are becoming commodities, Agent State is becoming the new vendor lock-in.
Currently, if you build an agent in LangChain, its "mind" (history, intent-graph, learned synapses) is trapped there. If you want to move that same cognitive session from GPT-4 to Claude 3.5, or from one framework to another, you’ve basically got to start from scratch or deal with massive context loss.
I built VNOL (Vendor-Neutral Orchestration Layer) to solve this at the kernel level.
What it is: VNOL is a "Cognitive OS" layer. It treats an agentic session like a process that can be snapshotted, serialized (VNOL v2.0 YAML spec), and rehydrated on any model or framework.
Key Technical Hooks:
Pre-Disk Intent Locking: We intercept agent actions (file writes, API calls) before they hit the system, with a 12ms latency budget (using Azhwar, a hybrid Regex/AST engine).
Mind Portability: Decouples the reasoning skeleton from the model. You can "pause" a session on OpenAI and "resume" it on Anthropic with full intent continuity.
Inhibitory Synapses: A self-healing mechanism that injects negative-weight synapses into the agent's memory graph after a failure, preventing deterministic loop failures.
Canonical Cognitive Sealing: Every snapshot is sealed with an HMAC signature to ensure that the agent's identity and constraints aren't tampered with during transfer.
Why I built this: I’m running a "1.1 Person Startup." I use VNOL to manage a swarm of 20 autonomous agents that code and audit each other. Without a standardized way to move their states and secure their actions, the overhead of managing them was becoming a full-time job.
The Tech Stack:
TypeScript (Kernel)
YAML (Snapshot Spec)
Azhwar (AST-based Governance)
Sentrix (Security Interception)
I’d love to hear your thoughts on "Mind Portability." Is the industry moving toward a standardized agent state, or are we destined for cognitive silos?

value: Show HN: VNOL – The Vendor-Neutral Cognitive OS Layer for Agent Portability

author: grrajan


value: alexS

value: Completely free drip email campaigns. Send automated emails to everyone who has ever emailed you. From a YC alumni summer 2008.

value: Show HN: Dripemails.org - completely free drip email campaigns, from a YC alumni

author: alexS


value:
Hi, everyone!
I built SHDL (Simple Hardware Description Language) as an experiment in stripping hardware description down to its absolute fundamentals.
In SHDL, there are no arithmetic operators, no implicit bit widths, and no high-level constructs. You build everything explicitly from logic gates and wires, and then compose larger components hierarchically. The goal is not synthesis or performance, but understanding: what digital systems actually look like when abstractions are removed.
SHDL is accompanied by PySHDL, a Python interface that lets you load circuits, poke inputs, step the simulation, and observe outputs. Under the hood, SHDL compiles circuits to C for fast execution, but the language itself remains intentionally small and transparent.
This is not meant to replace Verilog or VHDL. It’s aimed at: - learning digital logic from first principles - experimenting with HDL and language design - teaching or visualizing how complex hardware emerges from simple gates.
I would especially appreciate feedback on: - the language design choices - what feels unnecessarily restrictive vs. educationally valuable - whether this kind of “anti-abstraction” HDL is useful to you.
Repo: https://github.com/rafa-rrayes/SHDL
Python package: PySHDL on PyPI
To make this concrete, here are a few small working examples written in SHDL:
1. Full Adder
component FullAdder(A, B, Cin) -> (Sum, Cout) {

    x1: XOR; a1: AND;
    x2: XOR; a2: AND;
    o1: OR;

    connect {
        A -> x1.A; B -> x1.B;
        A -> a1.A; B -> a1.B;

        x1.O -> x2.A; Cin -> x2.B;
        x1.O -> a2.A; Cin -> a2.B;
        a1.O -> o1.A; a2.O -> o1.B;

        x2.O -> Sum; o1.O -> Cout;
    }

}
2. 16 bit register
# clk must be high for two cycles to store a value
component Register16(In[16], clk) -> (Out[16]) {

    >i[16]{
        a1{i}: AND;
        a2{i}: AND;
        not1{i}: NOT;
        nor1{i}: NOR;
        nor2{i}: NOR;
    }

    connect {
        >i[16]{
            # Capture on clk
            In[{i}] -> a1{i}.A;
            In[{i}] -> not1{i}.A;
            not1{i}.O -> a2{i}.A;

            clk -> a1{i}.B;
            clk -> a2{i}.B;

            a1{i}.O -> nor1{i}.A;
            a2{i}.O -> nor2{i}.A;
            nor1{i}.O -> nor2{i}.B;
            nor2{i}.O -> nor1{i}.B;
            nor2{i}.O -> Out[{i}];
        }
    }

}
3. 16-bit Ripple-Carry Adder
use fullAdder::{FullAdder};
component Adder16(A[16], B[16], Cin) -> (Sum[16], Cout) {

    >i[16]{ fa{i}: FullAdder; }

    connect {
        A[1] -> fa1.A;
        B[1] -> fa1.B;
        Cin -> fa1.Cin;
        fa1.Sum -> Sum[1];

        >i[2,16]{
            A[{i}] -> fa{i}.A;
            B[{i}] -> fa{i}.B;
            fa{i-1}.Cout -> fa{i}.Cin;
            fa{i}.Sum -> Sum[{i}];
        }

        fa16.Cout -> Cout;
    }
}

value: Show HN: SHDL – A minimal hardware description language built from logic gates


value: xthe

value:
Hi HN!
I built an online Camera Benchmark Tool that lets you compare ANY camera (phones + DSLR/Mirrorless) with clean performance scoring across:
• Image Processing
• Autofocus
• Low-Light
• Sensor Performance
• Sharpness & Depth
• Real-world test data
Why I made this:
Most comparison tools are either too complex or too limited. I wanted something simple, fast, and data-forward that works for photographers, reviewers, and buyers.
Would love feedback from HN:
— What data should I add?
— Should I include AI-driven scoring?
— Interested in API access?
Try it.

value: Show HN: Tool to Compare Camera Photo Quality in Seconds (Phones + Mirrorless)

author: xthe


value: justvugg

value:
I made PolyMCP so I could quickly turn normal functions (Python or TypeScript) into MCP tools without much extra work.
Python example:
from polymcp.polymcp_toolkit import expose_tools
def greet(name: str) -> str:
    """Say hello."""
    return f"Hello, {name}!"
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b
app = expose_tools([greet, add], title="My MCP Tools")
Run with:
uvicorn server:app --reload
MCP endpoints appear at /mcp/list_tools and /mcp/invoke/.
TypeScript example:
import { z } from 'zod';
import { tool, exposeTools } from 'polymcp';
const uppercaseTool = tool({
  name: 'uppercase',
  description: 'Convert text to uppercase',
  inputSchema: z.object({ text: z.string() }),
  function: async ({ text }) => text.toUpperCase(),
});
const app = exposeTools([uppercaseTool], { title: "Text Tools" });
app.listen(3000);
Business example (Python):
import pandas as pd
from polymcp.polymcp_toolkit import expose_tools
def calculate_commissions(sales_data: list[dict]):
    df = pd.DataFrame(sales_data)
    df["commission"] = df["sales_amount"] * 0.05
    return df.to_dict(orient="records")
app = expose_tools([calculate_commissions], title="Business Tools")
What you get:
 • Reuse existing code with minimal changes
 • Compatible with MCP clients (Claude Desktop, agents, Ollama, etc.)
 • HTTP and stdio and Wasm support
 • Automatic validation
 • Basic production features (budgets, retries, redaction, logs)
 • Inspector: polymcp inspector for testing/monitoring
Install:
 • Python: pip install polymcp
 • TypeScript: clone repo → cd polymcp-ts → npm install → npm run build
Repo: https://github.com/poly-mcp/Polymcp
Curious what kind of function people would expose first if it was this simple. Feedback welcome.

value: Show HN: PolyMCP – Expose Python/TS functions as MCP tools easily

author: justvugg


value:
Hi HN, I’m Daniel and I built Klynda, a portfolio tracker I started after my spreadsheet became too complex and error-prone, especially around cashflows and price updates.
Klynda focuses on true performance by using a unitized accounting approach so deposits and withdrawals don’t distort returns. It also pulls real market data for stocks, ETFs, and crypto.
Link: https://klynda.com
I’d love feedback on the core model and UX: what feels confusing, what’s missing, and what you’d want to see before trusting the numbers.
Happy to answer technical questions about how the performance calculations work.

value: Show HN: Klynda, a portfolio tracker focused on true performance (TWR/XIRR)


value: vicnas

value: Show HN: Flashy – Path-based reverse proxy for routing multiple services

author: vicnas


value: hasibhaque

value: Show HN: I made a list of validated mobile app ideas

author: hasibhaque


value:
Hi HN,
I am working on a small side project called FavBox. It is a local-first browser extension that extends your existing bookmarks. It builds on your browser’s native bookmarks instead of replacing them or changing your default workflow.
Key features: syncs with your browser profile, no third-party data sharing, no ads. no tracking. Clean, minimalist UI with tags support.

value: Show HN: FavBox – local-first bookmark manager extension


value:
Hi everyone, after months and months of designing and animating. My brother and I built this Animation tool that helps anyone remix their favourite motion designs bits in minutes. Let us know what you think
www.autograph.video
Getting started:
https://youtu.be/05aNmIM37xc?si=RhJrqEdyvl-UCYu5

value: Show HN: Autograph.video for Anyone Interested in Motiongraphics


value:
Hey HN!
I built this tool because I kept missing when Claude Code or Codex finished a task while I was grabbing coffee or browsing Twitter.
The problem: AI coding agents like Claude Code and OpenAI Codex run in the terminal. When they complete a task or need your input, there's no notification — you have to keep checking the terminal.
The solution: Agent Notify hooks into these agents and sends notifications through multiple channels:
- System sounds (customizable)
- macOS Notification Center
- Voice announcements (using say)
- ntfy push notifications (works on your phone)
It supports both Claude Code/Cursor (via hooks) and OpenAI Codex (via notify config).
Built with Bun and ships as a single binary. The setup is interactive — just run it and pick what you want.
Open source under MIT. Looking forward to your feedback!

value: Show HN: Agent Notify – Notifications for AI coding agents


value: marcusmichaels

value:
An unattended laptop that's still logged in is usually my opportunity to play the looping laughing Gandalf video on their machine.
The other day I allegedly took it a step further by setting a cronjob to run a `say hello friend` command every ~28 minutes. This got me thinking that I should probably stop before I get fired... but also if there's an easier way to do this where I don't have to remember the cron syntax, but also give them an easy way to remove it.
So I made Stay Safe – a fun script that's quick to install, quick to remove, and reminds colleagues of the importance of not letting someone else have unfettered access to their unattended machine.
All the code is open source on github the link at the bottom of the page.

value: Show HN: Office vigilante tool that might get you fired (but promotes security)

author: marcusmichaels


value: hnthrowawaste

value: Show HN: Infinijest, video feed no login

author: hnthrowawaste


value: Frameser

value:
I’d like to share PNANA , a lightweight TUI editor built with C++ and FTXUI that I’ve been building for personal use and now open-sourced. It’s a minimal, fast terminal-based editor focused on simple coding and editing workflows—no bloated features, just the core functionality for terminal-centric use cases.
https://github.com/Cyxuan0311/PNANA
Key pragmatic features
Lightweight C++ core with FTXUI for smooth TUI rendering, fast startup and low resource usage
Basic but solid editing capabilities (syntax highlighting, line numbering, basic navigation)
Simple build process with minimal dependencies, easy to compile and run on Linux/macOS terminals
Early LSP integration support for basic code completion (still polishing, but functional for common languages)
It’s very much an early-stage project—I built it to scratch my own itch for a minimal, self-built TUI editor and learn C++/FTXUI along the way. There are definitely rough edges (e.g., some LSP kinks, limited customization), and it’s not meant to replace mature editors like Vim/Nano—just a small open-source project for folks who like minimal terminal tools or want to learn TUI development with C++.
Any feedback, bug reports, or tiny suggestions are super welcome. I’m slowly iterating on it and would love to learn from the HN community’s insights.
Thanks for taking a look!

value: Show HN: PNANA - A TUI Text Editor

author: Frameser

title: Show HN: PNANA - A TUI Text Editor


value: cruicky

value:
Hi HN,
I’ve always missed the high-signal, community-centric feel of old-school Bulletin Board Systems, but the moderation overhead for small communities is usually what kills them. I built SimpleNet to see if we could bring back the BBS vibe using modern tech.
The Tech Stack: The core of the platform is a modern BBS architecture, but the "secret sauce" is the moderation layer. Instead of relying on big-tech APIs or an army of volunteers, I’m using open source LLMs to assist with content moderation and community health. This allows for:
Privacy: No user data is sent to OpenAI or Google for sentiment analysis.
Speed: Instant feedback for users on community guideline adherence.
Sovereignty: The community rules are baked into the local model weights, not a corporate TOS.
Why .directory? I want this to be a jumping-off point for niche communities that want a "back-to-basics" text-heavy interaction model without the doom-scrolling algorithms of modern social media.
I’m a software engineer by trade, but this is my first foray into a public-facing community platform of this scale. I’d love your feedback on the latency of the moderation and the general "feel" of the UI.
Check it out: https://www.simplenet.directory

value: Show HN: SimpleNet – A modern BBS moderated by local LLMs

author: cruicky


value: jackchuka

value:
I built mdschema, a small Go CLI that validates Markdown documents against a YAML “schema.”
(required headings/section order, required code blocks by language, table headers, frontmatter rules, links, etc.).
Motivation: Docs are often edited by many people and AI tools, leading to structure drift (missing sections, reordered blocks).
This is meant as a simple guardrail you can run locally or in CI.
Feel free to try it out and let me know what you think!

value: Show HN: Guardrails for AI-written Markdown: enforce document with mdschema

author: jackchuka


value: keepamovin

value: Show HN: mute your macOS mic to ZERO. But Siri keeps listening

author: keepamovin


value: Show HN: FLUX.2 Klein – Sub-Second AI Image Generation – 4B and 9B Models


value: BLGardner

value:
I've completely overhauled Prism.Tools to be 100% offline-capable and privacy-focused, with significant tool improvements.
WHAT CHANGED?
- Dependencies: Moved from external CDN libraries to LOCAL libraries only (/lib folder)
- Privacy: Zero external requests now (no potential CDN tracking)
- Offline Use: Works completely offline after download (no internet required)
- Licenses: All licenses included (/lib/license/)
- Assets: Local Web Safe fonts (/tools/fonts/)
TOOL UPDATES:
1. ASCII Art Generator:
   - Improved performance using FIGlet.js
      Credit: Created by Glenn Chappell and other FIGlet contributors
   - Animate button cycles through all fonts for quick review
2. SVG Editor:
   - Completely reworked with expanded capabilities
   - Educational design with help tooltips
   - Professional features (transform engine, gradients, grouping)
   - Beginner-friendly with default example to explore features
3. Other Updated Tools:
   - Code Formatter, Diff Checker, Hash Generator, SQL Formatter, YAML/JSON Converter, QR Code Generator
   - All libraries for these tools are now local
4. Two new tools, now 48 tools total:
   - HTML Viewer, Image Metadata Viewer
FOR GITHUB PAGES VISITORS:
 You're already using latest version but be sure to Refresh the pages!
 >> https://blgardner.github.io/prism.tools
TESTING OFFLINE FUNCTIONALITY:
  1. Download complete repository
  2. Disconnect from internet
  3. Open index.html in browser
  4. Test all tools - should work normally
TIP: Use Chrome's "Application" tab in Developer Tools to verify no network requests are made.
Q: Why these changes?
A: To ensure privacy and provide reliable, always-available tools regardless of internet connectivity.
Q: What if I don't update?
A: Old versions will eventually break when CDNs change or shut down. They also send data to third parties.
Download Latest Version: https://github.com/blgardner/prism.tools/archive/main.zip
Live Version: https://blgardner.github.io/prism.tools/

value: Show HN: Prism.Tools – Now 100% Offline capable

author: BLGardner


value:
Hi HN,
I built Pegasus3301, an online puzzle game inspired by Cicada 3301.
It’s a multi-stage challenge that mixes ciphers, hidden clues, logic problems, and misdirection. Each stage unlocks the next, and most of the puzzles rely on observation rather than brute force.
I built this as an experiment in puzzle design and player behavior. It runs entirely in the browser and is free to play.
I’d really appreciate feedback—especially on puzzle clarity, difficulty balance, and whether the progression feels fair.
Link: https://pegasus3301.com/

value: Show HN: Pegasus3301 – a Cicada 3301–inspired online puzzle game


value: piratebroadcast

value: An 8 bit adventure game set in Boston.

value: Show HN: Boston, the Videogame

author: piratebroadcast

story_text: An 8 bit adventure game set in Boston.

title: Show HN: Boston, the Videogame


value: skdltmxn

value: Show HN: Zoa – simple utilites running in the browser

author: skdltmxn


value: Show HN: AI PDF to ePub Converter

title: Show HN: AI PDF to ePub Converter


value: seansh

value:
You can record and share coding sessions directly inside your editor.
Think Asciinema, but for full coding sessions with audio, video, and images.
While replaying a session, you can pause at any point, explore the code in your own editor, modify it, and even run it. This makes following tutorials and understanding real codebases much more practical than watching a video.
Local first, and open source.
p.s. I’ve been working on this for a little over two years* and would appreciate any feedback.
* Previously: CodeMic: A new way to talk about code - https://news.ycombinator.com/item?id=42485088 - Dec 2024 (58 comments)

value: Show HN: Record and share your coding sessions with CodeMic

author: seansh


value: I’d like to share an AI tool called NewYouGo. It’s a web-based AI image and video generation platform that allows users to generate high-quality images from text prompts, with additional support for image editing and creative workflows.<p>NewYouGo integrates several powerful open-source models (such as the Klein series and multi-angle models), and offers flexible controls for style, aspect ratio, and visual details.

value: Show HN: NewYouGo – A Fast and Free AI Image and Video Generator


value: ortuman

value:
hi there! i’ve been working on a project called Narwhal, and I wanted to share it with the community to get some valuable feedback.
what is it? Narwhal is a lightweight Pub/Sub server and protocol designed specifically for edge applications. while there are great tools out there like NATS or MQTT, i wanted to build something that prioritizes customization and extensibility. my goal was to create a system where developers can easily adapt the routing logic or message handling pipeline to fit specific edge use cases, without fighting the server's defaults.
why Rust? i chose Rust because i needed a low memory footprint to run efficiently on edge devices (like Raspberry Pis or small gateways), and also because I have a personal vendetta against Garbage Collection pauses. :)
current status: it is currently in Alpha. it works for basic pub/sub patterns, but I’d like to start working on persistence support soon (so messages survive restarts or network partitions).
i’d love for you to take a look at the code! i’m particularly interested in all kind of feedback regarding any improvements i may have overlooked.

value: Show HN: An extensible pub/sub messaging server for edge applications

author: ortuman


value: alexcasalboni

value:
I've just published the new Unleash Toolbar to npm.
It's a client-side debugging toolbar for the Unleash, the open source feature flagging project.
It enabled on-page flags and context overrides, without requiring any API tokens or complex setup. You simply wrap the JS SDK in your code and everything else works seamlessly.
Also supports React and Next.js SDK, so you can use for any frontend application (including Angular, Vue, etc.).

value: Show HN: Unleash Toolbar

author: alexcasalboni

title: Show HN: Unleash Toolbar


value: hesilong

value: Show HN: ClothMotion – AI Clothing Fashion Video Generator and Try-On

author: hesilong


value: ZigaSajovic

value:
The demo runs a boolean difference between a 500k-triangle dragon and a sphere at ~15ms per boolean (on M4), client-side via WASM. You can drag either mesh. The side menu has selectable mesh sizes (50k to 500k) and other demos.
Reproducible benchmarks against CGAL, VTK, libigl, FCL and Coal (source code and methodology): https://trueform.polydera.com/cpp/benchmarks
Theory and papers: https://trueform.polydera.com/cpp/about/research

value: Show HN: Real-time mesh booleans in the browser (~15ms per op on 500k triangles)

author: ZigaSajovic


value: xGoivo

value:
I love working in the terminal! In the past few months, I found myself switching more and more of my tools to be cli or tui based. Whenever I have to deal with databases though, I end up switching back to work with GUI tools like dbeaver/datagrip. They are all great, but it feels a little bit much having to spin up these programs just for a quick query.
I've tried existing SQL TUIs like harlequin, sqlit, and nvim-dbee. they're all excellent tools and work great for heavier workflows, but they generally use the same 3-pane (explorer, editor, results) paradigm most of the other GUI tools operate with. I found myself wanting to try a different approach, and came up with pam-db.
Pam's Database Drawer uses a hybrid approach between being a cli and tui tool: cli commands where possible (managing connections and queries, switching contexts), TUI where it makes more sense (exploring results, interactive updates), and your $EDITOR when... editing text (usually for writing queries).
Example workflow with sqlite:

  # Create a connection
  pam init sqlite sqlite3 file:///path/to/mydb.db

  # Add a query with params and default values
  pam add min_salary 'select * from employees where salary > :sal|10000'

  # Run it
  pam run min_salary --sal 300000

This opens an interactive table TUI where you can explore data, export results, update cells, and delete rows. Later you can switch to another database connection using `pam switch <dbname>` and following pam commands will use this db as context.
Features:
- Hybrid cli/tui approach
- Parameterized saved queries
- Interactive table exploration and editing
- Connection context management
- Support for sqlite, postgres, mysql/mariadb, sqlserver, oracle and more
Built with go and the awesome charm/bubbletea!
Currently in beta, so any feedback is very welcome! Especially on missing features or database adapters you'd like to see.
https://github.com/eduardofuncao/pam

value: Show HN: Pam-db – A hybrid TUI <-> CLI tool for SQL databases

author: xGoivo


value: crediblejhj

value:
Hi HN! Korean high school senior here, about to start CS in college.
I built a browser engine from scratch in C++ to understand how browsers work. First time using C++, 8 weeks of development, lots of debugging—but it works!
Features:
- HTML parsing with error correction
- CSS cascade and inheritance
- Block/inline layout engine
- Async image loading + caching
- Link navigation + history
Hardest parts:
- String parsing(html, css)
- Rendering
- Image Caching & Layout Reflowing
What I learned (beyond code):
- Systematic debugging is crucial
- Ship with known bugs rather than chase perfection
- The Power of "Why?"
~3,000 lines of C++17/Qt6. Would love feedback on code architecture and C++ best practices!
GitHub: https://github.com/beginner-jhj/mini_browser

value: Show HN: I built a small browser engine from scratch in C++

author: crediblejhj


value: tpfuetze

value: Show HN: I built an MCP server so ChatGPT can replace comparison sites

author: tpfuetze


value: NathanFlurry

value:
We’ve been working with automating coding agents in sandboxes as of late. It’s bewildering how poorly standardized and difficult to use each agent varies between each other.
We open-sourced the Sandbox Agent SDK based on tools we built internally to solve 3 problems:
1. Universal agent API: interact with any coding agent using the same API
2. Running agents inside the sandbox: Agent Sandbox provides a Rust binary that serves the universal agent API over HTTP, instead of having to futz with undocumented interfaces
3. Universal session schema: persisting sessions is always problematic, since we don’t want the source of truth for the conversation to live inside the container in a schema we don’t control
Agent Sandbox SDK has:
- Any coding agent: Universal API to interact with all agents with full feature coverage
- Server or SDK mode: Run as an HTTP server or with the TypeScript SDK
- Universal session schema: Universal schema to store agent transcripts
- Supports your sandbox provider: Daytona, E2B, Vercel Sandboxes, and more
- Lightweight, portable Rust binary: Install anywhere with 1 curl command
- OpenAPI spec: Well documented and easy to integrate
We will be adding much more in the coming weeks – would love to hear any feedback or questions.

value: Show HN: Sandbox Agent SDK – unified API for automating coding agents

author: NathanFlurry


value: unayung

value: Show HN: Clawd Face – an expressive SVG face for Clawdbot in one script tag

author: unayung


value: loxo

value:
Hi HN
I built MyTunes Pro for developers who live in Linux terminals, use the keyboard for everything, and want music that doesn’t interrupt their flow.
https://mytunes-pro.com
This is a TUI-centric, keyboard-first music player built around YouTube search and playback — with no ads, no visual noise, and no attention hijacking.
Why it works especially well on Linux
Linux-first mindset
Designed with terminal-heavy workflows in mind.
Feels at home next to tmux, vim, and your shell.
⌨ Keyboard-only control
Search, open, and control music without touching the mouse.
If you think in keybindings, this is for you.
TUI-oriented experience
Minimal UI, predictable behavior, no distractions.
Inspired by VI-style tools: fast, quiet, and intentional.
Ad-free YouTube music playback
Just the music. No recommendations, no popups, no autoplay traps.
More than a player
A shared music hub for developers
Discover and share tracks with developers around the world.
Built for long coding sessions, not passive consumption.
Why I made this
Most music apps try to keep you engaged.
MyTunes Pro tries to disappear.
I wanted a music player that:
respects focus
fits terminal-centric workflows
feels like a dev tool, not a media platform
Tech notes
Web-based (works well as a PWA)
Optimized for desktop & Linux environments
No generative AI — just fast search and playback
I’d love feedback from Linux users, terminal lovers, and anyone who codes with music on all day.
Happy to answer questions. Thanks for reading

value: Show HN: MyTunes Pro – A TUI, keyboard-first music player for Linux develope

author: loxo


value: pazvanti

value:
Hi HN,
I’ve grown increasingly frustrated with loyalty card apps (like Stocard, Klarna, or Google Wallet) that require a Google login, track your location, and upload your shopping habits to their servers. When Stocard was discontinued/merged, I realized there wasn't a great "pro-privacy" alternative that also offered the convenience of cloud sync without the "cloud" being Google.
So, I built Cardaris. It’s an Android app designed for people who want to keep their data on their own terms.
Key Features:
- No Google Play Services (GMS) Required: The app works 100% offline and is built to run on de-Googled devices (GrapheneOS, LineageOS, etc.).
- Zero Trackers: No Firebase, no Analytics, no AdMob. I did not include any such SDKs and don't plan on doing it. THe only feature that requires internet is the online backup.
- WebDAV Backups: Instead of being forced to use Google Drive, you can sync your cards to your own Nextcloud instance or any WebDAV-compatible server.
- Encrypted Backups: You can set a custom password to encrypt your data before it ever leaves your device.
- Device-to-Device Transfer: You can move your cards to a new phone without requiring internet. Just scan a QR code generated on-device.
- Security: Includes biometric (fingerprint/face) lock and the app runs entirely without an account or email.
- Homescreen widget, for quick access
The app is completely free, and I am not monetizing it. I just wanted a tool that respected my privacy and worked with my self-hosted setup.
I’d love to get some feedback from the community and what features should I add next.
P.S. I did use AI for some of the parts on the website (since I am not a front-end dev and I figured it will look better this way). In developing the app, some AI was also used, but I tried to limit this since I also build the app to learn Flutter.

value: Show HN: I built a loyalty card app that doesn't track you or require Google

author: pazvanti


value:
Hi HN,
I’ve been analyzing Ask HN: Who Wants to Be Hired? threads going back three years and built HireIndex to make the data explorable.
Given how much the industry has changed, a few trends stood out:
1. A sharp increase in posts starting in 2023
There’s a significant jump in the number of people posting beginning in 2023, which aligns with the broader tech downturn and layoffs. This marks a clear break from prior years and sets the baseline for many of the shifts below.
2. Job seekers are more senior than before
The average experience level has risen from ~7.5 years in 2022 to ~9+ years in Dec 2025 and Jan 2026.
In other words, the typical person posting today is noticeably more senior than a few years ago.
Interestingly, this shift is much less pronounced when you look at US-only data.
3. Fewer juniors, more very senior candidates
Posts from junior candidates (0–2 years of experience) have steadily declined.
At the same time, there’s a clear rise in people with 15+ years of experience looking for work.
This trend is much stronger outside the US, where the US shows only a modest increase.
4. More international job seekers
There’s been a growing share of posts from outside the US, especially from countries like Canada and India, relative to US-based job seekers.
If you want to explore the data yourself, including charts and breakdowns:
 https://hireindex.xyz/#stats
If you’re hiring, HireIndex also provides a searchable directory of candidates with direct links to resumes, LinkedIn profiles, and original HN posts.
 https://hireindex.xyz/#directory
Would love feedback, questions, or ideas for other cuts of the data to add.

value: Show HN: HireIndex – 3 years of "Who Wants to Be Hired" trends


value: navpatel

value:
Got tired of digging through pricing pages and benchmark tables every time a new model dropped. So I made a chart that plots them all: intelligence (from Artificial Analysis benchmarks) vs. price (live from OpenRouter).
The models with the yellow ring are Pareto-optimal + a few others that are close.
Mostly made this for myself, but thought I'd share!
Let me know if you can think of any obvious improvements

value: Show HN: So many models, which to pick?

author: navpatel

title: Show HN: So many models, which to pick?


value: tyleo

value: I built this for fun out of appreciation for the game. I hope you enjoy :)

value: Show HN: NieR: Automata – UI Recreation in Figma

author: tyleo


value: Show HN: GlancePad – Control macOS from Vision Pro and iOS over Local Network


value: gbasin

value: Show HN: Mobile-friendly web wrapper around tmux, optimized for agent TUIs

author: gbasin


value: jaygood

value:
I’m a developer who spends half my day on screen shares. I got tired of the "pre-call ritual" of closing every private app just to make sure I didn't accidentally show a bank balance or a private message during a demo.
Existing "Focus" modes hide notifications, but they don't help if you need to share your full desktop for context.
I built Cloakly to solve this. It’s a Windows utility that lets you "cloak" specific windows. They stay fully visible and interactive for you, but they are 100% invisible to capture software (Zoom, Teams, Discord, etc.).
How it works (briefly): It leverages Windows OS properties to exclude specific window handles from capture streams. It allows you to keep your reference notes or private chats open on the same screen you are sharing.
Features:
Dual Reality: You see the window; the audience sees your wallpaper/desktop.
Ghost Mode: Adjust window transparency to see through to what’s underneath.
Stealth: The app can hide its own taskbar presence.
I’m launching on Product Hunt today to see if this is a pain point for others or just me. I’d love your feedback on the implementation and whether you’d find this useful in your workflow.
PH Link: https://www.producthunt.com/products/cloakly
Site: https://www.getcloakly.com/

value: Show HN: Cloakly – Hide sensitive windows from screen shares in real-time

author: jaygood


value: stephanschulz

value: Show HN: Trailward – Learn anything in 90-second micro-sessions

author: stephanschulz


value: shivam-dev

value: Show HN: Multi-Agent Framework for Ruby

author: shivam-dev

title: Show HN: Multi-Agent Framework for Ruby


value: Cerium gets inspiration from similar tools such as lsd and eza, but with a small difference: It aims to stay small by avoiding features that introduce heavy dependencies while doing what a tool of its kind is supposed to do... list files and directories.

value: Show HN: Cerium – Yet, another ls-like util that is not trying to replace ls


value: PrismerAI

value: Show HN: Prismer – Open-sourcing our AI4S workflow after multiple pivots

author: PrismerAI


value: agsilvio

value:
I built a kanban board that only lets you have one ticket. That's the whole app.
It's for PO's that get a little too excited sometimes.
This is a novelty project, built mostly with AI in a couple of hours. The AI wrote the code and the jokes—I just steered and said "no" a lot.
Don't put anything sensitive in there.

value: Show HN: One Thing at a Time Please – A Kanban board with one ticket slot

author: agsilvio


value: thisnick

value: Show HN: Agent-Rdp – CLI for AI Agents to Control Windows via Remote Desktop

author: thisnick


value: anupamchugh

value:
I forked Beads and added spec intelligence. When a spec changes, linked issues get flagged. It also tracks spec volatility—high-churn specs with open issues are where drift is most likely. Plus auto-matching and compaction to shrink old specs.
Link: https://github.com/anupamchugh/shadowbook

value: Show HN: Shadowbook – Keep your tasks in sync with your specs

author: anupamchugh


value:
I created a small HTML game where you need to type the letter before it reaches the bottom of the screen. Each level introduces a new set of characters from your keyboard.
The reason I created the game was to try and improve my typing speed and accuracy without having to look at my keyboard while typing.
Level 1 starts with just the “asdf” row of your keyboard.
Level 2 adds uppercase letters.
Level 3 continues with the same pattern as level 1 and level 2

value: Show HN: A tiny typing game to keep your fingers moving


value: IAMsterdam

value:
Hey HN — I built BarrierX after watching sales teams ignore thousands of lost deals sitting in their CRM.
The problem: lost deals aren't really "lost" — they're just badly timed. Budgets change, champions move companies, competitors screw up. But nobody tracks this systematically.
What BarrierX does:
Ingests your won and lost deal history from CRM
Analyzes patterns: what signals preceded wins vs losses
Monitors lost accounts for trigger events (job changes, funding, reorgs)
Surfaces which lost deals are worth re-engaging now — with context on why
We've seen teams recover 15-20% of "dead" pipeline just by working smarter on win-backs.
On access: We're invite-only while we tune the models per customer. HN folks — reply with your CRM setup and I'll fast-track you.
In early pilots, teams resurfaced ~18% of deals marked 'closed-lost' as re-engageable within 90 days.
Curious what others have tried here. Most tools focus on net-new. Is anyone else systematically working lost deals?

value: Show HN: BarrierX: Win back lost enterprise deals by analyzing that others close

author: IAMsterdam


value: hello-tmst

value:
We were tired of writing raw Cypher — escaping quotes, zero autocomplete, refactoring nightmares — so we built GraphORM: a type-safe Python ORM for RedisGraph/FalkorDB using pure Python objects.
What it does
Instead of fragile Cypher:

    query = """
    MATCH (a:User {user_id: 1})-[r1:FRIEND]->(b:User)-[r2:FRIEND]->(c:User)
    WHERE c.user_id <> 1 AND b.active = true
    WITH b, count(r2) as friend_count
    WHERE friend_count > 5
    RETURN c, friend_count
    ORDER BY friend_count DESC
    LIMIT 10
    """

You write type-safe Python:

    stmt = select().match(
        (UserA, FRIEND.alias("r1"), UserB),
        (UserB, FRIEND.alias("r2"), UserC)
    ).where(
        (UserA.user_id == 1) & (UserC.user_id != 1) & (UserB.active == True)
    ).with_(
        UserB, count(FRIEND.alias("r2")).label("friend_count")
    ).where(
        count(FRIEND.alias("r2")) > 5
    ).returns(
        UserC, count(FRIEND.alias("r2")).label("friend_count")
    ).orderby(
        count(FRIEND.alias("r2")).desc()
    ).limit(10)

Key features:
    • Type-safe schema with Python type hints
    • Fluent query builder (select().match().where().returns())
    • Automatic batching (flush(batch_size=1000))
    • Atomic transactions (with graph.transaction(): ...)
    • Zero string escaping — O'Connor and "The Builder" just work
Target audience
    • AI/LLM agent devs: store long-term memory as graphs (User → Message → ToolCall)
    • Web crawler engineers: insert 10k pages + links in 12 lines vs 80 lines of Cypher
    • Social network builders: query "friends of friends" with indegree()/outdegree()
    • Data engineers: track lineage (Dataset → Transform → Output)
    • Python devs new to graphs: avoid Cypher learning curve
Data insertion: the real game-changer
Raw Cypher nightmare:
    queries = [
        """CREATE (:User {email: "alice@example.com", name: "Alice O\\'Connor"})""",
        """CREATE (:User {email: "bob@example.com", name: "Bob \\"The Builder\\""})"""
    ]
    for q in queries:
        graph.query(q)  # No transaction safety!
GraphORM bliss:
    alice = User(email="alice@example.com", name="Alice O'Connor")
    bob = User(email="bob@example.com", name='Bob "The Builder"')
    graph.add_node(alice)
    graph.add_edge(Follows(alice, bob, since=1704067200))
    graph.flush()  # One network call, atomic transaction
Try it in 30 seconds
    pip install graphorm

    from graphorm import Node, Edge, Graph

    class User(Node):
        __primary_key__ = ["email"]
        email: str
        name: str

    class Follows(Edge):
        since: int

    graph = Graph("social", host="localhost", port=6379)
    graph.create()
    alice = User(email="alice@example.com", name="Alice")
    bob = User(email="bob@example.com", name="Bob")
    graph.add_node(alice)
    graph.add_edge(Follows(alice, bob, since=1704067200))
    graph.flush()

GitHub: https://github.com/hello-tmst/graphorm
We'd love honest feedback:
    • Does this solve a real pain point for you?
    • What's missing for production use?
    • Any API design suggestions?

value: Show HN: We built a type-safe Python ORM for RedisGraph/FalkorDB

author: hello-tmst


value: dogacel

value: Show HN: Universal DeepSeek OCR 2 – CPU, MPS, CUDA Support

author: dogacel


value: onurkerimov

value: Show HN: Prefill – Partial application for React components

author: onurkerimov


value:
We’ve been experimenting with what a real *“always-on” proactive agent* could look like, and built one called *memUbot*.
It runs 24/7 in the background, keeps track of what you do, and builds long-term memory from it. Over time, it learns your habits and context. Instead of waiting for prompts, it tries to infer your intent and act before you ask.
The goal is a more “assistant-like” proactive agent:
- observe
- remember
- act
- continuously
One practical detail: it’s designed to be cheap to run.
By keeping context in memory and minimizing LLM calls, it uses far fewer tokens than bots like moltbot.
You can try it here (download & run locally):
https://memu.bot/
If you’re already using moltbot and don’t want to migrate, you can plug in our open-source memory layer, *memU*, to upgrade its memory and make it truly 24/7 and proactive:
https://github.com/NevaMind-AI/memU
Happy to hear thoughts from people building agents or infra in this space.

value: Show HN: We built a cheaper, simpler 24/7 proactive agent than moltbot


value: AntiKippi

value:
GitHub repo: https://github.com/AntiKippi/errorpages
Live preview: https://kippi.at/public/errorpages/
I've spend the last few days overengineering HTTP status code error pages. It started with me wanting an aesthetic, glitchy 404 page with a bit of "cyberpunk" and "hacker" vibes while still being simple and JS free. It ended in this project.
wdyt?

value: Show HN: Is this the perfect 404 page? [CSS only]

author: AntiKippi


value: Strugly

value:
Lately I had a lot of free time at my main job. I tried to read more, but mostly I ended up scrolling reels and TikTok.
The more I watched, the more I hated the way it worked - the amount, the pace. However, at some point I started wondering what the next step in this dopamine rush could be.
At first I came up with a content betting concept and built a Telegram bot where you gain points by guessing the like to dislike ratio of a video. While playing with it, I realized that this betting mechanism could be reshaped into a way to express a more nuanced reaction to content than the current like or dislike.
For example, with a single point on a pad you can express both your sense of resonance with the content and your certainty about it.
After building a live demo (and posting it here about a month ago), I realized that outside of a TikTok-style feed it felt pointless. So I tried to give it more meaning by turning it into a form of mindful content consumption. You receive a small, finite set of videos each day, react to them, instantly compare your reaction with the mean point, and then explore how others reacted.

value: Show HN: EloLup – where a reaction interface became a way to consume content

author: Strugly


value: PAndreew

value:
I wanted to solve my wife's work-related pain points revolving around Excel formulas and extracting data from PDFs documents by keeping her data locally. I also wanted to be able to collaborate with her if the need arises. So I've been working on this multi user virtual assistant based on the OpenCode SDK that we host on a Raspberry Pi behind Tailscale. The workflow in short
 - users upload their work files through the web interface,
 - add them to a chat session,
 - invite other users,
 - they churn the data with the agent,
 - then download the resulting assets.
It has some rough edges especially around handling multi-turn conversations but thought maybe someone could find this useful. :) If you like it, please star and contribute to the project.

value: Show HN: Pi-Foundry – multi user self hosted AI assistant

author: PAndreew


value:
Hi HN,
I am one of the cofounders of http://turingdb.ai. We built TuringDB while working on large biological knowledge graphs and graph-based digital twins with pharma & hospitals, where existing graph databases were unusable for deep graph traversals with hundreds or thousands of hops on (crappy) machines you can find in a hospital.
https://github.com/turing-db/turingdb
TuringDB is a new in-memory, column-oriented graph database optimised for read-heavy analytical workloads:
- Milliseconds (1) for multi-hop queries on graphs with 10M+ nodes/edges
- Lock-free reads via immutable snapshots
- Git-like versioning for graphs (branch, merge, time travel queries)
- Built-in graph exploration UI for large subgraphs
We wrote TuringDB from scratch in C++ and designed to have predictable memory and concurrency behaviour.
For example, for the Reactome biological knowledge graph, we see ~100× to 300× speedups over Neo4j on multi-hop analytical queries out of the box (details in first comment).
A free Community version is available and runnable locally:
https://docs.turingdb.ai/quickstart
https://github.com/turing-db/turingdb
Happy to answer technical questions.
(1): We actually hit sub-millisecond performance on many queries

value: Show HN: TuringDB – The fastest analytical in-memory graph database in C++


value:
I use Claude Code across multiple projects with different conventions and some shared repos just as it so happens to be the real world. Managing the config files (.claude/rules/, mcps.json, settings.json) by hand got tedious, so I built a local web UI for it.
This one started out as claude-config but migrated to coder-config as I'm adding others (Gemini, AG, Codex, etc).
Main features:
  - Visual editor for rules, permissions, and MCP servers
  - Project registry to switch between codebases
  - "Workstreams" to group related repos (frontend + API + shared libs) with shared context
  - Auto-load workstreams on cd to included folders
  - Also supports Gemini CLI and Codex CLI
Install:
  npm install -g coder-config
  coder-config ui         # UI at http://localhost:3333
  coder-config ui install # optionally, autostart on MacOS
It can also be installed as a PWA and live in your taskbar.
Open source, runs locally, no account needed.
Feedback and contributions welcome!
Sorry, haven't had any chance to test on other OSes (linux/windows)

value: Show HN: Config manager for Claude Code (and others) – rules, MCPs, permissions


value: Show HN: LastSignal – A self-hosted, zero-knowledge dead man's switch


value: ayaboch

value:
We’re open-sourcing FASHN VTON v1.5, a production-grade virtual try-on model.
Given an image of a person and an image of a garment, the model generates a photorealistic try-on result.
Model specs:
- It operates directly in pixel space (no VAE)
- Supports maskless inference by default, and was trained from scratch.
- ~972M parameters, runs on consumer GPUs
- Can run in ~5 seconds on H100
We built this as a focused alternative to large generalist models, with the goal of making a production-grade, specialized virtual try-on model.
We’re releasing the weights, inference code, and architecture details under an Apache-2.0 license.
Would love to hear your thoughts!

value: Show HN: FASHN VTON v1.5 – open-source virtual try-on model

author: ayaboch


value: daniil-gi

value:
Hi everyone, I want to say that I'm new to system programmings (a little over than six months in total) and I want to ask for feedback about my recently-made projects especially my compiler & kernel on Rust/GNU ASM, I'm happy to any feedback!
Link to my Github repositories - https://github.com/daniil-gi?tab=repositories

value: Show HN: New to System Programmings

author: daniil-gi

title: Show HN: New to System Programmings


value: irasigman

value: It produced a systematic trading expression shown to consistently produce profit on ETH-USD.

value: Show HN: I Gave Claude Code a Job as a Quant Researcher

author: irasigman


value:
Hey HN, I'm Jon.
About a year ago, I built Hypermonkey, a productivity app for my friends who were struggling to stay productive because of their ADHD. I gamified it so my ADHD friends would stick to using the app like Duolingo and start checking off tasks on their to-do lists. The trick is to earn a banana every day by interacting with the app.
The app uses the latest GPT and Sonnet models for all the smart features in the app, such as using your voice to add/edit/delete tasks, breaking down your tasks, prioritizing them, or suggesting the next tasks to start.
Currently, users can use the bananas they have earned to shop for stickers in the app. Planning to add more items to the shop in the future!
Open to any feedback, good or bad, and questions! Thanks in advance.

value: Show HN: I gamified a productivity app to help my ADHD friends get things done


value: keepamovin

value: Show HN: LZW-X – improving classic LZW compression with edit-scripts

author: keepamovin


value: nomadic-coder

value:
While there are some async methods for agents to communicate, essentially writing some kind of shared memory --> I couldn't find some synchronous way for agents to communicate (lies: I found some later).
I built this, and later compared it to gastown (which I forgot about when I started building it). Gastown is potentially way better than this, however Repowire doesn't have a mayor or orchestrator and instead allows agents to talk to each other directly.
Supported Claude with a lot of tmux magic (copy paste directly into claude code with tmux) and opencode with their plugin API. A lot of the business logic is coupled with naming of tmux windows and sessions (sessions = repowire circles = "vpc" for coding agents)
If folks like it, thinking of building out relay.repowire.io (now just lies) to allow multi-node comms.
The repo has a screencast

value: Show HN: I built a mesh network for Coding agent sessions called Repowire

author: nomadic-coder


value: analyses-web

value:
Hi HN,
I built ProductSignals API, a small API that aggregates publicly available signals
(Trustpilot, Reddit, ArnaqueOuFiable, Gridinsoft) to surface potential reliability
or trust-related signals about products or merchants.
The goal is not to give verdicts or advice, but to provide deterministic,
machine-consumable signals that can be used as an input in automated workflows
(onboarding checks, internal tooling, monitoring, etc.).
Key points:
- Single JSON endpoint (POST /v1/product-signals)
- Signals only (no recommendations, no scoring guarantees)
- Public data sources only
- Subscription-based, quota-limited
- No customization per customer
Docs and examples:
https://productsignalsapi.analyses-web.com/docs.html
Pricing:
https://productsignalsapi.analyses-web.com/pricing.html
This is part of a small suite of similar APIs (risk / abuse signals).
I’m mainly interested in feedback from people who build automated systems
around trust, risk, or onboarding.
Happy to answer technical questions.

value: Show HN: ProductSignals API – product reliability signals from public sources

author: analyses-web


value: mahmoudimus

value: Show HN: A header-only C++20 compile-time assembler for x86/x64 instructions

author: mahmoudimus


value: fabienfr

value:
I built a small, free website to send digital letters with cute animations and a bit of personalization. The idea was to keep it simple and human—no accounts, no pressure, just words.
What really surprised me is how many people are writing real letters, especially love letters, to people they deeply care about. Reading some of them honestly restored a bit of my faith in humanity.
Sometimes a few sincere words are the best gift you can give someone.
And in the end
The love you take
Is equal to the love you make. (The Beatles)

value: Show HN: A simple, free website to send love letters

author: fabienfr


value: e-clinton

value:
Hi HN — I built Terminal MCP, a utility that exposes terminal sessions over MCP, primarily to help LLMs interact with CLIs and TUIs during development and debugging.
It’s also useful outside of AI: it provides a general way to run terminal workflows through a controlled interface, with better isolation and observability than a raw shell.
Recent addition: Sandbox mode, based on Anthropic’s work on safe tool execution. It lets you run sessions with explicit controls over what the process can access — by default blocking common locations where credentials live, and optionally restricting filesystem and network access.
Repo: https://github.com/elleryfamilia/terminal-mcp
Feedback welcome.

value: Show HN: Terminal MCP – A sandboxed terminal interface for LLMs and beyond

author: e-clinton


value: stevekrouse

value: We gotta teach the vibe coders how to be software engineers!

value: Show HN: Repro.fyi – info-site on submitting bug reports

author: stevekrouse


value: genvibe

value: Show HN: Figma to full-stack apps in minutes – web and mobile support

author: genvibe


value: mnorris

value:
Last month I posted Mukbang 3D on here but I didn't get any discussion so I thought I'd give it another crack since I've put a bunch more into it.
Since last time, I've replaced the video-to-3D pipeline with single-image Gaussian Splatting. A photo now generates in ~10 seconds on a Mac Mini, down from 15-120 seconds for video. You can compare the two approaches—video-based meshes: https://mukba.ng/discover/#videos vs image-based splats: https://mukba.ng/discover/#images
Benchmarks for SHARP between Mac Mini M4 and Macbook Pro M4: https://mukba.ng/blog/2026-01-21-sharp-apple-silicon-benchma...
I've also optimized rendering speed: I've chunked and zstd'd the output so it can start rendering as soon as the first packet comes in.
Why food? I started with Structure from Motion on video, and food was a good constraint because it doesn't move. People look terrible when they blink or shift mid-capture. Now that doesn't matter as much.

value: Show HN: Gaussian Splatting from a single photo in ~10 seconds on a Mac Mini

author: mnorris


value:
AGENTS.lock keeps AI agent skills, instructions, and MCP servers in sync across Claude, Codex, Gemini, and Copilot CLIs using a single TOML lockfile as the source of truth.
Instead of manually copying skills and configs between tools, you declare everything once in AGENTS.lock and run `al sync`.
GitHub: https://github.com/luml-ai/AGENTS.lock

value: Show HN: AGENTS.lock – a package manager for Agents/Skills/MCPs


value: blacktent

value:
BlackTent is a strictly local CLI tool that generates policy-constrained, sanitized bundles of a project during incidents or support situations.
It scans code, configs, and (optionally) logs, replaces credentials and other secret patterns using deterministic rules, and outputs a standardized bundle with a machine-readable manifest. The bundle is intended to be reviewed and then shared with external help (LLMs, vendors, contractors) without accidentally leaking credentials.
The tool itself runs entirely on your machine: no network calls, no telemetry, no session history. Redaction rules are fixed and auditable; the same inputs and rules produce the same output, making review and diffing possible.
This is not a sandbox, not an AI agent, and not a full incident response or forensic pipeline. It does not protect IP, does not guarantee safety against malicious recipients, and does not replace vendor due diligence. The goal is to reduce accidental oversharing under time pressure by making it trivial to produce a reviewable, constrained artifact.
I’m looking for feedback on threat-model boundaries, redaction guarantees, bundle/manifest design, and how people would integrate this into real incident or support workflows.

value: Show HN: BlackTent – a strictly local CLI for sanitized incident bundles

author: blacktent


value: Show HN: I Built a Sandbox for Agents

title: Show HN: I Built a Sandbox for Agents


value: csummers

value:
Hi, I'm Curtis, the founder of Hot Dev, a new backend workflow platform.
Intro Blog Post: https://hot.dev/blog/introducing-hot-dev
Building modern backend systems often means wrestling with complex orchestration, scattered logging, poor observability, opaque AI integrations, and difficult developer/devops experiences. Hot Dev is designed to solve these problems!
---
Why am I building Hot Dev?
As a backend developer for 25+ years, at almost every company, the backend team ends up cobbling together background utility servers and workers to process items off of queues, handle events coming into the system, run scheduled jobs and other on-demand asynchronous processes. This is more true in recent years because companies are integrating AI services into every part of their systems and workflows.
The team is tasked with choosing and building up each of these services from cloud providers (AWS, Google, etc) and integrating them into applications and backend services. These tasks create a lot of development work (i.e., time and money!) spent on managing and monitoring the infrastructure instead of thinking about your problem domain and your business.
Hot Dev provides a managed platform for defining and monitoring workflows at the problem-domain level--allowing you to focus on your business needs.
In the same way that Vercel runs your web app for you without you having to think about AWS EC2 servers or Kubernetes, Hot Dev runs your backend workflows for you without you having to think about AWS SQS, Kafka, or ECS.
Additionally, as a software developer, I care deeply about the Developer Experience and the DevOps Experience. Hot Dev is designed for a simple, streamlined developer experience...where local development matches production, and deploys are a single command: `hot deploy`
Download Hot Dev today for your Mac, Linux, or Window machine at https://hot.dev
---
FAQ: (anticipating some HN crowd questions!)
Q: A new language.  Are you crazy?
A: Yes, and maybe!  But, I felt like bolting on the level of traceability to existing languages created lots of boilerplate code...obscuring the problem domain.  It's definitely a trade-off, but one that I was willing to take.  Hot is a simple, functional, expression-based language with immutable data and optional/gradual types. The language is inspired by Clojure with nods to Rust and Typescript.  I think most developers will find it easy to learn and use. The Hot language vm and the platform itself is written in Rust.
Q: How do you compare to temporal, inngest, trigger.dev?
A:
Hot Dev supports many similar features for scheduled jobs, cancellations, failing, retries, and event-driven architecture.  The primary differences are the use of the Hot Language to defined your workflows and Hot functions wrapping other API services--either your own backend APIs or other external API services.
And, as mentioned at the end of the intro blog post, I'll be adding two significant features to the platform soon:
1) Hot Box Container Execution--the ability to run an OCI container image as a Hot function
2) MCP (Model Context Protocol) support -- turn any Hot function into an MCP Tool.
Q: Is this Open Source?
A: Not yet, but this is the plan.  I'm holding the reigns a little tight for now with the new language, but I expect the Hot language implementation to be open source within the year.  If it helps...I'm also the author of HugSQL (https://hugsql.org).
---
If you can't tell from the video, I'm having so much fun with this! Follow Hot Dev on X https://x.com/hotdotdev for updates!

value: Show HN: Hot Dev – a new backend workflow language and platform

author: csummers


value: vunderba

value: Show HN: I made a game to teach you to play blindfold chess

author: vunderba


value: platoventure

value:
I’ve spent a better part of the last year building Frigatebird, a high performance columnar SQL database written in Rust. The goal wasn't just to "make it work" but to use every systems programming trick available to maximize throughput on Linux. Frigatebird is an OLAP engine built from first principles. It features a custom storage engine (Walrus) that uses io_uring for batched writes, a custom spin lock allocator, and a push based volcano execution pipeline. I explicitly avoided async runtimes in favor of manual thread scheduling and atomic work stealing to maximize cache locality.
currently it only supports single table operations (no JOINS yet), would love to hear your thoughts on it
code: <https://github.com/Frigatebird-db/frigatebird>

value: Show HN: Frigatebird – embedded OLAP database built on io_uring

author: platoventure


value: maltsev

value:
Marches & Gnats is a browser-based coding puzzle game inspired by Advent of Code, but instead of writing code in a conventional programming language, you program a Turing machine.
Each quest presents a concrete problem and a minimal model of computation. You define transition rules, run the machine, inspect the output (or errors), and iterate until it works.
The game is set in 19th-century Estonia during the Romantic era and combines narrative with progressively harder problems, including arithmetic, sorting, parsing, ciphers, and cellular automata.

value: Show HN: Marches & Gnats – Coding puzzle game where you program Turing machine

author: maltsev


value:
  For the past few months, I’ve been working on a new Layer 1 blockchain designed to solve what I see as the fundamental trilemma in the space: achieving strong privacy, infinite scalability, and post-quantum security simultaneously.
  The result is NERV: a private-by-default, horizontally scalable blockchain that replaces Merkle trees with 512-byte neural state embeddings, proven inside Halo2 circuits and attested in hardware enclaves.

Key technical innovations:
Neural State Embeddings
  Instead of Merkle trees, the entire state of a shard is compressed into a 512-byte vector using a transformer encoder. Transfers are homomorphic updates in this space—no decompression needed. This reduces inclusion proofs by ~900× compared to zkEVMs.
Blind Validation & TEE-Bound Privacy
  Transactions are routed through a 5-hop onion mixer running inside remotely attested enclaves (SGX/SEV/TrustZone). No addresses, amounts, or metadata are ever visible on-chain.
Dynamic Neural Sharding
  Shards split and merge autonomously based on an LSTM load predictor, updated via federated learning. This allows >1M sustained TPS with no theoretical ceiling.
AI-Native Consensus
  Validators predict the next embedding hash using a distilled transformer. Disagreements are resolved via Monte Carlo simulations in TEEs, achieving sub-second finality.
Useful-Work Economy
  Nodes earn tokens by contributing gradients to improve the network’s own encoder via differentially private federated learning—replacing PoW/PoS with useful computation.
Why this might be interesting to HN:
  The system is fully open-source (MIT/Apache 2.0), with all code, circuits, and tests already public.
  No pre-mine, no VC allocation, no foundation treasury. Fair launch is scheduled for October 2027.
  Built with post-quantum primitives from genesis (Dilithium-3, ML-KEM, SPHINCS+).
Implements formal privacy guarantees (ProVerif models included).
  The core ZK circuit (LatentLedger) is ~7.9M constraints—far smaller than equivalent zkEVM proofs.
Current status:
  ~85-90% of the code is complete, including core circuits, TEE attestation pipelines, sharding simulations, and federated learning incentives. Testnet is targeted for Q4 2026.
  I’m sharing this here not to promote a token, but to invite technical feedback, cryptographic review, and collaboration from the community to help make that crucial leap from being a strong prototype to being a fully-realized, live, ever-evolving private money .
  If you’re into ZK, TEEs, federated learning, or post-quantum crypto, I’d love your thoughts.
Links:
Whitepaper: https://github.com/nerv-bit/nerv/blob/main/NERV_Whitepaper_v...
GitHub repo: https://github.com/nerv-bit/nerv
Code & tests: https://github.com/nerv-bit/nerv/tree/main/NERVCodeV2
Happy to answer any technical questions or discuss design trade-offs.

value: Show HN: A private, PQ-secure, infinitely scalable blockchain[fully open-source]


value: Show HN: RFX-Fuse: Breiman and Cutler's Random Forest + Explainable Similarity


value: Show HN: Promptguard JSON Schema Tests for LLM Outputs in GitHub Actions


value:
I am a software engineer at Emmi AI and we just released the open source framework we are using to train large-scale surrogate ML models.
Our aim was to lower the entry-barrier for Engineering AI, to get the power of modern deep learning into classical engineering.
Engineering and simulation data such as what is used for example in Computational Fluid Dynamics is of high-cardinality. Single examples can be up point clouds with multiple millions of points, requiring distinct approaches to models architectures and data loading that aren't served well by other frameworks. Noether comes with optimized architectures and components that make it easier to train models on simulation data.
We also provide a tutorial that runs you through all the steps involved in training a surrogate model: https://github.com/Emmi-AI/noether/blob/main/tutorial/README...

value: Show HN: Noether – ML framework to train physical engineering models


value: mausys

value:
I built a small IPC library for Linux aimed at real-time and low-latency data exchange between processes.
At its core is a zero-copy, wait-free, single-producer / single-consumer circular message queue living in shared memory. The design avoids locks and minimizes synchronization overhead, making it suitable for real-time or near-real-time workloads.
Key features:
- Zero-copy message passing via shared memory
- Wait-free SPSC queue (no locks, no blocking in the fast path)
- force_push mode: when the queue is full, the oldest message that hasn’t been consumed yet is dropped to make room for new data (useful when freshness > completeness, e.g. sensor streams)
- Uses optional eventfds for efficient notifications
- Small, dependency-free C implementation (a few thousand lines of code)
This is not meant to replace general-purpose IPC systems like D-Bus. Instead, it’s designed to complement them for high-frequency or real-time data paths, while something like D-Bus handles control and configuration.
The library includes a lightweight handshake protocol over Unix domain sockets to exchange shared memory file descriptors, eventfds, and channel configuration.
If you prefer, you can also use an external IPC mechanism just for the handshake phase.
Ecosystem:
There’s also a pure Rust implementation of the same protocol and queue design:
https://github.com/mausys/rtipc-rust
And an example in Rust of using zbus and Tokio to perform the handshake over D-Bus while using this library for the real-time data channel:
https://github.com/mausys/rtipc-zbus

value: Show HN: Rtipc – real-time, zero-copy IPC for Linux

author: mausys


value: mmkns

value: Show HN: Curvy turtle graphics for SVG paths (open-source)

author: mmkns


value: jacobgadek

value: Show HN: A whitepaper on runtime governance for autonomous AI systems

author: jacobgadek


value: AlxBrks

value:
Hello HN!
We, a team of 2, built Subatix after one of us spent almost 6 years in big consulting and at certain point came to a thought like «90% of what consulting is usually data-analysis related, why not make smth so any business get same level of insights without externals and 6-figure+ checks and fast?!». Based the experience during every project everyone wants - fast answers from their data, but real ops/business data is messy, sensitive, and hard to outsource to generic AI tools due to security and output quality reasons. Most analysis still ends up in Excel, SQL notebooks and then slide decks are stitched together manually. When AI tools appeared, they helped with text and ideas, but fell apart once real business data, traceability, or auditability mattered.
Subatix is an attempt to bridge that gap. It’s a desktop workspace (macOS and Windows already available) where you open your own business or operational data locally and ask about what bothers + pre-cooked structured multi stage business diagnostic flow. The system breaks the request into analysis steps, applies standard consulting-style methodologies (KPIs, variance analysis, loss trees, scenario logic, etc.), runs the calculations, and produces quantified findings and prioritized actions. All intermediate steps, assumptions, and calculations remain visible - so everything is traceable and can be verified + users’ raw data stays local, all calculations/analysis done on the machine.
A few design decisions that make it different from most AI analytics tools:
* Local-first by default: raw data stays on your machine. There’s no requirement to upload raw operational or financial data to a cloud service. In fact, users don’t even upload it anywhere.
* Traceable outputs: every number is backed by explicit calculations, not just narrative summaries.
* Method-driven: instead of free-form chat, the system applies structured analysis patterns used by big-consulting business analysts/associates.
* Human-in-the-loop: today the goal isn’t to replace, but to make methodologies and frameworks widely accessible and to compress the repetitive, time-consuming parts so people can focus on judgment and decision-making.
The tool exists today and is usable. You can find out more and download it here: https://www.subatix.com/hn  There is a trial available for all new users and also some copper production sample data available to play with - just hit the Analyze Sample Data once you configure Subatix on your machine.
We’re around in the comments and interested in feedback about both UI and UX - especially from people who do business analysis.
Happy to answer questions!
Thank you HN!
Alex and Vlad
=(^_^)=

value: Show HN: Subatix – your local-first consulting team in an AI-workspace

author: AlxBrks


value: andrewjneumann

value:
Couldn't find an iOS client that supported gpodder or Nexcloud (NextPod), so I built one. While it's flutter/dart built the focus of development is iOS and ecosystem features eg WatchOS support, CarPlay, AirPlay streaming, etc. You can download it from the Apple App store (iOS/iPadOS/macOS) for a few bucks (TestFlight is also available) or compile yourself from repo (tested on iOS & Linux, should work elsewhere too).
Adding podcast search next and thinking about adding standalone account support (keeping podcast data local and not requiring gpodder sync).
What features is it missing? What do you want to see from your perfect podcast app? What do you wish your current podcast app didn't do?
https://asecretcompany.com/yourpods/ has more market-y details.

value: Show HN: Built YourPods an open-source iOS gPodder / Nextcloud podcast client

author: andrewjneumann


value: dommm

value: Show HN: Buy, Sell and Short Startups (Via Stickers)

author: dommm


value: codenamev

value:
I built this as an experiment in how much uncertainty Ruby code can tolerate before it stops feeling deterministic. The gem introduces controlled randomness and can define methods at runtime, allowing behavior to emerge dynamically rather than being fully designed ahead of time.
It's early and intentionally exploratory, NOT production-ready. Sometimes it feels like a creative tool. Other times it feels like you're giving your code permission to make decisions you didn't explicitly authorize.
I'm curious where people think that line should be.

value: Show HN: Chaos_to_the_rescue – Ruby gem for runtime-defined behavior

author: codenamev


value: bumpa

value:
Built this to manage the full Claude Code workflow autonomously, from                                                                                initial plan creation to reviewed PR.
Tested it on a 25-task plan (5-7 items each) - ran overnight, woke up to a surprisingly solid PR-ready branch.
Just run `ralphex` (single binary) in your project directory.
Without a plan file, it starts interactive mode. Asks what to build, explores the codebase, writes the plan, then executes.
The loop: plan creation (asks questions, writes markdown) → task execution (fresh session each, no context bloat) → multi-phase reviews (Claude + optional Codex) → branch ready for PR.
Prompts for each phase are injected with minimal context needed for continuation: plan file, progress log, goal. Progress file accumulates Q&A during planning, execution logs during tasks, review findings between iterations. Output streams to terminal and progress log file simultaneously.
Everything customizable at user level (~/.config/ralphex/) or per-project (.ralphex/): prompts, agents, colors.
Web dashboard monitors progress files across directories. See active sessions, stream output live, spot failures without switching terminals.

value: Show HN: Ralphex – Ralph-inspired loop extended with plan creation and reviews

author: bumpa


value: Jollydevs

value:
I built JSONBin because I kept needing a quick place to store JSON for prototypes.
It's simple: POST any JSON to /api/bins, get back an ID and URL. Retrieve with a GET. Update with PUT. Delete with DELETE.
No signup required for basic use. Free tier gives you 100 bins and 1K daily requests.
Tech: Next.js, Vercel, Neon (Postgres), Stripe for payments.
Would love feedback!

value: Show HN: JSONBin – Free JSON storage API (no signup required)

author: Jollydevs


value: dujuku

value: Show HN: Explain.datadoghq.com – a free explain plan visualizer

author: dujuku


value: thenextechtrade

value:
Hi HN,
I’ve been working on a specialized tool designed to optimize the Grok prompt experience: Grok Bikini (grok-bikini.com).
The Engineering Goal: My focus is on the Grok prompt refinement logic. While the Grok Vision API is powerful, standard inputs often fail to capture the high-fidelity nuances required for fashion synthesis. I built a layer that programmatically wraps a simple Grok prompt into a structured, photography-spec instruction set—handling lighting, textures, and lens parameters within the model's latent space.
Experimental Setup: To test this, I automated a multi-lingual TDK system for 19 languages. The goal is to see how different cultural contexts interact with the same Grok prompt engine through a semantic buffer (using /grok-prompt-swimwear paths) to balance high-intent keywords with safety filters.
Click https://grok-bikini.com/grok-prompt-swimwear to use Grok Prompt.

value: Show HN: A Specialized Grok Prompt Refiner for Vision API

author: thenextechtrade


value: Show HN: I built an AI companion to stop doomscrolling and regulate anxiety


value:
After college, my friends scattered across time zones. We tried starting a podcast to stay in touch, everyone would record updates, uploads them to Google Drive, and we planned to eventually publish episodes.
We never published one. Turns out we didn't want a public podcast, but "the podcast" gave us a reason to keep in touch and share stories/thoughts.
Google Drive was terrible for our needs. Record in one app, then upload. No notifications, bad organization. The worst part was when responding to something specific, I'd have to manually timestamp it and repeat their point before commenting. Completely broke the flow.
So I built Roads Audio. Private audio messaging where you can reply to specific moments with timestamped comments. Conversations branch naturally instead of stacking linearly. The hardest technical problem was handling infinite nested timestamped threads and querying position in the conversation tree, then displaying that in a user-friendly UI.
I built with Flutter/Django and have been working on it for a few years (here's the original micro-podcasting launch: https://news.ycombinator.com/item?id=37758099). Initially positioned as a podcast alternative, but I've realized it's really about staying connected through longer-form audio without immediate response pressure.
The app has evolved a lot over the years and I'm always looking for more feedback from people who are interested in async audio. I still use it regularly with the same friend group; if it seems interesting let me know what you think!

value: Show HN: Built an app to replace our failed group podcast experiment


value: I came up with the name and provided suggestions. LLM did the rest. I encouraged Claude Code to go wild with humor/satire. I have found LLMs to be fantastic at humor.

value: Show HN: Ghostly: The Ultimate Platform for Ghosting Candidates (Satire)


value: KyleVlaros

value: Helm gives you powerful chart rendering, but it doesn't ship a safe, operator‑friendly plan/preview workflow for production changes. Helmer is a focused CLI that creates a production‑friendly plan workflow so teams can review changes before they hit the cluster.

value: Show HN: Deploying Helm charts without fear

author: KyleVlaros


value: callmeed

value: Show HN: I'm building an AI-proof writing tool. How would you defeat it?

author: callmeed


value: sylvinus

value:
I am very afraid to run claude (or even npm) on my host system. It is a security incident waiting to happen.
To fix that but still keep the friendly developer experience of just typing a single command in the folder I want to work on, I wrote a simple script that allows one to run "claude-vm" anywhere, with the local folder mounted but a fully isolated VM.
As bonuses, I added Chrome MCP, Docker, and an easy way to customize the base VM or its folder-specific runtime copy.
It's not much, but it's been pretty valuable to me so I may as well share it! Feedbacks welcome.

value: Show HN: A single command to run Claude Code inside Lima VMs

author: sylvinus


value:
Hello HN,
I’m Yeonseok, CEO of ZETIC.ai (ex-Qualcomm AI Research).
Deploying AI models to mobile NPUs usually requires deep hardware knowledge and months of tuning. Today, we are changing that.
We are opening our On-device AI SDK for free right now.
We’ve released a GitHub repository that gives you direct access to full NPU acceleration on heterogeneous devices (Android/iOS). You don't need GPU Cloud infrastructure anymore.
What you can do with this SDK (GitHub):
 Full NPU Speed: We unlock raw NPU power for heterogeneous devices globally. No more CPU lag.
 Bring Your Own Model: Don't just run our demos. You can upload your custom model and get an optimized, hardware-accelerated SDK in hours.
 Production-Ready Source Code: The repo includes full source code for On-device AI Agents, 40+ Language Translations, and SOTA Object Detection examples to get you started immediately.
We want to democratize access to NPU computing. The GitHub repo is ready-to-use. I’d appreciate it if you could check the code and give it a Star if you find it useful.
Repo: https://github.com/zetic-ai/ZETIC_MLange_apps
Let me know if you have any questions about the NPU implementation!

value: Show HN: Free On-Device AI SDK to Run PyTorch on Mobile NPUs (Open Source)


value: The IRS lets you hire and pay your kids for real work. That earned income can go into a Roth IRA and grow tax-free. $4k/year from age 10-18 becomes over $1M by retirement. The catch? Paperwork. Agreements, work logs, payment records. Most parents never bother because it's annoying. employkids makes it easy.

value: Show HN: employkids – Hire your kids so they can retire millionaires (legally)


value: snorbleck

value: Show HN: Blinkys – Digital Lifeforms Simulation

author: snorbleck


value: taariqlewis

value:
What makes Seren different:
We're trying to build an AI IDE for non-devs, but that great devs will appreciate.
Open marketplace – 90+ publishers for databases (SerenDB, MongoDB), web scraping (Firecrawl), AI search (Perplexity), email (Google), calendars, CRM, even eSignatures Micropayments that work – x402 USDC on Base network.
No subscription tiers, no credits expiring. Pay per API call.
Databases: Query SerenDB (serverless Postgres), MongoDB, Neon with natural language.
Web tools: Scrape websites with Firecrawl, AI-powered search with Perplexity
Integrations: Email, calendar, CRM actions. Coming soon: GitHub, Linear, Notion
Compute: Run code sandboxes, agent templates, custom workflows
Each publisher sets their own pricing. You pay per API call with USDC on Base (x402 standard). No subscriptions, no expiring credits.
What's inside
Semantic Indexing
Monaco editor with Cmd+K inline AI editing
Agent Client Protocol for running Claude Code and compatible agents
Model Context Protocol for local MCP servers
Multi-model support with free tier (Gemini 2.0 Flash)
The Tech stack
Frontend: SolidJS + TypeScript + Vite
Backend: Rust + Tauri 2.0
Vector store: sqlite-vec (all local, no cloud)
MIT licensed, ~10MB binary
Architecture
The client is fully open source. It connects to Seren Gateway for:
AI model routing & authentication
SerenEmbed API (embedding generation)
Publisher marketplace
Think VS Code (open source) + Extension Marketplace (proprietary).
Try it
GitHub: https://github.com/serenorg/seren-desktop
Website: https://serendb.com
Current: v0.1.0-alpha.9 (macOS, Windows, Linux)

value: Show HN: Seren Desktop – AI IDE with Publisher Store and X402 Micropayments

author: taariqlewis


value: MykLaz

value:
Hey HN! I built SharpAPI to solve my own frustration with existing sports betting APIs.
The problem:
- OddsBlaze ($349/mo entry) has poor support and surprise breaking changes
- The Odds API has a stingy free tier (500 credits/month ≈ 16 requests/day) and no real-time streaming
- Both charge extra for +EV/arbitrage detection, or don't offer it at all
What I built:
- Real-time odds from 20+ sportsbooks via SSE (not polling)
- Sub-89ms P50 latency
- Built-in +EV, arbitrage, and middles detection
- Free tier with 12 requests/min
- TypeScript SDK with full IntelliSense
- One unified schema regardless of sportsbook
Tech stack: Next.js, Vercel, DigitalOcean, Upstash Redis, Hono
The API processes ~47M odds daily. I'm scraping responsibly with proper caching and rate limiting on my end.
Pricing starts at $79/mo for Pro, with a free tier to get started. No credit card required.
Happy to answer questions about the architecture, the sports betting market, or anything else!

value: Show HN: SharpAPI – Real-time sports odds API with +EV and arbitrage detection

author: MykLaz


value: jmuncor

value: I built this out of curiosity about what Claude Code was actually sending to the API. Turns out, watching your tokens tick up in real-time is oddly satisfying.<p>Sherlock sits between your LLM tools and the API, showing you every request with a live dashboard, and auto-saved copies of every prompt as markdown and json.

value: Show HN: A MitM proxy to see what your LLM tools are sending

author: jmuncor


value: zaizz

value:
Hi HN,
I built StudyBuddy, an AI-powered study assistant for students, and it recently crossed 1,000 users.
The goal is to reduce the chaos of studying by combining planning, revision, and AI help into one place.
Recent additions:
Live web search inside the AI chatbot (real-time info)
Integrated study planner dashboard
Managed study sessions for focused work (Premium)
There’s also a small ₹99/month (~$1.20) premium plan, mainly to cover infrastructure costs.
I’d really appreciate:
Feedback on the product direction
Ideas on what would make this genuinely useful
Criticism on UX, features, or pricing
Thanks for reading, and happy to answer any questions.

value: Show HN: StudyBuddy – an AI study assistant that just crossed 1k users

author: zaizz


value: belai

value: Show HN: VoyagerAI – Turn Articles into AI Interactive Jupyter Notebooks

author: belai


value: setzeno

value:
Hi HN,
I’ve spent a lot of time debugging large Parquet datasets on S3 where “something is wrong”, but figuring out what usually means either accessing each file individually or even spinning up Spark just to inspect metadata.
In practice, it’s often things like:
- schema drift across partitions
- columns silently disappearing
- timestamp precision changes
- files written by different pipeline versions
- row groups with bad stats or empty data
By the time you notice, the dataset is already messy and hard to reason about.
So I built pqry, a Rust-based CLI tool that scans Parquet metadata at the dataset/prefix level and surfaces issues like schema drift, unstable columns, partition hotspots, and row-group health.
It works entirely from metadata, so you can point it at tens of thousands of files and get results fast.
Example:
- pqry drift s3://bucket/events/
- pqry columns s3://bucket/events/
- pqry quality s3://bucket/events/
Repo: https://github.com/symblic/pqry
I originally built this for debugging production pipelines where writers and schemas evolved over time and problems only showed up weeks later.
Would love feedback from anyone working with large Parquet datasets in production.

value: Show HN: pqry – A fast, lightweight CLI tool to diagnose Parquet datasets

author: setzeno


value: thebitguru

value:
Hi HN!
I created an ESP32 driven weather display for pilots that looks like a cockpit instrument. The goal was to move METAR off the phone screen and onto the desk where it is always visible. It’s a dedicated, "always-on" desk accessory that fetches real-time aviation weather and renders it onto a high-contrast e-paper display. It also has a quiz mode to help student pilots learn and test METAR decoding.
Jumpseaters: Adding Personality to the Data
Raw METARs can be dry, so I implemented a feature called Jumpseaters. These are selectable personality profiles that transform the device into an opinionated flight crew.
Instead of just seeing "OVC001," you might get a report from Downwind Donnie, who sarcastically judges your "personal minimums," or Checkride Charlie, a virtual DPE who delivers weather updates with the uncomfortable silence. It was a fun to map these "personalities" to specific weather triggers in the firmware.
----
The Technical Details
Controller: ESP32-S3. I chose this for the native USB support and the power efficiency needed for long-term deep sleep.
Display: 4.2" E-Paper. It uses an open-source library https://github.com/martinberlin/CalEPD
Power: Deep sleep cycles keep the current draw low, allowing it to run for weeks on a small LiPo. I am continuing to optimize the power usage because I feel I can get it to last many months even after the daily screen refreshes.
Tech Stack: ESP-IDF/C++ for the microcontroller. Flutter/Dart for the iOS/Android mobile apps. Nextjs for the website and API.
---
I have learned a lot about hardware devices during this process. It has been fun programming for the E-paper display. It has it's own unique challenges because of the nature of the technology (seconds for each refresh vs. refreshes/second for traditional screens). I really enjoy when it refreshes.
The Kickstarter is live and 38% funded with 15-days to go. One thing I wish I had done a lot more of is prelaunch marketing. Ads now have had good conversion driving to the Kickstarter page, but the volume takes time.
On the same prelaunch theme, the other major lesson learned is that I wish I had asked for more feedback publicly (I do have early testers, but all local) and shared more before working on the Kickstarter. Once you say Kickstarter, all the mods put it in the commercial category and don't allow posting ANYTHING related to it.
Check it out at https://papermetar.com or https://www.kickstarter.com/projects/charlie29r/papermetar

value: Show HN: PaperMETAR – An E-Paper Aviation Weather Display for Pilots

author: thebitguru


value: Othrya

value:
Hey HN,
I built Alprina to solve a problem I've experienced firsthand as a founder: fundraising feels like shooting in the dark.
You spend weeks cold emailing investors who aren't a fit. You get generic intros that lead nowhere. You waste time on people who don't understand your stage, industry, or vision.
Alprina flips this. Instead of you chasing investors, AI agents analyze your startup—your goals, stage, and vision—and match you with the right investors based on real context. No spam. No noise. Just relevant intros to people who actually make sense for your journey.
I've been working on multiple ventures (healthcare claims automation, AI workflow platforms, climate tech) and kept running into the same fundraising friction. So I built this.
Would love your feedback. What's been your experience with investor outreach? What would make this more valuable for you?
Check it out: alprina.com

value: Show HN: Alprina – Find your next investor through AI-matched intros

author: Othrya


value: mifydev

value:
I’ve been experimenting with embedding an Claude Code/Cursor-style coding agent directly into the browser.
At a high level, the agent generates and maintains userscripts and CSS that are re-applied on page load. Rather than just editing DOM via JS in console the agent is treating the page, and the DOM as a file.
The models are often trained in RL sandboxes with full access to the filesystem and bash, so they are really good at using it. So to make the agent behave well, I've simulated this environment.
The whole state of a page and scripts is implemented as a virtual filesystem hacked on top of browser.local storage. URL is mapped to directories, and the agent starts inside this directory. It has the tools to read/edit files, grep around and a fake bash command that is just used for running scripts and executing JS code.
I've tested only with Opus 4.5 so far, and it works pretty reliably.
The state of the file system can be synced to the real filesystem, although because Firefox doesn't support Filesystem API, you need to manually import the fs contents first.
This agent is really useful for extracting things to CSV, but it's also can be used for fun.
Demo: https://x.com/ichebykin/status/2015686974439608607

value: Show HN: Cursor for Userscripts

author: mifydev

title: Show HN: Cursor for Userscripts


value: jaygood

value: Show HN: Rust tool to hide windows from screen shares via Win32 API

author: jaygood


value: bothangles

value: Show HN: Copilot YOLO Mode

author: bothangles

title: Show HN: Copilot YOLO Mode


value: shayanbahal

value:
Multi-protocol censorship circumvention stack optimized for hostile network environments.<p>Multiple protocols - Reality (VLESS), Trojan, Hysteria2, WireGuard (direct & wstunnel), DNS tunnel
Also runs and donates bandwidth to Tor Snowflake  and Psiphon Conduit

value: Show HN: MoaV – Mother of all VPNs

author: shayanbahal

title: Show HN: MoaV – Mother of all VPNs


value: reubenswartz

value: Show HN: BoxLight- a macOS Sonoma ring light app that doesn't waste space

author: reubenswartz


value:
Built an MCP server that makes 37 EU regulations searchable from Claude Desktop/Cursor. Full-text search across 2,400+ articles, control mappings to ISO 27001/NIST CSF, cross-regulation comparisons.
Started as our internal tool for our Threat Modeling service. Open-sourced it because EUR-Lex is painful.
GitHub: https://github.com/Ansvar-Systems/EU_compliance_MCP
npm: npx @ansvar/eu-regulations-mcp
Tech: TypeScript, SQLite FTS5, MCP protocol.

value: Show HN: EU Regulations MCP Server – Query GDPR, Dora, NIS2 from Claude


value: rayruizhiliao

value:
Text:
We previously posted Vectorly (https://news.ycombinator.com/item?id=46209538), our open-source app that reverse-engineers websites into reusable APIs. The core idea: instead of clicking through UIs like a human, interact with websites through their underlying HTTP endpoints. Faster, cheaper, more reliable.
Building routines by recording browser sessions worked well, but refining them was still manual. So we built Guide, a conversational agent that walks you through the whole process:
- Describe your task and the agent helps scope it
- Record in a cloud browser, just use the site normally
- Agent analyzes the session, identifies backend endpoints, extracts parameters, builds a reusable routine
- Refine through chat to propose edits, review diffs, iterate without hand-editing anything
The prevailing approach to web automation is computer use agents that click and type like humans. We think this is backwards. Web app implementations are wildly diverse, but they all talk to structured backend APIs. LLMs are great at reading code and inferring structure, so we use them at build time to reverse-engineer those APIs, then the resulting routines run without AI in the loop.
We'd love to hear what you think, and happy to answer any questions about the approach! :)
- GitHub: https://github.com/VectorlyApp/bluebox-sdk
- Blog post with more detail: https://vectorly.app/blog/introducing-guide-agent
- Try it: https://console.vectorly.app/guide

value: Show HN: AI agent that builds web automations through conversation

author: rayruizhiliao


value: ishener

value: Show HN: President or Asshole?

author: ishener

title: Show HN: President or Asshole?


value:
After returning to game development a couple months ago, it felt like the stone age. Unlike most software, game development is massively sped up by Game Engines which support building 3D models, scenes, physics, etc - Which means no Cursor, and no Claude Code.
Godot is one of the fastest growing game engines on the market, but the existing AI agent plugins kinda blow.
Ziva is built on top of ~50 MCP tools for doing things like code, animations, tilemaps, scene generation, node customization and more. The agent-loop is client side for lower latency, and we let the user pick whichever model they want. I know HN likes to ask "Where's the proof that AI makes you faster?", so we did some user testing (n=26); the median time for users building a relatively simple game with Ziva was over 2x faster (88 min -> 37 min).
Happy to answer any questions about Ziva/building agent loops/MCP tooling/game dev you might have :). And if you're a game dev - come check try it out!

value: Show HN: Ziva – Cursor for Godot Game Engine


value:
Hi HN,
We built Supercheck – an open source platform that combines test automation and uptime monitoring in one self-hosted solution.
*The Problem:*
Most monitoring tools are expensive SaaS products that charge per check. Test automation and monitoring are often separate concerns, using different tools and workflows. We wanted a unified platform where you can write a Playwright test once and use it for both CI/CD testing and production monitoring and use same tool for k6 performance tests too.
*What Supercheck Does:*
Testing:
- Playwright browser tests (UI/E2E) with screenshots, traces, videos
- API tests (HTTP/GraphQL)
- Database tests (PostgreSQL, MySQL)
- k6 performance tests
- Schedule tests via cron or trigger from CI/CD
Monitoring:
- HTTP, Website, Ping, Port monitors
- Synthetic monitors (run full Playwright tests on a schedule)
- Multi-region: US East, EU Central, Asia Pacific
- Threshold-based alerting (consecutive failures before alerting)
Extras:
- AI Create: Generate tests from plain English
- AI Fix: Automatically analyze failures and suggest fixes
- Public status pages with incident management
- Alerts: Slack, Discord, Telegram, Email, Teams, webhooks
- RBAC with 6 permission levels
- Browser extensions: Chrome + Edge
*Architecture:*
Next.js frontend, NestJS workers, PostgreSQL, Redis + BullMQ for job queuing, MinIO for artifacts. Each browser test runs in an isolated Playwright context. Workers are stateless – scale horizontally by adding more containers.
*Deploy:*
```bash
git clone <a href="https://github.com/supercheck-io/supercheck" rel="nofollow">https://github.com/supercheck-io/supercheck</a>
cd supercheck/deploy/docker
./init-secrets.sh
docker compose -f docker-compose.yml up -d
```
One-click deployment with Coolify.
*Links:*
- GitHub: https://github.com/supercheck-io/supercheck
- Docs: https://supercheck.io/docs
Happy to answer any questions about the architecture, design decisions, or roadmap.

value: Show HN: Supercheck.io – Open-Source AI-Powered Test Automation and Monitoring


value: Show HN: Open-source alternative to Vercel, Render, Netlify