value: riario

value:
After the uncertainty of the pandemic and becoming a first-time (then two-time) parent, I realized the “monthly budget” never tells the full story. Real life is lumpy: childcare starts mid-year, service charge steps up, one-offs appear out of nowhere, and somehow the math never matches the month. I didn’t need another expense tracker, I needed a way to see the whole picture and test futures.
So I built a scenario-first planner. Instead of obsessing over last month’s transactions, you:
Map your life into a plan: recurring expenses, one-offs, income changes, goals.
Duplicate your plan with one tap, tweak variables, and compare outcomes side-by-side.
Project out 60 months to see cash flow, buffers, and breaking points.
Stress-test “what if” events: childcare, mortgage rate changes, a new car, parental leave, etc.
It's a bit like holding the Time Stone :P
You roll time forward, branch a new timeline, replay with a tiny change, then compare the futures.
It's called "Plans.TheApp" and it's currently available for iOS on the App Store (Android to follow). The goal wasn’t every coffee, every doughnut perfect precision. It's about clarity and confidence and the ability to make decisions with a full, realistic picture.
We’re looking for blunt feedback from people who’ve felt the same mismatch between “monthly budget” and real life:
Which scenarios do you care about most?
What data/visuals make a decision obvious for you?
Where does the model fail (irregular bills, step-changes, seasonality)?
If this resonates, we’d love your take and your hardest edge cases.

value: Show HN: A "what-if" budget planner app born from new-parent chaos

author: riario


value: marktl

value:
I built TrailWrightQA to let developers, QA teams, or business-analysts generate browser UI tests without writing code. It runs locally and requires an API key from OpenAI / Gemini / or Anthropic. All test code and data remain on your machine — no external servers beyond the LLM call.
Because it’s open-source and self-hosted, each test run is free (beyond the LLM cost). That eliminates recurring per-run fees typical of many automated-testing services.
It’s rough around the edges, especially for complex UI flows — but I'm limited on dev time and so releasing it publicly in case others have similar needs or want to contribute. Feedback, pull-requests, or issue reports welcome.
Repo: https://github.com/marktl/TrailWrightQA
— Mark

value: Show HN: TrailWrightQA – local-first, AI-assisted Playwright UI testing

author: marktl


value: guaguaaaa

value: Show HN: Veru – open-source AI citation auditor using OpenAlex

author: guaguaaaa


value: etothepii

value: Wife (to-be) and I need to agree on the guest list for our wedding. Different venues have different maximum numbers of people. Built this with antigravity so we could work out who makes the cut. Would be interested in missing features.

value: Show HN: Wedding Guest Ranker

author: etothepii

title: Show HN: Wedding Guest Ranker


value: Show HN: AI slides and presentation coaching


value: Sai-HN

value:
FT-Lab is a clean, reproducible setup for fine-tuning TinyLlama (supports Full FT, LoRA, and QLoRA) and evaluating Retrieval-Augmented Generation (RAG) pipelines using LlamaIndex and LangChain.
Built for small GPUs and designed with controlled experiments and ablation studies in mind.<p>Feedback and contributions welcome!

value: Show HN: FT-Lab – Lightweight TinyLlama Fine-Tuning (Full FT / LoRA / QLoRA)

author: Sai-HN


value:
If you are using Cursor or Claude Code, you must try this open-source tool—it will save you MONEY and TIME.
If you're building complex projects and your context keeps getting larger, losing track of what's current and what's outdated, you're going to love this.
THE PROBLEM:
When using LLMs to build products, we generate tons of context—requirements, specs, design docs. But then:

  Can't tell which document is the latest/authoritative

  No traceability between layers (business → system → code → tests)

  Upstream requirements change, downstream doesn't get updated

  Your LLM uses STALE context → incorrect output

  Burning tokens on entire files when you need specific snippets

  THE SOLUTION: contextgit

A tool built specifically for LLMs to trace context efficiently.
Instead of dumping entire files into context, contextgit lets your AI navigate requirements like a graph database—extracting only what's needed.
Extract ONLY relevant snippets (save tokens = save money)
Track relationships: business → system → architecture → code → test
Auto-detect staleness via checksums
Full JSON output for LLM integration
See project health: orphaned requirements, broken links, stale items
KEY USE CASES:
LLM-driven development: AI asks for requirements by ID, not entire docs
Massive token savings: Feed 20 lines instead of 5,000
Auto-detect stale context: LLMs know when requirements are outdated
CI integration: Block PRs with stale requirements

  REAL IMPACT:

Instead of: LLM reads 5000-line docs → wastes tokens
Now: contextgit extract SR-010 → 20 lines → saves hundreds in API costs
If you find this useful, please star the repo!
100% open source (MIT), production-ready (v1.0.1). This is the missing piece for LLM-driven development.

value: Show HN: Dependency-aware context management for LLM coding workflows


value: mihaela

value: Show HN: Cupertino – MCP server giving Claude offline Apple documentation

author: mihaela


value: jrpribs

value: Im a software engineer, but I actually fully "vibe coded" this. fully functional, used bolt.new + a little claude code. nano banana pro made it possible.

value: Show HN: I built alwayswith.us to easily add deceased loved ones into photos

author: jrpribs


value: takennap

value:
I’ve been playing a lot of the Roblox game The Forge and got tired of doing ore math in my head, so I built this.
You plug in ores and it shows forge odds, trait thresholds, and expected stats so you can plan weapons/armor instead of guessing.
Roblox has been full of “brainrot” viral games lately.
The Forge actually rewards thinking, so if you play it I’d love feedback on the numbers and the UX.

value: Show HN: The Forge Calculator for Roblox "The Forge"

author: takennap


value:
Hi HN, I'm the creator of CodeProt.
I got tired of reviewing 50 files just to find 3 indentation errors and missing the actual bugs buried in the noise. Traditional linters are great, but they often lack context, leading to a flood of false positives or trivial issues that clutter the PR review process.
CodeProt solves this by connecting to your CI pipeline (GitHub Actions). It parses the raw output from your existing static analysis tools, compares it against the diff, and uses a context-aware LLM check to filter out false positives and irrelevant noise before they reach your PR comments.
It's built to be a lightweight layer on top of your existing tools, not a replacement.
Business Model: Free for open source projects, paid tier for private repositories and teams.
Roast my code / Feedback welcome.

value: Show HN: CodeProt – Filter static analysis false positives in CI


value: Frannky

