value: gotzonza

value:
Hey HN!
I love building side projects in my free time, this is actually my third one this year.
I realized that whenever I travel, I’m always switching back and forth between the Notes app for phrases and a calculator/app for prices. I always ended up with a mess of notes I couldn't find, and it was just annoying to do every time I wanted to buy something.
So I built Nomad HUD for two simple reasons: to have everything I need at a glance, and to stop overpaying for things.
It puts currency conversion tables and essential phrases directly on your lock screen/wallpaper, and it works 100% offline.
I'd love to hear your feedback or any features you'd find useful while traveling.
Gotzon

value: Show HN: Essential travel info on you iPhone lock screen

author: gotzonza


value: EGreg

value: Show HN: QBridge, a clean, modern iOS alternative to Cordova and Capacitor

author: EGreg


value: slogansand

value: Show HN: Loki Mode – 37 AI agents that autonomously build your startup

author: slogansand


value: dewmal

value: Show HN: Turn your GitHub profile into a clean, shareable visual card

author: dewmal


value: jmkni

value:
I've been frustrated at how much worse ad-blocking in Chrome has gotten since Manifest v3, so I've built this.
I don't have it on the Chrome store yet (I'm not sure if they'll allow it) but you can pull down the code and install it into Chrome yourself, then just add your OpenAI API key (stored locally).
The way it works is pretty simple, it inspects the DOM for suspected ads, verifies using the gpt-4o-mini model and if it is indeed an ad, it simply gets removed from the DOM
From my admittedly limited testing, it's working pretty well, but feel free to suggest any improvements to the code or submit a PR
Hope someone finds this useful

value: Show HN: Ad-sentinel – An AI powered ad-blocker

author: jmkni


value: eigen-vector

value: Show HN: Claudereview – Share Claude Code Sessions with PRs and More

author: eigen-vector


title: Show HN: QBridge, a clean, modern iOS alternative to Cordova and Capacitor


value: stephen-m-lee

value:
Hi HN — we’re opening Talent Scout to a wider beta and inviting the first 50 people to request access via our site.
Talent Scout is built around the idea that resumes are an outdated medium for job search - it's easier to compress/summarize a detailed career history for a specific job than it is to try and decompress/extrapolate from a streamlined resume. Essentially, the job market today is a DDOS attack on HR departments, where spam applications prevent the candidates they actually want from being seen or reviewed. LLMs excel at summarization and translation tasks, so we sit as a platform between candidates and hiring managers to summarize your career history and translate that into the language of a specific hiring manager or recruiter.
What you can do in the beta:
- Interview prep with Athena (AI). Talk through your real work experiences the way you would with a trusted colleague over coffee or a beer. Athena asks follow-ups, probes for missing details, and pressure-tests claims the same way an interviewer or recruiter would.
- Receive feedback from a recruiter's perspective. See what a recruiter would likely infer from your background, what feels unsubstantiated, and what raises questions or skepticism before you ever apply.
- JD-aware resume builder. Paste in a job description and generate an ATS-compatible resume that emphasizes only strengths you actually demonstrate. No embellishment, no invented experience, just clearer framing and specific-to-general keyword optimization (e.g. you mention Airflow, but they JD is looking for someone with ETL experience).
- Beta candidates will also get early access to our pilot job-matching program with the hiring managers we’re currently onboarding. Join a small pool of candidates to be considered by hiring managers from both startups and fortune 50 companies.
This is early and we’re deliberately keeping the cohort small so we can iterate quickly based on your feedback. If this sounds useful, request access here via our waitlist (limited to the first 50 or so):
https://jointalentscout.com -> click "For Job Seekers".
Happy to answer questions.

value: Show HN: Talent Scout – job matching and prep with an independent AI assessor

author: stephen-m-lee


value: oliwary

value:
Hi HN!
Over the christmas days I created Motion Party, a webcam motion controlled game inspired by Eyetoy and the Nex Playground. Currently there are 8 games for between 1 and 4 players, including a ball game, a game similar to flappy bird, a memory game and a spelling game.
I made it mostly using Claude Code, and Eleven labs for sound effects. The graphics are rendered in p5.js. It should work on mobile as well as desktop, you just need a camera.
I think they're really fun, especially with more players playing together. My grandmother was able to play as well, which was cool to see. Let me know what you think, and merry christmas! :)

value: Show HN: Motion controlled party games on the web

author: oliwary


value: trapani

value:
Blazing-Fast Domain Redirects Without the DevOps Tax
Rediredge is a lightweight, self-hostable domain redirector that pairs a Go data plane with a Next.js control plane. It gives you instant 30x responses without cold starts, automatic HTTPS, and a beautiful dashboard that lets non-technical teammates manage redirects on their own.
Website: https://rediredge.app
Github: https://github.com/leonardotrapani/rediredge
Blog Post: https://leotrapani.com/blog/rediredge

value: Show HN: I was tired of link shorteners, so I built Rediredge

author: trapani


value: bustylasercanon

value:
I'm an indie hacker who builds a lot of small Phoenix apps, and I got tired of setting up LogSnag/Mixpanel/whatever for every project just to get pinged when someone signs up or makes a purchase.
My favorite thing about Elixir is not needing third parties -Phoenix.PubSub instead of Redis, Oban instead of Sidekiq, LiveView instead of React. So I built FYI to bring that same philosophy to product event tracking and notifications.
What it does:
- Track events with one line: `FYI.emit("purchase.created", %{amount: 4900})`
- Get Slack/Telegram notifications when things happen
- Route specific events to specific channels (e.g., waitlist.* → Slack, errors.* → Telegram)
- Beautiful admin UI at /fyi with live updates, search, and filtering
- Drop-in feedback widget (installs into your codebase, not an iframe)
Key features:
-  Zero external dependencies - just BEAM, Ecto, and Phoenix
-  One command setup: mix fyi.install
-  Integrates with Ecto.Multi so events only emit after transactions commit
-  Fire-and-forget - failures never block your app
-  Feedback component lives in YOUR repo so you can customize it
Philosophy:
No Oban queues, no retries, no backoff. Just simple HTTP notifications and Postgres persistence. Think "LogSnag but self-hosted and Elixir-native."
The installer even copies a feedback component into your codebase instead of making you use an external widget, so you can style it however you want.
Repo: https://github.com/chrisgreg/fyi
Hex: https://hex.pm/packages/fyi
Docs:  https://hexdocs.pm/fyi
Would love feedback from the community!

value: Show HN: FYI - Product Events Tracking and Notifications for Elixir Phoenix Apps

author: bustylasercanon


value:
TL;DR
Most systems treat “verified” as “allowed.”
StegCore separates those concepts.
StegCore is a small, docs-first project that defines a decision boundary:
given verified continuity (from an external system), it answers allow / deny / defer, with explicit constraints like quorum, guardian review, veto windows, or time-locks.
No policy engine yet. No AGI claims. Just the missing layer.
⸻
The problem
Modern automation — especially AI-driven automation — usually collapses three things into one:
 1. Truth (is this authentic / verified?)
 2. Authority (is this allowed?)
 3. Execution (do the thing)
That works… until it doesn’t.
When something goes wrong, there’s no clean place to:
 • pause an action
 • require consent
 • escalate to a human
 • recover without shutting everything down
Verified truth alone doesn’t tell you what is permitted.
⸻
What StegCore does
StegCore defines a narrow interface:
Given verified continuity, can this actor perform this action right now — and under what constraints?
Inputs:
 • verified continuity evidence (opaque to StegCore; e.g. from StegID)
 • actor class (human / AI / system)
 • action intent
 • policy context (structure only)
Output:
 • allow, deny, or defer
 • a stable, machine-readable reason code
 • optional constraints (quorum, guardian, veto window, time-lock, escalation)
StegCore:
 • does not verify receipts
 • does not store identity
 • does not execute actions
 • does not claim autonomy or intelligence
It declares decisions. Other systems act (or don’t).
⸻
Why “defer” matters
Most systems only support allow or deny.
In real systems, the safest answer is often:
 • “not yet”
 • “with consent”
 • “after review”
 • “after a delay”
StegCore treats defer as a first-class outcome, not a workaround.
That’s the difference between:
 • brittle automation
and
 • recoverable automation
⸻
What’s in the repo today
 •  Clear decision model and policy shape docs (authoritative)
 •  Explicit agent lifecycle (intent → continuity → decision → execution)
 •  A minimal, deterministic decision interface with tests
 •  Scaffolding for state/audit signals (not continuity truth)
There is no policy engine yet. That’s intentional.
The docs are the contract; code is subordinate.
⸻
What this is not
 • Not an AGI claim
 • Not an auth system
 • Not identity management
 • Not a rules engine
 • Not a replacement for existing security tooling
It’s a missing layer that can sit between verification and execution.
⸻
Why this exists
We kept seeing the same failure mode:
“The system was technically correct, but it shouldn’t have been allowed to do that.”
StegCore exists to make “allowed” explicit.
⸻
Positioning (locked)
We’re not building general intelligence.
We are enabling:
AI systems that are accountable, recoverable, and constrained by verifiable continuity.
⸻
Status
 • v0.1
 • docs-first
 • minimal decision boundary implemented
 • open to feedback before any policy runtime is built
Repo: https://github.com/StegVerse-Labs/StegCore
⸻
Questions we’d love feedback on
 • Is the separation between truth and permission clear?
 • Are “defer” + constraints useful in your systems?
 • Where does this boundary already exist implicitly, but undocumented?
 • What would you want before trusting a decision runtime?
Thanks for reading — happy to answer questions and clarify boundaries.

value: Show HN: StegCore – a decision boundary for AI systems (truth ≠ permission)


value:
Hi HN,
As more teams let AI draft or send customer-facing emails (support, billing, renewals), I’ve been noticing a quiet failure mode:
AI-generated messages making commitments no one explicitly approved.
Refunds implied. Discounts promised. Renewals renegotiated.
Not hallucinations but AI doing its job with no authority boundary.
I built a small authority gate that sits between AI-generated messages and delivery.
It does not generate content or replace CRMs or support tools.
It only answers one question before a message is sent=> Is this message allowed to promise money, terms, or actions to a customer?
The system inspects outbound messages, detects customer-facing commitments (refunds, billing changes, renewals, cancellations), blocks delivery or requires human approval, logs every decision for auditability
I’ve made a public sandbox available for teams experimenting with AI-driven customer communication.
I’m not sure yet whether this is a niche edge case or an inevitable new infrastructure layer as AI adoption increases, so I’m especially interested in hearing:
a) whether you’ve seen similar failures
b) how you’re currently handling authority and approvals or why you think this problem won’t matter in practice
Sandbox + docs here:
https://authority.bhaviavelayudhan.com
Happy to answer technical questions.

value: Show HN: An authority gate for AI-generated customer communication


value: mistivia

value: Show HN: A small embeddable and hackable Lisp-2 interpreter in C

author: mistivia


value: todsacerdoti

value: Show HN: Twine – A tool to dynamically trace calls in production Elixir systems

