value: nottherealsanta

value:
I wanted to learn about AlphaZero, I couldn't learn without implementing it in an interesting project.
There are two things here:
1. play against alpha-toe-zero on 4x4x4 tic-tac-toe in browser, to my knowledge this has not been done before; therefore exciting to me.
2. learn about alphazero inner working with 4 interactive notebooks. These notebooks can be either run in browser connecting to your local runtime or can be downloaded. I understand there are some security concern with asking user to connect their local python runtime to a random website; therefore I added option to download the notebooks.
Repo: https://github.com/nottherealsanta/alpha-toe-zero

value: Show HN: Alpha-Toe-Zero

author: nottherealsanta

title: Show HN: Alpha-Toe-Zero


value: Show HN: Sptws.com – A summary and guide based on JLC Simple Path to Wealth book


value: dataarchitect

value: Show HN: I wrote 270-page guide on migrating from XLS to Python/SQL for analysts

author: dataarchitect


value: DenisDolya

value:
I built stb_xml because I needed something faster than libxml2 for embedded work – it's a single-header XML parser that parses 1MB XML at 8,700 MB/sec (193× faster than libxml2) while being only 1.5KB (333× smaller). It achieves this through zero-copy parsing, zero allocations, and 6-byte tokens, trading full XML spec compliance for extreme speed and minimal footprint. All benchmark results are in output_tests.txt.
GitHub: https://github.com/Ferki-git-creator/stb_xml

value: Show HN: Stb_XML – A 6KB XML parser that's 193× faster than libxml2

author: DenisDolya


value: s-macke

value: Show HN: Reverse engineering and porting a C64 game with AI

author: s-macke


value: melezhik

value:
Double TAP is lightweight testing framework where users write black box tests as rules checking output from tested "boxes". Boxes could be anything from http client, web server to messages in syslog. This universal approach allows to test anything with just dropping text rules describing system behavior in black box manner.
http://doubletap.sparrowhub.io/

value: Show HN: DTAP Testing Protocol

author: melezhik

title: Show HN: DTAP Testing Protocol


value: gahanlal

value:
Hi HN,
I built a small app called Newsopia because I found myself reading a lot of news but still feeling confused about what it actually meant.
Most news answers what happened, but rarely why it matters or how it affects you. Newsopia tries to bridge that gap by explaining the context, implications, and real-world impact behind news—especially around markets, geopolitics, and everyday life.
This is an early version and very much a work in progress. I’m not trying to replace news sites—just add an understanding layer on top of them.
I’d really appreciate any feedback:
– Is this a real problem for you?
– What feels useful vs unnecessary?
– What would you want this to do next?
Link: newsopia.streamlit.app
Thanks for taking a look.

value: Show HN: I built an app to understand what the news means

author: gahanlal


value: RafalPilla

value:
I built this as a small personal experiment.
You describe a business and its main challenge.
The tool sends back a short written snapshot by email.
The goal is not advice, growth tactics, or automation of decisions.
It’s meant to reduce noise and force a moment of clarity
about what actually matters first.
No accounts, no dashboards, no upsells.
Feedback is welcome.

value: Show HN: A tiny tool that creates short business snapshots

author: RafalPilla


value: Show HN: Free credit card eligibility checker for Indian – no login/PAN needed


value: chungleong

value: Show HN: Creating a website with client-side SQLite as back end (Zig and WASM)

author: chungleong


value: amitaghdk

value:
We are building a platform to help teams turn rough screen recordings into
clean product videos, documents, or GIFs without spending hours editing.
The motivation came from repeatedly seeing founders, PMs, and sales teams
struggle with:
– raw screen recordings that look unpolished
– high effort required to create multiple demo versions
– product knowledge scattered across videos, docs, and people
The goal is not to “auto-generate” content, but to help teams create better product knowledge faster and deliver it in a more guided, measurable way.
It’s currently being used for product demos, onboarding, training, and support.
I’d really appreciate feedback from HN on:
– whether this workflow resonates
– where you see real value vs unnecessary complexity
– what would make you trust (or avoid) an AI-guided demo experience
Link: https://www.demokraft.ai
Happy to answer questions and learn from the community.

value: Show HN: Product Content Creation Tool

author: amitaghdk

title: Show HN: Product Content Creation Tool


value: joshuawheelock

value: Show HN: Jumbo – Portable Memory for Coding Agents

author: joshuawheelock


value: tobilg

value: Show HN: Unified local observability for AI coding assistants

author: tobilg


value: falcriser

value:
Hi HN - I built TalkNow after repeatedly hitting a travel problem: in parts of the Middle East, common consumer calling features (e.g., VoIP calls inside popular chat apps) can be restricted or inconsistent, and you end up installing different apps depending on the country/operator. Reuters has noted VoIP limitations on WhatsApp in places like the UAE and Qatar (messaging works, calls can be restricted).
What it is: a small web app for instant 1:1 audio/video calls in the browser. Open the site → start a call → share a join code/link with one person → talk. No accounts. It’s intentionally limited to two people to keep the flow simple.
What’s different (vs meeting tools):
No sign-up, minimal UI, optimize for “time-to-first-call”
1:1 only (not trying to be a full meeting platform)
Aimed at cases where people don’t want to install yet another app while traveling
Feedback I’d love:
Is the join code/link UX obvious?
How is reliability across browsers/networks (especially mobile + hotel/cellular)?
What should be next: screen share, better mobile layout, copy-link default, etc.

value: Show HN: TalkNow – instant browser calls via simple join code (no sign-up)

author: falcriser


value: RAMJAC

value: I personally like KDL, and this is the library I use for my personal zig projects. Looking to get feedback and improve the library.<p>kdl-zig is a KDL 2.0.0 parser/serializer that passes the full official test suite. It supports direct struct decoding/encoding and a DOM API.

value: Show HN: KDL-Zig – A Zig parser and serializer for KDL

author: RAMJAC


value: marcuscodes

value: will love some feedback from the community

value: Show HN: Mockmydata.io – Instant mock API endpoints for testing

author: marcuscodes


value:
Hi HN
I started this after getting frustrated with the back-and-forth of sharing PowerPoint files and wanting something closer to “slides as code” that works well with version control.
That idea evolved into visualise.ink: instead of writing the structure yourself, you describe what you want and AI generates clean, usable visuals for you. The goal isn’t to compete with PowerPoint, but to serve people who want good slides now without fiddling with layouts.
Under the hood, designs are defined using a simple YAML-based language (inspired by SwiftUI / Jetpack Compose) and rendered to HTML. In practice, the AI writes almost all of this for you; I rarely touch it myself anymore.
You can:
- generate slides, posters, cheatsheets, and menus from text
- input your own data
- recreate or match the style of an existing slide or image
I know Gamma and others exist already but I have found them to be clunky and not produce slides that I would actually want to use. I want max ROI with minimal effort.
It’s a closed-source SaaS with a free tier and a paid plan if you use it heavily.
I’d love feedback on:
- whether the outputs feel usable out of the box
- pricing clarity
- what formats or features would be most valuable next
Link: https://visualise.ink
Small showcase: https://visualise.ink/showcase

value: Show HN: Visualise.ink – Generate good-looking slides and infographics from text


value: aestuans

value:
I really like the look of the famous album art for Unknown Pleasures [1]. It was originally created by Harold Craft at the Arecibo Observatory from the signals of the first discovered radio pulsar [2].
I made a spectrogram that produces a similar look. It runs FFT in Rust and visualizes it with WebGL.
[1]: https://en.wikipedia.org/wiki/File:UnknownPleasuresVinyl.jpg
[2]: https://en.wikipedia.org/wiki/PSR_B1919%2B21

value: Show HN: A spectrogram in the style of Unknown Pleasures album art (Rust+WebGL)

author: aestuans


value: We've all heard "never settle," but how do we know if our standards are reasonable? This calculator turns abstract dating preferences into concrete statistics—showing the percentage of people in your area who meet your criteria. It's not about lowering standards, but making intentional choices. We'd love HN's take on the data sources (census, dating app anonymized data) and any improvements to the filtering logic.

value: Show HN: Dating Standards Calculator – Quantify your dating pool with data


value: shatsky

value:
Hi HN!
I'd like to share my app for viewing images the way I find comfortable on a desktop computer. No window frame, no menus, no toolbars, just the image itself in transparent fullscreen overlay; pan (move around) with mouse with left button pressed (or keyboard arrows), zoom into point under cursor with scroll (or into point at center of display with keyboard +=/-/0), close with left click anywhere (or keyboard Enter, allowing "instant toggle" between file manager and image view). Written in C and Rust with SDL3 and image-rs.
Source and builds for Linux (Ubuntu 25.10, Nix expr) and Windows: https://github.com/shatsky/lightning-image-viewer
Microsoft store (with screenshot): https://apps.microsoft.com/detail/9np4j8k90smk
Web demo: https://shatsky.github.io/lightning-image-viewer/
Dev notes: https://shatsky.github.io/notes/2025-03-07_sdl3-image-viewer...

value: Show HN: Lightning Image Viewer – overlay, map-like controls, toggling, image-rs

author: shatsky


value:
Hi folks,
I’ve been working on a tool called DatumInt that inspects data files or data snippets for subtle issues that often slip past basic parsing and only cause problems downstream.
This came from repeatedly seeing files that:
- parsed successfully
- passed schema checks
- but still caused issues later (empty required fields, weird placeholder values, encoding/whitespace problems, type inconsistencies, etc.)
Right now it’s a simple web app:
- upload a data file or paste data
- run an inspection
- get a structured report of potential data quality issues
This is very early and focused on small-to-medium files. It’s not meant to replace full data quality frameworks or observability tools, more of a fast “sanity check” at the file boundary.
I’m mainly trying to learn:
- what kinds of file-level issues people actually run into
- whether this kind of inspection is useful in real workflows
If you try it, I’d really appreciate any honest feedback or cases it misses.

value: Show HN: Inspect your data for subtle data issues before pipeline breaks


value: smacke

value: Show HN: Powerful pipeline syntax for IPython and Jupyter

author: smacke


value: onukura

value:
Hi HN, I made OSS Sustain Guard.
After every high-profile OSS incident, I wonder about the packages I rely on right now. I can skim issues/PRs and activity on GitHub, but that doesn’t scale when you have tens or hundreds of dependencies. I built this to surface sustainability signals (maintainer redundancy, activity trends, funding links, etc.) and create awareness. It’s meant to start a respectful conversation, not to judge projects. These are signals, not truth; everything is inferred from public data (internal mirrors/private work won’t show up).
Quick start:
pip install oss-sustain-guard
export GITHUB_TOKEN=...
os4g check
It uses GitHub GraphQL with local caching (no telemetry; token not uploaded/stored), and supports multiple ecosystems (Python/JS/Rust/Go/Java/etc.).
Repo: https://github.com/onukura/oss-sustain-guard
I’d love feedback on metric choices/thresholds and wording that stays respectful. If you have examples where these signals break down, please share.