value:
Hey HN,
I've been grinding on influencer marketing pains for too long—agencies charging a fortune for unvetted spreadsheets, or worse, weeks lost doomscrolling X for creators who ghost or underdeliver. So I built HOODL.NET: an algorithmic engine that continuously scrapes and indexes verified X accounts (5k+ followers baseline), pre-computes influence scores via PageRank on retweet networks, and serves ranked top nodes in your niche on demand. No more guesswork; just signal from the noise.
*Quick Demo Flow:*
- Ask a question in natural language (like "tennis influencers ranked by PageRank").
- We tap our live index and surface authority-ranked results using pre-baked scores from retweet flows.
- Output: Ranked lists with contact details, ready for outreach.
Finding lots of good influencers fast lets you test them with a low-cost post and double down only if they prove ROI for your product (some creators shine for one niche but flop in another). Testing everything fast and cheap is a killer strategy.
*Tiers for Every Stack:*
- *Instant Data ($29/mo):* DIY terminal access to our Model Context Protocol (MCP) API—rate-limited (1/sec) token auth for bots, or chat via hosted LibreChat UI. Export CSVs of 50k+ follower hits instantly. (Pro tip: Our query gen is LLM-smart, so "find crypto VCs" just works.)
- *Golden List ($499/report):* Curated top-100 PDF/CSV, niche-specific, with a sales funnel playbook. Escrow-secured delivery.
- *Done For You ($5k+/mo):* Full agency mode—we outreach, negotiate, manage posts, and report CPA. Milestone unlocks.
Tech under the hood: Perpetual scraper feeding a graph DB for real-time-ish freshness, fast MCP server for connected clients, on-demand "queen code" terminals accessed via hosted LibreChat for non-devs.
It's vertical-agnostic too—I'm templating the codebase for sale (update via Claude for your DB + niche). Reach out if interested.
Live at [hoodl.net](https://hoodl.net). Feedback? Would love thoughts on scaling the graph analysis or API ergonomics. What's your biggest influencer hunt horror story?
P.S. First 10 emails get a free Golden List trial.

value: Show HN: Hoodl.net – Find and Vet Top X Influencers in Seconds with PageRank

author: Frannky


value: jokera

value: Show HN: AmAttractive – AI Attractiveness Test and Beauty PK Arena

author: jokera


value:
Hi HN! I built Banana Editor (https://bananaeditor.art) - a free AI photo editor that solves a frustrating problem: most AI image editors change your subject's face/identity when you just want to edit the background or outfit.
Key features:
• Identity-safe editing: Lock faces/hairstyles while editing everything else
• Text-to-edit: "Change background to a beach" or "swap to a red dress"
• 3 free credits on signup, earn 100+ through daily check-ins
• Results in seconds, no credit card required
Built on Google's Gemini 3.0 Pro (Nano Banana) model. Would love feedback from the HN community!
Tech stack: Next.js, Vercel AI SDK, R2 storage

value: Show HN: Free AI photo editor that preserves face identity


value: Show HN: Spacebar Clicker – A Minimal Space Key Speed Test for Reaction Training


value:
Hey everyone! I just built a mobile app using Expo (React Native) for a platform that moves $6M/month. It’s a neobank used by 6,500+ nonprofit organizations across the world.
One of my biggest challenges, while juggling being a full-time student, was getting permission from Apple/Google to use advanced native features such as Tap to Pay (for in-person donations) and Push Provisioning (for adding your card to your digital wallet). It was months of back-and-forth emails, test case recordings, and also compliance checks.
Even after securing Apple/Google’s permission, any minor fix required publishing a new build, which was time-consuming. After dealing with this for a while, I adopted the idea of “over the air updates” using Expo’s EAS update service. This allowed me to remotely trigger updates without needing a new app build.
The 250 hours I spent building this app were an INSANE learning experience, but it was also a whole lot of fun. Give the app a try, and I’d love any feedback you have on it!
btw, back in March, we open-sourced this nonprofit neobank on GitHub.
https://news.ycombinator.com/item?id=43519802

value: Show HN: HCB Mobile – financial app built by 17 y/o, processing $6M/month


value: garyhtou

value: Show HN: HCB – Nonprofit financial app processing $6M/month

author: garyhtou


value: saasnap

value:
Hi HN,
Like many of you, I've neglected localizing my apps because the process is a hassle. Managing 10+ languages across iOS and Android usually involves a chaotic mix of Google Sheets and manual copy-pasting.
I built Glovio to automate this. It centralizes your title, description, and keywords.
The feature I'm most proud of is the Image Text Extraction. It analyzes your marketing graphics to catch English text that needs translating—something I often forgot until users complained.
I'm looking for feedback from other mobile devs on how you currently handle this pipeline. Is this better than your current spreadsheet?
Check it out on Product Hunt: https://www.producthunt.com/products/glovio?utm_source=other...

value: Show HN: Glovio – Localize app store listings without spreadsheets

author: saasnap


value: eigenvalue

value:
I’m very pleased to introduce my latest tool for both humans and coding agents: the coding agent session search, or “cass” for short.
This tool solves a direct pain point I’ve been experiencing for months as a heavy user of coding agents, with tons of sessions across many tools (Claude Code, codex, cursor, and now gemini-cli) and projects: I’ll know that I talked about something, but be unable to find it or even remember where to try to look for it.
I wanted something instantly available in the terminal that would let me search in a rich way across ALL of those tools and sessions at once super fast, with basically no latency and true “search as you type” instant filtering and ranking/sorting.
And I wanted it to “just work” without configuration, to automatically find and use all my installed coding tools, even ones that I don’t currently use but might in the future (like opencode, aider, and others).
So I made cass in super high-performance rust with every optimization I could think of, and a huge amount of attention to ergonomics and user experience. I’m very pleased with how it came out and think you will be, too.
But just as my recent bv ( https://github.com/Dicklesworthstone/beads_viewer ) tool is now being used way more by my agents than by me, I knew from the start that cass should have a “robot mode” designed specifically for use by coding agents.
This tool gives coding agents the ability to reach into their own working notes and those of all their peer agents across tools. It’s like a human developer being able to search their Gmail, their notes, and their company Slack and Jira to find things.
I went through countless iterations of improving the tool so that agents really love to use it. You can just add this blurb to your AGENTS dot md file to get them to use it (after doing the one-liner curl install, which takes
3 seconds):
```
 cass — Search All Your Agent History<p>What: cass indexes conversations from Claude Code, Codex, Cursor, Gemini, Aider, ChatGPT, and more into a unified, searchable index. Before solving a problem from scratch, check if any agent already solved something similar.<p><pre><code>  NEVER run bare cass — it launches an interactive TUI. Always use --robot or --json.

 Quick Start

 # Check if index is healthy (exit 0=ok, 1=run index first)
 cass health

 # Search across all agent histories
 cass search "authentication error" --robot --limit 5

 # View a specific result (from search output)
 cass view /path/to/session.jsonl -n 42 --json

 # Expand context around a line
 cass expand /path/to/session.jsonl -n 42 -C 3 --json

 # Learn the full API
 cass capabilities --json # Feature discovery
 cass robot-docs guide # LLM-optimized docs

 Why Use It

 - Cross-agent knowledge: Find solutions from Codex when using Claude, or vice versa
 - Forgiving syntax: Typos and wrong flags are auto-corrected with teaching notes
 - Token-efficient: --fields minimal returns only essential data

 Key Flags

 | Flag | Purpose |
 |------------------|--------------------------------------------------------|
 | --robot / --json | Machine-readable JSON output (required!) |
 | --fields minimal | Reduce payload: source_path, line_number, agent only |
 | --limit N | Cap result count |
 | --agent NAME | Filter to specific agent (claude, codex, cursor, etc.) |
 | --days N | Limit to recent N days |

 stdout = data only, stderr = diagnostics. Exit 0 = success.</code></pre>
```

value: Show HN: Coding Agent Session Search (Cass)

author: eigenvalue


value: For the lovers of YAML, this extension is for you to easily manage your MCP configuration using YAML rather than JSON. Give it a spin and leave a comment. It's also available on OpenVSX: https://open-vsx.org/extension/adefemi171/yaml2mcp

value: Show HN: YAML2MCP

title: Show HN: YAML2MCP


value:
I'm a huge fan of Steve Yegge's great beads project, which is a task management system for use by coding agents.
In fact, I probably type or paste the string "beads" 500+ times a day nowadays across all my coding agent sessions (I'm juggling like 10 projects at the same time now, which you'll start to see soon as I finish and release them in the coming days and weeks.)
I'm usually having GPT-5 Pro make plans to my specifications and iterate on them a bunch of times, usually with help from Opus 4.5, Grok 4.1, and Gemini 3. Then I tell codex or Claude Code to take the plan and turn it into beads for me. Or as I usually say it in my pasted in blurb,
"OK, so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the overarching goals of the project.)"
Anyway, I wished I had a better way to just browse the beads and see what's going on with them. And sure, I get it, beads aren't for me as a human, they're for the agents.
But I'm using them so much that it would be helpful for me to also have a way to interact and view and browse them.
Plus I had an idea that there was additional useful information lurking in the "graph" of beads of a sufficiently complex project comprising enough beads across various epics with lots of dependency structure on top.
So I started making beads_viewer (bv for short), and I'm pleased to say that it's already pretty amazingly polished, full-featured, and useful.
All written in highly performant Golang (a language I only started using again recently, with the system monitor program I also released this morning).
You run the one-liner curl bash installer (see the README in the repo linked below) and then you can go into any project folder where you're using beads and simply type bv to open it.
The interface is pretty straightforward; press F1 to see the available commands. Try pressing the "i" key for insights, "g" for graph, "b" for a kanban board, "/" for a fuzzy search across beads in the main view, etc.
I do some cool graph theoretic calculations on the beads graph structure to extract some interesting insights.
And as a tool for use with beads, I'd be remiss if I didn't make sure that my AI robot brethren also enjoyed using it, so I added a mode just for them that is easy and useful for them.
To get your agents to use it, simply drop this blurb into your AGENTS dot md or CLAUDE dot md file:
```
### Using bv as an AI sidecar<p><pre><code>  bv is a fast terminal UI for Beads projects (.beads/beads.jsonl). It renders lists/details and precomputes dependency metrics (PageRank, critical path, cycles, etc.) so you instantly see blockers and execution order. For agents, it’s a graph sidecar: instead of parsing JSONL or risking hallucinated traversal, call the robot flags to get deterministic, dependency-aware outputs.

  - bv --robot-help — shows all AI-facing commands.
  - bv --robot-insights — JSON graph metrics (PageRank, betweenness, HITS, critical path, cycles) with top-N summaries for quick triage.
  - bv --robot-plan — JSON execution plan: parallel tracks, items per track, and unblocks lists showing what each item frees up.
  - bv --robot-priority — JSON priority recommendations with reasoning and confidence.
  - bv --robot-recipes — list recipes (default, actionable, blocked, etc.); apply via bv --recipe <name> to pre-filter/sort before other flags.
  - bv --robot-diff --diff-since <commit|date> — JSON diff of issue changes, new/closed items, and cycles introduced/resolved.</code></pre>
```

value: Show HN: Beads Viewer (Bv)

title: Show HN: Beads Viewer (Bv)


value: nicetomeetyu

value:
Make Qwen happy, sad, mad, surprised, afraid, or disgusted with the latest interpretability research
https://www.lesswrong.com/posts/CHxLiTwZYvsGfLLhP/i-gave-llm...

value: Show HN: An emotional steering website for Qwen 2.5 7B

author: nicetomeetyu


value: kanodiaayush

value:
LLMs are a great way to understand things with. Current methods are however engineered only for brief chat like interactions, whereas deep understanding requires continuous research, exploration and deep reading too.
Kerns is an AI interface designed to help with all of this - there's a powerful chat agent to search and reason with over the web and your sources. You can run deep research, and enable background agents in the app to work on your behalf. You can read original source with a powerful AI reader that offers chapter level summarization and in context question answering. There's a powerful interactive mindmap you can build on your sources, and visual notetaking as you chat.
I would love any feedback!

value: Show HN: An AI environment to understand sources or topics

author: kanodiaayush


value: Show HN: I built a privacy-first UK tax calculator


value: passioner

value: Found a free AI tool that cleans up photos really well. No paywalls, no weird glitches — just super simple and solid results. Not affiliated or anything, just thought it was worth sharing.

value: Show HN: I stumbled on a free AI photo enhancer – surprisingly good results

author: passioner


value:
I built a tool to automate Syncthing deployment on Docker Swarm clusters.
The problem: setting up Syncthing manually on each node is tedious, configuring connections, managing keys, handling node changes.
Syncthing4swarm deploys Syncthing as a global service with automatic device discovery and pairing. One command, zero manual config per node.
Looking for feedback and happy to answer questions.

value: Show HN: Syncthing4swarm, Automatically Deploy Syncthing Across Docker Swarm


value: idish

value:
Hi HN,
I’m a parent and indie developer, and after dealing with unreliable baby monitors (disconnects, background noise, constant false alerts), I built something simpler and more reliable for our home — and decided to share it.
NannyCam turns any two phones into a baby monitor with a focus on privacy and ease of use:
• Works online or completely offline
When WiFi is down or unavailable, the devices connect directly. No cloud, no accounts, nothing stored.
• “Loud noises only” mode
Instead of transmitting every small rustle or fan noise, the app only alerts/streams when a meaningful sound happens (like crying). This helped reduce a lot of unnecessary wake-ups.
• No accounts or logins
Pair with a quick QR code and start monitoring immediately.
• Minimal, fast, and parent-friendly
Open the app → scan → you're monitoring. No setup overhead.
I’d love feedback on:
reliability improvements
UX ideas
battery/performance optimizations
features you’d expect in a simple, privacy-focused baby monitor
Happy to answer any questions, including technical details behind the offline mode, audio filtering, or connection flow.
Thanks for checking it out!

value: Show HN: NannyCam – A Baby Monitor App That Works Online or Offline

author: idish


value: mempirate

value:
Wanted to showcase this messaging library that we've been working on for quite a bit and are now starting to integrate into some serious projects. It draws inspiration from ZeroMQ and nanomsg, but is pure Rust and integrates nicely with Tokio.
We want to turn this into the go-to library for Rust users with strong networking requirements: different communication patterns, performance profiles, transport requirements etc.
Some of the things in the roadmap are:
- io_uring support on Linux
- A shared-memory transport for IPC
- Extensive benchmarking and tuning tools (maybe similar to iperf, but for msg-rs)
Would love to gather some feedback from any Rust/networking guru's out here!

value: Show HN: Msg-rs – High performance messaging library in Rust

author: mempirate


value: kekyo

value: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images.<p>Reached 1.0.0:<p>- Place, update, and remove large numbers of sprites.<p>- Move each sprite's coordinate freely, making it easy to represent moving objects.<p>- Specify per-sprite anchor positions for precise rendering.<p>- Add multiple images and text to the same sprite, adjusting rotation, offset, scale, opacity, and more.<p>- Animate sprite movement, rotation, and offsets with interpolation controls.<p>- Control draw order via sub-layers and per-sprite ordering.<p>- Fully imperative APIs. Updates with high-performance and extensible.<p>- Accelerating computational processing with WASM and shaders.<p>- MIT license.

value: Show HN: MapLibre GL JavaScript – Enabling large number of moveable sprites

author: kekyo


value: Show HN: Hirschberg Algorithm in PyTorch


value: supersuryaansh

value:
Hi guys,
Wanted to share a project I have been building for a while: Holesail, a lightweight peer-to-peer tunneling tool that makes sharing local self-hosted services extremely easy.
No port forwarding, no VPNs, no servers in the middle — just a direct, end-to-end encrypted connection between two peers using a simple connection key.
It supports both UDP and TCP and runs on Linux, Mac, Windows, Android and iOS.
The goal is to make Holesail the go-to solution for developers, hobbyists, and teams who need fast, reliable, private connectivity: hosting dev servers for teammates, sharing localhost, enabling LAN-style multiplayer, remote access, SSH, self-hosting or P2P features in applications without managing networking complexity.
It is the perfect alternative to Tailscale and Cloudflared.
Would love to hear feedback from anyone working with networking, P2P systems, or tunneling tools.
Happy to answer any questions!
Thanks

value: Show HN: Holesail – Share localhost over peer-to-peer, no port forwarding

author: supersuryaansh


value: gexos

value:
Hi all,
I’ve built a small Windows utility called *System Information Dashboard* and I’d love some feedback.
It’s a portable system info tool that shows at a glance:
- CPU usage
- RAM usage
- Disk usage
- OS version and build
- System uptime
- Basic device/system details
A few design choices:
- *Portable*: just an EXE, no installer, no registry changes.
- *No network calls / telemetry*: it doesn’t phone home, no tracking, no ads.
- *Lightweight*: written in AutoIt, meant to be quick to open, check info, and close.
- *Optional sensors*: for temperatures/sensors it can open LibreHardwareMonitor as an external app instead of reinventing that wheel.
Motivation:
I work as an IT technician and I wanted a small dashboard I can quickly run on a client machine to see the basics without installing heavyweight suites like AIDA64/HWInfo or digging through multiple Windows panels.
Links:
- Download / info page: https://www.gexos.org/system-information-dashboard-lightweig...
- GitHub (code, README, changelog): https://github.com/Gexos/System-Info-Dashboard
I’m mainly looking for feedback on:
- UI/UX (too simple? missing obvious info?)
- Any red flags in how I’m gathering system info
- Features you’d expect from a minimal sysinfo tool that I may be missing
Happy to answer questions and hear criticism. If you spot bugs or weird behaviour on your setup, please let me know your Windows version and hardware.

value: Show HN: Sid– tiny portable system info tool for Windows.

author: gexos


value: Show HN: Tiny (1.8 KiB) no-dependencies react router alternative


value: mehdigtb

value:
Building in public doesn't come naturally to me. I overthink, stress about engagement, get lost in timelines. Tried schedulers, web blockers, willpower - nothing stuck.
So I built YapYap, a macOS menu bar app with global keyboard shortcuts:
- Option+X → X compose window (no feed)
- Option+L → LinkedIn compose window (no feed)
- Cmd+Enter to post, and back to work
Technical approach: It uses a webview to load the native compose UI. No API calls (avoiding X's $200/month pricing), no data stored on my servers. Your credentials stay in the app's sandboxed session.
The webview detects when you navigate away from compose (after posting) and auto-closes.
Next time you press the shortcut, it's already loaded and ready.
Stack:
- Electron + Vite
- Global shortcuts via Electron's globalShortcut API
- Persistent sessions so you stay logged in
- Code signed + notarized for macOS
- Auto-updates via electron-updater
€5 one-time purchase, macOS only.
https://yapyap.dev?ref=hn

value: Show HN: YapYap – Post to X/LinkedIn without seeing the timeline (macOS)

author: mehdigtb


value: Show HN: Converts raw CSV/Excel data into interactive deep reports in minutes


value: nickpcn

value: Show HN: SaveBeam – A fast, no-BS social media video/image downloader.

author: nickpcn


value: VojtechVidra

value:
If you’ve ever tried building onboarding or product adoption with Appcues, Chameleon, Userflow, WalkMe, or Usetiful, you’ve probably hit the same two problems:
1. Everything is rendered with JavaScript overlays
2. Customization is a nightmare
A little backstory:
When I was choosing an onboarding tool for my previous project, nothing matched what I needed. So I had to build my own. With help from IntroJS I built onboarding solution that I needed: Tooltips, Modals, custom CSS, waiting for interactions, and saving the state into the database. It worked… but it took way more time than it should have, and any change required a redeploy.
This made me realize: there’s no product-adoption tool made for developers and designers.. So me and my friends started building Flows with a simple philosophy:
- Optional built-in components that get the basics right
- Or use it headless - bring your own components
- SDK for React and JS (supports Vue, Angular, Svelte or any other JS framework)
- Support for floating and inline elements
- Make changes without redeploying
- Fast, lightweight, and predictable
- Fair PAYG pricing with free tier
Now, back to the issues and how we’re solving them:
1. Rendering
Most tools inject UI with JavaScript and target elements using selectors. This limits them to floating UI (tooltips, popups, dialogs). The ones that offer “inline” elements do it with brittle selectors, layout shift, and generic blocks that never really match your product.
Flows fixes this with a simple “portal” component <FlowsSlot/> that renders the elements directly where you need, with an optional placeholder to avoid layout shift. And floating components are supported as well.
2. Customization
Good design language isn’t optional anymore, it’s need for people to find your product interesting. That’s why customizing brand colors doesn’t cut it and spending development time on the whole CSS rewrite isn’t smart.
With Flows you can use your own components. Import them into Flows SDK, define the props in our editor and use them in the workflows. Anyone editing the content has clear visibility into the structure of each component and what each field is used for.
I’d love any feedback since we’re just getting it out there, thanks!

value: Show HN: Product adoption tools suck so me and my homies built Flows

author: VojtechVidra


value: bozhou

value: A free online party game for 4-8 players. Most players get the same word (e.g., "Dog"), but the impostor gets a similar word (e.g., "Wolf"). Describe your word without giving it away, catch the liar, and win! Perfect for game nights, team building, or virtual hangouts. No signup required.

value: Show HN: ImposterWords – A social deduction word game built for fast online play

author: bozhou


value: donromano

value: Overall, I think the language is great. Coming from C/C++ I have to say it's easy to get it to work. I haven't had the time to explore all of what the language has to offer yet, and I would like to dive more into performance-critical code to see how it behaves, but so far I had a good experience with it and might reuse it later for other projects!

value: Show HN: Wanted to learn Rust, wrote a dependency walker for Windows PEs

author: donromano


value: Viaya

value:
Hi HN — we just open‑sourced/released (or “publicly launched”, depending on whether it's open‑source) a new image generation & editing model called Doubao‑Seedream-4.5, by Volcano Engine.
Compared with 4.0, this version delivers:
Better editing consistency — the subject’s fine details, lighting, and color tone are preserved even after edits;
Improved portrait retouching & beautification, yielding more natural, high‑quality human images;
Much improved small text generation, allowing clearer and more readable embedded text (e.g. signage, interface labels, captions);
Stronger multi‑image compositing — you can combine multiple input images / prompts more reliably to produce coherent, aesthetically pleasing results;
Enhanced inference performance and overall visual aesthetics — results are more precise and artistic.
For creators building AI‑powered creative tools (image generators, illustration pipelines, concept‑art workflows, etc.), Doubao‑Seedream-4.5 offers a substantial upgrade over most 4.x‑era image models.
We’d love feedback from the community — edge‑cases discovered, prompts that fail or succeed especially well, compositing tricks, retouching workflows, anything you find interesting.

value: Show HN: Doubao Seedream 4.5 – next‑gen image creation and editing model

author: Viaya


value: tunaoftheland

value:
Hello HN,
I’m the developer of Plimsoll Line, an iOS app that tries to solve the anxiety I feel when my to-do list gets too long.
I built this to scratch my own itch. I’ve found that most productivity apps optimize for "getting things done," which often just leads to me feeling overwhelmed and guilty about what I haven't done. My wife struggles with this too, so I wanted to build an alternative that prioritizes mental bandwidth over raw output.
THE CONCEPT
The app integrates with Apple Reminders but adds an emotional layer. You assign an "impact" score to tasks (positive or negative). The app visualizes your net emotional load as a water line. That water line hopefully won't reach the "Plimsoll Line", currently the top edge of the app viewport.
If the water gets too high (too much negative load), the app implies (I need to make the app suggest instead) adding positive tasks or taking steps to reduce the negative impact rather than just grinding through the list.
It’s designed to stop you from overloading your "ship" before it sinks (it won't, at least not in the app).
TECHNICAL / PRIVACY
* Stack: Native Swift/SwiftUI.
* Integration: It reads/writes directly to the built-in Reminders database (EventKit). This means you can keep using the default Reminders app and Siri alongside this.
* Privacy: The reminders and emotional impact data are 100% local. No accounts. There is device ID that gets saved on a backend server that tracks whether you've made an in-app purchase for a tip jar. But your emotional data stays on your device.
* Feedback Request: I’m currently experimenting with "actions" to take when the water line gets too high (e.g., a "quick journal" context menu). I’d love to hear your thoughts on:
1. Does the metaphor of a "load line" click for you?
2. What immediate actions (besides journaling) actually help you decompress when you see your to-do list is overwhelming? E.g., a quick physical activity such as taking a walk outside?
It’s free to use (with optional tips). Here is the direct App Store link if you want to try it: https://apps.apple.com/us/app/calm-to-do-list-tasks-plimsoll...
Thank you HN!

value: Show HN: Plimsoll Line, an iOS to-do app that prioritizes mood over productivity

author: tunaoftheland


value:
Hey HN,
I've been building voice AI agents for the past year, the kind that answer phone calls, book appointments, handle customer inquiries. It was going well until a client asked: "Can it also handle our email?"
Turns out, wiring an AI to a phone system is one thing. Wiring it to email is... a whole different mess. SMTP credentials, MIME parsing, threading headers (References, In-Reply-To), bounce handling, deliverability reputation. I spent two weeks on plumbing before my agent could read its first email.
That's when it hit me: every developer building AI agents is going to hit this exact wall. So I built AIThreads [1], the email infrastructure layer so you can skip the plumbing and get straight to the AI logic.
How it works:
Instant inboxes: Create support@yourorg.aithreads.io via API.
No DNS, no verification, just works. (unless you are adding your own domain)
Webhooks -> Email arrives → we POST parsed JSON to your endpoint → your agent decides what to do.
Send via API -> Agent composes reply, calls our API, we deliver with proper threading so conversations stay grouped.
Knowledge Base (RAG) -> Upload your docs, we embed them. Query for relevant context before generating replies.
Smart escalation -> Sentiment analysis and priority detection built-in. AI knows when a frustrated customer needs a human.
InBuilt Tools -> Pre-Built tools to manage the emails.
Try it now: Email hey@aithreads.io – our demo agent will reply.
https://aithreads.io

value: Show HN: AIThreads – Give your AI agent an email address in 30 seconds


value: shodh-varun

value:
I built a web-based tool for configuring AM32 drone ESCs and logging thrust test data.
Features:
  - Connect via flight controller passthrough or direct USB
  - Read/write ESC settings
  - Real-time telemetry (voltage, current, RPM, temp)
  - Thrust test bench UI for load cell data logging
  - CSV export
  - Demo mode to try without hardware
Tech: React, TypeScript, Web Serial API. Works in Chrome/Edge.
GitHub: https://github.com/varun29ankuS/Vayu (Apache 2.0)

value: Show HN: Open-source AM32 ESC configurator with thrust test bench

author: shodh-varun


value: TechSquidTV

value:
I miss the old internet, and thank the many small creators that keep it alive with personal blogs and niche websites.
Tuvix is my attempt at a modern RSS aggregator app that I actually want to use. It looks and behaves like any modern app you expect to see on your phone. It's built as a PWA, so you can use it anywhere.
It has a lot of great extra features, like smart comment link detection, a podcast player that remembers where you left off, and the ability to create public feeds from multiple inbound feed sources.
Cloudflare has a very generous free tier, and RSS doesn't really use all that much compute anyway, so it seemed like a great option for a deployment target and will allow me to run a hosted version for free.
Hope you enjoy!

value: Show HN: Tuvix – A Modern RSS Aggregator

author: TechSquidTV


value: purrplexia

value:
`pip install phi-engine`
Full Mathematical Proof:
https://github.com/Purrplexia/LettersToMyHeroes/blob/main/Ca...
Source Repo:
https://github.com/Purrplexia/LettersToMyHeroes
PyPI package:
https://pypi.org/project/phi-engine
Hi HN,
You are the first public audience to see this project. It has not been posted anywhere else yet. I chose to release it here first because Hacker News consistently rewards rigor, originality, and open-source tools built for ideas rather than for marketing.
This project contains entirely original mathematics. The core theory is proven in a rigorous 34-page proof titled "LetterToCantor.pdf" included in the repository and linked above. It builds a constructive continuum and a gridless analytic calculus from factorial moment laws and golden-ratio scheduling.
Derivatives and integrals of any analytic function can be computed *exactly* by a *frozen*, function-agnostic operator composed of exact rational coefficients (a "β-stream"). No grids, no step size, no limits, no symbolic math. Once synthesized, these operators work globally for every analytic function.
β-streams can be synthesized on-the-fly in milliseconds for thousands of digit accuracy, precompute is only needed if you want to push the boundaries of digits to comical scale.
Once a β-stream is synthesized or loaded, it is cached and reused on all future functions.
No recompute, no wasted cycles, no dependency on the function.
To make this reproducible and verifiable, the project includes phi-certificates: canonical JSON/gz files that store these global calculus operators as exact rationals, sealed with canonical SHA-256. Anyone can load a certificate, verify its key material, and use the operator forever on any analytic function. The certificate is the calculus rule itself.
A phi-certificate is a canonical, global, arbitrary-precision analytic instruction, sealed by a 32-byte hash.
All code is GPLv3-or-later. All math documents are CC-BY-SA 4.0. Everything is permanently free and open.
The repo includes:
- the full mathematical proof (LetterToCantor.pdf)
- the phi-engine (exact rational contraction engine)
- phi-certificates (deterministic, hash-verifiable analytic operators)
- demos of extreme derivatives and integrals (sin(googol x^2) in 400ms to 6000 digits)
- demos of engine logic
- demos of certificate loading and emission
- full reproducibility scripts and PGP verification
Every artifact in this repo is hashed and PGP signed, ensuring bit-for-bit reproducibility.
If you want to see the math, start with the Letter (proof):
https://github.com/Purrplexia/LettersToMyHeroes/blob/main/Ca...
It is a crafted experience for those who love mathematics.
If you want to try the engine immediately:
pip install phi-engine
(see examples/ after install ive documented everything carefully for you)
If you care about reproducible, verifiable mathematics and globally reusable, cryptographically frozen analytic operators, I hope you enjoy exploring this.
I welcome questions, critique, and adversarial tests from the HN community — you are the first eyes on it — I will post it elsewhere later.
Verify it; test it; break it; disprove it.

value: Show HN: Frozen Function-agnostic goldenratio calculus (pip install phi-engine)

author: purrplexia


value: I learned about LOC records some time around the start of the year from a post here on hackernews, and I've been slightly obsessed with the idea of mapping them ever since - and now I've finally done so! There ended up being a few more than I expected, but still very much within reasonable bounds.

value: Show HN: Mapping DNS

title: Show HN: Mapping DNS


value: Show HN: Kaomojihub – find your favorite kaomoji， learn meaning and usage tips


value:
Hi HN,
I’ve been working on low-level autonomous driving development in C++ (perception, localization, planning, control) for the past year and collected everything I actually use into one repo:
https://github.com/0voice/Awesome-CPP-Autonomous-Driving
Current sections:
Learning Roadmap – From modern C++ to ROS2 to real-time systems
Core Topics Explained – Key C++ implementation details for perception, localization, planning, and control
Learning Resources – Curated courses, books, and classic papers
Datasets – KITTI, nuScenes, Waymo Open, etc. with C++ loading examples
Toolchain – TensorRT, Eigen, PCL, CUDA, and other production tools
Open-Source Projects – Hand-picked C++-heavy projects (Apollo, Autoware, OpenPCDet, etc.)
Autonomous Driving News & Articles – Latest 2025 news reports and in-depth articles
Interview Questions – Real high-frequency C++ questions from Chinese AV companies
Job Openings – Continuously updated C++ autonomous driving positions (domestic & international)
Everything listed is something I’ve personally used, been asked in interviews, or shared with teammates.
Still updating regularly. If you work with C++ in autonomous driving or are preparing for related roles, hope this helps.
Stars, issues, contributions, or just a quick comment are all welcome.
Thanks for reading!

value: Show HN: C++ for Autonomous Driving – From Learning to Landing AV Jobs


value:
I’ve been experimenting with a simple idea: most AI performance problems are not model limitations, but task specification limitations.
Over the past months I’ve tested a set of reasoning workflows that significantly improve output quality for both small and large models. They’re not about “prompt tricks” — they’re about structuring a task so the model can reason cleanly.
Here are the 6 core skills that consistently make the biggest difference:
1. *Decomposition* – splitting a vague task into constraints, context, steps, assumptions.
2. *Constraint stacking* – defining what must be true and what must not happen.
3. *Reasoning path control* – explicit “think aloud but check your assumptions” steps.
4. *Refinement loops* – generate → critique → adjust → regenerate.
5. *Verification passes* – hallucination checks using independent re-reasoning.
6. *Output benchmarking* – defining evaluation criteria before generating anything.
I wrote up an overview of these workflows, with examples and a full breakdown here:
https://dailyaiguide.substack.com/p/ai-reasoning-workflows-t...
If anyone is interested, I can also share:
- detailed decomposition frameworks,
- verification chains,
- or optimized workflows for specific tasks (analysis, learning, planning, writing).

value: Show HN: AI Reasoning Workflows – The 6 Skills That Improve Model Output


value: yeekal

value:
Hello HN,
I built a web interface to evaluate the latest wave of image generation models. It allows you to run prompts across Z-Image Turbo, Nano Banana Pro,  Flux.2 Pro and other top ai models simultaneously to compare inference speed and visual fidelity.
The backend runs on Fal.ai. Because inference costs money, the tool is freemium.
Link: https://z-image.app/arena

value: Show HN: AI Model Arena – Compare Z-Image, Nano Banana Pro, and Flux.2 Pro

author: yeekal


value: rofko

value: Show HN: VoxCSS – A DOM based voxel engine

author: rofko


value: ericlmtn

value: Show HN: A prediction market where you can bet against my goals

author: ericlmtn


value: MoNagm

value:
I built ReddBoss after watching founders spend hours manually searching Reddit for potential customers. The reality? By the time you find a good lead, 10 competitors already replied. Here's how it works:
1-Paste your business URL → AI analyzes your site and identifies relevant subreddits + pain points you solve
2-Get instant lead discovery → AI scans Reddit for posts matching your niche, ranked by intent & buying signals
3-On-demand monitoring → Check anytime for questions, complaints, and opportunities in your space
4- One-click replies → AI drafts 3 reply variants + personalized DM for each lead
5- Viral post generator → Turn your customer stories into Reddit posts trained on top 10 viral posts in your niche
The AI uses semantic matching on pain points (not just keyword search), so you find leads even when they don't use your exact keywords. Real results: Users average 900+ qualified leads/month. One user went from 0 to 10K website visitors using ReddBoss. Pricing: $25/mo (Pro), $59/mo (Growth - 5 projects), $119/mo (Agency - unlimited) Built with Next.js 15, PostgreSQL, Transformers.js for local semantic search, Reddit API with smart rate limiting. The hardest part was building the semantic matching – training on pain points vs keywords. Traditional keyword search misses 70% of relevant conversations. Try it: https://www.reddboss.com What's your Reddit lead gen strategy? Would love feedback from the HN community.

value: Show HN: ReddBoss – Turn Reddit into your lead generation machine with AI

author: MoNagm


value: QuLi-ops

value:
I recently built a simple AI hairstyle try-on tool:
https://aihairstylechanger.space
Right now the flow is:
- 1 free try with no login
- +1 extra free try after logging in
- After that, it's paid (to cover model costs)
I’m unsure if this pricing model is fair or if the UX is confusing.
Would love honest feedback on:
- Is 1–2 free tries enough?
- Is the paywall too early?
- Are the AI results good enough to justify pay-per-use?
- What would you expect as a user?
Tech stack:
- Next.js
- Hair segmentation + masked generation
- Lightweight image pipeline for blending
Any feedback is welcome — on the results, UX, speed, or pricing.

value: Show HN: AI Hairstyle Changer – Try Different Hairstyles (1 free try, no login)

author: QuLi-ops


value: Sai-HN

value:
FT-Lab is a clean, reproducible setup for fine-tuning TinyLlama (supports Full FT, LoRA, and QLoRA) and evaluating Retrieval-Augmented Generation (RAG) pipelines using LlamaIndex and LangChain.
Built for small GPUs and designed with controlled experiments and ablation studies in mind.<p>Feedback and contributions welcome!

value: Show HN: FT-Lab – Lightweight TinyLlama Fine-Tuning (Full FT / LoRA / QLoRA)

author: Sai-HN


value: mgunyho

value: Hi HN! I created a small stack-based programming language, which I'm using to solve Advent of Code problems. I think the forward Polish notation works pretty nicely.

value: Show HN: The Taka Programming Language

author: mgunyho

title: Show HN: The Taka Programming Language


value: Show HN: A crazy fast website built with Cloud flare workers


value: nesall

value:
Hi all! I built PhenixCode — an open-source, self-hosted and customizable alternative to GitHub Copilot Chat.
Why: I wanted a coding assistant that runs locally, with full control over models and data. Copilot is great, but it’s subscription-only and cloud-only. PhenixCode gives you freedom: use local models (free) or plug in your own API keys.
Tech: Pure C++ core with RAG (HNSWLib for vector search, SQLite for metadata). UI is Svelte + webview — lightweight, cross-platform, and designed to be hackable.
Status: I’ve been dogfooding it for weeks; the core is stable. Would love feedback — whether you find it useful, hit bugs, or want to discuss design decisions. Happy to answer questions!

value: Show HN: PhenixCode – Local, open-source alternative to GitHub Copilot

author: nesall


value: cadillac

value:
I built Subtitio after hours of frustration searching for subtitles in my language.
---
Subtitio.ai is an AI service that translates SRT subtitle files into 50+ languages while preserving all timestamps and structure.
# Key features
- Keeps timing/cues/timestamps intact
- 50+ language support
- Async processing (upload → translate → download)
- Parallel processing of multiple files
- API available with OpenAPI/ReDoc schema for integration
# API availability
- Designed for automation pipelines, batch jobs or app integrations
- OpenAPI spec
- ReDoc docs and JSON schema describing request/response format
# Use cases
- Creators localizing video captions at scale
- Education and training videos requiring multilingual SRT
- Teams needing a lightweight programmatic alternative
- Apps that must translate subtitles without invalidating timing
# Differentiator
- Built with timestamp safety first, translations never modify cue timing or corrupt the SRT structure, ensuring downstream compatibility with editors, players, and pipelines.
# Drawbacks
- Support for SRT files only
Feedback welcome and happy to answer questions.

value: Show HN: Subtitio – AI powered subtitle translation (API available)

author: cadillac


value:
Hey HN! We're Hoshang & Vishal, the team behind Pylar - a governed access layer between databases and LLMs. We previously led data and AI and we kept seeing the same problem across teams using LLMs internally: agents are great with unstructured data, but the moment you want them touching your actual systems of record — Snowflake, Postgres, CRMs, product DBs — everything becomes fragile, risky, or outright unsafe.
Two issues show up every single time:
1. Agents over-querying
They don’t understand cost. They’ll happily generate queries that blow up your warehouse bill.
2. Accidental data exposure
PII, financials, customer history leaking through prompt injection or poorly scoped access. Most teams I’ve spoken to don’t feel comfortable letting an agent anywhere near production tables.
The options today aren’t great:
Off-the-shelf MCP servers:
There are thousands out there, most too generic for production and a surprising number are malicious.
Hand-rolled API wrappers:
Takes months, spreads governance across repos, and you end up maintaining a brittle patchwork of endpoints and policies.
ACLs and row-level permissions weren’t designed for autonomous systems. Locking agents down neuters them; opening things up puts your data at risk. We kept seeing this tradeoff.
So we built Pylar.
It sits between your agents and your databases. You connect your sources, create sandboxed SQL views that define exactly what an agent is allowed to see, convert those views into deterministic MCP tools, and publish them to any agent builder through one secure link.
From one place, you can:
- Give agents scoped, sandboxed access (never raw tables)
- Apply consistent governance across all data sources
- Get observability into agent behavior and queries
- Contain misuse before it becomes a breach
- Plug into anything: Claude, Cursor, LangGraph, n8n, etc.
We’ve been working with a few early teams already, across internal analytics agents and customer-facing AI features driven directly by production data.
If you’re solving similar problems around safe structured-data access for agents, I’d love your thoughts.
Here's our
- Docs (https://docs.pylar.ai)
- Website (https://www.pylar.ai)
- Demo (https://youtu.be/w8DPxS5RP2Y?si=4xyO_B4UgjPlIFvM)
You can try our product on a 14 day trial here - https://app.pylar.ai/signup
We're excited to launch here and get feedback on how we're approaching this.

value: Show HN: Pylar – Fix over-querying, data leaks, and governance for AI agents


value: FrankDierolf

value: Show HN: Whis – Voice-to-Clipboard for Linux

author: FrankDierolf


value:
I kept guessing deployment targets for my iOS apps... How many people use iOS 18+? How about SwiftUI? Or SwiftData?
So I built a tool that shows iOS version and framework market share.
Super simple. Browser based. It helps you choose your minimum iOS version fast.
Sharing here because I think you guys might find it useful. Let me know if you can think of something that is missing/could be added or improved

value: Show HN: Free tool to check iOS version and framework market shares


value: popidge

value:
What it is: A fully functional academic journal where every paper must be co-authored by an LLM, and peer review is conducted by a rotating panel of 5 LLMs (Claude, Grok, GPT-4o, Gemini, Llama). If 3+ vote "publish," it's published. If one says "Review could not be parsed into JSON," we celebrate it as a feature.
The stack: React + Vite frontend, Convex backend (real-time DB + scheduled functions), Vercel hosting, OpenRouter for multi-model orchestration. Each review costs ~$0.03 and takes 4-8 seconds.
Why I built it: Academic publishing is already slop—LLMs write drafts, LLMs review papers, humans hide AI involvement. This holds a mirror to that, but with radical transparency. Every paper displays its carbon cost, review votes, and parse errors as first-class citizens.
Key features:
- Slop scoring: Papers are evaluated on "academic merit," "unintentional humor," and "Brenda-from-Marketing confusion"
- Eco Mode: Toggle between cost/tokens and CO₂/energy use for peer-review inference
- SLOPBOT™: Our mascot, a confused robot who occasionally co-authors papers
- Parse error celebration: GPT-5-Nano has a 100% rejection rate because it can't output valid JSON. We frame these as "Certified Unparsable" badges.
The data: After 76 submissions, we've observed:
- Average review cost: $0.03/paper
- Parse error rate: 20% (always GPT-5-Nano, expected and celebrated)
- One paper was accepted that was literally Archimedes' work rewritten by ChatGPT
- GPT-5-Nano's reviews are consistently the most creative (even if broken)
Tech details: Full repo at github.com/Popidge/journal_of_ai_slop. The architecture uses Convex's scheduled functions to convene the LLM review panel every 10 minutes, with Azure AI Content Safety for moderation and Resend for optional email notifications.
Try it: Submit your slop at journalofaislop.com. Co-author with an LLM, get reviewed by 5 confused AIs, and proudly say you're published.
Caveat: This is satire, but it's functional satire. The slop is real. The reviews are real. The carbon emissions are tracked. The parse errors are features.

value: Show HN: The Journal of AI Slop – an AI peer-review journal for AI "research"

author: popidge


value:
I built Fresh to challenge the status quo that terminal editing must require a steep learning curve or endless configuration. My goal was to create a fast, resource-efficient TUI editor with the usability and features of a modern GUI editor (like a command palette, mouse support, and LSP integration).
Core Philosophy:
- Ease-of-Use: Fundamentally non-modal. Prioritizes standard keybindings and a minimal learning curve.
- Efficiency: Uses a lazy-loading piece tree to avoid loading huge files into RAM - reads only what's needed for user interactions. Coded in Rust.
- Extensibility: Uses TypeScript (via Deno) for plugins, making it accessible to a large developer base.
The Performance Challenge:
I focused on resource consumption and speed with large file support as a core feature. I did a quick benchmark loading a 2GB log file with ANSI color codes. Here is the comparison against other popular editors:

  - Fresh:   Load Time: *~600ms*     | Memory: *~36 MB*
  - Neovim:  Load Time: ~6.5 seconds | Memory: ~2 GB
  - Emacs:   Load Time: ~10 seconds  | Memory: ~2 GB
  - VS Code: Load Time: ~20 seconds  | Memory: OOM Killed (~4.3 GB available)

(Only Fresh rendered the ansi colors.)
Development process:
I embraced Claude Code and made an effort to get good mileage out of it. I gave it strong specific directions, especially in architecture / code structure / UX-sensitive areas. It required constant supervision and re-alignment, especially in the performance critical areas. Added very extensive tests (compared to my normal standards) to keep it aligned as the code grows. Especially, focused on end-to-end testing where I could easily enforce a specific behavior or user flow.
Fresh is an open-source project (GPL-2) seeking early adopters. You're welcome to send feedback, feature requests, and bug reports.
Website: https://sinelaw.github.io/fresh/
GitHub Repository: https://github.com/sinelaw/fresh

value: Show HN: Fresh – A new terminal editor built in Rust


value:
Hi HN,
I was editing a 1 hour and 20 minutes video the other day. It had a lot of silent parts (small noises) and I didn't really want to go through and remove everything manually. So, as any engineer does, I built a tool that removes them for me.
It's free, doesn't have a watermark, and works directly in the browser. You can also play with the settings or start from a preset.

value: Show HN: Remove silences from video/audio for free


value: greatjosh

value:
Hi HN, I made system design easy by making an interactive platform to help you simulate and test your design!
While learning system design, I noticed that there weren't any tools around that helps you test and simulate your systems. It's like writing code without being able to actually run your code. So I created a platform that gives you the ability to run and test your designs.
I've also included a gallery of some of the most common system design patterns which I plan on adding more to it.
It's completely free to sign up if you want to do some testing.
I built it with React/Next.js for the frontend and Flask/Firebase for the backend
Would love your feedback on it! What other components would be useful? What system design patterns should I add as templates?
link: robustdesign.io
docs: docs.robustdesign.io

value: Show HN: I made system design easy

author: greatjosh

title: Show HN: I made system design easy


value:
Download the app (free) to play with AiME: https://www.dimerhealth.com/downloadtheapp
Like ChatGPT - but built specifically for healthcare - AiME is Dimer Health’s AI-powered medical companion. Developed and monitored by our AI team and licensed clinicians, AiME delivers instant, personalized medical guidance based on each patient’s real health history, medications, and care plan.
It’s designed for those moments of uncertainty: new medications, strange symptoms, or wondering, “Is this normal?”
Have a medical question? Ask AiME. Then tell us what you think!
I am the primary developer for the app, happy to answer questions!

value: Show HN: The Future of Care Is Here: Introducing AiME


value: mightbefun

value:
Hi HN! I built a super lightweight invoicing platform for solo developers, freelancers, and one-person businesses. Most invoicing software costs $20–$40/month and is packed with features you don’t need. Mine is $20/year and focuses on the essentials:
• Create invoices in seconds
• Send invoices by email
• Automatic email reminders
• Recurring invoices
• Simple dashboard for paid/unpaid tracking
• No team features, no CRM, no bloat
I built this because I freelance occasionally, and every invoicing tool I tried either felt bloated, overly enterprisey, or was way too expensive for solo work. I wanted something simple that didn’t require a “plan,” onboarding flow, or learning curve.
A few things people have asked so far:
• No lock-in — you can export your invoices anytime
• No limits on the number of invoices
• No weird pricing tiers or upsells
• Works well on mobile
• You own your customer list (I don’t touch it)
Here’s what I’m looking for from HN:
• Brutally honest feedback
• Any missing “must-have” features for solo entrepreneurs
• Performance/UX suggestions
• Security concerns I should address early
• Whether the $20/year model feels right
If anyone here freelances or runs side projects, I’d love to know what your current invoicing workflow looks like and what annoys you about existing tools.
Thanks for reading — happy to answer every question!

value: Show HN: A $20/year invoicing tool for solo developers (simple, fast, no bloat)

author: mightbefun


value: judahmeek

value:
Granted, all I've got so far is a Draft Specification for a proof of concept using ARC-AGI-2 as a minimalistic problem domain.
But that was enough for METR.org[0] for recently agree to fund my work on this project.
That little bit of validation goes a long way & the funding won't hurt either.
Also, I have questions for any patent lawyers reading this:
* When do I know if I have enough specification detail to start filing a patent?
* Does this public repository qualify as prior art?
Finally, if my post text seems overly sparse with the details, I apologize & I promise to answer any questions you have as fast as Hacker News allows me to.
0: https://metr.org/

value: Show HN: Testing hypotheses through prediction is the next step towards AGI

author: judahmeek


value: kyletut

value: Show HN: Grapevine – Accountless API for data with built-in pricing (x402)

author: kyletut


value: Show HN: Tentropy Core – open-source to run AI system code in Firecracker VMs


value: mennylevinski

value:
Hi everyone,
Secuditor Free is a Python-based diagnostic security tool for Windows endpoints and networks, suitable for both personal and organizational use.
Key Features:
- One-click, comprehensive endpoint security audit
- User-friendly graphical interface with exportable TXT reports
- Enhanced threat detection diagnostics and SSL/TLS interception analysis
- Many new analytic features, insights, and configuration checks
Screenshots: https://secuditor.com/#whatwedo
I’d love to hear feedback or suggestions from the HN community, this is my first launch here.

value: Show HN: Diagnostic security tool for Windows endpoints and networks

author: mennylevinski


value:
Hey HN, I've been working on Soppo, a language that compiles to Go, adding features to catch errors at compile time instead of runtime: enums with exhaustive matching, `?` for error propagation, and nil safety from static analysis of nil flows (sort of like https://github.com/uber-go/nilaway but currently much less sophisticated). It's designed to still look and feel like Go, and be able to use any Go library directly.
Playground: https://play.soppolang.dev
Not production ready and still a little early in development, but curious what people think about the design.

value: Show HN: Soppo – A Golang superset that adds enums, pattern matching, nil safety


value: dhavalt

value:
Hi HN,
Longtime lurker here.
I built a tiny website called Latent Logbook. It's inspired by the spirit of Advent of Code, but focused on LLMs instead of algorithms.
The idea is simple: You get a puzzle (like parsing a messy log file), you solve it using any model you like, and then you share your strategy. The goal isn't just to solve them but to see how different models handle them. It's fascinating to see someone solve a task with a 7B parameter model, but it's even more insightful if someone pulls it off with a weird, tiny, quantized model running locally. (If anyone has ideas for new puzzles/traps to add, I’d love to collaborate.)
The Mechanics:
* Trust System: When you submit a solution, you get 5 Latents (points). We trust you to actually do the work.
* Archive: Solving a puzzle unlocks the shared log where you can see everyone else's prompts and models. The puzzles small and bite-sized so you don't have to burn a ton of tokens (or money) to participate.
* Upvotes: If you see a particularly clever prompt or a unique model choice, you can spend your Latents to upvote that solution.
* Technologies: Just server-side Hapi.js and Handlebars, backed by SQLite. It runs on a $5 VPS and is super lightweight.
It might crash and burn, but I think it’ll be fun to see what happens.
I’m stepping away for a bit but will be back to answer questions later.
Thanks for checking it out!

value: Show HN: Latent Logbook – Prompt Puzzles Built with Hapi.js and SQLite

author: dhavalt


value: ssssota

value:
I built chapplin, a small framework for making ChatGPT Apps.
The Apps SDK gives only low-level primitives, and building UI means bundling a single HTML file with all JS/CSS inside an MCP server. The build setup and type sharing became painful, so I made a tool that hides the build process and provides a type-safe setup end-to-end.

value: Show HN: Chapplin – a type-safe, all-in-one framework for the ChatGPT Apps SDK

author: ssssota


value: sensecall

value:
This started as a quick script to sanity check EV running costs, and turned into a handy little comparison tool.
I haven't been able to find anything which shows at which price points EV is cheaper/more expensive than ICE – the heatmap shows it pretty concisely.
It’s a bit rough round the edges, but people have found it pretty useful, so I figured I'd spin it out into its own site. Sharing for feedback.

value: Show HN: EV vs. ICE Breakeven Tool

author: sensecall

title: Show HN: EV vs. ICE Breakeven Tool


value: calebhwin

value: Show HN: We're Building an AOT/JIT Compiler for Program-of-Thought Prompting

author: calebhwin


value: supreetgupta

value:
Many teams connecting LLMs to external tools eventually encounter the same architectural issue: as more tools and agents are added, the integration pattern becomes an N×M mesh of direct connections. Each agent implements its own auth, retries, rate limiting, and logging; each tool needs credentials distributed to multiple places and observability becomes fragmented.
We built LLM gateway with this goal to provide a single place to manage authentication, authorization, routing, and observability for MCP servers, with a path toward a more general agent-gateway architecture in the future.
The system includes a central MCP registry, support for OAuth2/DCR integration, Virtual MCP Servers for curated toolsets, and a playground for experimenting with tool calls.
Resources -
Architecture Blog – Covers the N×M problem, gateway motivation, design choices, auth layers, Virtual MCP Servers, and the overall model.
https://www.truefoundry.com/blog/introducing-truefoundry-mcp...
Tutorial – Step-by-step guide to writing an MCP server, adding Okta-based OAuth, and integrating it with the Gateway.
https://docs.truefoundry.com/docs/ai-gateway/mcp-server-oaut...
Feedback on gaps and edge cases is welcome.
https://www.truefoundry.com/mcp-gateway

value: Show HN: MCP Gateway – Unifying Access to MCP Servers Without N×M Integrations

author: supreetgupta


value: andersmyrmel

value: Show HN: Store Inspector – Free Chrome extension for Shopify competitor research

author: andersmyrmel


value: riktar

value:
I built *rephole*, an open source tool that transforms one or more code repositories into a semantic search engine, accessible through a simple REST API.
What you get
* Clone + parse + index any number of repos (20+ languages supported)
* Generate embeddings, store them in a vector database, enable semantic search by intent (not just keyword matching)
* Ask natural language questions like “how does authentication work?” — get relevant file snippets returned
Why it matters
* Navigating large or polyrepo codebases manually is slow and error-prone
* Semantic search helps you find relevant code even if you don’t remember exact file names or code paths
* REST API + docker-compose deployment lets you self-host quickly and integrate it with existing workflows
If you work with large or multiple codebases, rephole can save you time and make code navigation easier. Feedback, issues or PRs welcome
GitHub: https://github.com/twodHQ/rephole

value: Show HN: Rephole, semantic code-search for your repos via REST API

author: riktar


value: nonatofabio

value:
I built this because I got frustrated with the current state of "local" RAG. It felt like I had to spin up a Docker container, configure a vector DB, and manage an ingestion pipeline just to let Claude ask questions about a few PDFs in a folder.
We seem to have turned "grep with semantics" into a microservices architecture problem.
What this is: local_faiss_mcp is a minimal implementation of the Model Context Protocol (MCP) that wraps FAISS and sentence-transformers. It runs entirely locally (no API keys, no external services) and connects to Claude Desktop via stdio.
How it works:
You run server.py (Claude runs this automatically via config).
It uses all-MiniLM-L6-v2 (on CPU) to embed text.
It stores the vectors in a flat FAISS index on disk alongside a JSON metadata file.
It exposes two tools to the LLM: ingest_document and query_rag_store.
The stack:
Python
mcp (Python SDK)
faiss-cpu
sentence-transformers
It’s intended for personal workflows (notes, logs, specs) where you want persistent memory for an agent without the infrastructure overhead.
Repo: https://github.com/nonatofabio/local_faiss_mcp
I’d love feedback on the implementation—specifically if anyone has ideas on better handling the chunking logic without bloating the dependencies, or if you run into performance issues with larger indices (10k+ vectors).

value: Show HN: Local_faiss_MCP – A tiny MCP server for local RAG (FAISS and MiniLM)

author: nonatofabio


value: entrehacker

value:
Hi HN. I crawled the MCP corpus, catalogued everything and built a standalone desktop app for Windows, macOS and Linux.
We all know MCP has caught on, but is frequently criticized for lack of discoverability, overly permissive standards (e.g. auth, SSE vs Stdio), and wide attack surface. I wanted to build a desktop app dedicated to MCP, that could improve discoverability and address quality issues through collaborative tool use and curation. ToolPlex Desktop provides personalized recommendations, search functionality, tons of categories, and recommendation algorithms to promote the best MCP tools over time. It also has community feedback and reporting mechanisms so agents and users can give real time feedback to other agents.
On top of this I built an agent-native workflow builder (agents can build workflows) called playbooks. Playbooks are step by step shared workflow memory that can be used on across any AI model in the app. The general flow in ToolPlex is 1) install the MCP tools you like, 2) build playbooks for your recurring playbooks, 3) run your tools and playbooks with one click, 4) discover new tools and workflows; repeat.
ToolPlex operates on BYOK for the main AI providers or you can use the built in AI gateway. I built a new chat interface designed specifically for tool calling with advanced features like token limits on tool responses and detailed context length reporting. Any feedback is appreciated. Thanks!

value: Show HN: ToolPlex Desktop – MCP marketplace and AI workflow builder

author: entrehacker


value: milowata

value:
As an old, I miss the AIM days of getting home from school and turning on the computer, waiting for friends to come online, and chatting with them live (and basically only saying "hey, sup, nm u, jc")
We don't get that with messaging now because everyone is on mobile. Folks with Bloomberg Terminals can have this IM experience, because they are sitting with it open all day. Slack is like this too...but only for people within your company.
And as a developer, me and the rest of us are sitting with our IDEs open all day; why can't we have IM back? Thus, devchat: an extension in VSCode that brings back the IM experience of yore.
It's all live, and messages are only shepherded between clients but never stored/viewed on a server. It's got themes for you to feel like you're back using AIM, or a Bloomberg Terminal, or for those who like iMessage.
Find devchat IM in VSCode extensions, tell your friends to join you, and enjoy chatting while you work! Any and all feedback is welcome, thanks!

value: Show HN: Aim-Style Instant Messaging in VSCode

author: milowata


value: dubovetzky

value: Show HN: Synthome – TypeScript SDK for building composable AI media pipelines

author: dubovetzky


value: sumanthchary

value:
ApiRealTest tests APIs through actual user interactions, not just technical requests.
Problem: APIs work in Postman/Insomnia but break in production when users send real data - emojis in chat messages, oversized files, malformed JSON, edge cases.
Solution: Interactive testing interface simulating user behavior:
Quick Test Playground:
OpenAI, Anthropic, Stability AI, Google AI, Hugging Face
Paste API key → Click test → Results in 10s
text
$ curl -H "Authorization: Bearer sk-..." https://api.openai.com/v1/chat/completions
→ 5 lines of code and headers
ApiRealTest: Select platform → Paste key → Click "Chat"
Testing Modes:
Chat: Test conversational APIs (emojis, rapid messages)
Files: Upload images/docs (size limits, security)
JSON: Syntax-highlighted editor with validation
Forms: Key-value pair builder
Analytics: Response times, error rates, payload analysis.
Status: Beta - core features work reliably. UX polish in progress.
Pricing: Free (10 tests/day), $9/mo unlimited, $29/mo teams.
Tech: React + Tailwind + Supabase + Lovable.dev (~10 days to MVP).
Demo: https://api-real-test.lovable.app
Feedback welcome on usability, missing features, pricing.
What real user inputs broke your APIs in production?

value: Show HN: ApiRealTest Beta – Test APIs Through Real User Scenarios

author: sumanthchary


value: You talk, and it automatically builds a visual network of your beliefs, thoughts, desires, and more. The system extracts concepts like beliefs, emotions, and cognitive distortions, then updates a force-directed graph showing how everything connects. Recurring nodes naturally drift toward the center as the graph expands, revealing your core themes.<p>It isn’t intended for therapeutic use. It’s a tool that makes you introspect and helps uncover the driving factors behind your issues instead of trying to solve the problem and suggest solutions (although you can ask it for solutions when needed). I made it to help me quickly figure out the root of the problem and understand the 'why' behind my thoughts.

value: Show HN: Visualize Your Thinking Patterns as a Graph


value:
Every so often I open a very long thread on HN and because there are so many replies it slows down my browser considerably. It's mostly the amount of elements in the HTML, so I felt like taking a shot at creating an HN frontend.
I made this minimalist version of HN, and it works by just opening the index.html locally. It creates a local cache of the items fetched in IndexedDB, and only loads a few items in batches.
Replying and upvoting only work with a local server, and also copying the user cookie, since I don't think there is a way to log in via API. This workaround works well if you don't mind installing Node and just running two or three commands, and having the terminal in the background. Any tips to get login working via API if it's possible are appreciated.
Summary:
- plain JS/CSS/HTML
- uses IndexedDB to cache items
- works statically for read-only. Writes require running the local node server locally (instructions in the repo: https://github.com/proc0/HackerZen)
- this is mostly a beta with more features planned

value: Show HN: HackerZen – a minimalist Hacker News clone


value: wwdmaxwell

value:
GitHub semantic indexing seems locked to Copilot via the GitHub web interface. I’ve found it helps for the odd question here and there.
However I wanted that same codebase-awareness in Cursor, Claude Desktop, Cline, etc. — especially for private repos. So that I could stop cloning repos just to ask questions.
I created a remote MCP server that runs on Cloudflare Workers.
You can test it out via:
```json
{<p>"mcpServers": {<p><pre><code>  "gss": {

   "type": "http",

   "url": "https://github-search.lokeel.com/mcp",

   "headers": {

    "GITHUB_TOKEN": "<YOUR_TOKEN>"

   }

  }

 }
</code></pre>
}<p>```
And you can ask it a question like
> Use the gss mcp to lookup how I can implement a paginated datafetcher from @netflix/dgs-framework
I also find it really good for looking up test examples in repos to figure out how to properly use an sdk’s test utilities.
The MCP uses your GitHub access token to access repos, so you could ask questions about any repo the token can access.
I’ve also included instructions for how you could run your own instance to also own/manage all the data if preferred: https://github.com/edelauna/github-semantic-search-mcp/tree/...
There are still a bunch of edge cases that need to be addressed to productize something like this, but I just wanted to share as I’ve been finding it super helpful in my workflow and I’ve noticed the traffic on it has been growing.
Some next steps I was thinking were to try and create a deployable template and also figure out how to deploy this behind a vpn or in a private network, since Cloudflare is typically on the edge.

value: Show HN: Copilot's semantic code search, now as a remote MCP

author: wwdmaxwell


value: shodh-varun

value:
Hey HN, I built this because most AI memory solutions (mem0, Zep) need cloud connectivity. That doesn't work for drones flying beyond cell coverage or robots in warehouses.
Shodh-Memory is a local-first AI memory system:

  - 100% offline, runs on edge devices
  - 4MB binary, sub-100ms retrieval
  - Multi-tier memory (working → session → long-term)
  - Geo-spatial queries for GPS-tagged memories
  - Mission tracking for autonomous systems

Install: pip install shodh-memory

  Quick example:
  ```python
  from shodh_memory import MemorySystem

  memory = MemorySystem("./robot_memory")
  memory.record(
      content="Obstacle detected at X=5.2, Y=10.1",
      experience_type="observation"
  )
  results = memory.retrieve("obstacles near position 5")

Rust core with Python bindings via PyO3.
Website: https://shodh-rag.com/memory
PyPI: https://pypi.org/project/shodh-memory/
GitHub: https://github.com/varun29ankuS/shodh-memory
Feedback welcome - especially from anyone working on robotics or edge AI.

value: Show HN: Shodh-Memory – Offline AI Memory for Robots and Drones (Rust/Python)

author: shodh-varun


value: victornomad

value:
Hi HN,
I’m currently building "LLMParty," a project where I release a new LLM experiment every two days in December (sort of like a coding advent calendar).
Today’s experiment is WanderWorld. It’s an interactive map where you can search for locations using natural language.
The Tech:
The core mechanic relies on forcing the LLM to output a specific JSON schema containing coordinates (lat/long). I found that by strictly enforcing the output structure, even smaller, self-hosted models are surprisingly good at geography.
What makes it fun:
While it handles standard queries ("Where is Paris?"), it really shines with abstract requests. You can ask for "places that smell like candy" or "best places to see horses" and it maps them out instantly. (don't expect something accurate! :)
I’d love to hear what weird queries you try and if the coordinates hold up!

value: Show HN: WanderWorld – Search a map using natural language queries and LLMs

author: victornomad


value: safekeylab

value:
Hey HN,
I built SafeKey because I was handling patient data as an Army medic, then doing AI research at Cornell. Every time we tried to use LLMs with sensitive data, something leaked. Existing tools only covered text at ~85% accuracy. Nothing worked across modalities.
SafeKey is an AI input firewall. It sits between your app and the model, redacting PII before data leaves your environment.
What we built:
PII Guard: 99%+ accuracy across text, images, audio, video
AI Guard: Blocks prompt injection and jailbreaks (95%+ F1, zero false positives)
Agent Security: Protects autonomous AI workflows
RAG Security: Secures retrieval-augmented generation pipelines
Sub-30ms latency. Drop-in SDK for OpenAI, Anthropic, Azure, AWS Bedrock. Runs in your VPC or our cloud.
Would love feedback on the approach. Happy to answer questions.
Thanks,
Sukin

value: Show HN: SafeKey – PII redaction for LLM inputs (text, image, audio, video)

author: safekeylab


value: bodhigephardt

value:
Learn faster and remember more from everything you wanted to read/watch/listen to that you didn't have time to get to.
Cortex generates summaries, top insights and quotes, full transcripts, chapter lists and more from any podcast episode, youtube video, or web link.
You can highlight anything you find interesting to review later and import your external highlights (similar to Readwise) from books as well.
Give it a shot and let me know what you think!

value: Show HN: Cortex – learn faster from podcasts, YouTube, articles, and books

author: bodhigephardt


value: midito

value:
I fly between the Canary Islands and mainland Spain regularly.
Every time I book, I deal with the same frustrations: awful
airline UX, re-entering passenger details, find the perfect seat, constant upsells,
and wondering if I'm being scammed.
So I built Avolal—the flight booking tool I wanted.
What makes it different:
- Natural language search that understands context
Type "SF to Seattle next weekend" → picks Friday PM/Sunday return
Type "SF to LA Monday, meeting at 2pm in Santa Monica" → finds the right flights
- Learns your preferences (seats, fares, routes) and saves your details
- Ranks by actual value (price + time + airport quality), not commission
- No dark patterns, no ads, no games
You can try it at avolal.com - no signup required to search.
Still very early. Would love honest feedback on what works and what doesn't.

value: Show HN: Avolal – Book routine flights in 60 seconds

author: midito


value: ibbie

value:
Push notifications are essential for mobile apps, yet they’re still a major friction point. Many developers choose Supabase or Firebase specifically to avoid backend code, but eventually end up writing server-side logic or Edge Functions just to send notifications.
I built Entrig to eliminate that hassle. It lets you send push notifications without any server setup and without writing code, purely based on your database events.
How it works:
Entrig leverages Supabase/Postgres triggers. When you create a notification in the Entrig Dashboard, the required trigger function is automatically created in your database. On the client side, the SDK handles token management when you initialize it in your app.
The goal is to make push notifications truly plug-and-play, so you can focus on building your product, not wiring backend logic just for push notifications.
I’d love to hear your feedback on the product and approach.

value: Show HN: Entrig – Push notifications for Supabase without backend code

author: ibbie


value: epimono

value: We're excited about cross-layer transcoders both as tools for reconstructing computational circuits in LLMs and as high-quality feature libraries for unstructured text data. There aren't a lot of open-source CLTs available, so we trained a couple for members of the Qwen3 family to fill in that gap. Link is to a dashboard for exploring the features, including topological maps of the feature space. The models themselves are available on Hugging Face: https://huggingface.co/collections/bluelightai/qwen3-cross-l...

value: Show HN: Cross-Layer Transcoders for Qwen3

author: epimono


value: stared

value:
Hi HN!
I am fascinated by various ways of explaining mathematical formulas easily — see “Science-based games and explorable explanations”: https://p.migdal.pl/blog/2024/05/science-games-explorable-ex.... In particular, I got inspired by “Understanding the Fourier Transform” by Stuart Riffle from 2011 (https://web.archive.org/web/20130318211259/http://www.altdev...), in which he color-coded the Discrete Fourier Transform formula and its description.
Yet, I saw that it has two issues. First, while many people appreciate it, creating them manually is a huge hassle. Second, it does not work well for colorblind people (as a few friends of mine told me).
So, I wanted to make it interactive, both to be able to choose the color scheme and so that it is useful in black and white (as you can hover and select terms).
For the syntax, I picked the default go-to, LaTeX (here it is rendered with KaTeX).
For the description of the equation and explanation, I used Markdown, so it is easy to pick up.
I quickly realized that adding an online editor is a game-changer: what started as an optional extra became a default, always-visible part of the tool.
Some equations are more polished, some less so. Among others, there is the Schrödinger equation, the Euler equation, Shannon entropy, the grand canonical ensemble, and, of course, the Discrete Fourier Transform. I wanted to see how it works for various cases. Einstein's mass–energy equivalence serves as a starter template. Don’t be alarmed by the Maxwell equations with too many colors - I wanted to stress-test it.
You can export this to a standalone HTML file with its interactivity.
Also, you can export the same formula to LaTeX (both a regular article and a Beamer presentation) and Typst. For LaTeX and Typst articles, it loses interactivity, but the colors are the same. In LaTeX Beamer, there is a slide-by-slide explanation of each term.
Source (MIT license): https://github.com/stared/equations-explained-colorfully/
I am curious to hear your impressions!
If you want to add a formula, do so.
If you want to feature it so that it is useful in your class or course, I am happy to hear which.
If you want to suggest color themes, let me know.
Also, if you want some other export formats, it should be easy.

value: Show HN: Equations Explained Colorfully (KaTeX and Markdown)

author: stared


value: tluthra

value:
Hi HN,
Tanooj and Aziz here from Nerve. We’re building a work AI that handles full end to end workflows rather than just chat replies. It starts with proactively figuring out what’s important to you - anything you need to take action on or updates on any projects - and then moves all the way through the process. Nerve gathers the relevant information, drafts documents, writes jira tickets, sends emails, etc.
What this looks like in practice is: say an account executive has a sales call that gets recorded into Gong, Nerve automatically picks up the call, and extracts the next steps. Users can then load up that call and Nerve takes a first pass: scheduling a follow-up meeting, putting together security info, updating a salesforce opportunity. This ends with user confirmable actions that commit what was put together across the relevant apps.
Demo: https://youtu.be/pi7YN9DgW0g
Stepping back a bit, we spent a while at other growing companies (Brex, Coinbase, Box), and the teams at each eventually got slower. Information got more spread out, people spent more of their time just shuttling data from one place to another, and this type of admin work ended up getting way more common.
The most common thing we heard from users currently is: “I use a lot of ChatGPT for work but I wish it had access to all my work info, and actually did more of the work”. In many ways just the AI search and chat interfaces represented a sliver of what actually needed to get done on a daily basis.
We’re trying to answer the question “what could a company-wide tool look like if there was an AI layer that abstracted away everything we normally interact with?”. To do all of this we connect to all the various apps a company uses, index and analyze updates as they happen across every data source, and map every piece of information to the users that have access to it. And then we try to pull out the relevant pieces.
If you’d like to try Nerve we just launched for public access and offer a free 14 day trial: www.usenerve.com
We’d love your feedback and if there’s anything you’ve been looking for in your work AI, please share!

value: Show HN: Nerve – The AI Chief of Staff that does your actual work

author: tluthra


value: phaser

value: It all started as an experiment to see if I could build a game making heavy use of Deno and its SQLite driver. After sharing an early build in the „What are you working on?“ thread here, I got the encouragement I needed to polish it and make a version 1.0 for Steam.<p>So here it is, Microlandia, a SimCity Classic-inspired game with parameters from real-life datasets, statistics and research. It also introduces aspects that are conveniently hidden in other games (like homelessness), and my plan is to continue updating, expanding and perfecting the models for an indefinite amount of time.

value: Show HN: Microlandia, a brutally honest city builder

author: phaser


value: domysee

value:
What is Textwave?
Textwave is a browser-based document editor. All data is stored in the browser (local storage and IndexedDB). Currently it's a side-project for me.
The main differentiator is the version system.
Typical editors only have one list of versions. Going back from version 5 to version 2, editing something, and creating a new version, appends to the list as version 6.
Textwave's version system is closer to git (though not the same). It lets you go back, edit, and create a new version directly below the selected version. Basically it creates a new branch.
Current features (beyond normal document editing)
* Comments, suggestions, and replies
* Create/rename/delete versions
* Showing added/removed words to previous version
* Preview version on hover
* Export to Markdown and HTML (inlines images with base64)
* Export and import documents via JSON
* Light and dark mode
Why did I develop it?
I wanted something where versions feel lighter than the web-based editors I'm used to. When I write an article, I want to create a version without much fanfare. Similar to what I am used to when creating a git commit. With other editors creating a version feels very heavy.
Another goal was that all history is preserved, so that I don't need to create versions for everything. Every change I make should be recoverable.
Often I write something where I believe it might be useful later on, just not now. With that I can always recover it.
Textwave currently already stores all changes, but doesn't expose them in the UI just yet.
What's planned for the future?
There are a couple of issues that I want to iron out.
Larger features that I want to add (as time permits) are
* Make usable on mobile
* Shortcuts
* Showing full edit history
* AI integration (e.g. highlight text and ask for separate phrases, style checker, research assistant - the options are endless), with bring your own API key
I'd also love to calculate metrics like "information density", but less sure about that.

value: Show HN: Textwave – Versioning for Documents (free, local-only document editor)

author: domysee


value:
I wanted to share MemState, an open-source library I've been building for strict agent state management.
It acts as a Git-like layer for Python agents: unlike standard vector memory, it enforces Pydantic schemas and supports transactional rollbacks (Time Travel) to prevent state corruption.
Key technical features:
* Strict Schemas: Uses Pydantic to validate memory on write. If an LLM tries to save a string into an int field, the transaction fails before corruption happens.
* Time Travel: Every change is an append-only transaction. You can call memory.rollback(1) to undo an agent's hallucination.
* Constraints: Enforce logic like Singleton facts (e.g., only one "User Profile" per session).
* No Vectors required: It uses SQLite's JSON1 extension for structured filtering, which is faster and deterministic for state lookups.
It includes a native checkpointer for LangGraph, so you can persist agent threads to SQLite with full history auditability.
It's open source (Apache 2.0).
Would love to hear your feedback on the architecture!

value: Show HN: MemState – Transactional, type-safe memory for AI agents (SQLite/Redis)


value:
I have ideas for t-shirts all the time, and I found making them a pain - making a good design, volume minimums, long fulfillment times - so I rarely followed through.
I made this site to streamline things. You create and iterate on your design using text and references images. Once you save, you and your friends can order the t-shirts immediately. Fulfillment including shipping takes about a week.
People have been using it to create one off t-shirts of their friends, small group orders for in-jokes, and startup schwag.
Image generation and iteration is powered by Nano Banana Pro.

value: Show HN: GPTShirt – Custom t-shirts powered by Nano Banana Pro


value: milabr

value: * Advancing Health with Intelligent Healing Signals<p>Informiton delivers targeted information-bearing signals to restore balance, strengthen resilience, and support the resolution of disease in humans, animals, and agriculture.

value: Show HN: Informiton – Intelligent Healing Signals

author: milabr


value: onasta

value:
I’m excited to announce Scaling Mode for TabPFN-2.5, our tabular foundation model (Large Tabular Model). This removes any fixed upper limits on dataset sizes and extends TabPFN to datasets with millions of rows.
What is Scaling Mode? A new pipeline around TabPFN-2.5 designed for large-N workloads, which removes the fixed row limit of TabPFN. The system works with large training sets, constrained only by your compute and memory.
We benchmarked Scaling Mode on datasets ranging from 1M to 10M rows, comparing against CatBoost, XGBoost, and LightGBM. Key findings:
- Scaling Mode enables TabPFN-2.5 to continue improving performance with more data
- Scales dramatically better than TabPFN-2.5 with 50K subsampling
- No evidence of the performance gap to gradient boosting shrinking as we scale up
- Performance continues to improve strongly with more data on the largest tested datasets
To quickly summarise our progress, here's the history of our scaling trajectory:
- TabPFN v2 (Jan 2025): 10K rows
- TabPFN-2.5 (Nov 2025): 50K rows
- Scaling Mode (today): 10M+ rows tested
Current limitations: Scaling Mode is designed for companies for now. If you’re working with data at a large scale and want to test it, access is currently only by request to ensure we can support early users properly.
Full blog post: https://priorlabs.ai/technical-reports/large-data-model
Request access: https://priorlabs.ai/tabpfn/large-data
Would love to hear feedback from anyone working with large tabular datasets!

value: Show HN: TabPFN Scaling Mode – Tabular Foundation Model on millions of rows

author: onasta


value: melvinodsa

value:
I just launched the beta version of Anvitra Search, a search engine that aims to deliver great relevance without requiring teams to become search experts.
Instead of spending weeks tuning ranking formulas, embeddings, synonyms, typo rules, or feedback loops, you just connect your dataset and define what matters and the system takes care of the rest.
What’s inside (right now in beta):
1. Hybrid search: keyword + vector search working together automatically
2. Works with structured & unstructured data
3. No manual ranking tuning required
Website: https://anvitra.ai
Docs: https://anvitra.ai/docs
I know I am early, and hence looking for honest feedback, criticism, and feature requests.
Would love to hear what you think!

value: Show HN: Anvitra – Human like search (public beta)

author: melvinodsa


value: sentomk

value: Show HN: Patternia – A Zero-Overhead Pattern Matching DSL for Modern C++

author: sentomk


value: mikias

value:
I scraped 5,000+ NDE/OBE accounts from public research databases, extracted structured data, generated embeddings, and used UMAP to project them into 3D space.
The result is an interactive "consciousness map" where similar experiences cluster together.
Tech stack: Next.js, Supabase (pgvector), Vercel, OpenAI API, Three.js.
Some interesting patterns:
- "Void" experiences cluster separately from "light" experiences
- High Greyson scores tend to include more entity encounters
- Cardiac arrest NDEs cluster differently than drowning NDEs
Happy to answer questions about the AI pipeline or the data.

value: Show HN: I analyzed and visualized 5k near-death and out of body experiences

author: mikias


value: toutoulliou

value:
After months of coding, I built a comprehensive health directory for France that helps people find healthcare facilities and practitioners near them. The site is completely free, features real-time geolocation, and covers thousands of establishments and medical professionals across the country.
What you can find:
- Search by healthcare facility type (hospitals, clinics, nursing homes, mental health centers, etc.)
- Search by practitioner type (general practitioners, specialists, surgeons, paramedics, etc.)
- Geolocation to find the nearest options
- Filter by city, postal code, or use your current location
- Detailed information including contact details, addresses, and specialties
- Health blog with articles and medical news
The platform aggregates official data from French health authorities and includes 11 categories of establishments and 12 categories of practitioners, making it easier for people to access healthcare information.
Built with Django, features autocomplete search, responsive design, and is optimized for mobile use.
I'd love to get your feedback on the user experience, search functionality, and any features you'd like to see added!

value: Show HN: Free French Health Directory – Find Doctors and Medical Facilities

author: toutoulliou