author: todsacerdoti


value:
Polibench runs the Political Compass questions across AI models so you can compare responses side by side. No signup.
Built on top of work by @theo (https://twitter.com/theo) and @HolyCoward (https://twitter.com/HolyCoward).
Question set is based on the Political Compass: https://www.politicalcompass.org/
Early and rough. Feedback welcome on revealing questions, possible misuse, and ideas for extending it.
Happy to answer questions.

value: Show HN: Polibench – compare political bias across AI models


value:
Hi HN,
After launching an AI tool, many founders ask the same question:
where else should I submit it after Product Hunt?
This page focuses on manual submissions to 300+ AI directories, with:
a prioritized list
clean manual execution (no bots)
a detailed submission report
Link:
https://300aidirectories.com
Sharing in case it helps founders working on post-launch distribution.

value: Show HN: AI Directories – Submit your AI tool to 300 directories (2 minutes)


value: jonnyhere

value:
Single-model inference is a single point of failure. I got sick of Chatgpt hallucinating fake citations and having to manually check them in a different tab with Claude.
So I built Council
The Difference: Shared Context Most "multi-bot" UIs are just parallel silos. Council uses a sequential backend stream where every response is injected into the context of the next model.
If GPT cites a fake study, Claude sees it and calls it out.
If Gemini misses a logic gap, Grok roasts it.
Adversarial Logic Instead of "consensus" (which leads to boring, average answers), I'm using model-on-model friction to surface the truth. By forcing GPT-4o, Claude 3.5, Gemini 1.5, and Grok into one adversarial window, you get a "red-teamed" output that’s harder to fake.
What I need: It's an MVP. I'm trying to figure out if "Inter-model Cross-Examination" actually kills hallucinations or just creates more expensive ones.
Give it a spin and try to break the logic. No fluff, just testing the architecture.

value: Show HN: Chaos engineering for LLMs – Making models cross-examine each other

author: jonnyhere


value: melenaboija

value: Show HN: A lightweight UI to manage my LXC dev environments

author: melenaboija


value: atulvi

value: Testing my auto-moderation logic. Please be gentle. No login. All messages are global.

value: Show HN: Automoderated Anonymous Wall of Messages

author: atulvi


value: sdan

value: Show HN: Real-Time Website Generator

author: sdan

title: Show HN: Real-Time Website Generator


value: dsagal

value:
GrainJS is a JavaScript / TypeScript library for building dynamic web applications.
- It's in part inspired by React, but based on observables (like Knockout) instead of virtual dom.
- It is lightweight, has no dependencies, and takes only ~30KB minified.
- It needs no special tooling. It's nothing more than a library.
- It supports convenient DOM-building in JS, event dispatching, DOM event subscriptions, 9disposable components, and in-code CSS styling.
- It's fully typed for use with TypeScript.
- It's proven its worth by powering Grist's rich frontend app.
Source code: https://github.com/gristlabs/grainjs/

value: Show HN: GrainJS – a light TypeScript web framework

author: dsagal


value: mikeortman

value:
Inspired by the terrible search on the DOJ website, I created this project I've been working on over the last few days to modernize it. Slightly different than sites like JMail (which I highly recommend others play with too, super cool), I primarily focusing on both visual search, text semantic search, and full text search of all documents. Wanted to share the progress so far.
Any and all constructive feedback would be appreciated!
Work in progress:
- More mobile friendly search
- Better loading states
- Better ranking on lean text and lean visual searches
- Better thresholding of search results
- Gallery view improvements including original document view with a thumbnail timeline.
- Anyone can flag a document today, I'm working on taking those flags into the search results to better filter out redacted pages, blank pages, and junk pages while boosting consistently flagged newsworthy.
- Open sourcing the processed dataset in a single download / torrent

value: Show HN: The Epstein Library

author: mikeortman

title: Show HN: The Epstein Library


value:
I built AceIQ360, a deterministic agentic memory system.
Results:
- LongMemEval: 100% (500/500) - first ever
- LoCoMo: 75.32% J-Score (vs Mem0 68.44%)
- 80x cheaper per turn
- 13x faster
Built on RudraDB, my relationship-aware vector database with automatic relationship detection.
No LLM extraction calls. Pure embedding-based.
Solo developer. Looking for feedback.

value: Show HN: AceIQ360 – First AI memory system to achieve 100% on LongMemEval


value: debba

value:
Hi HN,
I’ve been working on a desktop client for Storytel, as there is currently no official app for PC/Mac. I wanted something that felt more "native" than a browser tab and included features like offline listening and system tray integration.
The stack:
• Frontend: React 18, Tailwind CSS, Vite.
• Backend: Fastify (embedded within the app to handle API logic and streaming).
• Desktop: Electron with TypeScript.
One of the challenges was managing the streaming API and session persistence in a way that feels seamless across different OSs. It currently supports Windows, macOS (x64/ARM64), and Linux.
It is still a work in progress, but the core player and library management are stable. Any feedback on the architecture (especially the Fastify-within-Electron approach) or the app itself would be greatly appreciated.
Repo:
https://github.com/debba/storytel-player
Releases:
https://github.com/debba/storytel-player/releases

value: Show HN: Storytel-player – unofficial desktop client for Storytel

author: debba


value: SkyLinx

value: Show HN: The easiest way to set up Kubernetes clusters on Hetzner Cloud

author: SkyLinx


value: sethhovestol

value: My buddy spent the last few months working on making an app to take notes the way he wanted to have them. I'd love to see what you all think.

value: Show HN: Jotter – A Note Keeping App

author: sethhovestol

title: Show HN: Jotter – A Note Keeping App


value: GFuller

value:
Not a startup attempt, just a weekend project for my family. My parents do a daily quiz, but the site they use looks like it was built in 1999 and not touched since. I thought it’d be a fun excuse to rebuild something simple and leverage AI for automation.
The app uses 5 agents to generate a 10 question general knowledge quiz, daily, with loose association to a random topic. It also allows for user generated quizzes based on a provided topic.
Side note: I built the majority of it whilst riding my indoor bike. Claude Code + WisprFlow is insanely good these days.

value: Show HN: An AI-generated daily quiz app I built on my bike

author: GFuller


value: jawns

value: Show HN: What if Dr. Mario had more than 3 colors?

author: jawns


value: ragelink

value:
We built two desktop apps for developers and data scientists who want AI assistance without subscription lock-in or API proxying, or to run against local models.

  - Calliope AI IDE: VSCode-based, full dev environment with AI chat, live coding, and autonomous agents
  - Calliope AI Lab: JupyterLab under the hood, with built-in AI chat and local Postgres

Both free. No account. No login. BYOK (OpenAI, Anthropic, Google, Mistral, Ollama).
How it's different from Cursor/Continue/Windsurf/Antigravity: Your API keys stay local. Requests go direct to providers – we don't route through our servers, don't see your prompts, don't mark up API costs, we don't train on your data.
The agents can search the web, write code, manage git, scaffold projects, and run iteratively until completion criteria are met. Not autocomplete – actual background task runners on your machine, not some hosted service.
Offline works too. Pair with Ollama for fully airgapped operation.
Business model: Desktop apps are free. We make money from our hosted cloud platform for teams that want collaboration, SSO, managed infrastructure, and AI for secure environments.

  builds for macOS (Intel + Apple Silicon), Windows (64-bit), Linux (64-bit/deb/rpm/AppImage) - unsigned

  Download: https://calliope.ai/download
  Issues: https://github.com/calliopeai/calliope-ai-desktop-releases/issues

Give it a spin, file bugs. Fresh release – expect rough edges. Feedback welcome, patience appreciated.

value: Show HN: Calliope AI – Free AI IDE and AI Data Lab BYOK

author: ragelink


value: Show HN: Pdf X-ray – find data leaks in the redacted pdf files


value: kaashmonee

value: Show HN: Candid – Minimal Private Bring Your Own Model Email Revision Tool

author: kaashmonee


value: lilsquid

value: Hacker News has been my homepage and my inspiration for many years. While I’m still learning the ropes of building a public website, I created DreyX.com out of a simple necessity: I wanted a better way to track AI news without all the fluff. Literally a tool built by a curious reader, for curious readers. Thoughts? Suggestions?

value: Show HN: Got tired of searching for AI news daily so I built my own AI news page

author: lilsquid


value: tuvshaw

value: Show HN: Open source, self-hosted AI nutritionist for diabetes (Laravel/React)

author: tuvshaw


value: ostashenkods

value: Show HN: Soil – Systematic autopsy database for dead organizations

author: ostashenkods


value:
Hi everyone,
I made an app to learn about countries of the world, including landmarks, culture, history, flags, and much more!
The idea is to make learning fun and engaging, but at the same time provide a clear, structured path, that makes learning effective and meaningful.
It has multiple game modes, where you can learn, play, compete and socialize with peers.
Check it out and let me know what you think!
The app is free to download:
iOS: https://apps.apple.com/us/app/globo-learn-world-geography/id...
Google Play: https://play.google.com/store/apps/details?id=app.getglobo.a...

value: Show HN: An app to learn about the world


value:
MAPLE (Multi Agent Protocol Language Engine) - a communication protocol for multi-agent AI systems.
The gap I'm filling: MCP handles tools, A2A handles agent discovery, but neither lets agents specify resource requirements.
With MAPLE, an agent can say: "I need 4GB GPU, 8GB RAM, complete within 30 seconds."
Key features:
- Resource-aware messaging (CPU, GPU, memory, network, deadlines)
- Link Identification Mechanism (LIM) for secure agent-to-agent communication
- Distributed state synchronization
- Type-safe error handling
- Works with any LLM/framework
900+ downloads on PyPI.
pip install maple-oss
GitHub: https://github.com/maheshvaikri-code/maple-oss
Looking for feedback from anyone building multi-agent systems.

value: Show HN: MAPLE – Multi-agent protocol with resource-aware scheduling


value: tomstig

value: Show HN: The 「Imposter Game」 Spanish Version – Juego Del Impostor

author: tomstig


value: Show HN: Spacelist, a TUI for Aerospace window manager


value:
ISON (Interchange Simple Object Notation) - a data format optimized for LLMs and Agentic AI.
The problem: JSON wastes tokens. Curly braces, quotes, colons, commas - all eat into your context window.
ISON uses tabular patterns that LLMs already understand from training data:
JSON (87 tokens):
{
  "users": [
    {"id": 1, "name": "Alice", "email": "alice@example.com"},
    {"id": 2, "name": "Bob", "email": "bob@example.com"}
  ]
}
ISON (34 tokens):
table.users
id:int name:string email
1 Alice alice@example.com
2 Bob bob@example.com
Features:
- 30-70% token reduction
- Type annotations
- References between tables
- Schema validation (ISONantic)
- Streaming format (ISONL)
Implementations: Python, JavaScript, TypeScript, Rust, C++
9 packages, 171+ tests passing
pip install ison-py        # Parser
pip install isonantic      # Validation & schemas
npm install ison-parser    # JavaScript
npm install ison-ts        # TypeScript with full types
npm install isonantic-ts   # Validation & schemas
[dependencies]
ison-rs = "1.0"
isonantic-rs = "1.0"       # Validation & schemas
Looking for feedback on the format design.

value: Show HN: ISON – Data format that uses 30-70% fewer tokens than JSON for LLMs


value: richardknop

value: I have been working on reverse engineering SQLite in Go. Not exactly as I am borrowing some features from other databases so it is not a 1 to 1 exact replica but the main idea is the same and I have been keeping it as close as possible. A simple embedded single file database. It's an ongoing effort but I wanted to share what I have done so far after over a year.

value: Show HN: Reverse Engineering (Kind of) SQLite in Go

author: richardknop


value: kossnocorp

value:
Hey HN!
We made a VS Code extension that allows developers to play with their prompts right in their editor. It uses Oxc and RustPython to parse and detect the prompts in the source code.
Devs can test their prompts against different models and/or variables (models*data matrix). With a CSV dataset, one can test their prompt changes against multiple rows and verify whether the change is good or not. Automated evals are coming soonish.
The request/response JSONs are available to inspect, as well as usage stats with projected cost.
The extension supports hundreds of models thanks to the Vercel Gateway. If you need more provider options (planned but not priority), please let me know. Users without keys will get their requests served by LM Studio running on my PC. Please don't crash my workstation!
It only supports JS/TS and Python for now, but many more languages are coming. Compiling tree-sitter crates to Wasm is PITA, but I'm getting there.
I also work on improving the heuristics so prompt strings can be detected from arrays or when passed as arguments to popular LLM APIs. Now you can use "prompt" in the variable name or put a comment with "@prompt" in front of it.

value: Show HN: Open-source LLM playground for VS Code

author: kossnocorp


value: bryanstjohn

value: Show HN: ForwardToAudio – Turn newsletters into a private podcast using AI

author: bryanstjohn


value: geiser

value:
Hi! I’m Sergio, the founder of LynxPrompt: https://lynxprompt.com
I built it because I got tired of rewriting the same “how I want the AI to code” rules every time I started a new repo. LynxPrompt generates and manages AI coding rules/config files in a portable way across IDEs and other AI-enabled coding tools. It also lets you save, share & discover blueprints (also called templates/AI configs/prompts — the industry has many names for these) made by other devs.
Honestly, I know: yet another AI tool. But my problem was very specific: keeping AI coding rules consistent across projects and tools without relying too much on “memory” features. LynxPrompt focuses on bootstrapping a repo config quickly and making those rules portable and versionable.
What it does:
- Wizard generator: bootstrap an AI config for an existing repo or a new project in minutes
- Portable rules: keep your AI coding preferences consistent across coding sessions
- Blueprints: publish/share (and optionally sell) your team or personal setup
One feature I like a lot is having the API enabled in LynxPrompt, so your AI of choice can self-update its coding rules and save/version them in the platform (also, if you configure it that way in the wizard).
I’m posting to get feedback (and ideally a few early users): Does the “portable AI coding rules” idea make sense? or what would you need to trust shared/paid blueprints (previews, diffs, versioning, ratings, etc.)?... What is your real pain here?
Links below. Thank you and "happy" vibe-coding — at least, we have LynxPrompt ;).
- First blog post: https://lynxprompt.com/blog/thrilled-to-welcome-you
- Docs: https://lynxprompt.com/docs
- Ideas/bugs/support (please, show some love): https://lynxprompt.com/support
- Wizard (requires sign-in—sorry, I decided to do this to prevent abuse): https://lynxprompt.com/wizard