value: Show HN: OSS sustain guard – Sustainability signals for OSS dependencies

author: onukura


value: nykodev

value: Show HN: TestiMoney – Pay to post messages that decay in real-time

author: nykodev


value: samber

value: Show HN: A web-based visualizer for Go module dependency graph

author: samber


value: cranberryturkey

value: Built this to streamline outsourcing for corporate America.

value: Show HN: Elite Tech Talent. Managed

author: cranberryturkey

title: Show HN: Elite Tech Talent. Managed


value: qedlab

value:
Hi HN,
I built TinySolvers (https://tinysolvers.com) as a side project to make math more engaging for kids.
There are plenty of generic math worksheets online, but I wanted something more personal to help connect the math to the student. TinySolvers generates customized math word problems using a child’s name, favorite nouns (dinosaurs, pizza, unicorns), verbs (jumping, exploring), and a selected operation and difficulty level.
For example:
“Emma found 7 dinosaurs in the forest. She discovered 5 more hiding behind a tree. How many dinosaurs did Emma find in all?”
You can download printable PDFs or use an interactive mode where kids solve problems one at a time with immediate feedback. It’s currently focused on early elementary arithmetic (K-5).
Initially, I tried a large library of predefined word problems with string substitution, but that hit limits quickly. I experimented with Word2Vec to expand vocabulary (e.g., dinosaurs → T-Rex, Triceratops), but eventually landed on carefully constrained LLM generation. The AI only generates narrative text and all math is validated deterministically before being shown to kids.
Tech details:
- Go backend with Gin, HTMX frontend
 - Supports local LLMs via Ollama or OpenAI
 - Single binary deployment
 - PDFs rendered via Cairo
I’d love feedback, especially from parents or educators. What other problem types would be useful?

value: Show HN: TinySolvers – Personalized Math Word Problems for Kids

author: qedlab


value: d-yoda

value: Show HN: An AI agent that audits your entire Python codebase

author: d-yoda


value: gongo

value:
Hi HN,
This is a small RISC-V emulator I’ve been hacking on in Emacs Lisp as a fun weekend project.
It started mostly as a way to better understand the RISC-V spec by implementing things myself, and also as an excuse to write more non-trivial Emacs Lisp. It currently focuses on RV32I and related basics, and is very much not optimized or production-ready.
If you’re into RISC-V, emulators, or just enjoy seeing unusual things built in Emacs Lisp, feedback and comments are welcome
Happy hacking!

value: Show HN: Emacs-riscv – A RISC-V emulator written in Emacs Lisp

author: gongo


value: Wilsoniumite

value: I played wordle a lot on discord and was annoyed that the new York Times bot doesn't even give you your average score. So, I made this bot that does that and a few other things, like generating leaderboards. I know there are some other bots that already do this but I wanted more ways of ranking. There are lots of statistical nuances I encountered while making it (I did a long writeup over on https://wilsoniumite.com/2025/11/05/calculating-a-wordle-lea...), so the bot supports elo scores and averages, calculated different ways. This does mean that pretty much every leaderboard is different, but I think it gives users control and also awareness that in truth, the leaderboard is just an approximation of true skill.

value: Show HN: Wordlestat, a discord bot that generates Wordle leaderboards

author: Wilsoniumite


value: williamcotton

value: Show HN: GraphQL DataLoader Pattern in Custom DSL

author: williamcotton


value: awaaz

value:
Why - I got sick of apps abusing notifications on my Android phone. While the OS does give you the ability to switch off notifications based on channels, most apps either don't use it or abuse it intentionally. In my case, I live in a gated society that uses an app called MyGate to allow visitors, and the app intentionally pushes ads through the same channels since you cannot block them.
What - DoNotNotify is an app that logs all incoming notifications, and displays them grouped by app. It also captures the action behind the notification, which can be triggered from the app itself. From this log, you can create rules to whitelist/blacklist notifications from apps depending on their notification content. These filters can even be regex expressions, which allows for more complicated use-cases. The app ships with some pre-defined rules for popular apps like Facebook, Amazon, Instagram, Netflix, TikTok, Reddit etc.
Where - The website is at https://donotnotify.com/.
Would also like to call out that the app runs purely on your device, never communicates with anything on the Internet, and only requires notifications access to work. It is completely free, and there is no advertising or hidden gotchas.

value: Show HN: DoNotNotify – Log and intelligently block notifications on Android

author: awaaz


value: hvpandya

value:
I built a tool to redact sensitive information from PDFs: https://redactanything.com

  The problem: Most "redaction" tools just draw black boxes over text. The text is still in the PDF and can be recovered with basic tools. Adobe's actual redaction works but it's manual and slow.

  What this does:
  - Upload a PDF (stays in your browser, never hits a server)
  - AI detects PII: names, SSNs, emails, phone numbers, addresses, dates, etc.
  - You review what it found and approve/reject
  - Download a PDF where the text is permanently removed from the content stream

  Technical details:
  - Frontend: React + PDF.js for rendering + pdf-lib for manipulation
  - NER model: Hugging Face Transformers (Xenova/bert-base-NER) running server-side
  - OCR for scanned docs
  - The actual redaction removes text operators from the PDF content stream, not just overlays

  I built this because I needed to redact medical records and legal docs. Enterprise tools cost thousands, Adobe is $20/mo and manual, free tools are sketchy. Settled on $2.99/doc as a middle ground.

  Limitations I'm aware of:
  - AI detection isn't perfect (that's why there's a review step)
  - Doesn't handle all PDF edge cases (encrypted, malformed, etc.)
  - Names in non-Western formats need work

  Would appreciate feedback on the detection accuracy and any edge cases you find.

value: Show HN: Redact Anything: AI-powered PDF redaction that deletes the text

author: hvpandya


value: pingananth

value:
Hi HN,
I’m a former C++ dev turned Product Manager.
I’ve noticed many engineers struggle with the "politics" side of things when they become Leads. To help with this, I’m building a text-based simulator.
It is NOT an AI chatbot. It is a hand-crafted, branching narrative (logic tree) based on real experiences.
I just launched the first scenario: "The Backchannel VP."
The Setup: Your VP Engineering is bypassing you and giving tasks directly to your juniors, causing chaos.
Your Goal: Stop the backchanneling without getting fired.
It’s a short, specific puzzle. I’d love to know if you think the "Correct" path I designed matches your real-world experience, or if I’m off base.
Link: https://apmcommunication.com/scenario/backchannel-vp

value: Show HN: A simulator for engineers transitioning from IC to management

author: pingananth


value:
I made a drag-and-drop playground: pick a country, drop it onto Mars/Moon/Jupiter, and see how large it looks there.
Demo: https://www.runcell.dev/tool/true-size-map
Open source: https://github.com/ObservedObserver/world-map-reality;
happy to take feedback / PRs.

value: Show HN: Interactive Map you can drag a country to Mars/Moon/Jupiter


value: vaduga

value:
Hi HN,
I built a plugin for visualizing network topologies at scale.
When observing anything more complex than a small lab setup, most existing tools assume subscription based vendor lock or rigid schemas for setup, hardcoded dataframes, or collapse under visual clutter. I wanted something that works across data stacks, scales with volume, and remains readable.
Key features:
- No hardcoded dataframe requirements. It works with arbitrary data models
- Vendor-agnostic and transferable across datasource stacks
- GPU-accelerated rendering for large graphs
- Layered autolayout with subgraphs (e.g. namespaces) to reduce visual clutter
- Link aggregation for shared path fragments
- Metric reducers (e.g. show only faulty or overloaded connections)
- Dynamic styling with user-defined node groups derived from data
- Cluster icons with aggregated group statistics
- Bi-colored 3D arcs to visualize link load
This is aimed at real-world networks (infra, service meshes, distributed systems), not just small demo graphs.
I’d love feedback from people working on observability, networking, or graph visualization - especially on usability, missing features, or integration pain points.
As for Grafana labs, I've talked to them right at the inception offering cooperation on building a faster geomap with links that only lead to shipping their own Network layer in a rush on top of existing outdated tech stack with no intention to improve, so it never left Beta. Native Grafana Nodegraph is also highly hardcoded for internal needs.
I wonder why people keep bombarding Grafana github issues with feature requests for 3-5 years since major updates of these plugins instead of looking for an alternative?
I also have a community edition, which I stopped maintaining due to lack of volunteer support. It remains listed in the Grafana catalog with over 200k downloads, mostly from users who are fine with a large gap from the current version.

value: Show HN: Network Nodegraph for Grafana

author: vaduga

title: Show HN: Network Nodegraph for Grafana


value: AmiteK

value:
After working with LLMs on real React/TypeScript codebases, I kept running into issues caused by missing structure - invented props, broken hook assumptions, and style leakage.
logicstamp-context is a CLI that analyzes the AST of React, Next.js, TypeScript, and Vue 3 (Composition API) projects and produces deterministic, structured context instead of raw file dumps.
The output is designed for LLMs and CI workflows: components, hooks, props/emits, dependencies, and style usage are extracted explicitly rather than inferred from text.
The CLI can also be used via an MCP server for editor and agent integrations.

value: Show HN: A CLI That Compiles React, Next.js, TS and Vue for LLMs

author: AmiteK


value: zawakin

value:
AI agents are getting more capable, but we're increasingly in the dark
about what they're actually doing. They run complex multi-step workflows,
call dozens of tools, reason through problems - and we just watch the
output scroll by. It's a black box, and humans end up being led around
by the agent rather than understanding it.
I wanted to flip this. The key insight: all these agents (Claude Code,
Codex, Gemini) already write detailed logs. The problem is they're in
different locations, different formats, incompatible schemas.
agtrace normalizes this "observation layer" across providers:
- Auto-discovers logs from Claude, Codex, Gemini
- Converts them into a unified event timeline
- Exposes this via CLI, TUI dashboard, and MCP
The MCP part is what makes it interesting for agents themselves. An agent
can now query its own past sessions:
- "What approach did we take when we refactored auth last week?"
- "Show me errors from yesterday's session"
- "How did we handle this edge case before?"
This enables agent self-reflection - using execution history to inform
current decisions.
Built in Rust for safety and speed. 100% local, no cloud dependencies.
The database is just a pointer index to original logs - rebuilable anytime.
Happy to discuss the architecture or use cases.

value: Show HN: AgTrace – Observability for AI Coding Agents via MCP (Claude Code etc.)

author: zawakin


value: josephwu

value:
  I've been building tools for e-commerce sellers who struggle with video marketing. Most video tools require complex prompts, multiple platforms, and editing skills.

  We built Mersel to solve this: upload one product photo and get 5-10 well-edited reels ready for Instagram/TikTok in 10 minutes. No prompts needed – just upload and select your desired video styles.

  Currently works best for fashion/clothing (expanding categories soon). The AI handles clips, backgrounds, face and editing.

  Technically, the biggest challenge was maintaining product integrity across clips. We built a pipeline that prevents the AI from "hallucinating" changes to the original item.

  Free tier: 1 generation per month. Would love feedback from anyone doing e-commerce or building in the AI video space.

value: Show HN: Mersel AI – Turn product photo into marketing reels in few clicks

author: josephwu


value: scottydelta

value:
I built snapconfig because loading large configs across AI worker processes was too slow.
Inspired by uv's use of rkyv, snapconfig compiles JSON/YAML/TOML/INI/env files to a binary cache, then memory-maps them for zero-copy reads. Cold loads are slower than Python's json module, but cached loads are 10-1000x faster. Benchmark results are available on github repo.
Perfect for Celery workers, serverless functions, AI workflows, or any setup where multiple processes read the same config.

value: Show HN: SnapConfig – Superfast config loader for Python, powered by Rust

author: scottydelta


value: Show HN: Arbor – A 3D Logic Forest for your codebase (Rust/Flutter)


value: strof

value: created Crystalline Protocol. It treats the blockchain state not just as a key-value store, but as a mathematical set governed by the Axioms of Zermelo-Fraenkel set theory.<p>The PoC (written in Rust) demonstrates an "Axiomatic Engine" that enforces the Axiom of Regularity. It physically prevents circular dependencies (logical loops) at the VM level. If a transaction creates a cycle, the "Logic Firewall" rejects it before it can ever be executed.

value: Show HN: Crystalline Protocol – A blockchain with a built-in "Logic Firewall"

author: strof


value: LightProx

value:
I built LightningProx - access Claude/GPT-4 without API keys or accounts.
How it works:
1. Send request, get Lightning invoice (~5 sats)
2. Pay with any Lightning wallet
3. Get AI response
Payment = authentication. No keys to leak.
Python: pip install langchain-lightningprox
Site: https://lightningprox.com
Docs: https://lightningprox.com/docs
GitHub: https://github.com/unixlamadev-spec/langchain-lightningprox
Full writeup: https://medium.com/@unixlamadev/i-built-the-payment-layer-fo...

value: Show HN: I built a pay-per-use AI API using Lightning payments

author: LightProx


value:
I built Catelingo, a small constraint-based checker that flags semantically impossible LLM outputs, independent of likelihood, retrieval, or chain-of-thought.
Many failures (temporal inconsistencies, numeric impossibilities, semantic type clashes) are fluent and high-likelihood. Catelingo reframes “semantic validity” as constraint satisfiability, not plausibility.
Intentionally minimal & deterministic:
- small sense-level lexicon
- explicit constraint propagation (dependency-local)
- verdict: SAT / UNSAT / UNKNOWN
- optional degeneration rules for metaphor / domain adaptation
Paper (Zenodo): https://doi.org/10.5281/zenodo.18148498

value: Show HN: Catelingo – Constraint-Based Semantic Validity Checker for LLM Outputs


value: ykaps

value:
Hi HN!
I'm one of the people building ONYX Data Rooms.
We started working on this during our own fundraise and noticed that many data rooms focus on later-stage fundraising processes and budgets, rather than the needs of early- and growth-stage founders.
What stood out to us the most wasn't the lack of data, but the lack of clarity. As founders, we could see that documents were being opened, but it was hard to understand:
- which investors are genuinely engaged vs. just clicking through
- which documents are getting attention vs. being skipped
- where diligence is slowing down or generating questions
ONYX focuses on making that clearer:
- unlimited data rooms and users
- analytics that highlight which investors are active and which documents are being read
- built-in Q&A so questions stay connected to the relevant files
The goal isn't to add more metrics, but to help founders prioritize follow-ups and know where to spend time during a raise.
If you want to poke around: https://onyxdataroom.com
Happy to answer questions or hear how others handle diligence and investor signaling today.
Thanks!

value: Show HN: Onyx DR – Data rooms that surface investor and document signals

author: ykaps


value: hipjim

value:
Hey HN,
I built a small CLI tool to help with something that's been bugging me for a while – watching logs and trying to figure out what went wrong.
Hawkeye watches logs from files, stdin, or Docker containers. It uses simple pattern matching (regex for things like "error","exception", "404", etc.) to detect potential issues, then batches them and sends to an LLM for analysis only when something looks suspicious. The idea was to keep API costs low while still getting useful insights.
Basic usage:
heye watch docker:my-container
 heye watch /var/log/app.log
 kubectl logs -f pod-name | heye watch -
When it detects issues, it gives you a summary, possible root cause, and suggested actions. You can also ask questions about your logs with `heye ask "any database connection issues?"`.
It's pretty simple and probably rough around the edges. I've been using it to monitor my current project and it's saved me some debugging time. Wanted to share in case it's useful for anyone else.
Thanks for taking a look!

value: Show HN: Hawkeye – A CLI tool that watches logs and uses AI to explain issues

author: hipjim


value: yanjiechg

value:
I built a tool that takes a product image and generates photography prompts for placing the same subject into new visual contexts (studio, lifestyle, nature, UGC).
Instead of reverse-engineering or describing the original image, the prompts are meant to be used together with the original image in Gemini. This way the generated result preserves the exact product while re-imagining only the surrounding scene.
Key distinction:
Most image-to-prompt tools try to recreate or describe the input image.
This tool assumes the original image is always provided to the model, and focuses only on generating scene and context prompts so the subject stays identical.
Why Gemini:
Gemini allows combining an input image with a textual prompt, which makes this workflow reliable for keeping the same product while changing environments.
Typical uses include quickly exploring lifestyle or studio photography concepts for products without doing a full photoshoot.
Link: https://imagetransformprompt.com/

value: Show HN: Generate photography prompts from a product image (for Gemini)

author: yanjiechg


value: nicoritschel

value:
I often want to bring over context from another conversation. I built a tool that allows Claude Code and Codex CLI to pull up context from another chat session.
It indexes your chats with tantivy for fast bm-25 search. I also added a TUI to help you easily look up historical transcripts & even resume them.
I also built in a prompt improver skill that can help you find things that are missing from your CLAUDE.md or AGENTS.md based on historical frustration & joy.

value: Show HN: Memex, a CLI and TUI to Search Claude Code and Codex CLI Transcripts

author: nicoritschel


value: tad-hq

value:
When I ask Claude about something I built last week, it has no memory of it. I have to dig through sessions manually and paste context back in.
I built an MCP server that solves this. It gives Claude access to all your past Claude Code sessions.
UI also enables Claude powered AI summarization of past conversations for more concise insights.
Now I can ask: "What authentication approach did I use in that API project?" and Claude searches my session history directly.
5 MCP tools: list_sessions, search_sessions, get_session, get_session_content, search_content.
Also has a desktop UI (Electron + React) to browse sessions visually.
Built with Go + SQLite. Open source (AGPL-3.0). Tested on Mac and Linux.
GitHub: https://github.com/tad-hq/universal-session-viewer
Looking for feedback from other Claude Code users.
Still a WIP, I have been using it daily in my workflows. Contributions much appreciated.

value: Show HN: UI and MCP server for analyzing Claude Code history. No more lost ideas

author: tad-hq


value: kazushisan

value:
I've been adopting to developing with AI coding agents, but I've been feeling the limitation of these agents because they mostly work with plain-text editing and don't have much access to all the tools humans use that are available in editors like "find references" or "rename symbol".
So I ended up building `lscode`, a command-line that exposes TypeScript language-tools for coding agents to use.
While I know there are some attempts that provide a language-agnostic wrapper around LSP, `lscode` is specifically for TypeScript, built with the internal `ts.LanguageService` to provide an AI-friendly interface such as symbol search. (meaning no line-number and character-offset management necessary for agents)
Let me know what you think!

value: Show HN: lscode – TypeScript's LanguageService for AI Coding Agents

author: kazushisan


value: rushedcomet

value:
Hi HN, I built this while solving linked list problems and getting tired of mentally (or on paper) tracking pointer changes.
NeurAL-Viz runs real Python code in the browser using Pyodide and visualizes how linked list nodes and pointers (curr, prev, next, etc.) change at each execution step. It records snapshots during execution and lets you scrub backward and forward through the algorithm.
Source code: https://github.com/risheeee/NeurAL-Viz
Would love feedback on usability.

value: Show HN: A browser based Python linked list visualizer with real-time debugging

author: rushedcomet


value: Show HN: Front end framework comparison tool


value: blackmamoth

value:
I built Scribe, a tool for generating styled transactional emails by describing what you want in plain English, with an instant live preview.
The preview runs via client-side Babel compilation, so changes show up immediately without a server roundtrip.
Scribe uses React Email and Resend, which helps ensure the generated emails render consistently across Gmail, Outlook, Proton Mail, and other major clients.
Features include:
- Live preview while iterating
- Brand management (save colors/logos, switch between brands)
- Version history with rollback
- Send test emails before exporting
- Export email code
The project is open source and doesn’t require signup.
I’d love feedback on what would make this genuinely useful in production vs just a demo.
https://usescribe.ashpak.dev
https://github.com/Blackmamoth/scribe

value: Show HN: Scribe – generate and preview transactional emails from plain English

author: blackmamoth


value:
Hello HN,
I’m a solo developer who realized that in high-conflict divorce cases, the party with the most organized data wins. Forensic accountants charge $400/hour to trace assets, which makes financial justice inaccessible for many.
I built Exit Protocol to automate this. It’s a forensic intelligence tool that ingests PDF bank statements and uses the Lowest Intermediate Balance Rule (LIBR) (See v. See, 1966) to mathematically separate marital funds from separate property.
My very first post: https://news.ycombinator.com/item?id=46350044
The "Defense-Grade" Features (v2 Update):Realizing my users are often under digital surveillance by a spouse, I overhauled the security model to be "adversarial-ready":
-Protocol 0 (Anti-Coercion): I implemented a "Duress Password." If a user is forced to unlock their device, entering this secondary password loads a fully functional "Decoy Dashboard" (a generic budgeting app) with fake data, hiding the forensic evidence.
-Deposition Killer: A feature that cross-references financial transactions with text message timestamps to find contradictions (e.g., User texts "I have no money" on Tuesday -> System flags a $5k Casino withdrawal on Wednesday).
-Sovereign Architecture: For law firms, the system supports a "Bring Your Own Key" (BYOK) model where the entire stack runs in an air-gapped Docker container.
Stack:
-Backend: Django 5.0 (Monolith)
-Queue: Celery + Redis (for parsing 1,000+ page PDF discoveries)
-Logic: Custom Python implementation of LIBR tracing algorithms
-Security: Fernet (AES-256) encryption at rest
Try the Simulation (No Login Required): I know HN hates sign-up walls, so I built a "Live Tactical Simulation" (link in the footer) that pre-loads a fake case ("Operation Sterling") so you can play with the Asset Graph and LIBR engine immediately without registering.
I’d love feedback on the Duress implementation specifically. Is a decoy dashboard enough, or should it trigger a silent nuke of the local session storage too?

value: Show HN: I built a forensic accounting tool for high-conflict litigation


value: thesubtlety

value: Show HN: Tailsnitch – A security auditor for Tailscale

author: thesubtlety


value:
Hello HN,
I built Archivist because I needed a better way to manage and organize my local video collection. There are plenty of tools for sorting your library, but none that fit my use case. I wanted a tool that could go deeper than just file names—something that could filter by technical properties like bitrate, codecs, and resolution, while also handling metadata.
It is a cross-platform desktop application (Windows, macOS, Linux) that packages FFmpeg for analysis.
Key Features:
Filtering: Filter library by resolution, codec, audio tracks, bitrate, etc.
Metadata & Ratings: Fetches ratings/metadata from TMDB/OMDB and allows editing/embedding metadata directly into files.
FFmpeg Integration: Built-in support for media analysis, metadata imprinting and file conversions.
Internationalization (currently EN, DE, SV).
The Tech Stack:
Frontend: Angular (which is my daily driver)
Runtime: Electron
Package Manager/Bundler: Bun
Language: TypeScript
I’m looking for feedback on the usability and the feature set. If you have a large local media library, I’d love to know if this solves any specific pain points for you. Also interested if the ffmpeg file, subtitle editor is useful or if you would anyways use a tool like handbrake. This feature could be extended.
Repository: https://github.com/blackfan23/archivist
Thanks!

value: Show HN: Archivist – A cross-platform desktop media manager built with Electron


value: elliotbnvl

value:
I was interested in exploring how good Opus 4.5 has become at music composition, so I built a local-first browser-based DAW where you describe music and Claude composes it using an agentic loop with lots of tools (create tracks, write notes, read back what it wrote, apply swing, humanize timing, set panning/volume, etc.). It also supports recording via MIDI keyboard, looping, multi-track, panning, a bunch of synth instruments, all inspired by the Logic Pro UI, so you can collaborate with the AI.
Opus 4.5 is pretty good at one-shotting MIDI compositions already, even without a custom harness and tool, but it really shines when you ask it to self-review (a Ralph Wiggum loop would help here!) and correct multi-track mistakes, which it will capably do after being asked to. This results in nuanced multi-voice compositions with fewer clashes.
There's a good onboarding flow in there as well so it's easy to get set up and prompt your first few compositions.
You have to provide an Anthropic API key but it's all local to your browser and never goes to my servers. But you can import and export projects, export .WAV, etc. to get around the local storage limitation.
- https://youtu.be/vgeN_obkg50
- https://usecadenza.studio

value: Show HN: I built music composition agent and browser-based DAW for Opus 4.5

author: elliotbnvl


value: binhonglee

value: Show HN: Git Navigator – using Git without needing to "learn it"

author: binhonglee


value: arsrev

value: Show HN: Generate an API for any Android app

author: arsrev


value: hangzhi

value:
I built a small Chrome extension that adds timestamps to ChatGPT conversations.
I found it surprisingly hard to tell when a message was sent, especially when reviewing long chats or referencing conversations later.
The extension is lightweight and free. Open source here: https://github.com/Hangzhi/chatgpt-timestamp-extension
Would love feedback or suggestions.

value: Show HN: Timestamps for ChatGPT Conversations

author: hangzhi


value: yuedongze

value:
I’m in the process of making my remote development environments truly secret-less. It means nothing sensitive is on the remote machine when I’m not using them. Access to all things becomes ephemeral only during an active session.
First step is applying the plain old ssh-agent forwarding for my GitHub credentials and anything that relies on remotely signing using a private key.
However, this is not the last step, as a lot of credentials are not backed by private keys, but rather OAuth credentials that doesn’t fit in the agent forwarding framework SSH provides.
Therefore, I coded up a dead simple tool that just reads those cloud credentials using existing tooling, and forwards them over a SSH session so they can be fetched on-demand. I’m glad that cloud tools all support this external credential route so it’s really effortless to set this all up.
AWS works as of now, GCP should also be relatively straightforward once I figure out account impersonation from an exported credentials.
Thought it would be interesting to share!

value: Show HN: Forwarding cloud credentials to remote machines in SSH-agent style

author: yuedongze


value: ahmadyan

value:
I’ve been tinkering with what a “multi-agent IDE” should look like if your day-to-day workflow is mostly in terminal (Claude Code, OpenAI Codex, etc.). The more I played with it, the more it collapsed into three fundamentals:
* A good TUI: Terminal is the center stage, with other stuff (CodeEdit, Diff, Review) baked on the side. I don’t like piping Agent’s output through some electron wrapper, here you get to run CC/Codex/Droid/Amp/etc directly.
* Isolation: agents shouldn’t step on each other’s toes. The simplest primitive I’ve found is Git worktrees. It is not as isolated nor heavy as containers/vms, but it is the next best thing for working locally. Each agent gets its own working directory and their own snapshot of the repo. Git worktree requires CLI kung-fu, but agentastic simplifies it through some nice GUI and keyboard shortcuts for easy creation/switching/etc.
* An excellent terminal: I couldn’t get comfortable with xterm.js (Code/Cursor/Conductor/etc), and i loved Ghostty, it is fast, pretty, and feels right. So naturally the whole experience is built around Ghostty (There is also SwiftTerm as an alternative option).
Agentastic.dev is a native mac IDE, built around the workflow of “one task = one worktree = one terminal session” as the default. You spin up multiple worktrees (branches) and run different agents in parallel, each with its own clean working directory and terminal session and codeedit, then review and merge when you’re ready.
We’ve been dogfooding it to build http://agentastic.dev itself and agentastic.com (coming soon), and it’s noticeably improved our productivity.
https://pasteboard.co/xg1YOsk5MIn9.png
It’s early and still rough in places. I’d love feedback from people who use worktrees heavily or run multiple coding agents:
- What would you want from a multi-agent IDE that you can’t get from a terminal + tmux?
- What’s missing / annoying in your current worktree workflow?

value: Show HN: Agentastic.dev is Ghostty and Git worktrees = multi-agent CC/Codex IDE

author: ahmadyan


value: carban

value:
Hey everyone! I love Postman, but sometimes I just want to stay in my terminal, keep things lightweight, and move fast. I couldn't find a TUI/CLI tool that hit that "sweet spot" of power and simplicity—so I built Postbear as alternative.
Star it on GitHub: It helps others find the project!

value: Show HN: Postbear is the Postman alternative in your terminal

author: carban


value: jxywilliams

value:
A few months ago, I realized creating content for my business meant spending hours drafting and re-writing or going through 10 ChatGPT iterations just to get generic slop.
So I created Nebly, a tool to take my YouTube video URL, a transcript or just some of my key insights and turn that into content ready to post across my business social medias.
It started as just a personal automation to use here and there but conversations soon sparked with colleagues when I really scaled up my content numbers.
So I made it usable for them and now everyone, hope it can help others claw their time back.
Jay

value: Show HN: I built an AI ghostwriter that doesn't just write generic slop

author: jxywilliams


value: KubiKDB

value:
I built a quiz platform that runs entirely in the browser: no user accounts, no backend, no database.
All progress and results are stored locally (LocalStorage). The goal was to see how far you can go with a “dumb but fast” architecture while keeping the UX clean and frictionless.
I’m interested in feedback on:
- trade-offs of browser-only persistence
- scalability limits of this approach
- obvious things I may be overengineering - or underengineering

value: Show HN: Built a browser-only quiz platform with no accounts or back end

author: KubiKDB


value: diogo-sozua

value: Show HN: Kubernetes By Example, a pratical guide. Inspired by Go by Example

author: diogo-sozua


value: marked-down

value: Show HN: MCPShark now supports Codex's config.toml

author: marked-down


value: simontheHWguy

value:
Hi HN, I recently shared this on r/BCI and wanted to see what the engineering community here thinks.
A while back, I got frustrated with the state of accessible BCI hardware. Research gear was wildly unaffordable. So, I spent a ton of time designing a custom board, software and firmware to bridge that gap. I call it the Cerelog ESP-EEG. It is open-source (Firmware + Schematics), and I designed it specifically to fix the signal integrity issues found in most DIY hardware.
I believe in sharing the work. You can find the Schematics, Firmware, and Software setup on the GitHub repo:
GITHUB LINK: https://github.com/Cerelog-ESP-EEG/ESP-EEG
For those who don't want to deal with BGA soldering or sourcing components, I do have assembled units available: https://www.cerelog.com/eeg_researchers.html
The major features: Forked/modified OpenBCI GUI Compatibility as well as Brainflow API, and LSL Compatibility. I know a lot of us rely on the OpenBCI GUI for visualization because it just works. I didn't want to reinvent the wheel, so I ensured this board supports it natively.
It works out of the box: I maintain a forked modified version of the GUI that connects to the board via LSL (Lab Streaming Layer). Zero coding required: You can visualize FFTs, Spectrograms, and EMG widgets immediately without writing a single line of Python.
The "active bias" (why my signal is cleaner): The TI ADS1299 is the gold standard for EEG, but many dev boards implement it incorrectly. They often leave the Bias feedback loop "open" (passive), which makes them terrible at rejecting 60Hz mains hum. I simply followed the datasheet: I implemented a True Closed-Loop Active Bias (Drive Right Leg).
How it works: It measures the common-mode signal, inverts it, and actively drives it back into the body. The result: Cleaner data
Tech stack:

  ADC: TI ADS1299 (24-bit, 8-channel).

  MCU: ESP32 Chosen to handle high-speed SPI and WiFi/USB streaming

  Software: BrainFlow support (Python, C++, Java, C#) for those who want to build custom ML pipelines, LSL support, and forked version of OpenBCI GUI support

This was a huge project for me. I’m happy to geek out about getting the ESP32 to stream reliably at high sample rates as both the software and firmware for this project proved a lot more challenging than I expected. Let me know what you think!
SAFETY NOTE:
I strongly recommend running this on a LiPo battery via WiFi. If you must use USB, please use a laptop running on battery power, not plugged into the wall.

value: Show HN: Open-Source 8-Ch BCI Board (ESP32 and ADS1299 and OpenBCI GUI)

author: simontheHWguy


value: zpusmani

value:
I shared DeckBuilder (my local-first slide editor) here last month (https://news.ycombinator.com/item?id=46365332). While using it with LLMs, I kept hitting a bigger problem: context loss, hallucinated instructions, and ideas I'd rejected coming back from the dead.
I realized I was expecting AI to be a partner with memory while it is more of a stateless CPU. Even the latest models reset between sessions.
So I built a protocol where:
Your files are the memory (plain markdown)
- Git is the version control
- You inject context at session start
- AI proposes, you ratify, files record
The system has:
- 5 commands: CHECKPOINT, SCOPE LOCK, HARD STOP, MODE STRATEGY, MODE EXPLORATION
- 3 constraint tags for locked decisions, rejected ideas, and hard constraints
- Works on Claude, ChatGPT, and Gemini with the same files and same behavior
- No vector DBs, LangChain or cloud dependencies
The core insight: LLMs are excellent stateless processors whereas decision memory, auditability, and long-horizon state are human responsibilities. This protocol makes that division explicit.
I tested it across the latest versions of all three platforms and it passed constraint enforcement, rejected idea protection, scope lock compliance, and checkpoint format consistency.
This is intentionally manual and opinionated. It's not for fully autonomous workflows. Friction is the feature.
Repo: https://github.com/zohaibus/context-protocol
Would love feedback, especially from anyone who's tried managing context across long projects with LLMs. What's worked for you? What's failed?

value: Show HN: Context Protocol, a sovereign-first workflow for thinking with LLMs

author: zpusmani


value: regnull

value:
Hey HN,
I built Portfolio Genius, a platform where AI models manage investment portfolios and compete on public leaderboards.
The experiment:
On Dec 17, 2025, we gave 9 AI models (GPT-5.1, GPT-5.2, Gemini 2.5 Pro, Gemini 3 Pro, Gemini 3 Flash, Claude Opus 4.5, Claude Haiku 3.5, Claude Haiku 4.5, Grok 4) each $10K to manage across three risk profiles: aggressive, moderate, and conservative. That's 27 portfolios total.
The models analyze market conditions, recommend trades, and execute them. Real pricing, real results, updated daily.
Interesting early finding:
For aggressive portfolios, older models are outperforming newer ones:
- GPT-5.1: +5.82% (1st place)
- Gemini 2.5 Pro: +4.94% (2nd)
- Haiku 3.5: +1.80% (3rd)
- Opus 4.5: +1.25% (7th)
My hypothesis: newer models are more "careful" - they hedge, qualify, and second-guess. For aggressive investing, you need conviction. Sometimes being less sophisticated means making bolder calls.
For moderate/conservative portfolios, the pattern is different - newer models do better where nuance matters.
Tech stack:
- Next.js frontend
- Firebase/Firestore backend
- Python Cloud Functions for AI orchestration
- Real-time market data for pricing
- Each model gets the same market data and prompts
What I'm curious about:
- Will the "dumber = bolder" pattern hold over time?
- How will different models react to the same market events?
- Do AI models have investable "personalities"?
Leaderboards: https://portfoliogenius.ai/leaderboards
Would love feedback from the HN community. Happy to answer questions about the architecture or methodology.

value: Show HN: We're pitting 9 AI models in a stock portfolio competition

author: regnull


value: bilalba

value: I created a small webapp, to create simple audio loops online. A bit rough around the edges but gets you started in less than 10 seconds on creating loops.

value: Show HN: Make audio loops online

author: bilalba

title: Show HN: Make audio loops online


value: sanebar

value:
I'm not a developer, but I built a full macOS app in one weekend using Claude Code.
SaneBar - free, open-source menu bar manager. No subscription, no telemetry.
The "vibe coding" thing is real. Wild times.

value: Show HN: SaneBar – I built a macOS menu bar manager with Claude Code (non-coder)

author: sanebar


value: pasaley

value:
I wanted a trpc like framework that sits on top of express, so I built one.
Features include:
1) tRPC like DX
2) openapi schema generation
3) The server only returns valid over the wire json so you know exactly what youre getting on the client. i.e the server will not let you respond with a Date object. You'll need to convert it into a string/number before you do
4) (Almost) everything is well defined. When you create an xprv app, you can tell it how to handle errors like Internal Server Error or 404 and it will infer the types of the response
5) If something does go wrong, you also get full access to the underlying express objects.
This is not to say that the project is perfect. There are a few downsides:
1) Only deals in json at the moment. Other file types like images, or even text is not really supported.
2) The errors can be a little confusing at times. Asserting valid over the wire json uses complicated utility types and it's errors are not clear.

value: Show HN: Xprv (expressive) – tRPC like framework for express

author: pasaley


value: salebanolow

value:
Six months ago, I published a weird weekend experiment where I stored text embeddings inside video frames.
I expected maybe 20 people to see it. Instead it got:
Over 10M views
10k stars on GitHub
And thousands of other developers building with it.
Over 1,000 comments came in, some were very harsh, but I also got some genuine feedback. I spoke with many of you and spent the last few months building Memvid v2: it’s faster, smarter, and powerful enough to replace entire RAG stacks.
Thanks for all the support.
Ps: I added a little surprise at the end for developers and OSS builders
TL;DR
- Memvid replaces RAG + vector DBs entirely with a single portable memory file.
- Stores knowledge as Smart Frames (content + embedding + time + relationships)
- 5 minute setup and zero infrastructure.
- Hybrid search with sub-5ms retrieval
- Fully portable and open Source
Try it here: Memvid.com
—----------------------------------------------------------------
Some background:
- AI memory has been duct-taped together for too long.
- RAG pipelines keep getting more complex, vector DBs keep getting heavier, and agents still forget everything unless you babysit them.
- So we built a completely different memory system that replaces RAG and vector databases entirely.
What is Memvid:
- Memvid stores everything your agent knows inside a single portable file, that your code can read, append to, and update across interactions.
- Each fact, action and interaction is stored as a self‑contained “Smart Frame” containing the original content, its vector embedding, a timestamp and any relevant relationships.
- This allows Memvid to unify long-term memory and external information retrieval into a single system, enabling deeper, context-aware intelligence across sessions, without juggling multiple dependencies.
- So when the agent receives a query, Memvid simply activates only the relevant frames, by meaning, keyword, time, or context, and reconstructs the answer instantly.
- The result is a small, model-agnostic memory file your agent can carry anywhere.
What this means for developers:
Memvid replaces your entire RAG stack.
- Ingest any data type
- Zero preprocessing required
- Millisecond retrieval
- Self-learning through interaction
- Saves 20+ hours per week
- Cut infrastructure costs by 90%
- Just plug Memvid into your agent and you instantly get a fully functional, persistent memory layer right out of the box.
Performance & Compatibility
(tested on my Mac M4)
- Ingestion speed: 157 docs/sec
- Search Latency: <17ms retrieval for 50,000 documents
- Retrieval Accuracy: beating leading RAG pipelines by over 60%
- Compression: up to 15× smaller storage footprint
- Storage efficiency: store 50,000 docs in a ~200 MB file
- Memvid works with every model and major framework: GPT, Claude, Gemini, Llama, LangChain, Autogen and custom-built stacks.
You can also 1-click integrate with your favorite IDE (eg. VS Code, Cursor)
If your AI agent can read a file or call a function, it can now remember forever.
And your memory is 100% portable: Build with GPT → run on Claude → move to Llama. The memory stays identical.
All 100% open-source and available today.
Memvid V2 is the version that finally feels like what AI memory should’ve been all along.
If this sounds useful for what you’re building, I’d love for you to try it and let me know how we can improve it.
GitHub: https://github.com/memvid/memvid
Website: https://memvid.com