value: Show HN: LynxPrompt – repo-first AI config generator and shareable blueprints

author: geiser


value: saisrirampur

value: Show HN: GitHub Activity Analytics Powered by ClickHouse

author: saisrirampur


value: dusted

value: Show HN: DStream (bespoke music player for web) non-web clients

author: dusted


value: lawrencehook

value: I'm having Claude Opus 4.5 make as many HTML/JS apps as it can -- 100+ so far. Quite remarkable how capable it is, one-shotting most of these.

value: Show HN: Apps by AI (Claude Opus 4.5)

author: lawrencehook

title: Show HN: Apps by AI (Claude Opus 4.5)


value:
We've spent the last 6 months building Seer, an agent engine for enterprise workflows. We’re launching on NYE, but honestly, we’re still in the trenches.
While scanning the space, I keep seeing devs (us included, initially) get obsessed with complex "memory" layers and graph-based reflection. In practice, we found they mostly lead to context poisoning and high latency.
We pivoted to a "Barbell Strategy": Crisp, lean inter-agent instructions paired with massive, localized "artifact" context for sub-agents that are immediately killed after the task.
I’m curious—for those of you building agents in production:
Have you found a way to make "long-term memory" actually reliable, or are you also moving toward ephemeral, specialized agents?
What’s the "boring" plumbing problem (Auth, state rollback, etc.) that took you way longer to solve than the actual AI logic?

value: Show HN: Why delegation beats memory in AI Agents


value: modinfo

value: Show HN: Word Wizardry – Dijkstra-powered sentences, crafted from LLM magic

author: modinfo


value:
Hi HN — I extracted a small “AI collaboration playbook” from my open-source project after repeatedly seeing coding agents go off-track (touch unrelated files, miss entry points, forget constraints in long threads).
The repo includes templates for:
- `AGENTS.md` guardrails + Done criteria
- A 1-page index
- A code map
- Key flows
- A plan-first change template (mini design doc)
It’s meant to be copied into any repo and used as a default workflow for Claude/Codex-style agents.
I’d love feedback on what you’ve found actually works to keep agents aligned, and what you think is missing/overkill here.
Links:
- Repo: https://github.com/david-bai00/PrivyDrop
- Write-up: https://www.privydrop.app/en/blog/ai-collaboration-playbook

value: Show HN: An AI collaboration playbook(AGENTS.md and code map and template)


value: jobswithgptcom

value: I started jobswithgpt as a side project few months back to experiment with LLMs, RAG and am hoping it will be useful for the community looking to change jobs in the new year. The search focusses primarily on direct listings - aka no job boards. There is an MCP server and chatgpt plugin for more advanced use cases. Feedback appreciated!

value: Show HN: Jobswithgpt.com Semantic Job Search

author: jobswithgptcom


value: DerekDragon

value:
Hi HN,
I built JSON Editors, a lightweight online JSON editor and developer toolbox focused on speed and simplicity.
It supports JSON formatting, validation, and visualization, along with practical tools like Base64 encode/decode, regex testing, cron helpers, and color converters.
No login, no ads, and everything runs directly in the browser.
Feedback is very welcome:
https://jsoneditors.com

value: Show HN: JSON Editors – Online JSON Editor and Developer Toolbox

author: DerekDragon


value: ZOROX