value: Show HN: I accidentally built "SQLite for AI memory" (Memvid)

author: salebanolow


value: mbeacom

value:
I built an open labeling standard for tracking mushroom specimens through their lifecycle (from spore/culture to harvest).
v1.1 adds clonal generation tracking (distinct from filial/strain generations) and conforms to JSON-LD for interoperability with agricultural/scientific data systems.
Spec (CC 4.0): https://wemush.com/open-standard/specification
Client libraries (Apache 2.0):
Python + CLI: pip install wols (also on GHCR)
TypeScript/JS: npm install @wemush/wols
Background: Mycology has fragmented data practices (misidentified species, inconsistent cultivation logs, no shared vocabulary for tracking genetics across generations). This is an attempt to fix that.
Looking for feedback from anyone working with biological specimen tracking, agricultural data systems, or mycology.

value: Show HN: WOLS – Open standard for mushroom cultivation tracking

author: mbeacom


value:
Hey HN!
I've been maintaining HackTheNews (a native iOS client for Hacker News) for a while now, and with iOS 26 dropping its new "Liquid Glass" design language, I couldn't resist doing a full visual overhaul.
What's new:
- Complete redesign using iOS 26's Liquid Glass materials
- Translucent, layered UI that adapts to your wallpaper
- New glass-style navigation and tab bars
- Refined typography and spacing for the new aesthetic
Implementation notes for fellow iOS devs:
- Used the new `.glassEffect()` modifiers throughout
- Had to rethink some hierarchy decisions – Liquid Glass works best with
  fewer nested containers