value:
Hi HN,
I made a scripting lang RustX (https://github.com/GrandpaEJx/RustX). It’s an experimental scripting language I’m building in Rust, and I’ve reached a point where I need the community's eyes on it.
Reason : A high level syntax can be work with rust. <it's slower than rust, but faster dev speed>
Why I'm asking for help: Building a language engine is a massive task, and I want to make sure the foundation is solid before I commit to more features. I am specifically looking for:

    Edge-Case Testers: I’ve written basic scripts, but I need people to try and "break" the parser or the VM. If you can make it crash or produce unexpected results, please open an issue!

    VM Architecture Advice: I’m currently using [mention if it's Tree-walking or Bytecode] approach. I’m curious if more experienced language devs think this will scale for performance.

    Rust Best Practices: This is my biggest project in Rust so far. I’d love a code review on the memory management side of the interpreter.

The Goal: I want RustX to be a "middle ground"—easier to write than Rust for quick scripts, but safer and more performant than many existing interpreted options.
The Repo: https://github.com/GrandpaEJx/RustX
I’m very open to criticism and would appreciate any "Don't do it this way" or "Check out this project for inspiration" comments. Thanks for taking a look!
Why this works better:

    Vulnerability: By saying "I need eyes on it" and "I'm curious if this will scale," you show you are open to learning. HN users love to share their expertise.

    Specifics: You aren't just saying "test my code." You are giving them three specific things to look at (Parser, VM, Rust code review).

    Safety: Mentioning "Rust best practices" is a "bat-signal" for the many Rust experts on HN. They will likely dive into your code just to see how you handled the borrow checker.

value: Show HN: RustX – Help me test/architect this new Rust-based scripting language

author: ZOROX


value: cozymori

value:
Hello HN,
I built an open source Python framework called VectorWave. It connects your code execution flow directly to a Vector Database (Weaviate).
Instead of dumping inputs/outputs into unstructured text logs, VectorWave embeds them as vectors. This allows you to:
1. Search execution history semantically (e.g., find "bad input" errors without exact keyword matching).
2. Implement semantic caching (skip expensive calls if similar inputs were processed).
3. Enable "Self-Healing" by comparing error traces with past successful runs.
It is designed for AI engineers needing long-term memory for agents, or backend devs debugging complex workflows.
Repo: https://github.com/cozymori/vectorwave
Docs: https://cozymori.github.io/vectorwave-docs/
I'd love to hear your feedback on the concept of "Execution RAG".

value: Show HN: VectorWave – Turn Python function execution into searchable vector data

author: cozymori


value: josharsh

value:
I built a CLI tool that lets you do common video/audio operations without remembering ffmpeg syntax.
Instead of:
ffmpeg -i video.mp4 -vf "fps=15,scale=480:-1:flags=lanczos" -loop 0 output.gif
You write:
  ff convert video.mp4 to gif
More examples:
  ff compress video.mp4 to 10mb
  ff trim video.mp4 from 0:30 to 1:00
  ff extract audio from video.mp4
  ff resize video.mp4 to 720p
  ff speed up video.mp4 by 2x
  ff reverse video.mp4
There are similar tools that use LLMs (wtffmpeg, llmpeg, ai-ffmpeg-cli), but they require API keys, cost money, and have latency.
Ez FFmpeg is different:
  - No AI – just regex pattern matching
  - Instant – no API calls
  - Free – no tokens
  - Offline – works without internet
It handles ~20 common operations that cover 90% of what developers actually do with ffmpeg. For edge cases, you still need ffmpeg directly.
Interactive mode (just type ff) shows media files in your current folder with typeahead search.
npm install -g ezff

value: Show HN: Ez FFmpeg – Video editing in plain English

author: josharsh


value: thepramodgeorge

value: Show HN: A daily newsletter tool with an evergreen fallback queue

author: thepramodgeorge


value: zfoong

value:
This is a minimalist news digest site that helps readers understand the biggest news happening around the world in one minute.
We work on this as a side project. So why are we doing this? Welp, I myself am a clickbait hater. Sometimes I click into a news story on Facebook just to find out the content is nothing as the title suggests. Born from pure hatred, we have created One Minute News to make sure every headline literally says what the content is about. This helps readers save tons of time filtering out unimportant news just by scanning through the honest headlines.
So far, here are the current features One Minute News is offering:
- Rewrite clickbait headlines into honest, straightforward, and literal titles.
- Filter out unimportant news.
- Rank news importance with a rubric-based, time-decayed scoring system
- Allow readers to filter news with preferred tags.
- Compile periodic digests/briefings that summarize high-scoring articles every 6 hours.
- Display the source link back to the original article.
- Bookmark news.
- Saved preferred tags.
Please let me know if there are any future features you want to see.
For now, we only have the website version and 0 experience in journalism. If you want to be a part of this anti-clickbait adventure too, let me know.

value: Show HN: One Minute News: Your Minimalist Anti-Clickbait News Platform

author: zfoong


value:
Hey HN,
I built Doculearn after watching my team (and myself) ship faster than ever with Claude, Cursor, and Copilot—but understand less and less of what we were actually deploying.
The vibe coding problem:
We'd accept a 200-line AI suggestion, tests pass, PR approved, merged. Two weeks later: "Wait, how does this authentication flow work again?" No one knew. The person who approved it just trusted the AI. The person who merged it moved on to the next feature.
Sound familiar?
What Doculearn does:
It watches your GitHub activity and automatically generates flashcards from YOUR code. Not generic "what is a closure?" cards—actual flashcards about the authentication middleware you merged yesterday, the API endpoint you refactored, the algorithm you copy-pasted from Claude.
When you push code, Doculearn:
Generates spaced-repetition flashcards from your commits
Updates your team board automatically (no more manual Jira)
Creates "Context Cards" that surface when you're working on related code
Sends daily/weekly LogLetters showing what everyone shipped
Why this matters in the AI era:
You can ship 10x faster with AI. But if you don't understand
what you shipped, you can't:
Debug it when it breaks at 2am
Extend it for the next feature
Explain it in code review
Onboard new teammates
We're optimizing for velocity at the cost of understanding.
Doculearn tries to bridge that gap.
How it works:
Connect your GitHub repo
Doculearn analyzes commits, PRs, code changes
Azure AI agents generate personalized flashcards
Review cards in your workflow (web, mobile, CLI coming)
Team stays synced on what everyone actually knows
The stack:
Next.js + Django on Azure Container Apps
Azure AI Foundry for flashcard generation
GitHub Apps for real-time monitoring
PostgreSQL for persistence
Current features:
AI-generated flashcards from commits
 Context Cards (study while you build)
 Auto-updating team/work boards
 Bug tracker with AI-suggested fixes
 LogLetters (changelogs from GitHub)
 Social login (GitHub, LinkedIn, X, Microsoft)
Things I'm wondering:
Do you find yourself shipping code you don't fully understand?
How do you currently retain knowledge about your codebase?
Would flashcards feel like homework or helpful?
Is "team knowledge sync" a problem you experience?
Try it: doculearnapp.com – Live now with 7-day free trial
I've been testing this with early teams for the past month.
The most common feedback: "I didn't realize how much I forgot until the flashcards reminded me."
Would love HN's feedback. Is this solving a real problem or am I overthinking the vibe coding phenomenon?

value: Show HN: Doculearn – How much of your Gen-AI code do you understand?


value:
I built this to collect and share useful slash commands for AI agents in one place.
The goal is to make agent workflows more discoverable and reusable.<p>Still early — feedback very welcome.

value: Show HN: AgentCmds – A directory of slash commands for AI agents


value: smugesh

value: Show HN: An AI pipeline to find anomalies in FDA medical device reports

author: smugesh


value: detectivestory

value:
Disclaimer: This is not a language course and it will not bring you to full fluency. Please join a class if you are serious about learning a new language, and do not count on any app for fluency.
However, this will act as a great supplementary tool in your language learning journey. The concept is simple: describe a new image in your target language each day. That's pretty much it.
The app provides some helpful features to assist in your learning. There are clues mapped to the image, some LLM feedback (if you are into that), and it generates some smart flashcards based on your spelling mistakes.
App Store: https://apps.apple.com/us/app/snapalabra/id6747401847
Google Play: https://play.google.com/store/apps/details?id=com.whatever55...

value: Show HN: Snapalabra – A daily exercise for learning new vocabulary

author: detectivestory


value: Show HN: Learn how to make your first open source pull request on GitHub


value: fitzz

value: Show HN: Stripe default config often bypasses AVS

author: fitzz


value: kan-bayashi

value:
I built svt, a terminal-based image viewer inspired by sxiv.
Motivation: I often need to browse images on remote servers over SSH. I wanted something fast and keyboard-driven that works entirely in the terminal (including inside tmux), but couldn’t find a good fit—so I built one.
Features:
- sxiv/vim-style keybindings with counts (e.g., 5j, 10k)
- Works over SSH + tmux (auto-detects and enables passthrough when needed)
- Fast rendering: cache + prefetch + zlib-compressed transport
- Tile mode for a thumbnail grid view
- OSC 52 clipboard support (e.g., copy image path even over SSH)
- High-quality rendering via the Kitty Graphics Protocol (KGP)
Requirements: a KGP-capable terminal (Kitty, Ghostty, WezTerm).
GitHub: https://github.com/kan-bayashi/svt

value: Show HN: SVT – A fast terminal image viewer with sxiv-like keybindings

author: kan-bayashi


value:
I want to get stuff done, deliver value and make money.
I got tired of the constant churn in the modern web ecosystem and missed the simplicity of the "good old 2010 days" (Request → Loader → HTML). I assembled a little repo boring-stack because I wanted a point to start from focused purely on shipping features fast and sustainably, rather learning a new framework every six months and handing all the complexity of cool new tech. I am sooo fatigued by now. Goal: maximize developer velocity by using "boring," stable technology that lets me focus entirely on building value and making money, rather than fighting with your tools and throwing away knowledge with every new tool. I want to focus on features.
I used React Router v7 (SSR) to escape the soft vendor lock-in of Next.js, combined with a "Postgres for everything" approach (Data, Auth, and Background Jobs). I drop the API layer and treat frontend and backend as one unit. An added benefit of this boring, explicit architecture (like using routes.ts over file-system magic) is that it happens to be incredibly readable for coding agents, allowing them to handle the boilerplate effectively while you focus on the hard logic.
I have created the repo for myself but thought I share it with you guys in case that anyone feels the same fatigue and needs a starting point :-)

value: Show HN: Code webapps like it is 2010 – with agents & modern tech. A starter


value: 8 years sober. Most recovery apps are just counters. Built something with actual tools: AI companion, audio content, meditations, psychological instruments.<p>React Native/Expo. AMA.

value: Show HN: I built a recovery app after 8 years of sobriety


value: adiadd

value:
hi hn!
i’m experimenting with an ai “rubber duck” idea that helps engineers think through bugs and design decisions by asking questions instead of spitting out code. this is an early prototype and i’m trying to validate whether ai tools are hurting code understanding.
most ai software engineering assistants like cursor and claude code focus on the implementation details/results but don’t help teams upskill or build in a reliable manner.
would love to get any feedback and thoughts!

value: Show HN: Ducky – AI for the thinking parts of engineering

author: adiadd


value: fkapsahili

value:
I'm working on an open-source project dokimos, because every LLM eval framework I found was Python and TypeScript-only, but a lot of companies will be building LLM apps and AI agents with Java.
Key features:
- JUnit 5 integration for test-driven evals
- Works with LangChain4j
- Framework-agnostic
- Supports custom evaluators and datasets
GitHub: https://github.com/dokimos-dev/dokimos
Would love contributions or to team up with anyone who has Java experience and wants to work on this together.

value: Show HN: Dokimos – LLM evaluation framework for Java

author: fkapsahili


value: orbanlevi

value: Show HN: Mole – Deep clean and optimize your Mac

author: orbanlevi


value: isaadgulzar

value:
Hey HN!
I built Year in Code to turn your Claude Code usage into a beautiful Wrapped-style report (like Spotify Wrapped).
If you use Claude Code with ccusage, it's super quick to try:
Setup (2 minutes):
1. Run: `npx -y ccusage@latest daily --since 20250101 --until 20251231 --json > wrapped.json`
2. Upload at yearincode.xyz/2025
3. Get your report!
*What you'll see:*
- Total tokens
- Activity streaks & patterns
- Top models used
- Shareable report
Key features:
- 100% secure: 100% browser processing, no server uploads
- 2-minute setup: One npx command, upload JSON, done
- Free & open source
Built with Next.js.
Source on GitHub: https://github.com/isaadgulzar/year-in-code
Would love feedback from the HN community!

value: Show HN: Year in Code – Wrapped for Claude Code Users

author: isaadgulzar


value: solosquad

value: Built an AI trading bot using Deep RL and open-sourced it. Trained on 10 years of gold market data with 140+ features. Includes full source code, training scripts, Colab notebooks, and docs. Backtest shows 80-120% returns. Not financial advice just sharing for learning/feedback.

value: Show HN: I spent 3 months building an AI trading bot using DRL like AlphaGo

author: solosquad


value: stavros

value: Hey everyone, I made another bedside clock, because my last one was getting a bit long in the tooth. This is a very straightforward build, because it turned out you don't need to mess with the AliExpress-bought hardware, so you can easily make your own!

value: Show HN: The bedtime, another little bedside clock

author: stavros


value:
Hi HN,
I’d like to share BIBROF AI, an AI-powered background removal tool that runs entirely offline on your Windows PC. It removes backgrounds from images without any cloud servers - everything happens locally for privacy and speed.
Use case: Ideal for developers, designers, or founders who need to batch-edit product photos, create marketing images, or just don’t want to send files to a third-party server. We built it after feeling uneasy uploading client images to random cloud services.
Key features: Process up to 100 images at once, fairly accurate edge detection (does hair, fur, semi-transparent objects decently well), and it doesn’t require a GPU (runs fine on CPU). There’s no “credit” system or usage limit - one subscription and you can use it on unlimited images.
Quality & speed: It always outputs the highest resolution results. In our tests it’s faster than waiting for many cloud API calls, since processing is local.
Tech stack: Built on an MIT-licensed InSpyReNet model. We’re not open source (the UI code and packaging are proprietary), but we credit the open-source model.
System requirements: Windows 10 or 11, at least 4GB RAM. Uses about ~1.5GB disk after install (includes the AI model).
Pricing: Free 7-day trial (no credit card needed). After that, it’s paid: currently $23.88/year. No per-image fees.
Try: https://bibrof.lislip.com/
Security note: The app is not code-signed yet. This means when you install, Windows SmartScreen might warn that the publisher is unknown. This is expected (EV certs are expensive for us right now). We plan to sign the binaries once we can afford it (targeting after first 100 sales). For now, users have to click “run anyway” on the SmartScreen dialog. We totally understand if that’s a dealbreaker for some - just want to be upfront about it.
Why Show HN: We figured fellow developers might appreciate an alternative to cloud APIs for image processing. Also, dealing with an unsigned app and building an offline-first tool has been an adventure - I’m happy to answer questions about the tech or our journey.
We launched very recently and are eager for feedback. Open to all questions. Happy to discuss trade-offs, accuracy, or why offline matters.
Looking forward to your thoughts. Thanks HN!

value: Show HN: Bibrof AI – Bulk Image Background Remover Offline


value: kadiran

value:
I got tired of logging into my banking app just to copy my IBAN every time a client asked.
So I built iban.bio - a privacy-focused page for your financial identity.
It lets you share bank accounts, crypto wallets, and payment links (Wise, PayPal) in one URL. It supports phone number lookup (like Venmo) and uses AES-256 encryption for data storage.
Live here: https://iban.bio
Feedback welcome!

value: Show HN: I built a secure "Linktree" for IBANs and Crypto addresses

author: kadiran


value: freakynit

value:
Built json-healer, a small npm package that repairs malformed or partial JSON produced by LLMs.
Inspired by OpenRouter’s recently launched response healer (https://openrouter.ai/docs/guides/features/plugins/response-...), this implementation is model-agnostic and works with JSON from any LLM or text source, not just OpenRouter.
Includes comprehensive test cases and is designed to be easy to drop into existing pipelines that rely on structured LLM output.
https://www.npmjs.com/package/@freakynit/json-healer
Feedback welcome!

value: Show HN: JSON-Healer: Repair and Validate Broken JSON from LLM Outputs

author: freakynit


value: alvinunreal

value: A small hobby project

value: Show HN: Folder Structure Templates

author: alvinunreal

story_text: A small hobby project

title: Show HN: Folder Structure Templates


value: perhapsAnLLM

value:
I'm a huge sports fan and long-time fantasy football player. I recently launched FantasyDawg, a custom Year in Review website for your Sleeper league!
Simply input your Sleeper League ID or username, and we'll generate a custom dashboard packed with fun stats, analytics, and visualizations about your season. (If your league doesn't use Sleeper, let me know which platform you use).
Also, give the "Season Wrapped" feature a try. We'll generate a graphic, Spotify Wrapped-style, to easily share with your leaguemates or on social media!
My goal is to build _the_ Analytics Hub for the fantasy football community - a tool that adds some fun to your season, for any platform, league type, or scoring system. If there's anything you've ever wished you could add to your fantasy experience, let me know!
Check it out at https://www.fantasydawg.com

value: Show HN: I Built Your Fantasy Football Year in Review

author: perhapsAnLLM


value: addressGen

value:
Hi HN — I built a small fan reference site for DeepSeek:
https://chat-deepai.com
What it is:
- A lightweight place to learn what DeepSeek is (V3, R1, Coder, etc.)
- A community-written pricing overview so you don’t have to chase screenshots
- Getting-started guides (web/app/API) and a small blog
What it is NOT:
- Not affiliated with DeepSeek
- Not a checkout page / not selling “Plus” subscriptions
- All “use DeepSeek” buttons lead back to official DeepSeek properties
Why I made it:
Information about DeepSeek is spread across announcements, console pages, and social posts.
I wanted a simple, readable page I could send to friends and teammates, and I tried to be
extra careful about not impersonating the official service.
Would love feedback on:
- What’s missing / confusing
- Anything that feels misleading
- What would be most useful for developers evaluating DeepSeek (API, limits, pricing diffs)
I’m around to answer questions.

value: Show HN: Chat-DeepAI – DeepSeek pricing and getting-started guides (fan project)

author: addressGen


value: codazoda

value: Show HN: Create old-timey silent-film style caption cards

author: codazoda


value: mxxc

value: i've been a big fan of fedora's atomic distros and i decided to make my own but arch based to get the best of both worlds, which is kind of funny now because it looks exactly like silverblue. is it worth it? not sure, but it's been a interesting experience – and it's usable as a daily driver if your specs match.<p>worth noting that because of the constraints of the setup you can develop something similar on your main machine without any realistic possibility of data loss since you never really touch the bootloader or the filesystem (partitioning and so on).

value: Show HN: An immutable ostree-based Arch Linux image

author: mxxc


value: spannercode

value:
`openapi-batch` is a small Python library for running batches of LLM requests reliably.
It provides:
- Async submission by default (you don’t block while the batch runs)
- Durable state in SQLite (track progress, resume inspection)
- Retries + partial failure handling
- Native batch support where providers offer it (OpenAI, Gemini)
- Provider adapters (no gateway required)
- Callbacks for progress, per-item completion, and job completion
License: MIT

value: Show HN: OpenAPI-batch: library for batch execution of LLM requests

author: spannercode


value: orrbenyamini

value: Show HN: Jsonic – Python JSON serialization that works

author: orrbenyamini


value: dhamidi

value:
Hey HN!
First time showing something here, but I've been furiously working over the holidays on Feather, a from scratch reimplementation of TCL designed for embedding in modern applications.
It's starting out as a faithful reimplementation of TCL without I/O, OOP features, or coroutines.
TCL has a special place in my heart because the syntax is so elegant for interactive use, and defining domain specific languages.
My motiviation is twofold: faster feedback loops for AI, and moldable software for users.
It turns out giving AI agents access to the runtime state of your program makes for really fast feedback loops, but embedding existing options in a world where shipping binaries for each platform is commonplace is tricky.
Embedding the real TCL is tricky because it comes with its own event loop (in 2025 you alreay have one), a GUI framework (you have a web framework already, or develop on mobile), and has access to the filesystem (don't forget to delete all commands with file system access!).
Feather just doesn't ship with those - expose only what you need from your application.
A WASM build comes out of the box and clocks in at ~120kb plus 70kb for connecting it to the browser or node.js.
And if embedding becomes easy, you can put a REPL everywhere: in mobile apps, in desktop software, as a control plane into web servers.
I want to imagine a world where all software is scriptable just like Emacs and nvim, with agents doing the actual work.

value: Show HN: Feather – a fresh Tcl reimplementation (WASM, Go)

author: dhamidi


value: adamofk

value:
Hi HN, I’m Adam. I built Crovise, a tool that performs static analysis on landing pages to generate CRO hypotheses.
I started this after building a few small SaaS projects where improving conversion rates often felt vague and subjective. Most advice was generic (“make the CTA clearer”) or required long A/B tests that weren’t realistic with low traffic. I wanted something more deterministic and engineering-driven.
Crovise analyzes the HTML structure and DOM hierarchy of a landing page to surface potential conversion issues and testable hypotheses. It looks at semantic structure, element placement, hierarchy depth, and common patterns seen in high-converting pages — not just visuals or copy tone.
Technical notes:
- The analysis engine is currently rule-based, not ML-heavy
- Built with Next.js
- Translating qualitative UX heuristics into deterministic rules was the hardest challenge
This is an MVP in a *waitlist / early-access phase*. It works best on simple marketing pages; complex SPAs or dynamic content are a known limitation, and false positives are expected.
I’m 16 and have been learning the SaaS stack for 8 months. I’d really appreciate feedback on:
- Whether static analysis is a reasonable approach for CRO
- Which signals feel useful vs misleading
Waitlist/demo: https://crovise.netlify.app
Thanks for taking a look.

value: Show HN: Crovise – Static analysis for landing page conversion hypotheses

author: adamofk


value:
Hi HN,
I built write.rocks because I kept abandoning my own blog.
The pattern was always the same: SSH into VPS, edit markdown files, rebuild, fix some nginx config, redeploy. By the time everything worked, I'd lost the motivation to actually write.
Static sites are fast and simple to host, but the editing workflow kills momentum. CMSs solve editing but add complexity and slow things down.
write.rocks tries to give you both:
- Static site performance (ISR, edge caching)
- True static site performance – PageSpeed scores hit 95-100
- Notion-like editor that switches between rich text and markdown
- Own your data
- Your own subdomain or custom domain
I'm a developer who just wanted to write more without fighting my infrastructure. If you've ever abandoned a blog because the publishing friction was too high, I'd love your feedback.
Free tier available. Paid planif you want custom domains and more storage.
try it at
https://write.rocks

value: Show HN: Write.rocks – Blog speed like a static site, edit like Notion


value:
YouTube's "Save to Watch Later" popover menu has been broken in Firefox for years (at least on my Linux installations). The three-dot menu → "Save to Watch Later" doesn't respond to clicks. Other popover menus work fine (account menu, upload menu), but this specific one is broken.
I reported it on Twitter/X (YouTube staff responded asking for feedback), submitted feedback through YouTube's website, but it's still broken as of December 27, 2025.
My workaround: Copy video URL → Open Chrome → Save → Switch back to Firefox. Very inconvenient when Firefox is your main browser.
I finally built a userscript workaround that fixes this for me:

  - Adds a direct "Watch Later" button to the video menu via DOM injection (bypasses broken popover)
  - Saves videos to localStorage and automatically saves them when they appear in recommendation sidebars on other pages
  - Injects pending videos directly into the Watch Later playlist page DOM (shows them at the top with clear "not saved yet" indicators)

Why this approach? YouTube has complex authentication checking, so you can't simply send a POST request to add videos to playlists. Instead, the script waits for videos to naturally appear in recommendation sidebars, then clicks YouTube's own "Watch Later" buttons (which DO work in Firefox when hovered).
Works in Firefox with Tampermonkey or other userscript addons.
Code: https://gist.github.com/beenotung/6cfb46bd5f4f800ac539331753...
Sharing in case other Firefox users are experiencing the same issue. I hope YouTube will eventually fix this and make sure it works not just in Chrome, but until then, this script works for me.

value: Show HN: Workaround for YouTube's "Save to Watch Later" Broken in Firefox


value: balachandarmani

value:
Hi HN,
I’ve been working on an open-source project called IntentusNet.
It focuses on a narrow but persistent problem in AI systems:
AI executions are observable, but not reproducible.
When a production issue happens:
the model may already be upgraded
fallback logic may have changed
retries may be implicit
routing decisions are no longer recoverable
Logs tell you something happened, but they don’t let you replay the execution itself.
What IntentusNet does
IntentusNet is not a planner, prompt framework, or model wrapper.
It’s an execution runtime that enforces deterministic semantics around models:
explicit intent routing
deterministic fallback behavior
ordered agent execution
transport-agnostic agents (local, HTTP, ZeroMQ, WebSocket, MCP-style)
In the latest release, I added execution recording and deterministic replay.
Each intent execution can be:
recorded as an immutable artifact
replayed later without re-running models
explained even after models or agents change
The core invariant is simple:
The model may change.
The execution must not.
Why I built this
Most AI systems implicitly trust the model to drive control flow.
That makes failures hard to reason about and almost impossible to reproduce.
IntentusNet takes the opposite approach:
models are treated as unreliable but useful
routing and fallback are explicit and deterministic
executions are facts, not logs
This is closer to how distributed systems treat requests than how most LLM stacks work today.
Demo (what it actually proves)
There’s a small demo that shows:
A live execution with “model v1”
The same execution with “model v2” (different output)
A deterministic replay of the original execution, even after the model changes
Routing and execution order stay the same.
Only the model behavior changes.
No debugger UI, no dashboards — just execution semantics.
What this is not
Not a replacement for MCP
Not a prompt-engineering framework
Not a monitoring system
Not trying to be “smart”
It’s infrastructure for making AI systems operable.
Repo
GitHub: https://github.com/Balchandar/intentusnet
I’m especially interested in feedback from people who’ve had to debug LLM-related production incidents or explain AI behavior after the fact.
Happy to answer questions or criticism.

value: Show HN: IntentusNet – Deterministic Execution and Replay for AI Agent Systems

author: balachandarmani


value: shauryaasingh

value:
Hey HN! I built Devion after spending way too many Friday afternoons writing release notes instead of shipping code.
Devion connects to your GitHub repo and automatically generates professional release notes from your commits and PRs. It:
- Analyzes commit messages and PR descriptions using AI
- Groups changes into meaningful categories (features, fixes, breaking changes)
- Recognizes and highlights contributors automatically
- Generates changelogs in customizable formats
- Works with your existing git workflow - no changes needed
We're currently in demo phase and I'd love your feedback. The goal is to make release notes something that happens automatically, not something you dread doing.
Try it at https://devion.dev - would especially love to hear:
- What's missing from your ideal release notes tool?
- What would make you switch from your current process?
- Any workflow quirks we should handle?
Also working on surfacing good-first-issues for maintainers. Happy to answer any questions!

value: Show HN: Devion – AI powered release notes from your commits

author: shauryaasingh


value: glorifiedgluer

value: Show HN: Commandry – A Command-Line Parser for Standard ML

author: glorifiedgluer


value: bryantn

value: Show HN: MemoryGate – zero-friction trust-correcting memory for agents

author: bryantn


value: EncoreVlaced

value: Lumina is a private reflection app that gives you a calm, minimalist space to slow down, think clearly, and explore your thoughts without distraction or pressure.

value: Show HN: Lumina – a minimal AI reflection app (source code)

author: EncoreVlaced


value: teycirb

value:
# Hacker News Submission
## Title
Show HN: TimeSeal – Cryptographic time-locked vaults with Dead Man's Switch
## Post Text
I built TimeSeal to solve a problem: most "future message" apps rely on trust. TimeSeal uses split-key cryptography to make early access mathematically impossible.
*How it works:*
Your browser generates two random AES-GCM-256 keys. Key A stays in the URL hash (never sent to server). Key B goes to Cloudflare Workers. The server refuses to release Key B until the unlock time. Without both keys, decryption is impossible—even for me.
*Three modes:*
1. *Timed Release* - Opens at exact future date (product launches, birthday messages)
2. *Dead Man's Switch* - Auto-unlocks if you stop checking in (crypto inheritance, whistleblower insurance)
3. *Ephemeral* - Self-destructs after N views (one-time passwords, confidential sharing)
*Architecture highlights:*
- Triple-layer encryption (client-side AES-GCM + server-side key encryption + master key)
- Split-key design: no single party can decrypt early
- Server-side time enforcement (client clock is irrelevant)
- Cloudflare Workers + D1 database (edge-native, globally distributed)
- Replay attack prevention with nonce-based pulse tokens
- Rate limiting via SHA-256 browser fingerprinting
- Open source (BSL license, converts to Apache 2.0 in 4 years)
*Security model:*
Even with full database access, an attacker cannot decrypt without:
- Key A (in URL hash, never transmitted)
- Master encryption key (environment secret)
- Both keys combined
The server enforces time-locks via Cloudflare's NTP-synchronized infrastructure. No root access = no time manipulation.
*Use cases I didn't expect:*
- Estate planning (crypto seed phrases that unlock after 30 days of silence)
- Journalist insurance (evidence auto-releases if arrested)
- Marketing stunts (countdown timers for product drops)
- Legal holds (contracts that activate on settlement date)
Live demo: https://timeseal.online
Source: https://github.com/teycir/timeseal
Docs cover threat model, attack scenarios, self-hosting, and trust assumptions. Happy to answer questions about the crypto, architecture, or edge cases.
---

author: teycirb


value:
I love starlings and algorithms and decided to combine.
I built a starling murmuration simulation that scales to one million birds.
The flocking emerges from simple local rules and continuous adjustment to nearby birds. It is based on Boids - separation, alignment, cohesion, soft boundaries and a gentle pull toward the center.
The flock’s motion also drives sound, where altitude controls pitch and local density shapes texture.<p>Desktop supports up to one million birds with adaptive limits on mobile.
Make sure to play around with the controls and let me know what you think.

value: Show HN: Simulation of 1M Flocking Birds


value: sumamedi

value:
Hello HN,
I’m a hobby music producer with a changing studio setup and got tired of losing track of what’s patched where (especially after gear swaps).
I built PatchMyGear, a website to map audio setups / routing and generate a cable list + wiring checklist, save / load locally. (no signup)
Let me know what you think. Happy holidays!

value: Show HN: PatchMyGear – a living map for your studio gear (cables and checklist)

author: sumamedi


value: stfurkan

value: Show HN: Krypto Markets – Real-time financial dashboard built in <2 days with AI

author: stfurkan


value: investbuddy

value: Show HN: I built a MCP Server for stock analysis (9% alpha vs. VOO)

author: investbuddy


value: DoingSomeThings

value:
Inspired by the HN Wrapped Roast (https://news.ycombinator.com/item?id=46336104), I built a web app that analyzes your Goodreads library and generates a literary roast, personality profile, and book recommendations.
Upload your Goodreads export CSV and get:
- Reading stats
- A roast of your reading choices
- Inferred personality traits
- Year-by-year thematic analysis
- Personalized book recommendations
Uses Gemini API for analysis. Book data stays in browser (localStorage), only titles/reviews/dates sent for insights. Demo mode available if you want to try it without uploading your own data.
This started as an experiment in prompt engineering and pattern recognition. I was curious how much personality insight you could extract from reading patterns alone.
The results were surprisingly accurate. It correctly inferred my shifts in physical location, political beliefs, and religious affiliation based purely on reading history.
Would love feedback on the analysis accuracy or additions that would make this more fun to use.

value: Show HN: Goodreads Analyzer – AI roast and book recs from your reading history

author: DoingSomeThings


value: Show HN: JJK Domain Expansions

title: Show HN: JJK Domain Expansions


value:
Hi HN!
I’ve been building SQL Data Builder, a web-based visual database management tool that makes creating and managing SQL databases way easier — no SQL syntax knowledge required. It’s a part of the VPS Commander suite but fully usable on its own:What it does
Visual table designer with drag-and-drop column & relationship editing
Interactive ER diagrams that update as you design
Inline data editing & filtering in a spreadsheet-like view
Automatic SQL code generation so you can learn from your actions
Works with real databases: MySQL, PostgreSQL, and SQLite
Web-based, no installation — just open your browser and connect
VPS Commander
Why I built it
I was tired of heavyweight, desktop-only tools and outdated UIs that make simple schema design and querying slower than it needs to be. I wanted something:
Fast to learn and productive from the first click
Accessible from anywhere without installing
Helpful both for beginners and seasoned developers. I’m sharing this not just for feedback, but to find out how visual DB workflows resonate with devs who deal with schema design and ad-hoc data tasks every day.
Happy to answer questions about design, implementation, UX choices, or future features! Thanks!

value: Show HN: SQL Data Builder – Visual schema and query builder


value: dkalola

value: Just a quick experiment I thought of building. Limited practical usage, for sure.<p>A Python library that uses LLMs as comparators for semantic sorting. Sort any list by meaning, tone, complexity, urgency, or any criteria expressible in natural language. This library uses an OpenRouter API key to interface with LLM providers.

value: Show HN: LLM Sorter – Python package to sort lists of items using LLM calls

author: dkalola


value:
Hi HN! it's year-end, so I built a very responsible way to review my GitHub year: turn my contribution calendar into a Breakout level and smash through it.
gh-kusa-breaker is a terminal Breakout game where each day on your GitHub contribution graph becomes a brick (more contributions = tougher brick). It uses `gh` auth and GitHub’s GraphQL contributionCalendar.
Try it:
gh extension install fchimpan/gh-kusa-breaker
gh auth login
gh kusa-breaker
In Japanese we call the contribution graph "kusa"(grass). Now you can literally break it.
Repo + demo: `<a href="https://github.com/fchimpan/gh-kusa-breaker" rel="nofollow">https://github.com/fchimpan/gh-kusa-breaker</a>`.
Feedback welcome.

value: Show HN: Year in Review – Breakout with your GitHub contributions


value: mirrormaster

value: A web application to inspect webhooks built using Bun and Server Sent Events.

value: Show HN: Webhook Inspector – Inspect and debug webhook requests in real-time

author: mirrormaster


value: rcarmo

value: Show HN: Export All Your Data from Apple Photos

author: rcarmo


value: taklaxbr

value: Show HN: I'm 15. I built an offline AI Terminal Agent that fixes errors

author: taklaxbr


value: CaptianFluffy

value:
Net Sentinel is a network monitoring tool with a custom pseudo-code engine for defining checks.
It allows users to build packet-level probes, HTTP requests, parsing rules, and metrics without writing full programs. The goal is flexible monitoring for game servers, APIs, and custom protocols.
Early release (v0.1.0). Looking for feedback on the engine design and use cases.

value: Show HN: Net Sentinel – Network Monitoring with a Pseudo-Code Engine

author: CaptianFluffy


value: krschacht

value:
I built a demo of a voice AI task manager. You speak naturally and it updates your visible task list in real time.
Try it here, no sign up: https://taskmaster.keithschacht.com
I find it useful to talk aloud to figure out priorities. With this, I can just ramble, “Mark that first task as done. Actually undo that. Add a task to proofread it. Move that to the top…”
It’s built on LiveKit with a Rails web UI. It listens continuously, maps speech to tool calls, and keeps full task-list state so it understands vague references like “the third item” or “the one with my kids.”
Voice feels much faster for input, but visual feedback is still higher bandwidth for output. This is intentionally rough—a demo focused on interaction, not features.
Curious how the interaction model feels for people?
Code: https://github.com/keithschacht/taskmaster

value: Show HN: Voice-first todo list that updates live as you talk

author: krschacht


value: omojo

value: Show HN: Space AI SIM – Orbital mechanics and power systems simulator

author: omojo


value: ovidiuvio

value:
Hi Everyone,
I've been working for some time on RelicBin, a modern self-hosted pastebin with the following features:
- Deployable via docker compose.
- Support for text, images, binaries, documents, logs, terminal ansi logs and archives.
- Public / Private relics
- Bookmarks
- Built-in rich rendering:

  - syntax highlighting
  - ANSI log viewer mode
  - Static HTML rendering
  - PDF/CSV viewing
  - archive browsing
  - excalidraw files
  - markdown files

- Collections via .rix relic index files
- CLI for uploading straight from your terminal
- S3 as storage backend
- DB backups in S3
- S3 sync service to sync storage to an other S3 bucket as backup
Why I built it:
I wanted a self hosted pastebin that is scalable, flexible and developer / devops focused
Made with AI ( Claude / Gemini / GLM )
Feedback, criticism are very welcome.
Repo: https://github.com/ovidiuvio/relic

value: Show HN: RelicBin – A modern take on pastebin

author: ovidiuvio


value: xlii

value:
Hi HN,
I've been coding for over 20 years, and I've always had this specific annoyance: when I grep or rg through a codebase, the definitions or declarations I actually want to see are often buried in the middle of the stream.
I got tired of crafting magic regex sequences to find them, so when I came down with the (actual) flu this week and needed to occupy my brain, I built ssort.
It's a CLI tool that buffers input and bubbles specific matches (like "struct", "class", "func") to the top while flushing the rest later. It was partially "vibe coded" with Gemini during (ongoing) recovery.
It's simple, written in Go, and finally solves my search ordering problem. Hope you find it useful.

value: Show HN: Ssort – I got sick and vibe coded a stream priority sorter

author: xlii


value: lukecarr

value:
Over the holidays, I've been working on a small side-project that includes some LLM prompting from the end user. Admittedly, I struggle to keep track of the latest and greatest models, and I've also never bothered to read up on "prompt engineering," so I built a little testing utility to solve both of these problems at the same time.
Enter Litmus. I'm pitching it as "specification testing" for LLMs. You define test cases (input prompt -> output JSON), as well as your system prompt and structured output (JSON Schema). All of this gets chucked at OpenRouter, and you get some nice terminal output summarising the test results (with a breakdown per-field for any failing cases) to see how well the model performed.
Although it's framed as an LLM testing tool, it also serves as a model comparator. You can pass the `--model` CLI argument multiple times, and this will let you run the test cases against multiple models, with a comparison table generated in the output at the end for evaluating latency, throughput, tokens, and accuracy (tests passing vs. failing).
The GitHub README contains a full example output of what a test report from Litmus looks like.
With this, I've managed to get my system prompt for my side-project whittled down to the point where the accuracy is acceptable and it's not an exorbitant amount of tokens. I've also found out, through model comparison, that I didn't need anywhere near as large of a model as I had originally envisioned.
You can grab it on GitHub as a single-file, zero-dependency executable (written in Go). Admittedly, I've not tested the pre-built binaries that are created via GitHub Actions, but there's no reason why they shouldn't work.

value: Show HN: Litmus – Specification testing for structured LLM outputs

author: lukecarr


value: thepoet

value: Show HN: Design your own post-AGI civilization with tradeoffs

author: thepoet


value:
Hey HN,

  I built Buildex (https://buildex.dev) to help engineers practice system design interviews interactively.

  The problem: System design prep usually means reading blogs or watching videos passively. There's no way to actually practice designing systems and get feedback.

  How it works:
  - Pick a challenge (URL shortener, rate limiter, chat system, etc.)
  - Drag-and-drop components onto a canvas to design your architecture
  - Connect them to show data flow
  - Submit and get scored on efficiency, cost, and reliability
  - AI evaluates your design and gives specific feedback

  Tech stack:
  - Frontend: React + Vite
  - Backend: Go
  - Database: PostgreSQL
  - AI: Claude API for design evaluation
  - Payments: Razorpay

  Free tier gives you 2 AI evaluations/day. I'm a solo dev and built this over the past few months while prepping for interviews myself.

  Would love feedback on:
  - Challenge difficulty/variety
  - Scoring system fairness
  - UI/UX issues
  - What's missing?

  Happy to answer any questions about the implementation.

value: Show HN: Buildex – Interactive system design practice with AI feedback


value: abdulbasitali

value:
Hey HN,
I’ve been building agents recently, and I hit a problem: I fell asleep while a script was running, and my agent got stuck in a loop. I woke up to a drained OpenAI credit balance.
I looked for a tool to prevent this, but most solutions were heavy enterprise proxies or cloud dashboards. I just wanted a simple "fuse" that runs on my laptop and stops the bleeding before it hits the API.
So I built AgentFuse.
It is a lightweight, local library that acts as a circuit breaker for LLM calls.
Drop-in Shim: It wraps the openai client (and supports LangChain) so you don't have to rewrite your agent logic.
Local State: It uses SQLite in WAL mode to track spend across multiple concurrent agents/terminal tabs.
Hard Limits: It enforces a daily budget (e.g., stops execution at $5.00).
It’s open source and available on PyPI (pip install agent-fuse).
I’d love feedback on the implementation, specifically the SQLite concurrency logic! I tried to make it as robust as possible without needing a separate server process.

value: Show HN: AgentFuse – A local circuit breaker to prevent $500 OpenAI bills

author: abdulbasitali


value: KrishBaidya

value: Show HN: I built a small interpreted programming language from scratch

author: KrishBaidya


value: ZuzuDuck

value: Show HN: VoteSprint – Planning poker without the bloat

author: ZuzuDuck


value:
I’ve conducted a technical audit on the physical limits of H100 GPUs for long-context retrieval. At scale (N=500k+), standard fp16 NxN materialization is physically impossible on a single 80GB card (requires ~500GB HBM).
I’m releasing CTDR (Cold Tensor Deterministic Reasoning) evidence and the Maxwell Dashboard. It allows you to:
1. Visualize the OOM Feasibility Boundary (The NxN Wall).
2. Audit real NVML energy receipts (Joules per query) showing 90.4% SM utilization.
3. Compare your own GPU performance against our baseline.
Honest caveat: At small N, we carry a constant overhead for p-adic quantization. The asymmetry kicks in as scale grows.
Evidence and Audit Repo in git

value: Show HN: Solving the H100 OOM Wall with CTDR – Maxwell Dashboard Included


value: saisrirampur

value: Show HN: ClickHouse Fiddle – A SQL Playground for ClickHouse

author: saisrirampur


value: Show HN: Morph-AI-Era – A dashboard making tool without any manual setup


value: electrodisk

value: Show HN: Create your own corner of the internet

author: electrodisk


value: Rethink your notebook: write code, math, and diagrams together with instant feedback and beautiful rendering. Great for sharing reproducible tech work.

value: Show HN: TensorPad – The Engineering Notebook You've Been Waiting For


value: Show HN: Drop-in maps for Markdown and HTML, wrapping leaflet and OSM


value: casmn

value:
Hi HN,
I posted dotenv-diff here a couple of weeks ago. Since then, I’ve made several improvements based on feedback and real-world usage.
The goal remains simple: statically audit how environment variables are actually used in a JS/TS codebase.
Repo: https://github.com/Chrilleweb/dotenv-diff
Docs: https://dotenv-diff-docs.vercel.app/
npm: https://www.npmjs.com/package/dotenv-diff
Feedback always welcome :)

value: Show HN: Dotenv-Diff – Recent Improvements

author: casmn


value: moeidheidari

value:
Hi HN,
Crossplane is powerful, but once you start working with multiple compositions, claims, and managed resources, it becomes hard to understand how everything is connected.
We built Crossview to solve this problem for ourselves. It’s an open-source UI that visualizes Crossplane resources and compositions as graphs, making it easier to explore relationships, debug issues, and reason about complex setups.
Some of the things we focused on:
Visualizing relationships between compositions, claims, and managed resources
Real-time views with search and filtering
Multi-context support to switch between clusters easily
The project is still early, and we’re actively improving it. We’d really appreciate feedback from people using Crossplane, Kubernetes, or building internal platforms:
Is this useful in real-world setups?
What features would you expect from a Crossplane visualization tool?
What’s missing or unclear?
Repo: https://github.com/corpobit/crossview
Thanks for taking a look.

value: Show HN: Crossview – visualize Crossplane resources and compositions

author: moeidheidari


value: kivarada

value:
I built InsideStack to make it easier to find high-quality technical and software articles.
Why?
- The web is flooded with AI-generated content
- Businesses are publishing tons of articles with biased content
- Search results are often driven by engagement rather than quality.
- AI-generated summaries of articles don’t drive traffic back to the original creators
InsideStack lets you:
- Search across curated RSS feeds with semantic search
- Subscribe, bookmark, and follow topics or authors
Currently, only a small set of feeds is included, but I am adding more every day. Suggestions for high-quality RSS feeds and any feedback are very welcome!

value: Show HN: InsideStack – Find curated tech articles with semantic search

author: kivarada


value: smiiith

value: Show HN: Follow independent journalists across platforms in one app

author: smiiith


value:
The problem: I kept making "mega-commits" with unrelated changes because I get in a flow state and then end up with a huge number of changes I forgot to commit.
The solution: I built a tool that analyzes your staged git changes, clusters them by semantic similarity using embeddings + hierarchical clustering, and creates separate commits for each cluster.
How it works:
- Parses diffs into semantic chunks using tree-sitter
- Generates embeddings (OpenAI text-embedding-3-small)
- Clusters with single-linkage hierarchical clustering
- Interactive dendrogram UI to adjust cluster threshold
- Creates one commit per cluster
Currently Mac-only (uses self-written https client with kqueue), but happy to add cross-platform support if there's interest. Also planning local LLM/embedding support.
Looking for feedback!

value: Show HN: Gcommit – clustering code changes semantically


value: lgdimaggio

value: Show HN: MCP server for vibration-based predictive maintenance

author: lgdimaggio


value: msuvakov

value:
I generalized and vibe coded a 3D version of factorization diagrams. If you are not familiar with factorization diagrams, you can find more information here: https://naturalmath.com/factorization/
There are many ways to generalize them in 3D. Hope you’ll like my approach.
How it works:
The app visualizes a number N by recursively building a hierarchy of spheres based on its prime factors.
Given N with prime factors p_1, p_2, …, p_k:
- Start with a single root sphere.
- For the first factor p_1, place p_1 smaller spheres with their centers on the surface of the root.
- For the next factor p_2, place p_2 even smaller spheres on the surface of each sphere from the previous level.
- Repeat until all prime factors are used.
At the end, the number of smallest spheres is exactly N.
Sphere placement on each level is handled by a simple physics simulation using Coulomb-style repulsion, normalized by the size of spheres on the previous depth level, while keeping centers locked on the surface of the parent sphere. All spheres on the same depth level interact, not only those positioned on the same parent sphere. This way, spheres spread out evenly over the surface and in space. Sphere size is based on the minimum distance between spheres at the same level, scaled by an adjustable factor.
The code was written using Google Antigravity with the Gemini 3 Pro model.

value: Show HN: 3D Factorization Diagrams

author: msuvakov

title: Show HN: 3D Factorization Diagrams


value:
Uses an LLM to identify where tables actually start/end in Excel/CSV files, then extracts clean, typed data.
Handles all the messy formatting (currency, percentages, different number formats) and streams efficiently for large files.
Works with OpenAI, DeepSeek, or any compatible API.

value: Show HN: LLM-powered data extraction from messy spreadsheets


value: claygood

value: Show HN: Runtime data provenance for AI pipelines

author: claygood


value: phntmdz

value: Show HN: HookVerify – Webhook delivery visibility for production systems

author: phntmdz


value: portablesheep

value: Http request client that removes the need for complex UI (postman) and instead focuses on text to support requests, chained requests, pre/post scripts, load testing, and more.

value: Show HN: HTTP Request tool made for devs

author: portablesheep


value: cpath

value:
NotebookLM doesn't have any export functionality, so I built one. Pulls your full conversation history, source metadata, and citation mapping (which sources informed each AI response). Outputs JSON, Markdown, CSV, or Excel.
Free while in beta. Planning to add support for adding sources to notebooks programmatically next. Feature requests welcome.

value: Show HN: Export your NotebookLM data – conversations, sources, citations

author: cpath


value: birdculture

value: Show HN: Twine – A tool to dynamically trace calls in production Elixir systems

author: birdculture


value: Uptrenda

value: Show HN: Namebump is a registrationless, KVS. Unused names are bumped overtime

author: Uptrenda


value: nikhonit

value:
OP here. I've been trying to "build in public" recently, but I found that switching context from VS Code to Twitter/X just to write "Fixed a race condition" felt like friction. I often ended up posting nothing because translating code-diffs to human-readable text takes more mental energy than fixing the bug.
I built Git to Tweet to automate this loop.
How it works:
It hooks into your GitHub repo (via OAuth).
It pulls the metadata and diff summaries of your recent commits.
It passes the diff through a specifically tuned prompt (to avoid generic "AI slop") that extracts the intent of the code change rather than just listing file names.
It generates a draft that you can edit before posting.
The Tech Stack:
Frontend: React + Framer Motion (spent way too much time on the "terminal" animations you see on the landing page).
Backend: Node.js/Supabase.
LLM: Currently testing models to see which is best at understanding code context without hallucinating features.
The landing page includes an interactive simulator (hardcoded scenarios for now) if you want to see how the "translation" logic works without connecting a repo.
I’m curious if others find this "translation" layer useful, or if you prefer manual changelogs? Feedback on the diff parsing accuracy would be awesome.
URL: https://landkit.pro/git-to-tweet

value: Show HN: Turn Your Git Commits into Tweets

author: nikhonit


value: jeanmayer

value:
I made this for my wife, who’s a big Stranger Things fan, to keep her entertained while we wait for the final episode coming out in a few days.
Built in ~2 hours. It’s a short clicker game (~15–20 minutes) and it actually ends.
I personally love the tree ui, if I spent more time i'd definitely improve the performance and replace those emojis with actual images.

value: Show HN: I Made a Tiny Stranger Things Game While Waiting for the Finale

author: jeanmayer


value: ejncman

value: Show HN: UpDown, Simple Website Uptime Checker

author: ejncman


value: DGrechko

value:
Hi HN,
I’m building Waycore, an open-source project exploring what a flexible, offline-first field computer should look like for outdoor, survival, and off-grid scenarios.
The core goals are adaptability and resilience:
modular hardware (external sensor/tool modules)
extensible OS with support for external apps (guidelines in progress)
no required internet connection — maps, models, and knowledge work offline
optional LTE/Wi-Fi when available and explicitly enabled
A major focus is on-device agentic AI, not just chat or image recognition. The AI is intended to:
read live sensor data (GPS, compass, environment)
reason over offline knowledge
use apps and core APIs
assist with navigation, safety checks, logging, and communication
Main project repo (OS & architecture):
https://github.com/dmitry-grechko/waycore
There’s also a separate repo curating freely downloadable survival & outdoor PDFs for offline use:
https://github.com/dmitry-grechko/waycore-knowledge
I’m looking for feedback and contributors around:
UI/UX for rugged touch devices
hardware modularity & interfaces
offline/edge agent architectures
small models that work well without internet
high-quality public-domain or permissive survival knowledge sources
Happy to answer questions or hear critique.

value: Show HN: Waycore – an open-source, offline-first modular field computer

author: DGrechko


value: davasny

value:
I had a problem with keeping focus on opencode terminal when it was doing tasks longer than ~30 seconds, so I built a small plugin that sends telegram notification to ping me when agent finishes.
Setup:
1. Send /start to the bot
2. Execute bash command that the bot sends you back. You can see source code of the script here [1] and the built plugin here [2].
3. Done! Whenever your agent finish, you will get message with project name, session title and duration of the agent work.
I decided to make it available to everyone on my free tier of cloudflare workers, but it's fully hostable on your own cloudflare accounts or even docker containers on custom infra with few minor changes in the code.
Development was done mostly by Claude Opus 4.5 and custom agents in opencode.
[1] https://github.com/Davasny/opencode-telegram-notification-pl...
[2] https://github.com/Davasny/opencode-telegram-notification-pl...

value: Show HN: I built opencode –> telegram notification plugin

author: davasny


value: clintjhill

value:
This began as a passion project and an opportunity to learn new tech.
I've always experienced frustration developing APIs, especially the RESTful CRUD style of data APIs. It always felt like I was repeating the same patterns over and over again, and that was tedium I didn't want. A little over a year ago, I wanted to learn more about Go, Firecracker microVM, and Svelte and thought "Could I build an API framework that was just a simple description of resources? What would that look like?"
That lead me to https://firecracker-microvm.github.io/, which landed me on https://fly.io, then https://rqlite.io, and the further I got into it, the more I really liked what I had. It's been over a year of learning and trying out all forms of tooling, CLIs, LSPs, and finally I landed on this.
So I decided to try my hand at making this a product. I'd really enjoy feedback about it and whether it's something folks would use. Here's hoping others feel the way I do about APIs and the developer experience building them!

value: Show HN: attainable – The fastest and easiest way to design and deploy APIs

author: clintjhill


value: salebanolow

value:
Hey HN,
We analyzed 4,010,957 Hacker News submissions to find what actually makes posts perform well.
Key findings:
 - 93.2% of posts never hit 50 points
 - Top 1% starts at 270 points
 - Certain keywords boost engagement by 1000%+
Built a free tool that scores your launch title and predicts viral potential: [link]
The entire 4M post dataset is available as a single 700MB .mv2 file if you want to run your own analysis.

value: Show HN: Viral Potential Predictor

author: salebanolow

title: Show HN: Viral Potential Predictor


value:
We built Iris after watching friends spend weeks doom-scrolling Craigslist, Zillow, Apartments.com and broker sites — only to miss good units or run into stale / scammy listings.
Iris is a SF-only rental marketplace with a few differences from existing platforms:
1. Search by natural language (“1BR near BART under $3.2k”) or images (upload inspiration photos)
2. Verified listings only from property managers, owners, and authorized agents
3. SF-specific filters: rent control toggle, transit lines, neighborhood context
What surprised us since launch:
1. A large share of inventory never shows up cleanly on national portals
2. Renters care more about context (block, transit, light, noise) than raw filters
3. Narrow vertical focus (one city) lets us build features Zillow can’t justify
Would love feedback from people who’ve built:
- Vertical marketplaces
- Local-first products
Happy to answer questions.
-- Manan Shah

value: Show HN: Iris – an AI-powered rental search built specifically for San Francisco


value: Rabidgremlin

value:
As a holiday project to test out spec first development using Codex CLI, I ended up creating https://boxinsertdesigner.com/
It lets you design a box insert in 2D and spits out a cutting list.
I'm looking for feedback, bugs, feature ideas etc and figured this would be a good place to find it :)

value: Show HN: I created a tool to design and create foamcore inserts for boardgames

author: Rabidgremlin


value: thomasfromcdnjs

value: Show HN: tpmjs - npm for ai sdk tools

author: thomasfromcdnjs

title: Show HN: tpmjs - npm for ai sdk tools


value: setmd

value:
Hey HN!
I'm tired of the ritual where we assume AI needs a GPU cluster and a prayer to avoid crashing.
I built BESTBRAIN Core to prove that intelligence—real, deterministic, safe intelligence—can live in the "room at the bottom." This is a 12KB kernel designed for robotics where failure isn't an option.
What it is:
- 12KB decision kernel (10.7KB Python + 1.8KB JS wrapper)
- 100% deterministic (same input → same output, always)
- 0 crashes across 10,260+ tests
- <1ms latency (edge-deployable)
- No GPU, no neural nets, no randomness
What it's NOT:
- Not a trajectory planner
- Not a perception system
- Not a learning algorithm
- Those belong in user space, not the kernel
Why I built this:
Everyone's racing toward bigger models. I went the other direction: smaller, simpler, provable.
The robotics industry has this ritual where we throw NumPy (15MB), SciPy (31MB), and TensorFlow at every problem. I asked: "What if we just... didn't?"
Result: A kernel that fits in L1 cache and makes decisions you can actually audit.
Try it now:
git clone https://codeberg.org/ishrikantbhosale/bestbrain-core.git
cd bestbrain-core && python3 -m http.server 8000
Open http://localhost:8000/demo.html in your browser
Why local? Codeberg doesn't render HTML directly (security). This setup runs the actual Python kernel, not a hosted simulation. You can inspect the code yourself.
Technical receipts:
https://codeberg.org/ishrikantbhosale/bestbrain-core/src/bra...
Philosophy:
https://codeberg.org/ishrikantbhosale/room-at-the-bottom

value: Show HN: A 12KB Deterministic AI Kernel for Robotics (bestbrain-core)

author: setmd


value: mhcoen

value:
Desktop is good for conversation—planning, reviewing, brainstorming. Code is good for execution—editing files, running commands. But they don't share context.
This connects them via a shared SQLite buffer. Say "send this to Desktop" or "ask Code"—the model handles it. Notifications when something's waiting.

value: Show HN: Relay – Connect Claude Desktop and Claude Code via MCP

author: mhcoen


value: claudianadalin

value:
I built a module bundler for PineScript (TradingView's scripting language).
The problem: TradingView doesn't support multi-file projects. As indicators grow complex, you end up with 1000+ line files that are painful to maintain.
Pinecone lets you split code across multiple .pine files using import/export directives, then bundles everything into a single TradingView-compatible script.
It handles automatic namespacing to prevent variable collisions between modules, deduplicates external library imports, and includes watch mode for development.
Built with Python. Uses the pynescript library for AST parsing and manipulation. I had to work around some upstream parser bugs with generic type syntax, which was an interesting challenge.
GitHub: https://github.com/claudianadalin/pinecone
Blog post with more technical details: https://www.claudianadalin.com/blog/building-pinecone
This is a niche tool, but if you've ever built complex TradingView indicators, you know the pain. Would love feedback on the approach.

value: Show HN: PineCone – A bundler for splitting PineScript into multiple files

author: claudianadalin


value: devhammed

value: Show HN: Laravel Brick Money Package

author: devhammed

title: Show HN: Laravel Brick Money Package


value:
Hi HN
Over the last few weeks, I analyzed 50+ real directories to understand what’s actually working in 2025.
Instead of opinions or hype, I focused on:
Real traffic data (SimilarWeb)
SEO & keyword shifts (Ahrefs / Semrush)
Public revenue signals
Category-level patterns (what’s growing vs saturated)
The goal was simple:
If someone were starting a directory today, where should they focus — and what should they avoid?
I turned these findings into a free Directory Trends Report 2025

value: Show HN: I analyzed 50 directories to see what makes money