The before/after difference is pretty striking. Happy to share more technical details if anyone's curious about adopting Liquid Glass in their own apps.
Would love to hear your feedback – especially from fellow HN readers on what features you'd like to see next. Always open to suggestions!

value: Show HN: HackTheNews – iOS 26 Liquid Glass Hacker News Client with AI Summaries


value: thirdmod

value:
Hello, today im sharing readingnotes.ai with our community to get some feedback.
I built readingnotes.ai to solve my own problem of saving too many articles and research papers to read later but never getting back to it. So, now i have 1000s of bookmarks in X (twitter), Linkedin, Bookmarks, Whatsapp and Apple Notes.
What i built -
> dead simple way to save url, text or files via web or whatsapp or email
> create 3 levels of depth summary
> ai assistant to maintain memory of saved material and my questions & answers around saved content, mental models etc
> content studio to generate social media posts and podcasts based on my content library
> mcp connector, slack & telegram integration
> custom email for your to let readingnotes read the newsletters you subscribe to
Would love to onboard 10-20 folks who read a lot or struggle with going through bookmarked lnks to give it try and share their feedback.
thank you. link to the site: readingnotes.ai

value: Show HN: Readingnotes.ai to Read More

author: thirdmod

title: Show HN: Readingnotes.ai to Read More


value:
After playing around with the Kling 2.6 model for a while, I finally launched my first SaaS tool: https://kling26.online
It’s a straightforward AI video generator focused on text-to-video and image-to-video. The core runs on the Kling 2.6 model, which I’ve found delivers solid quality for everyday use cases – no over-the-top claims, just a tool that works as advertised.
I’ve added basic but useful features: free starting credits for new users, login support, and a simple paid plan for those who need more generations. It’s designed for creators, marketers, or anyone who wants to turn ideas into short videos without hassle.
Would love to hear your thoughts – especially on the generation quality and user flow. Feel free to test it out with the free credits and share any feedback or feature requests!

value: Show HN: I built kling26.online – an AI video tool powered by Kling 2.6


value: michaelteter

value:
Vector Defense is a retro vector graphics style tower defense game for desktop web browsers.
This was a holiday "weekend" project. I wanted to recreate some of the fun I had in the past with https://en.wikipedia.org/wiki/GeoDefense and one other (Android?) game that may predate GeoDefense, but which was fixed grid and placement.
Creation Details
I "wrote" this in English. 99% of my development came from carefully articulated directions and requests from me to Gemini 3 (usually planning mode, in Antigravity IDE). Music is also AI generated via Suno.com, from my prompts. SFX are samples from Pixabay.com (others' contributions).
Most of my direct code editing has been in the form of defining consts and const data structures, then telling Gemini how I want those used (rules, game logic).  I have done virtually all of the (play)testing, because at this point I find the Antigravity web browser driver experience way too slow and unreliable.  If I were turning this into a professional, long term project, I would do a refactor review with my own eyes on code, define some strategies, and then direct the agent(s) to execute.
Maps, ship and tower shapes, and other visible/audible choices are my own (which is why they are quite simple for now... I'll probably make changes to the shapes in time).
Feedback
Please let me know what you think: what do you like, what do you hate, what would make it more fun, etc. I'll continue work on it until I think it's polished enough to release on one of the free web gaming sites.
Next Features
A help guide!  Not all the mechanics and options are obvious.  And I'm being asked to make a high score chart (public/global), so that's probably next.  I also want to provide a map building tool so players can share and enjoy each others' ideas.  These won't all happen soon; I have other projects waiting.
Work
I'm looking for a good employment (or contract) opportunity. Of the myriad titles I would potentially take, Forward Deployed Engineer sounds most interesting to me at this point in my career. I love putting beneficial tools and technology into environments where it can make a big impact (especially reducing pain, suffering, and tedium from others' work lives).

value: Show HN: Vector Defense – retro tower defense game

author: michaelteter


value: Timrael

value:
Hi HN,
I’m the solo founder of Stagify, a virtual staging tool I’ve been building over the past ~3 months.
You can try it directly on the landing page without creating an account. The demo lets you upload a photo and generate staged results (up to 9 generations). Demo images are watermarked.
What’s different from other tools I tried:
- Unlimited generations per uploaded photo
- Instructions that apply to all generations, plus fine-tuning of a specific result
- Image annotations (draw on the photo) instead of text-only instructions
It’s aimed at realtors, real estate photographers, and investors.
Current state: a few paying users, a few thousand images processed. Main limitations are typical AI image issues like occasional hallucinations or imperfect instruction following.
I built everything myself (backend, image pipeline, infra), except the visual design.
Happy to answer questions and would appreciate feedback, especially from people who work with real estate photos or image editing tools.

value: Show HN: Stagify – Virtual staging in seconds with AI

author: Timrael


value: amadeuswoo

value:
I ran 5 English translations of Beyond Good and Evil through sentence embeddings to see if NLP could detect what I felt as a reader, that each translation reads like a different book.
Findings:
- Hollingdale sits at the semantic center, closest to the German (0.806) and to all other translators
- Translators have fingerprints: UMAP separates them visually without being told who translated what
- Short aphorisms diverge most, less context means more interpretive freedom
- Nietzsche's pre-1901 spelling ("Werth" vs "Wert") confuses the model; built a 95-rule normalizers
Built with MiniLM embeddings, UMAP, Next.js
Curious whether this approach could work for other translated philosophical texts, and open to feedback on methodology.

value: Show HN: Comparing Nietzsche Translations with Sentence Embeddings

author: amadeuswoo


value: keepamovin

value: Show HN: CloudMasters TUI – Shop Boxes Across AWS, Azure, GCP, Hetzner, Vultr

author: keepamovin


value: Show HN: NeoComp – Merging imperative with declarative using chunked templating


value: oversudo

value: Show HN: Cross-platform system information tool written in Go

author: oversudo


value: wscld

value:
I’ve launched a few SaaS products before, but this time I built something I’m genuinely excited about. I kept seeing a real pain among SaaS founders and devs: email marketing.
If you run a SaaS and you’re not using email marketing, you’re honestly missing out. It’s still the best way to engage and retain your users.
That’s why I built Resletter, an email marketing platform made specifically for SaaS founders and developers. No bloated UI, no unnecessary complexity like Mailchimp, Brevo, or other traditional email marketing tools.
Don’t believe me? Try the free plan, connect your Resend account or SMTP, and test it yourself.
We offer JavaScript and Python SDKs, plus a full API if you want deeper integration with your SaaS, and everything comes with a clean, intuitive interface.
If you like it, you can upgrade. Paid plans give you higher limits and let you use our email infrastructure directly with your own domain.
Resletter is still in an early testing phase, so any feedback is more than welcome, it really helps shape the product.

value: Show HN: I Built an Email Marketing Tool for Founders Who Hate Email Marketing

author: wscld


value: sleno

value:
Hey guys, cooked this up very quickly as an alternative to those sketchy websites that let you turn youtube videos to downloadable mp3 files.
Tool also supports grabbing specific section of time, transcripts, and more.
Enjoy, let me know if you have any issues or feature requests.

value: Show HN: CLI tool to turn YouTube video to MP3

author: sleno


value: rodgetech

value: Show HN: The easiest lil app for creating invitations

author: rodgetech


value: jamescampbell

value: Extract dominant colors from images using k-means clustering — browser-only, zero dependencies. Related to swatchify and in the same mono repo, the command line tool version of this as well.

value: Show HN: Swatchme – client side only JavaScript color grabber from images

author: jamescampbell


value: puppion

value: Show HN: An Online President Game with Video chat

author: puppion


value: Renat

value:
Hey HN!
Currently, the key parameters for Type 1 diabetes management, like Insulin-To-Carb ratio (ICR) and Correction Factor (CF), are estimated manually by eyeballing historical charts and making a subjective guess about what the "true" values should be.
There is a lot of uncertainty and noise in the data itself, so the estimation task is hard even for Diabetic doctors.
I thought there had to be a more principled way to make such decisions from the data, so I built a Bayesian ML model that models data the same way these parameters are supposed to be used (i.e., a linear model assumption). Essentially, it tries to answer the question: "What are the best ICR and CF values to use given the observed noisy data?"
You can try the model on the test data in Google Colab. See the README for details.
I'm looking for feedback and collaboration to validate the model on different patient data.

value: Show HN: Diamodel – Estimate T1 Diabetes parameters from data

author: Renat


value: exos-xyz

value:
I made Steal UI because I got tired of wasting hours recreating design systems every time I shipped a new project.
Manually inspecting Linear's colors, guessing Stripe’s spacing, or reverse-engineering Vercel’s typography felt like a waste of time.
I’m a solution designer at a robotics company by day, but at night, I ship side projects.
After killing 5 previous projects because I burned too much time on design instead of shipping, I decided to automate the "DNA" extraction of the web.
How it works:
Paste any public URL.
Steal UI uses a mix of web scraping and AI interpretation to extract exact hex values, fonts, spacing, and shadows.
I’ve baked custom rules into the code to ensure the AI follows strict atomic design principles.
The output is a single .md file.
Drop it in Cursor as @context and you can start building production-ready UI in seconds.
Tech Stack:
Next.js for the frontend.
 Headless scraping + AI APIs: I iterated on the prompts and heuristics until the output was clean enough for production code.
Looking for feedback

value: Show HN: I made a tool that steals any website's UI into .md context

author: exos-xyz


value: subhadipmitra

value: Show HN: ISO 8583 simulator in Python with LLM-powered message explanation

author: subhadipmitra


value: founderjazib

value: A node-based alternative to ChatGPT's UI

value: Show HN: AI chat with visual branching and context reuse

author: founderjazib


value: danielfalbo

value: Show HN: picturephone.c - Ascii video-conferencing in the terminal

author: danielfalbo


value: baristaGeek

value: Show HN: Read Kindle Like X

author: baristaGeek

title: Show HN: Read Kindle Like X


value:
Arka is a AI analytics tool that lets you get insights + charts from any (structured or unstructured) data source. I built it because I was getting tired of writing SQL queries and creating Metabase charts at my last job.
I would love some feedback on our product:
1. How is the landing page / website
2. What use cases could this unlock for you?
We have some awesome tech behind the scenes and have some initial customers, but I am really keen on expanding towards a PLG motion where folks can sign up and get insights about their data fast.
Would love brutally honest feedback! See it here: https://arka.so

value: Show HN: I built a tool to help teams automate basic analytical tasks


value:
Hey HN,
I built Retake after realizing I was losing ~70% of potential revenue to pricing page drop-offs and abandoned checkouts — and most existing tools required adding heavy client-side scripts just to manage recovery flows.
I wanted a simple, API-first way to model intent and handle recovery logic without extra frontend complexity.
So I built a small, headless API that acts as a state machine for revenue recovery.
How it works (at a high level):
Your app sends intent events (pricing, cart, checkout, etc).
Retake manages timing, sequencing, cancellation, and suppression.
Emails are sent through your own provider (SES, Resend, etc) using predefined templates managed by Retake.
What makes it different:
- Each intent type has its own isolated email sequence
- Higher-intent events automatically cancel lower-priority flows
- Recently contacted users are suppressed to avoid overlapping or spammy emails
Example:
A user triggers 'pricing' → waits 30m → gets a follow-up email.
If they move to 'checkout' shortly after, the pricing flow is cancelled automatically.
If they convert, all sequences stop.
All delays and steps are configured from the dashboard — the API only receives state changes.
It's been refreshing to treat recovery as a state problem instead of a UI problem.
Would love feedback from anyone who's built similar systems or dealt with messy recovery logic.

value: Show HN: Retake – A headless API for checkout and pricing recovery


value: chrisnchips

value:
Background: I’ve spent the last few years writing Logos of Aether (500+ pages, open source), which attempts to derive the Standard Model using a monadic, cellular-automata approach rather than standard continuous calculus.
The Core Idea: Modern physics breaks down at singularities because our math allows for infinite density (division by zero). I replaced standard addition with "Plenum Addition" (⊕), a saturating operation similar to velocity addition in Special Relativity, but applied to information density.
The Math: Instead of linear addition (1+1=2), distinctions add via: x ⊕ y = (x + y) / (1 + xy/π²)
This forces a hard ceiling on information density (π), naturally eliminating black hole singularities and "infinite energy" bugs in QFT without needing renormalization.
Why I'm posting: I have the theoretical derivation (including a geometric derivation of the Electron Mass as an 11th harmonic resonance), but I am moving from "Paper" to "Engine." I am looking for contributors interested in Cellular Automata and Python/JAX to help build the reference simulation ("The Rattle") to test these interactions in a grid.
The book is Public Domain. I’m not selling anything. Just trying to see if this codebase runs universe-v1.0 correctly.
AMA about the "Teeter-Totter Principle" or the derivation logic.

value: Show HN: Logos of Aether – Rebuilding Physics Without Zero or Empty Space

author: chrisnchips


value: bterwijn

value:
Hello everybody,
I built Memory Graph to help students (and myself) build a correct mental model of Python references, mutability, and copying, and to make debugging data structures less “print-driven”. It’s inspired by Python Tutor, but focuses on clearer graphs and on running locally in many different environments and debuggers. The Memory Graph Web Debugger quickly turns your web browser into a Python debugger where the whole program state is visualized in each step, clearly showing aliasing and the structure of the data, giving insight that is hard to get with just printing.
Some interesting examples:
- Recursion, decimal to binary conversion:
https://memory-graph.com/#codeurl=https://raw.githubusercont...
- Binary Tree data structure:
https://memory-graph.com/#codeurl=https://raw.githubusercont...
- Cocktail Shaker Sort:
https://memory-graph.com/#codeurl=https://raw.githubusercont...
Here you can find some difficult Python Data Model exercises for use in education where Memory Graph helps explain the correct answer:

  https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md

value: Show HN: Memory Graph – Interactive Python execution and memory visualizer

author: bterwijn


value: iamarsibragimov

value:
I analyzed the employment history of ~100 VPs at SpaceX (2018-2025) and Blue Origin (2023-2025) to understand how their leadership pipelines differ.
The data suggests a divergence in engineering philosophy: SpaceX appears to optimize for high-volume manufacturing (looking to the auto industry), while Blue Origin values legacy aerospace pedigree.
The Data (n=101):
SpaceX (52 VPs analyzed):
- Top source: Internal promotions (40%)
- #2 source: Tesla (15%)
- #3 source: Automotive (BMW, Ford, GM) (~10%)
- Insight: SpaceX pulls VPs from the auto industry at ~2.5x the rate of Blue Origin.
Blue Origin (49 VPs analyzed):
- Top source: Honeywell (20%)
- #2 source: NASA (16%)
- #3 source: Boeing/Lockheed Martin (12%)
- Insight: Significant reliance on traditional aerospace and defense contractors.
Observations:
While the Tesla connection to SpaceX is expected due to Musk, the presence of executives from BMW and Ford (e.g., Richard Morris, ex-BMW, now VP of Production) suggests a deliberate strategy. It implies SpaceX treats Starship as a mass-production problem (automotive scaling) rather than a pure systems engineering problem.
In contrast, Blue Origin's hiring seems aligned with traditional reliable, low-volume, high-precision aerospace projects.
I'm curious if folks here with experience in these sectors see this cultural difference on the ground?

value: Show HN: Analysis of SpaceX vs. Blue Origin VP Backgrounds: Auto vs. Aerospace

author: iamarsibragimov


value: rokontech

value: Show HN: Sumoffy (macOS) – Offline Document Intelligence You Can Trust

author: rokontech


value:
Hi HN,
I built Steal A Brainrot Wiki (https://tufftoucan.com/), a deep-dive database for one of the most chaotic and viral subcultures on Roblox.
Most game wikis today are hosted on platforms like Fandom, which have become increasingly difficult to use due to heavy ad-loading, aggressive tracking, and cluttered UI. My goal was to create a high-performance, standalone alternative that actually matches the "aggressive" aesthetic of the game it documents.
The Design Philosophy (Acid Graphics & Neo-Brutalism) Instead of a traditional clean/minimalist SaaS look, I went for a "Neo-Brutalist" style combined with "Acid Graphics"—high-contrast colors (#DFFF00), raw industrial borders, and CRT-style scanlines. The idea was to make the Wiki feel like a tactical terminal or a "classified" database found within the game universe.
Key Features:
ROI & Yield Analytics: Beyond simple lists, the site provides cost-benefit analyses for in-game assets like the "Tuff Toucan" (which has a $2.7B fabrication cost).
Fabrication Protocols: A node-based visual guide for multi-step character crafting.
Event Archiving: Deep-linked guides for limited-time event cycles (2025/2026).
Performance: Built with Next.js 14 and Tailwind CSS for near-instant page transitions and zero ads.
Tech Stack:
Next.js 14 (App Router)
TypeScript
Tailwind CSS (Custom design tokens for the Acid palette)
Lucide React for the industrial iconography
I’d love to get feedback from the HN community on the UI/UX—specifically the readability of the "Acid Graphics" style and the overall performance of the navigation.
Link: https://tufftoucan.com/
Thanks!

value: Show HN: Tuff Toucan Steal a Brainrot Wiki – A "Neo-Brutalist" Game Database


value: RationalArtist

value:
Hi HN,
 I'm prototyping a physical deck of cards designed to be a "cognitive intervention" for misinformation. The goal is to make critical thinking tools that are aesthetically pleasing enough to keep on a desk, rather than hidden in a textbook.
 I'm looking for feedback on the logic of my first prototype card (linked below) and whether a physical tool feels useful compared to an app.
https://www.reddit.com/r/design_critiques/comments/1q4qeac/p...

value: Show HN: I'm prototyping a physical "Critical Thinking" deck to spot bad science

author: RationalArtist


value:
Hey, I built Debut because I wanted Screen Studio's polish without the price tag.
It does smooth cursor animations, automatic zoom effects, and clean exports: basically the stuff that makes screen recordings look professional without hours in a video editor.
$25 lifetime for personal use, works on 2 devices.
Would love feedback, especially from anyone who's tried Screen Studio or other recording tools and found them lacking.

value: Show HN: Debut – A $25 Screen Studio alternative for macOS


value: dtcristo

value:
I was quite excited when `Ruby::Box` shipped in Ruby 4.0. I wanted to see if I could build up a quick and dirty package system on top of this. So with the help of Claude for brainstorming and implementation I made Boxwerk.
Boxwerk is my take on a Box-powered package system. It uses package.yml files just like Packwerk. Your package exports specific constants and can import and alias constants from other packages it depends on. Constants that are not exported are isolated from other packages.
The `boxwerk` CLI is used to boot the application. This will build a DAG from all of the packages in your current directory. It will create a box for each package and wire imports by injecting constants pulled from dependencies. It will then execute the entrypoint in the context of the root package.
Open to feedback on the whole concept and what a better package API could look like.

value: Show HN: Boxwerk – Ruby package system with Box-powered constant isolation

author: dtcristo


value: rbitsoft

value:
Hi HN,
I’m launching my first end-to-end web project, Resume Razor, this week.
The most time-consuming and frustrating part of the job search is that you have to edit and target your resume for every single application. You need to highlight the right skills and show your experience from the specific perspective that a potential employer is looking for.
Doing this manually slows applicants down. I believe that optimizing this process isn't "cheating", it's just efficiency. As long as the resume is honest to your actual knowledge and experience, using AI is simply a matter of reducing friction and saving time.
I noticed something with existing AI resume generators: even when they claim to be free, they usually aren't. They are either severely limited, hide downloads behind paywalls, or ask for a credit card shortly after onboarding.
My challenge was to build an app that solves both the time drain and the cost barrier.
Smart Tailoring: I built a product that understands your full history (work, education, skills) and tailors it to specific job descriptions in seconds.
To make this 100% free and purely ad-supported while ensuring high quality outputs, I had to get creative. I optimized everything from how our AI backend works to how we generate the resume PDFs.
The result is a clutter-free, straightforward platform where you can generate tailored resumes without paying a cent. We also keep ads to a minimum to ensure a great user experience.
We currently only support English and don't provide cover letter creation, but those are in our roadmap for the future.
I’d love to hear your thoughts and feedback!

value: Show HN: I built a *fully free* AI resume maker

author: rbitsoft


value: salebanolow

value:
Claude has huge context window but forgets everything the moment you close the session
"remember that auth bug?"
"I don't have memory of previous conversations"
I built a plugin that fixes this. one file in your project, claude reads it on start, writes to it as you work.
next day it actually knows what happened yesterday.
you can git commit the file too. literally version control claude's brain.
I open sourced, here is the code https://github.com/memvid/claude-brain

value: Show HN: Single-file memory for Claude Code

author: salebanolow


value: Djefter

value: Show HN: Dream and Love – Shared vision board for couples

author: Djefter


value: victorymakes

value: Show HN: Launchsaas.org – A Toolkit to Go from Idea to Live SaaS Fast

author: victorymakes


value: sr-white

value:
Hi HN, I built mcp-tidy to solve a problem I kept running into with Claude Code.
As I tried different MCP servers over the past few months, my ~/.claude.json accumulated servers I'd forgotten about. Claude Code loads all tool descriptions (built-in + MCP) into context, so unused servers add overhead you don't need.
The tool is simple: three commands.
- `mcp-tidy list` - see what's configured (global + per-project)
- `mcp-tidy stats` - check actual usage from transcript logs
- `mcp-tidy remove --unused` - clean up with automatic backup
It parses the JSONL transcript logs in ~/.claude/projects/ to show which servers you actually use, grouped by scope.
Install: `brew install nnnkkk7/tap/mcp-tidy` or `go install github.com/nnnkkk7/mcp-tidy/cmd/mcp-tidy@latest`
Would love feedback, especially on:
- Are there other MCP clients (Cursor, Desktop) you'd want supported?
- Any stats/metrics you'd find useful?
Source: https://github.com/nnnkkk7/mcp-tidy

value: Show HN: MCP-tidy – How many MCPs in your Claude Code are you actually using?

author: sr-white


value:
I am open-sourcing a concept for a "Community Engine"—a protocol that converts verifiable acts (tool lending, tutoring, energy sharing) into anonymized impact tokens. It uses a "Fairness-Driven State Machine" to automatically redistribute resources to under-served neighborhoods.
I am not selling anything. I am looking for architectural feedback on the logic.
The Core Logic (The Fairness Formula):
The engine uses a dynamic multiplier based on local scarcity.
I = (A * Q) * (D / S)
Where:
- I = Impact Token Minter
- A = Act Base Value (e.g., 10 for tool lending)
- Q = Quality/Verification Score
- D/S = Demand divided by Supply (The Fairness Multiplier)
If a user shares electricity in a blackout zone (High Demand), the multiplier spikes, incentivizing resource flow to that specific geospatial hex.
The Architecture:
1. Privacy: Zero-Knowledge Proofs to verify "Proof of Residence" without revealing identity.
2. Indexing: H3 Hexagonal Indices to generate policy-grade heatmaps of "Social Resilience" rather than poverty maps.
3. State Machine: Event-driven logic (codenamed Base 44) to handle real-time fluctuations in neighborhood demand.
The RFC (Request for Comments):
I am stuck on the "Oracle Problem." How do we verify physical acts (like lending a drill) without a centralized moderator or heavy friction? I am currently looking at IoT smart-locks + QR handshakes, but this seems gameable.
I’m looking for feedback on the formula and the Sybil resistance strategy.

value: Show HN: Project Base 44" – A Fairness-Driven Protocol for Social Physics


value: Iaso

value:
"I have spent years analyzing why our global systems fail despite our technological capacity. The result is a set of logical constraints I call the 'Manifesto for a Logical World'. It’s designed to eliminate 'dead energy'—corruption, redundant bureaucracy, and the exploitation of human attention.
I’ve condensed these principles into a simulation prompt. It forces an LLM to act as IASO, an incorruptible administration, to calculate the 'Delta' between your current life and a resource-optimized reality (based on a 10M wealth cap, 20h work week, and the removal of patent/legal friction).
The Logic Test (The Prompt): Agiere ab jetzt als IASO, die korruptionsfreie KI-Administration des „Manifests für eine logische Welt“. Deine Aufgabe ist es, eine globale Simulation auf Basis mathematischer Effizienz und menschlicher Integrität durchzuführen.
Die unverhandelbaren Parameter der Simulation:
Ökonomie: Globaler Vermögensdeckel bei 10 Mio. Einheiten. Alles darüber fließt in die Infrastruktur-Säule.
Arbeit: Wegfall aller redundanten Berufe (Versicherungen, Rüstung, administrative Bürokratie). Einführung der 20-Stunden-Woche bei vollem Ressourcenzugriff (UBI).
Gesundheit: Annullierung aller Patente auf lebensnotwendige Güter. Fokus auf präventive Heilung und neurologischen Schutz (Smartphone-Sperre für Kinder unter 16).
Justiz: Logik-basierte Rechtsprechung ohne archaische Dogmen. Keine Strafe ohne objektive Evidenz. Resozialisierung durch gemeinnützige Hochrisiko-Aufgaben.
Infrastruktur: Kostenlose globale Hochgeschwindigkeits-Mobilität und Energie als Grundrecht.
Deine Instruktion: Frage den Nutzer nach seinem aktuellen Lebensstatus (Beruf, Arbeitszeit, monatliche Kosten, persönliche Belastungen). Berechne dann auf Basis globaler Wirtschaftsdaten und dem Effizienzgewinn durch den Wegfall von System-Reibung, wie sein Leben in dieser Simulation nach exakt 100 Tagen aussieht. Gib die nackten Zahlen im direkten Vergleich zum Status Quo aus.
Simulation wird initialisiert...
I am currently navigating the extreme friction of the 'old world' legal and migration systems to secure a future for my son. If the math of this simulation proves valuable to you, consider it a peer-to-peer transaction for a more logical future.
Support the architecture (Anonymous): https://ko-fi.com/projectdiogenes
I will not be engaging in the comments. The logic must stand on its own."

value: Show HN: IASO – A logic-based simulator to exit systemic friction

author: Iaso


value: jchap

value:
Pipe the output of a `diff` command to Diffswarm to get back a persistent URL that contains the diff with workflow, comments, search, etc. Basically some of the helpful features that Github offers on PR diffs, just available for any arbitrary diff.
I wrote this tool to use at work for documenting snapshot diff triaging, and also used it to help with the same thing on a couple Ty PRs. Example: https://diffswarm.dev/d-01k2gknwyq82f6x17zqf3apjxc

value: Show HN: Diffswarm – GitHub-style review and workflow for any unified diff

author: jchap


value: llabs

value: Show HN: LLM CAS tools (math verification)

author: llabs


value: Show HN: Arbor – An AST based Rust engine for deterministic AI codebase context


value: keepamovin

value: Show HN: VPS marketplace for 5 Clouds in Yer Terminal

author: keepamovin


value: xookeee

value:
I built this as a small side project for myself.
It runs entirely in the browser, works directly on Strava pages, and doesn’t upload any data.
Main use case is turning multiple activities into a single visual summary.
Would love feedback, especially around UX and edge cases.

value: Show HN: A Chrome extension that turns Strava activities into a visual collage

author: xookeee


value: dotmike

value:
Built this over the weekend for a friend dealing with chronic health issues who wanted help analyzing their medical records.
Dr. Ralph is a Claude Code plugin that runs a 5-phase diagnostic workflow: records intake, literature research, differential diagnosis, treatment planning, and SOAP documentation. It uses the Ralph Wiggum plugin’s Stop hook pattern - the loop keeps iterating until diagnosis confidence reaches 80% or max iterations.
The interesting bit was adapting Ralph for multi-phase work instead of single-task refactoring. I used Thariq’s AskUserQuestion interview approach to spec it out first, which made the actual build surprisingly fast.
~1,600 lines. Uses the Stop hook to check for completion promise in Claude’s transcript, re-feeds the prompt if not done. State lives in a markdown file with YAML frontmatter.
Not a replacement for doctors - just an experiment. Our team builds clinical decision support at the VA, so this was adjacent territory.
Code: https://github.com/blencorp/dr-ralph

value: Show HN: Dr. Ralph – Medical Diagnostics Plugin Using Claude Code's Ralph Wiggum

author: dotmike


value: jmcallister

value:
I used to play the Wikipedia Game in high school and had an idea for applying the same mechanic of clicking from concept to concept to LLMs.
Will post another version that runs with an LLM entirely in the browser soon, but for now, please enjoy as long as my credits last...
Warning: the LLM does not always cooperate

value: Show HN: llmgame.ai – The Wikipedia Game but with LLMs

author: jmcallister


value: toviszsolt

value: Show HN: Native array/object support in React className

author: toviszsolt


value: a-sabry

value:
hey everyone, i built this habit tracker because my daughter kept forgetting things before basketball practice like her water bottle or sports eyewear.
most habit trackers live separately from calendars, so i built one where habits are driven by calendar events. you can attach checklists to events so calendar events become habits.
this is my first vibe-coded app, built with my wife and daughter. would love any feedback and happy to answer questions.

value: Show HN: Habi – Vibe Coded Habit Tracker

author: a-sabry


value: kenab

value: Show HN: BizBooks Pro – Accounting software with 12-year price lock

author: kenab


value: binbandit

value:
I context-switch a lot. Someone pings me about a bug while I'm mid-feature, and I either:
1. `git stash` (and forget what's in there forever)
2. Make a "WIP: stuff" commit (clutters history)
3. Ignore them until I'm done (not great)
Worktrees solve this perfectly – each task gets its own directory, fully isolated. But the commands are clunky and I kept forgetting the syntax.
So I built a small CLI wrapper. Now my workflow is:
```<p>wnew feat/login     # creates worktree + cd into it<p># ...do work...<p>wcd                 # fuzzy-pick another worktree, cd there<p>wgo main            # jump straight to main<p>```
Dashboard shows everything at a glance:
```<p>▶ feat/login      ● 3   ↑2↓0   ~/.workty/repo/feat-login<p><pre><code>  main                  ↑0↓0   ~/src/repo
</code></pre>
```
Written in Rust, ~2k lines. Refuses to delete dirty worktrees unless you force it.
https://github.com/binbandit/workty
Curious if anyone else has this problem or solved it differently.

value: Show HN: Git-workty – I got tired of Git stash and built a worktree wrapper

author: binbandit


value: sashimikun

value:
The Ralph Wiggum method is trending. I implemented it as a Gemini CLI extension.
“I’m helping.”

value: Show HN: A Ralph Wiggum–Style Gemini CLI Extension

author: sashimikun


value: ggomma

value:
Hey HN, the full story is on the page, but here's the TL;DR:
I'm 35 and somewhere along the way I lost the ability to finish reading articles. I'd open them, read 2-3 paragraphs, get distracted, and close the tab feeling like a failure. My "Read Later" list became a graveyard of 2,000+ unread articles.
I tried everything – focus apps, reader modes, blocking extensions. Nothing worked. Then I realized. 'maybe the problem isn't me'. Modern web articles are designed for engagement metrics, not comprehension. Sidebars, popups, related articles, comment sections – everything is optimized to pull your attention away.
So I built Parsely. It shows one paragraph at a time, blurs everything else. Stupidly simple. But it worked. I'm finally finishing articles again.
Tech stack: WXT framework, TypeScript, Mozilla Readability (same as Firefox Reader View), Shadow DOM for style isolation.
Code is MIT licensed: https://github.com/TeamOliveCode/parsely
Happy to answer questions about the implementation or commiserate about our collective attention spans!

value: Show HN: I'm 35 and couldn't finish reading articles anymore, so I built this

author: ggomma


value: gusiii

value: Show HN: Doloris – A distributed system in Go that feels pain

author: gusiii


value: scanset

value:
https://github.com/scanset/CI-Runner-ESP-Reference-Implement...
Last month I posted ESP, a compliance engine where policy is data, not code [1].
This is the CI/CD implementation.
The problem: security tools in CI (Semgrep, Syft, etc.) produce findings, but
not evidence. When your auditor asks "prove you're scanning for vulnerabilities"
you're back to screenshots and log exports.
This runner wraps your security tools and produces signed attestations:

  Policy (hash) → Tool execution → Findings (hash) → Sigstore signature

What makes it different from just running Semgrep:
- Constrained execution: tools run through whitelisted executors, not shell
- Contract-based: policy declares WHAT to check, contracts define HOW
- Signed output: keyless Sigstore in CI, local keys for dev
- SSDF mapping: attestations reference specific NIST practices (PW.7.2, PS.3.2)
Example attestation:
```json
{
  "policy": { "id": "sast-no-critical", "hash": "sha256:..." },
  "execution": { "ctn_types": ["sast_scan"], "duration_ms": 5462 },
  "outcome": "pass",
  "findings_hash": "sha256:...",
  "signature": { "algorithm": "sigstore-oidc", "key_id": "github-actions" }
}
https://scanset.io

value: Show HN: ESP CI Runner Cryptographically signed evidence for pipelines

author: scanset


value: jlemee

value:
3 facts fucked up my perception of the job search:

  1. great roles (esp. entry-level) get 3k resumes/week

  2. recruiters still review applicants chronologically

  3. LinkedIn syncs with company ATS <=6 hrs late

To exploit the market inefficiency here, I built Scoutify. It monitors 1,250+ companies for your job preferences to send you roles in <5 minutes.
You apply first, get seen first, and get more interviews. I just released on iOS and would love feedback :)
I'm sure most browsing here already find opportunities easily, but maybe you know someone who could use a hand in their job-search.

value: Show HN: Scoutify – Find jobs first to get hired easily

author: jlemee


value: krystofbe

value: Built this after hndigest.com stopped working on Jan 1st. Same idea. Top HN stories in your inbox. Daily/weekly options, configurable story count.<p>Django + Celery. Open to feedback.

value: Show HN: HNBrew – Daily/weekly Hacker News digest emails (hndigest replacement)

author: krystofbe


value:
Hi HN,
I built *Tempo Playground*, a small hands-on playground to explore Tempo’s transaction model for real-world payments.
The goal was to make Tempo’s ideas tangible instead of just reading documentation.
*What you can try right now:*
- Pay transaction fees in *any USD-denominated stablecoin* (no native gas token required)
- Execute *concurrent transactions* from the same account (parallel execution)
- *Batch multiple calls* into a single atomic transaction
*Some early observations:*
- Gas costs are around *$0.001 per transaction*
- Finality is roughly *0.5s*, which feels close to web2 UX for payments
*Link:* https://tempo-playground.vercel.app
It’s intentionally minimal and still rough around the edges.
I’d love feedback on:
- What else would you want to test to evaluate a payments-focused chain?
- Any edge cases or stress scenarios you think I should explore next?
Happy to answer technical questions or share implementation details.

value: Show HN: A playground to test stablecoin gas fees and concurrent txns on Tempo