value: justvugg

value:
PolyMCP is a framework for building and interacting with MCP (Model Context Protocol) servers and for creating agents that can use those servers as dynamic tools.
Developing and managing MCP servers often involves several challenges:
Exposing Python functions as discoverable tools requires repetitive boilerplate.
Coordinating multiple MCP servers simultaneously is complex.
Debugging tools during development is hard due to limited visibility into calls and outputs.
Integrating agents with LLMs to automatically discover and invoke tools is usually ad-hoc.
PolyMCP addresses these challenges by providing:
Flexible tool exposure: Python functions can be served over HTTP, in-process, or stdio with minimal setup.
Inspector dashboard: Monitor tool invocations, metrics, and test calls interactively in real-time.
Agent integration: Support for multiple LLM providers and automatic tool discovery and invocation.
CLI and workflow utilities: Streamline project setup, testing, and execution.
PolyMCP reduces friction in MCP server development and multi-tool agent orchestration, offering a reliable framework for building intelligent, tool-driven systems.
Github: https://github.com/poly-mcp/Polymcp

value: Show HN: PolyMCP – a toolkit for MCP servers and agent integration

author: justvugg


value: alepacheco-dev

value:
I built Stash because I was tired of the usual tradeoff in file sharing: either force recipients to create accounts or give up on privacy.
How it works
 1. Upload from the iOS, iPad or Mac app
 2. Get a shareable link
 3. Recipients download in the browser, no app, no account, nothing to install
Encryption model
Files are encrypted on device using AES 256 GCM before upload.
The encryption key lives only in the URL fragment (after #), which browsers never send to servers.
Even if the link is intercepted in transit, the file cannot be decrypted without the fragment.
The server never sees plaintext or keys.
Native Mac app
Built with Mac Catalyst and full bidirectional drag and drop.
Drag files onto the app to upload.
Drag files out of the app to save them anywhere.
No save dialogs, no friction. It feels like moving files in Finder.
What I optimized for
• No file size limits
• No compression, original quality preserved
• Links do not expire unless you delete them
• Native Apple UX for senders, universal browser access for recipients
The goal was something my non technical family could use to receive files securely without walkthroughs, accounts or app installs.
I would love feedback on the encryption approach and the UX, especially from people who have built or reviewed similar systems.
Web: https://stash-app.xyz

value: Show HN: Stash: End-to-end encrypted file sharing with zero friction

author: alepacheco-dev


value: adesane

value:
Hello,
I built Frontmatter Core after repeatedly hitting the same problem: modern frontends and CMS don’t share the same model.
Astro components define structure through props.
CMS expect explicit content models.
Frontmatter Core scans Astro, Markdown and YAML files and extracts a stable, typed JSON Intermediate Representation that adapters or CMS can consume.
It runs at build time only:
- no runtime
- no client-side JS
- no database
- no CMS coupling
The idea is to keep:
- layout in .astro
- content in .md / .yaml
- structure expressed once, in code, then exposed as data
Adapters (PHP, flat-file CMS, headless CMS, etc.) plug into the same IR.
GitHub: https://github.com/withfrontmatter/frontmatter-core
Happy to answer technical or architectural questions.

value: Show HN: Frontmatter Core – a build-time content layer for Astro

author: adesane


value:
Gitmore (https://gitmore.io) – plain English access to your Git activity.
If you're a founder, PM, or exec who doesn't code, you probably rely on engineers to tell you what's shipping. That works until investors ask for updates, customers want a changelog, or you just need to know where things stand.
*The problem:*
Your engineers already document their work. Every commit, every PR. But that information lives in GitHub – a UI built for developers, not stakeholders.
*What Gitmore does:*
Connect your repos. Ask questions like you're talking to a teammate:
- "What shipped last week?"
- "Who's working on the mobile app?"
- "What's blocking the release?"
Plain English in, plain English out.
*Slack integration:*
Connect the bot to your workspace. Ask questions directly from Slack – no need to open another dashboard. Your whole team gets access without needing GitHub logins.
*Automated reports:*
Schedule weekly or monthly summaries to Slack or email:
- Features shipped
- Bugs fixed
- Who contributed
Forward to investors. Share with your board.
*How it works:*
Webhooks only. Git platforms push metadata to us – commit messages, PR descriptions, authors, timestamps.
Every event normalized into a structured schema. The AI queries structure, not raw text.
*Who it's for:*
- Non-technical founders
- PMs writing changelogs
- Execs who need visibility
- Anyone outside engineering who needs to know what's shipping
*Security:*
Metadata only. We never clone repos or access source code.
- Encrypted tokens (Fernet)
- Webhook signature verification
- 2FA support
GitHub, GitLab, Bitbucket – one dashboard.
Free for 1 repo: https://gitmore.io
Are there non-technical people on your team who struggle to get dev visibility?

value: Show HN: Building dev visibility for non-technical founders and stakeholders


value: Show HN: TinyCity – A tiny city SIM for MicroPython (Thumby micro console)


value: sbondaryev

value:
Hi HN,
I made an interactive guide showing why neural networks need specific training techniques.
Start with a simple network trying to learn x². Each section introduces a problem like gradient explosion or dead neurons and shows the fix that solves it using ReLU activation, He initialization, gradient clipping, and momentum.
All code is editable and runs in the browser.

value: Show HN: Why Neural Networks Need He Init, Clipping, and Momentum

author: sbondaryev


value: Show HN: I recreated the "popcorn" Time Service


value: dangtung

value: Show HN: MarkView – Markdown viewer with folder navigation and bookmarks

author: dangtung


value: emnudge

value:
Hey!
First was just a test to see if I could. Then became a pretty fun test on iteration loops. How little I could be involved and what kind of instruction works best.
It's a language server for WAT, the webassembly text format. There are not many of these that exist in general, so it's very easy for this to claim the #1 spot.
It's a problem that has some clear correctness criteria so putting it in a loop with Claude Code on Opus 4.5 kept producing really nice results.
The repo includes a playground so you can see how it feels without needing to download anything. Check it out at https://wat-lsp.emnudge.dev/

value: Show HN: I vibecoded a language server for web assembly

author: emnudge


value: QaysHaji

value:
Hello HN,
I’m the builder behind Azurite. I built this because I found that my bottleneck wasn't the volume of notifications (Linear, Slack, GitHub), but the context switching cost required to process them.
The Problem: Every time I opened a Linear ticket, I had to:
Read the ticket.
Search Slack to find the thread where the decision was made.
Check GitHub to see if the PR was actually merged. Result: Context switching 3 times just to make one decision.
What it is: Azurite is a unified triage interface that treats notifications as a deck of cards. The "magic" is that it pre-fetches the Context Graph. Instead of just showing you "Fix Login Bug," it scans the ticket description, finds the linked Slack thread URL, fetches the summary via the Slack API, and pins it to the card. You see the answer, not just the task.
The Architecture:
Frontend: React + Framer Motion (Optimistic UI with spring physics for 60fps interactions).
Backend: Python (FastAPI) handling Async Webhooks (no polling lag).
Orchestration: Built on Anthropic's Model Context Protocol (MCP). We treat SaaS tools as standardized "Servers" and the backend as the "Client."
Intelligence: Hybrid Chain. Llama 3.3 (via Groq) for sub-second classification, GPT-4o-mini for deep context summarization.
Data: SQLite (Edge-Cached). We map the relationships between external tickets and conversations server-side for speed.
A Note on Access (The Google 100-User Limit): Because Azurite requires sensitive scopes (Gmail/Calendar) to function, I am currently restricted by Google's unverified app limit to 100 active tokens. This is a hard technical ceiling until my security audit is complete.
I am manually cycling users in batches of 10 every day as I rotate inactive users out. I am prioritizing the HN queue for the next 24 hours.
If you want to help break the beta (or critique my implementation of MCP), get in line here: https://azurite-labs.vercel.app/?ref=AZ-PJQEY5

value: Show HN: Azurite – Triage Linear and GitHub issues using MCP (Deck of Cards UI)

author: QaysHaji


value: jacobgadek

value: Show HN: Romek – CLI to inject local Chrome cookies into headless Playwright

author: jacobgadek


value: Show HN: Ctrl – Open-source AI OS where each app has an AI that knows its data


value: Show HN: Open-source accessibility scanner with AI-powered fixes


value: barrell

value:
Hello HN -
Over the last few years, I've been building an app to learn languages. It supports ~85 languages and ~40 dialects, and is optimized for learning and maintaining multiple languages.
Learning a language is a ton of work, but really quite simple. Find text you're interested in, dissect and understand it, and review it often. Grind that every day for a few years, and you'll be fluent.
So I built Phrasing for 4 main reasons:
1. To have an app I would actually be excited to use every single day for years.
2. To do all the research, explanation, prioritization, course planning and management for me, so I could just focus on learning
3. To support learning multiple languages as a first class citizen
4. To have a nice, unified interface to learn languages from Spanish to Arabic to Cantonese
I've been using it daily now for almost a year to learn a variety of languages and I've been loving it. I have an awesome group of users in the Telegram channel who have been using it as well to great success.
If you're a polyglot, an avid language learner, or someone who tried to use Anki in the past but found it wasn't for them — I think you might really like Phrasing :)
EDIT: Phrasing is a paid application, but there are 30 expressions you can try for free in the islands tab (you'll see 10 of them in the onboarding flow as well)
--
PS: Phrasing uses FSRS under the hood, so a huge thank you to the FSRS team and Jarrett Ye for all the amazing work. Phrasing would not be the product it is without you!
PSS: I'm documenting some of the latest updates on the blog this week, they're 50% product and 50% technical, might be of special interest to the HN crowd: https://phrasing.app/blog/launch-week-1

value: Show HN: I spent 10k hours building the perfect language learning app

author: barrell


value: ajjcoppola

value:
I built an open-source system that generates truthfulness reports for YouTube videos using multimodal AI and a counter-intelligence approach.
*Live demo:* https://verityngn.streamlit.app
*Documentation:* https://hotchilianalyticsllc.mintlify.app
*Repo:* https://github.com/hotchilianalytics/verityngn-oss
*Substack Article:* https://ajjcop.substack.com/p/i-built-an-ai-that-fact-checks...
### The Problem
Existing fact-checking tools only analyze text transcripts. They miss on-screen graphics, visual demonstrations, and the multimodal nature of video. Worse, when you search for evidence, you often get promotional press releases that confirm false claims because the misinformation ecosystem is SEO-optimized.
### How VerityNgn Works
1. *Multimodal analysis*: Uses Gemini 2.5 Flash (1M token context) to analyze video frames at 1 FPS — audio, OCR, visuals, and transcript together.
2. *Intelligent Segmentation*: Automatically calculates optimal segment sizes based on model context windows (reduces API calls by 86% for typical 30-min videos).
3. *Enhanced claim extraction*: Multi-pass extraction with specificity scoring (0-100) and "absence claim" generation (identifying what's NOT mentioned, like missing FDA disclaimers).
4. *Counter-intelligence*: Actively hunts for contradiction — searching for YouTube review/debunking videos and detecting self-referential press releases (94% precision).
5. *Probabilistic output*: A calibrated THREE-state distribution (TRUE/FALSE/UNCERTAIN) based on Bayesian aggregation of source validation power.
### Results (200-claim test set)
- 75% accuracy vs. ground truth (95% CI: 61-85%)
- +18% improvement from counter-intel on misleading content
- Well-calibrated (Brier score = 0.12, ECE = 0.04)
- Cost: $0.50–$2.00 per video
### Tech Stack
- Python 3.12, Gemini 2.5 Flash via Vertex AI
- LangChain/LangGraph for orchestration
- Streamlit UI, Cloud Run backend
- yt-dlp for video download
- Google Custom Search + YouTube Data API
### Honest Limitations
- English only
- YouTube only (no TikTok/Instagram yet)
- ~25% error rate (75% accuracy means 25% wrong)
- Susceptible to coordinated fake review campaigns
- No human-in-the-loop
### Why Open Source
Misinformation is too important to solve behind closed doors. The methodology needs to be transparent and auditable. Full research papers with step-by-step calculations are in the `papers/` directory.
Looking for feedback on the approach and contributions (especially: multi-language support, additional platforms, expanded evidence sources).

value: Show HN: VerityNgn–Open-source AI that fact-checks YouTube videos

author: ajjcoppola


value: zanehelton

value: Show HN: Keep Talking and Nobody Explodes as a TUI over SSH

author: zanehelton


value: shuvrokhan

value:
Hello HN,
I am building RepoEngine to solve a problem I encountered as a backend engineer. Once a codebase grows into multiple repositories, documents, and teams, it becomes tough to track context or find the code for a specific feature/functionality. Even if it becomes harder to know in which context a decision was taken to implement it that way.
To overcome these issues, I have started building a systematic approach in RepoEngine, which unifies your repositories, docs, and decisions into a knowledge layer you can actually build on (onboarding flows, internal agents, automated docs, etc.).
What it does:
  - Multiple Repositories at once. ( that's from an organisation's repositories or even from personal profiles' selected repositories)
  - Ask questions across repos + docs and get answers with citations.
  - Every answer links to the exact sources (files, Notion pages, Slack threads, Jira tickets, etc.).
  - It indexes structure/meaning but doesn’t store your source code.
  - Connect GitHub, GitLab, Notion, Google Drive, Dropbox, Confluence, Slack, Jira, and Linear.
This is early, and I’m actively seeking feedback from people working with large or messy codebases. I really want a product that captures the shared context of decisions/directions taken to build a feature.
Would love feedback on the product direction, integrations you want, and how teams want to use this day‑to‑day.
https://repoengine.com

value: Show HN: RepoEngine – turn repos and docs into a shared knowledge layer

author: shuvrokhan


value:
Hi HN,
We have developed (from scratch) the world's first production-grade Font GenAI system, and have used it to put together the largest collection of fonts on the planet:

  https://fonthero.com

(1) There have been other serious efforts at developing GenAI fonts. These have struggled to produce consistent, professional-looking fonts and most of them produce irregular and inconsistent results that do not pass the bar of usability. (We of course also have some "claw hands" in our results, but large swaths are more or less error free.)
(2) Our filter lists are organized using the traveling salesman problem (TSP) on the distances between feature vectors established from the VAE's latent space. This creates lists that have enough movement to allow exploration, while having enough local continuity to feel coherent and smooth. (Keyword searches are not organized by TSP because those lists are ad-hoc and TSP takes too long to do live.)
(3) Our descriptions are LLM generated and are full of accurate and descriptive keywords, making free text search a meaningful tool. See the keyword suggestions for the types of things you can meaningfully search for.
(4) Our terms are free for commercial use, and we don't require login or other hoop-jumping to access the fonts. The font world is full of complex licenses, high prices, and aggressive gatekeeping and that is just not reasonable in a world of ubiquitous GenAI.
(5) Because they all come out of the same model, all fonts have the same 255 glyphs, covering more or less all Latin-derived character sets.
(6) Single click download of the TTF. If a full font is more than you need you can also get a PNG or SVG of your text sample.

value: Show HN: First professional-grade AI fonts


value: deduxer

value:
Hey HN,
I'm Roma, 21, from Bucharest, Romania. At 20 I was running a 12-person design studio doing €250K/year.
Then I lost €50K+ to clients who never paid. No contracts, just trust. Studio collapsed, I took €40K in debt.
That experience led me to build Accordio – an AI-powered contract and payment platform for freelancers.
The core idea: paste your meeting notes, AI extracts scope/deliverables/payment terms and generates a proposal.
Client accepts → contract auto-generates. Contract signed → invoice auto-generates.
Everything interlinked, no re-entering data across 4 different tools.
Tech stack: Next.js, Supabase, Claude for AI, Stripe Connect for payments, custom e-signature system (built from scratch – DocuSign API was too expensive).
The AI has memory...it learns your rates, terms, clients over time. Not just one-off generation.
Built it for freelancers like me.
Been "vibe coding" this for 2 years... before the term even existed.
Would love feedback from HN.

value: Show HN: I lost €50K to non-paying clients, so I built an AI contract platform

author: deduxer


value: alexkranias

value:
Thought I'd dive into this cool streaming/approximation algorithms problem I encountered a few months ago.
TLDR: we can create our own custom floating point representation for encoding and decoding integers and use this to index into a tiny 2D histogram, upper-bounding approximation error based on the number of bits per integer we specify to keep.
---
Broadly useful for aggregating statistics from massive data streams of user data. Also turns out this is incredibly similar to data structures used in production, like HDRHistogram.

value: Show HN: Compressing a Histogram from 16GB to 2KB

author: alexkranias


value: creativedg

value: Show HN: Next.js Boilerplate 6.1 – a Next.js starter I've maintained for 5 years

author: creativedg


value: ronsor

value: Recently I was inspired by exe.dev to finally finish a project I'd been procrastinating on for half a year. You can simply `ssh gpu.st new` and instantly create instances with a variety of GPUs attached. Instances boot a custom image with PyTorch, Jupyter, and the CUDA toolkit installed by default.<p>Currently we give access to 3090s and 4090s for free users; paid users get access to all GPUs.

value: Show HN: Gpu.st – Instant GPU Instances over SSH

author: ronsor


value: nkalupahana

value: Show HN: Proximity Voice Chat in VS Code

author: nkalupahana


value: arthurnogman

value:
I'm interested in Buddhist philosophy, and specifically studying Nāgārjuna's Middle Way gave me inspiration to formalize it mathematically and see what would emerge as a result.
(My background: engineer/co-founder (Qualcomm/Adreno GPU, Bumble, Stereo), 16 years of meditation practice, 2+ years in Southeast Asian monasteries and silent retreats)
Starting from one Buddhist-inspired axiom—recursive duality E={E⁻,E⁺} - I derived:
1) Boolean logic (from period structure of minimal couplings)
2) Universal computation (closure enables Turing-completeness)
3) Memory (pattern persistence across computational steps)
4) Three-dimensional space (stabilized projection of structure)
5) Quantum-like behavior (pre-spatial compatibility constraints)
6) Gravity-like effects (stability gradients in hierarchical structure)
The logic/computation part is rigorous. I've worked out a formal derivation with proofs. The quantum/gravity parts are more exploratory.
I discovered Spencer-Brown's Laws of Form late in this process. His approach encodes Boolean structure through chosen rewrite laws. My derivation differs: no free parameters, canonical constructions only, truth tables computed rather than designed.
I'm seeking:
- arXiv endorsement (first-time submitter, need referral for cs.LO or math.LO)
- your feedback of my book (it's free on Kindle: https://theplusminus.xyz if for some reason doesn't work can send a PDF)
The book is illustrative/accessible. The technical paper with rigorous proofs needs 1-2 more days of polishing before I'm ready to share. If you're interested in endorsing, I can prioritize sending you an early draft.

value: Show HN: My attempt to formalize "Buddhist" reality

author: arthurnogman


value: saulpw

value:
Hey hackers,
A couple weeks ago I launched the podcast I've been working on for the past several months, called Mag World.
Mag World is an effort to develop an intuitive sense of scale-–not just “bigger” or “smaller”, but how much bigger, and how much smaller. And what are each of the levels of scale like?
To develop fluency, we use a simplified notation for numbers that focuses on the magnitude. We apply this notation broadly to get a perspective on life and the universe and everything.
You may remember Mag Wealth on the front page of Hacker News a few months ago.  It was one of the first articles I'd written for Mag World, and the subject got me thinking about the entire project.  Now, we have a website at magworld.pw, including 3 finished episodes queued up for January (episode 2, Mag Perception, comes out today), and more episodes in the works.
The podcast is listed on Apple Podcasts and Spotify, and can listen directly on the website.  I'd love to hear your feedback!
Saul

value: Show HN: Mag World – develop an intuitive sense of scale

author: saulpw


value: Show HN: EasyDex Contacts App

title: Show HN: EasyDex Contacts App


value: mukulhjoshi

value:
Hey HN,
We built ADBWrench – a browser-based ADB tool that connects to Android devices via WebUSB. No SDK install, no drivers, no PATH config. Just plug in and debug.
The problem: Every Android dev knows the friction of setting up adb. Install platform-tools, fight with USB drivers (especially on Windows), hope `adb devices` shows something. Then remember the exact syntax for that one command you need.
ADBWrench runs entirely in the browser. Open the URL, grant USB permission, done.
The interesting part: There's an AI assistant built in. Describe what you want to do in plain English – "show me all apps using more than 100MB", "find crash logs from the last hour", "uninstall all debug builds" – and it executes the right ADB commands for you.
BYOK (bring your own key) – add your OpenAI/Anthropic API key and it works. We don't track anything, no data leaves your browser except to the AI provider you choose.
What else it does:
- Full interactive shell (pm, am, dumpsys, etc.)
- Real-time logcat with filtering
- File browser with drag-and-drop transfers
- App manager (install/uninstall APKs)
- Screenshot and screen recording
- Live CPU/memory monitoring
- Device controls (reboot, volume, brightness)
- Bugreport generation
Everything runs client-side. Your device data never touches our servers.
Built with Next.js, TypeScript, and @yume-chan/adb for the protocol implementation.
Limitations (being honest):
- Chromium only (WebUSB requirement)
- No wireless ADB
- No screen mirroring (scrcpy wins there)
Open source: https://github.com/superrAI/adbwrench
Try it: https://adbwrench.com/
Would love feedback, especially on the AI assistant.

value: Show HN: ADBWrench – ADB in the browser with AI assistant, no install needed

author: mukulhjoshi


value: huongphamx

value:
ZodQR is a free QR codes generator, where you can generate unlimited QR code (static and dynamic) for free. Belong basic static QR code types, we have many dynamic types: URL, smart URL, vCard plus, list of links, social media, landing page, menu, PDF, MP3 and file.
It come with many features that other generators required a paid subscription:
- Unlimited edit QR codes after printing
- Set password, schedule or limit scans
- Group QR codes into folder
- Customize QR code with custom shapes, color and logo
- Save templates to use later
- Download QR code upto 4096px size
If you need advanced features for team, you can unlock all for $29/month or $290/year:
- Bulk generate QR code
- API
- Custom domains
- Workspace and members, with fine grained permission
- QR code campaigns, similar to Bitly campaign
- Sync QR code to Canva
- Get notification via Telegram
- Subfolder, download PDF/EPS image
And more incoming...
Please give it a try and let me know your thoughts, what I can improve.
Thank you!!!

value: Show HN: ZodQR – create, share and track unlimited dynamic QR codes for free

author: huongphamx


value: stellarcat

value: Show HN: Zero to One but it's a game (built with Rust)

author: stellarcat


value: ClassicOldSong

value: With the default theme and everything enabled, it renders 1000 pages of markdown in under 20 seconds. With a simpler blog theme and code highlighting disabled, it renders the same amount in 5 seconds.<p>Tested on Mac mini M4 base model.

value: Show HN: Render static blog/document site in seconds with Methanol

author: ClassicOldSong


value:
Hello HN,
I'm the creator of Auraly, a web app that helps people understand ingredient labels for food and personal care products by scanning them with their phone.
The idea came from a personal place. A few years ago my father was diagnosed with terminal cancer, which pushed me to learn more about nutrition, environmental exposures, and how everyday choices can affect long-term health. One thing I found frustrating was how hard ingredient labels are for most people to actually understand. They’re often long, filled with unfamiliar chemical names, vary across countries, and become even less useful when they’re written in a language you don’t speak.
Most existing tools rely on static databases or focus on a single category. I wanted to build something that works on real-world labels in any language, adapts to what the user personally cares about such as allergens or ingredient sensitivities, and avoids fear-based or overly simplistic scoring.
Auraly:
- Scans ingredient labels using OCR and AI
- Works with labels in any language
- Supports multiple interface languages (English, Spanish, Chinese currently)
- Lets users customize what they want flagged
- Is optimized for mobile and built as a lightweight web app
This is still very early and I’m mainly looking for feedback. I’d love thoughts on the technical approach, the UX, the risk framework, or whether this is even a useful idea.
We currently run on a freemium model, with 7 days of free unlimited access but I'm happy to extend free access for members of the HN community once your trial is up. Just let me know in the comments or send me a message via the app.
Happy to answer any questions, and thanks for taking a look.

value: Show HN: What's in Your Food?

title: Show HN: What's in Your Food?


value: metawake

value:
CLI tool to debug and benchmark RAG retrieval without LLM calls.
- `ragtune explain "query"` → see what was retrieved with scores
- `ragtune simulate` → batch eval with recall/MRR metrics
- `ragtune compare` → compare embedders or chunk sizes
- CI/CD mode for quality gates
Works with Qdrant, pgvector, Weaviate, Chroma, Pinecone.
Built because I kept guessing why retrieval was bad. Now I can see exactly what's happening.

value: Show HN: RagTune – EXPLAIN ANALYZE for your RAG retrieval layer

author: metawake


value: ChatCapturePro

value:
Hi HN,
I built a browser extension that auto-saves your AI conversations locally.
Problem: I kept losing important ChatGPT/Claude conversations. No proper export,
chats disappear, browser crashes.
Solution: ChatCapture Pro monitors chat pages and saves messages to IndexedDB.
Export as HTML, JSON, or plain text. 100% local, no cloud.
Tech: Manifest V3, MutationObserver for real-time detection, IndexedDB for storage.
Free: 5 chats, JSON export
Pro: €4.99 one-time (unlimited)
Built with  for privacy-conscious AI users.

value: Show HN: ChatCapture Pro – Auto-Save AI Conversations Locally (Chrome/Firefox)

author: ChatCapturePro


value:
Hello Hacker News! I'm Mark. I'm building Moru, an open-source runtime for AI agents that runs each session in an isolated Firecracker microVM. It started as a fork of E2B, and most of the low-level Firecracker runtime is still from upstream.
It lets you run agent harnesses like Claude Code or Codex in the cloud, giving each session its own isolated microVM with filesystem and shell access.
The repo is: https://github.com/moru-ai/moru
Each VM is a snapshot of a Docker build. You define a Dockerfile, CPU, memory limits, and Moru runs the build inside a Firecracker VM, then pauses and saves the exact state: CPU, dirty memory pages, and changed filesystem blocks.
When you spawn a new VM, it resumes from that template snapshot. Memory snapshot is lazy-loaded via userfaultfd, which helps sandboxes start within a second.
Each VM runs on Firecracker with KVM isolation and a dedicated kernel. Network uses namespaces for isolation and iptables for access control.
From outside, you talk to the VM through the Moru CLI or TypeScript/Python SDK. Inside, it's just Linux. Run commands, read/write files, anything you'd do on a normal machine.
I've been building AI apps since the ChatGPT launch. These days, when an agent needs to solve complex problems, I just give it filesystem + shell access. This works well because it (1) handles large data without pushing everything into the model context window, and (2) reuses tools that already work (Python, Bash, etc.). This has become much more practical as frontier models have gotten good at tool use and multi-step workflows.
Now models run for hours on real tasks. As models get smarter, the harness should give models more autonomy, but with safe guardrails. I want Moru to help developers focus on building agents, not the underlying runtime and infra.
You can try the cloud version without setting up your own infra. It's fully self-hostable including the infra and the dashboard. I'm planning to keep this open like the upstream repo (Apache 2.0).
Give it a spin: https://github.com/moru-ai/moru
Let me know what you think!
Next features I'm working toward:
- Richer streaming: today it's mostly stdin/stdout. That pushes me to overload print/console.log for control-plane communication, which gets messy fast. I want a separate streaming channel for structured events and coordination with the control plane (often an app server), while keeping stdout/stderr for debugging.
- Seamless deployment: a deploy experience closer to Vercel/Fly.io.
- A storage primitive: save and resume sessions without always having to manually sync workspace and session state.
Open to your feature requests or suggestions.
I'm focusing on making it easy to deploy and run local-first agent harnesses (e.g., Claude Agent SDK) inside isolated VMs. If you've built or are building those, I'd appreciate any notes on what's missing, or what you'd prioritize first.

value: Show HN: I'm building an open-source AI agent runtime using Firecracker microVMs


value: kxbnb

value: Show HN: Keypost – Policy enforcement for MCP pipelines

author: kxbnb


value: Codegres

value: Show HN: Background Remover

author: Codegres

title: Show HN: Background Remover


value:
Hi HN,
I’m a developer who struggles with the mental cost of context switching. When I sit down to code after a chaotic day, my brain often feels like a browser with 20 tabs open (I call this "Browser Brain"). I usually freeze up before I can even write the first line of code.
I tried using standard productivity apps to fix this, but they were part of the problem. They were too bright, too complex, and felt like "marketing" tools rather than "builder" tools.
So, I built Inspiropage to solve my own Internal Obstacle.
What it is: It’s a "digital quiet space." Think of it as a clear command for your mind. It serves a single quote, a mini-story, or a micro-action to help you perform a "state reset" before deep work.
Design Decisions (For Devs):
Proper Dark Mode: I didn't use funky marketing colors or high-contrast neons. It is a strict, neutral dark theme designed to sit comfortably on a second monitor next to your IDE without causing eye strain.
Zero "Engagement" Features: No gamification, no streaks, no notifications. The goal isn't to keep you in the app; the goal is to get you off the app and into your flow state.
The Honest Constraint: This app won't manage your JIRA tickets or optimize your sprint velocity. It is strictly a utility for that 5-minute window where you need to transition from "Chaos" to "Focus."
You can try it here:
[ https://inspiropage.pages.dev/ ]
I’d love feedback on the dark mode implementation—I aimed for something that feels native to a developer's workflow.

value: Show HN: I built a 'state reset' tool for my brain. Proper dark mode, no extras


value: AveryClapp

value: Show HN: Cache Explorer – The Compiler Explorer for CPU Cache Behavior

author: AveryClapp


value: burcs

value:
I built okiro because AI coding tools mostly felt like one-shots. They write directly to your files, and you either have to rollback or push forward. You don't really get to explore multiple ideas in parallel like you would if you were generating an image with AI.
okiro creates instant, zero-cost clones of your codebase so you can try several AI-driven approaches at once.
It uses filesystem copy-on-write (APFS on macOS, btrfs on Linux), so you can spin up dozens of variants of a large repo without actually duplicating it on disk. The copies only diverge when files change.
Example:
okiro 3 --prompt "add authentication"
# var-1: use Better Auth
# var-2: use Clerk
# var-3: roll your own with JWT
Each variant gets its own directory and an AGENTS.md with specific guidance. Open them side-by-side, let your AI tool work, then diff and keep the best result.
Would appreciate your feedback!

value: Show HN: Okiro – spin up ephemeral codebases for parallel AI coding

author: burcs


value: AttentionBlock

value:
Hi HN,
I have been recently geeking on agentic memories, and I believe I finally came up with something that works.
I spent the last couple of weeks building a memory[0] for Claude Code that dynamically evolve as you talk with it.  I followed a new paradigm inspired from zettelkasten method.  Whenever Claude discover something new in the codebase or during your conversation with it, it writes a note about it, link it with related memories, update the related memories accordingly, and store it in chromaDB (this part where it keeps self-evolving based on new inputs). Later when you ask it to do/explore/implement something, it peeks into its memories (breadth-first) then drills into matches (depth-first) . The graph that builds this memory is untyped, so Claude isn't limited to a predefined relations. Its also time-aware so you can ask it to recall from yesterday for example.
What motivated me to build this tool is that I work with big codebases, I spend hours with claude digging into some functionality, and it was frustrating that I have to start from scratch next day/session. I can resume to the same session but at some point when the conversation gets too long, the responses quality drop.
I tried some of the available solutions, most of them are Knowledge Banks or some static RAG that didn't do it for me.
Here's example scenario how it helped me: I had to debug some error that was coming from one of the new functionalities that Claude implemented few days ago, when I shared the error message with Claude, it immediately recognized that this was a change we made recently, why we implemented and how we implemented it and managed to debug it fairly quickly.
Another example: vercel have encapsulated 10+ years of Next.js optimization knowledge into a bunch of .MD files[1], this is something that I would love to inject to my agent memory (if only I used Next.js)
Some of the limitations are:

  - Sometimes the agent forgets about it and I need to give it a nudge: however I implemented some hooks and so far they seem to be doing the job.

  - Response time: it's still way faster compared to re-exploring and discovering from scratch, but I would love to see it even faster

  - Categories: some memories are project-specific, others aren't e.g. preferences, best-practices, etc

What I built is based on concepts from A-MEM paper[2]  with some tweaks, so I didn't personally invent something new :)
Looking for your feedbacks :)
[0]: https://github.com/DiaaAj/a-mem-mcp/tree/main
[1]: https://vercel.com/blog/introducing-react-best-practices
[2]: https://arxiv.org/pdf/2502.12110

value: Show HN: A-MEM – Memory for Claude Code that links and evolves on its own

author: AttentionBlock


value: dexteryy

value:
Many AI agent chats should be turned into web apps (they often involve a lot of deterministic calculations and would benefit from richer GUI feedback). I used AI to build an AI app that helps you read tons of Steam game reviews, generates insight reports. It even creates player personas with virtual identities and writes new representative reviews.
Here's an example of a game analysis result:
https://steam-review.dexmage.com/results/steam-504210
The analysis you start will be public to save others time and tokens, and it's shareable via URL.
I'm personally covering the token costs (unless you use your own API key due to dissatisfaction with default model choices), so I had AI build a dashboard to help me monitor tasks and track AI expenses. Thanks to some smart optimizations and model choices, analyzing over 100 games has only cost me $4.50 so far.

value: Show HN: Turn Steam reviews into personas and insights, without agent chatting

author: dexteryy


value: sidgarimella

value: We’ve been building visual rule engines (clear spreadsheet interfaces -> API endpoints that map incoming data to a large number of potential outcomes), and had the fun idea lately to see what happens when we use our decision table UI with Claude’s PreToolUse hook.<p>The result is a surprisingly useful policy/gating layer– these tables let your team:<p>- Write conditional, exception-friendly policies beyond globs/prefixes (e.g. allow rm -rf only in */node_modules/*, deny / or $HOME, ask if --force or network call; gate kubectl delete / SQL DROP with a clear reason)<p>- Roll out policy changes instantly (mid-run, flip a risky operation from allow → ask; the next attempt across devs and agents is gated immediately– no git pull or agent restart required)<p>- Adopt lightweight governance that is somewhat agent agnostic and survives churn (MCP/skills/etc)- just add columns/rules as new tools and metadata show up<p>- Gain a central utility to understand which tools are being used, which tools get blocked most often, and why

value: Show HN: Control Claude permissions using a cloud-based decision table UI

author: sidgarimella


value: talatuyarer

value:
Hi HN,
I’m one of the creators of this project.
We noticed that while many developers want to experiment with Apache Iceberg the "entry cost" is often high. You usually have to set up your own storage buckets, configure a catalog (like Hive), and ingest data before you can even run a single SELECT statement.
We wanted to lower that barrier. We’ve hosted a production-grade Iceberg REST Catalog on BigLake with public datasets (starting with the NYC Taxi data) that anyone can query.
You can point Spark, Trino, or Flink directly at the REST endpoint and start querying immediately.
You do need a Google Cloud Project ID for authentication/quota, but the data access itself is free and public.
I’d love to hear your thoughts. Are there specific datasets or Iceberg features you’d like to see added to the dataset?

value: Show HN: Public Apache Iceberg datasets via a REST catalog

author: talatuyarer


value: cblovescode

value:
Hi HN,
I built Tact, a keyboard-first client that sits on top of your LinkedIn inbox and makes outbound faster without turning it into AI-generated slop.
The goal was to help people who do targeted, relationship-driven outreach move quickly while still writing every word themselves. Tact doesn’t ghostwrite messages or auto-send anything. Instead, it gives you speed, structure, and light AI coaching while you write.
What it does today:
- Keyboard-first LinkedIn inbox
Navigate conversations, open threads, reply, and move between messages using shortcuts instead of clicking through LinkedIn’s UI.
- Snippets + dynamic snippets
Reusable sentence/paragraph blocks with variables (name, company, role, etc.) that you can drop in instantly and still edit freely. Dynamic snippets let you just describe the variable, and we'll generate using enriched data and web search.
- Coaching instead of ghostwriting
AI flags things like missing personalization, awkward phrasing, or placeholders you forgot to update, but it doesn’t generate full messages for you.
It’s a thin layer focused purely on the act of writing and handling your LinkedIn inbox more deliberately. The mental model is closer to a power-user email client (Vim-style speed) than a "click a button and spray AI" tool.
You can try it here:
https://withtact.app
I’d love feedback on:
- Whether "coaching, not ghostwriting" is actually useful in practice
- How the keyboard UX compares to native LinkedIn
- What’s missing
Happy to answer questions about implementation details or anything else.

value: Show HN: Superhuman for LinkedIn Inbox

author: cblovescode

title: Show HN: Superhuman for LinkedIn Inbox


value:
I work alone. I travel constantly:- Bangkok, Dubai, Singapore, Vietnam. I'm a workaholic and honestly pretty confined to myself because there's never enough time. Sometimes I just want to talk through what's on my mind but it's 3 am, or I'm in a new city, or I don't want to bother anyone with half-formed thoughts.
So I built TalkMate. It's a voice companion that actually talks back. Open it in your browser, start speaking, and it responds out loud. No signup, no account needed.
I used to earlier chat with ChatGPT and Claude in my free time but talking to someone feels different, someone on the other side is listening to you, though virtual but lets forget that for now that there's some virtual someone and imagine that its someone real who is talking to you.
For this reason, I built TalkMate. t's a voice companion that actually talks back. Open it in your browser, start speaking, and it responds out loud. No signup, no account needed.
It supports 17 languages, doesn't save your conversations by default (privacy first), and runs on a simple credit system instead of yet another $20/mo subscription. You get 20 free messages a week to try it. I also built a pro version in case someone needs longer chat durations.
If you have tried it, please spare a moment to tell me what you think about the voice UX - is the flow natural? Does the "thinking companion" angle make sense or is it too soft? I've been using it myself for over a week now before taking the site live.
thank you for your time!

value: Show HN: TalkMate – Someone to Talk To, Anytime


value: raethro

value:
I use a variety of tools including Claude Code, Gemini CLI, Codex and others depending on the task, but that chat history is scattered across different locations. I needed something to:

  - Search across all of them
  - Link conversations to the commits I made
  - Ask my current LLM session about any previous session and get answers

Lore runs a daemon that watches your session files, stores everything in SQLite, and automatically links sessions to commits as you work.
A few things it does:

  - `lore blame` - trace a line of code to the conversation that wrote it

  - `lore search "websocket reconnect"` - search across all tools

  - MCP server - ask Claude "what was the websocket issue last week and how did we fix it?"

Thanks for checking it out.

value: Show HN: Lore – search and link AI coding sessions to commits

author: raethro


value: ronantech

value: Show HN: TestSpec – Test Heavy Machinery Parts Intantly(Rotary Center Joints)

author: ronantech


value: tomge

value:
I built a free online tool for generating large batches of unique random codes - up to 250,000 per generation (roughly 2.5M/hour).
It's designed for cases like:
- custom discount/voucher codes
- giveaway or lottery tickets
- product serial numbers printed on packaging
- one-time passwords or secure tokens
- bulk fake/test data
- random strings
You control:
- quantity (up to 250k per batch)
- length (up to 40 chars + optional prefix/suffix)
- exact character sets (letters, digits, symbols, Unicode/emojis)
- precise position rules (e.g. letters in positions 1-3, digits after)
- uniqueness (required or optional duplicates)
Three modes: basic (quick defaults), advanced (character sets + prefix/suffix), expert (per-position rules).
Export formats: CSV, XLS/XLSX, JSON, plain text.
Codes are generated on-the-fly and never stored on the server - files are deleted immediately after download. Configurations can be saved as shareable links.
No signup, no tracking, completely free.
(Note: this generates your own codes for use in your systems/promotions - it does not find or create codes for existing stores/services.)
The tool is a part of our upcoming code generation and management platform, which is currently in beta.
Feedback welcome.
Thomas

value: Show HN: I have build a free random code generator (250k codes/batch)

author: tomge


value: dperalta

value: Show HN: Google Flights TUI

author: dperalta

title: Show HN: Google Flights TUI


value: iliashad

value:
I've been working on a project to solve my problem of finding and searching across my videos (I do have a lot of videos). I decided to solve this issue. I looked at APIs that could help me transcribe and analyze video frames. (Google Video Intelligence was out of my budget and I had to upload videos to Google Cloud which I didn't wanna do).
I decided to build Edit Mind, which started as a simple CLI that would transcribe videos using OpenAI Whisper and search across them using text, nothing fancy.
Then I decided to add frame analysis. I built a Python script that would handle that, take the full video, divide it into smaller parts that would be 1 second to 2 seconds long, pass the frame to another system that would recognize faces, objects, text over image, etc.
After that, I decided to build an Electron desktop app that would manage the UI and have a search and chat feature.
Then, I was like let's open source it and share it with the community over Reddit. People loved it (https://www.reddit.com/r/selfhosted/comments/1ogis3j/i_built...). Many of them requested Docker integration. I decided to focus on that instead, which was a great idea and suggestion. (https://www.youtube.com/watch?v=YrVaJ33qmtg&t=12s)
Now, we have 3 Docker containers: one responsible for the web UI, one for the background jobs , media stuff and local vector integration, one for the ML service (transcription and frame analysis) that will be a Python script communicating via WebSocket.
After posting over X and tagging Twelve Labs for inspiring me to add new features and UI enhancements to the project, I had the opportunity to present the project live at their webinar series (if you wanna check Edit Mind in a live demo: https://www.youtube.com/watch?v=k_aesDa3sFw&t=1271s)
After getting the proof of concept with all the features that I was hoping to get from Edit Mind, it's time to focus on improving the code quality, refactoring, and implementing best practices. Remember that I'm working solo with the help of external contributors.
I would love to get your feedback about the project.
GitHub: https://github.com/iliashad/edit-mind

value: Show HN: I built a self-hosted video search tool because Google's API was $$$

author: iliashad


value: MrEricSir

value:
During a recent subway outage in San Francisco I decided to build a webapp in the spirit of "Do I Need an Umbrella," basically to answer the question "Should I take the subway or a bus?"
In the interest of learning new tools I decided to vibe code it as much as possible.
First, I had Claude Code write a background script to download images of the real-time circuit diagram of the subway, which are publicly available here:
http://sfmunicentral.com/
Next I had it build an image labeler tool in tkinter, which turned out to need a lot of manual tweaking before I could even get to the labeling. Seemed like the right tool for the job, but it would have saved time if I'd built it from scratch myself.
The most interesting part was turning the labeled image data into predictions with pytorch. Claude wrote the initial script fairly quickly, but as these things go it required manual tweaking and second guessing myself on the images flagged as outliers. I'll admit I got embarrassingly far along before realizing that Claude hadn't enabled pytorch's GPU support; a real facepalm moment on my part.
For those curious, brave, or crazy enough to dive in the source code is available here under an MIT license:
https://github.com/MrEricSir/munimet.ro

value: Show HN: Munimet.ro – ML-based status page for the local subways in SF

author: MrEricSir


value: jy-tan

value:
Hi HN! In the past few months my team and I have been working on Tusk Drift, a system that records real API traffic from your service, then replays those requests as deterministic tests. Outbound I/O (databases, HTTP calls, etc.) gets automatically mocked using the recorded data.
Problem we're trying to solve: Writing API tests is tedious, and hand-written mocks drift from reality. We wanted tests that stay realistic because they come from real traffic.
versus mocking libraries: Tools like VCR/Nock intercept HTTP within your tests. Tusk Drift records full request/response traces externally (HTTP, DB, Redis, etc.) and replays them against your running service, no test code or fixtures to write/maintain.
How it works:
1. Add a lightweight SDK (we currently support Python and Node.js)
2. Record traffic in any environment.
3. Run `tusk run`, the CLI sandboxes your service and serves mocks via Unix socket
We run this in CI on every PR. Also been using it as a test harness for AI coding agents, they can make changes, run `tusk run`, and get immediate feedback without needing live dependencies.
Source: https://github.com/Use-Tusk/tusk-drift-cli
Demo: https://github.com/Use-Tusk/drift-node-demo
Happy to answer questions!

value: Show HN: Tusk Drift – Turn production traffic into API tests

author: jy-tan


value:
Howdy HN,
I built Pageplane (https://pageplane.app) to solve a workflow problem I kept running into: generating single-file HTML apps with LLMs (following Simon Willison's "HTML tools" pattern), but deploying them still required the friction of creating repos, configuring build steps, waiting for CI/CD.
So I made CI/PD instead (Copy It & Paste Deployments, lol).
Pageplane strips it down to copy HTML → paste → deploy. Takes about 30 seconds.
I kept it boring on purpose:
- Python/Flask on Fly.io
- SQLite (read-heavy workload, no separate DB server needed)
- Cloudflare R2 for storage (S3-compatible, zero egress fees)
I also published a short backstory[1] as a concrete example that’s hosted on Pageplane and uses Flatcontent[2], a small markdown-to-JSON tool I built to keep the site single-file.
[1] https://flatcontent-demo.pgpln.app/#/blog/copy-and-paste-dep...
[2] https://github.com/bootstrapital/flatcontent

value: Show HN: Pageplane – Copy and Paste Deployments for HTML Apps


value: pawandeepsingh

value: Show HN: I built an 11MB offline PDF editor because mobile Acrobat is 500MB

author: pawandeepsingh


value: barefootsanders

value: Show HN: Skillthis.ai – Generate AI skills using Claude's best practices

author: barefootsanders


value:
Hi HN,
I'm the creator of BlogHunter. I built this because I have several side projects that needed SEO traffic, but I kept burning out trying to maintain active blogs for all of them. I wanted a "set it and forget it" solution that handled everything from generation to hosting.
What it is: BlogHunter is a platform where you input topics/keywords, and it generates full-length, formatted blog posts using LLMs at scale
It then hosts these blogs for you (no WordPress/Ghost required).
It's definitely not for "thought leadership" pieces that require deep personal insight, but for top-of-funnel SEO content and filling out topic clusters, it's been working really well for me.
Would love to hear your feedback on the generated content quality and the platform itself!
Link: https://bloghunter.se

value: Show HN: BlogHunter – Generate and host SEO blog posts with AI


value: Bunas

value:
Hi, we're Sergey and Serafim. We've been building dev tools at 21st.dev and recently open-sourced 1Code (https://1code.dev), a local UI for Claude Code.
Here's a video of the product: https://www.youtube.com/watch?v=Sgk9Z-nAjC0
Claude Code has been our go-to for 4 months. When Opus 4.5 dropped, parallel agents stopped needing so much babysitting. We started trusting it with more: building features end to end, adding tests, refactors. Stuff you'd normally hand off to a developer. We started running 3-4 at once. Then the CLI became annoying: too many terminals, hard to track what's where, diffs scattered everywhere.
So we built 1Code.dev, an app to run your Claude Code agents in parallel that works on Mac and Web. On Mac: run locally, with or without worktrees. On Web: run in remote sandboxes with live previews of your app, mobile included, so you can check on agents from anywhere.
Running multiple Claude Codes in parallel dramatically sped up how we build features.
What’s next: Bug bot for identifying issues based on your changes; QA Agent, that checks that new features don't break anything; Adding OpenCode, Codex, other models and coding agents.
API for starting Claude Codes in remote sandboxes.
Try it out! We're open-source, so you can just bun build it.
If you want something hosted, Pro ($20/mo) gives you web with live browser previews hosted on remote sandboxes. We’re also working on API access for running Claude Code sessions programmatically.
We'd love to hear your feedback!

value: Show HN: 1Code – Open-source Cursor-like UI for Claude Code

author: Bunas


value: ZeroAurora

value: I'm tired of prompting agents. Not even for beautiful code. Just correct code is making me painful. So here it is.<p>I'll play around this skill in my own workflow. It's in public domain. Any adaption is welcome.

value: Show HN: Stdskill – The skill for wicked coding agents

author: ZeroAurora


value: Jcjimenez

value: Show HN: Superfocus – Pomodoro timer built for students

author: Jcjimenez


value: AzizBelAbed

value:
Hey HN,
I’m building ShareMRR for a pretty common problem: a lot of solo founders can build a product, but don’t have marketing or distribution figured out. It’s also hard to know who to reach out to, and hard for marketers/creators to know which products are real.
ShareMRR is a marketplace where founders list startups with revenue/MRR verified from Stripe. Growth partners can browse those startups and request partnerships.
How it works:
Founder connects Stripe to verify MRR/revenue
Startup appears in feeds and category pages (recent launches, MRR leaders, etc.)
A partner requests to promote the product
If the founder accepts, ShareMRR generates a unique coupon/code for that partner
Purchases made with that code are attributed to the partner
The partner earns a one-time commission per converted customer (example: a % of the first payment)
The goal is to keep partnerships lightweight: simple tracking, simple terms, and less time spent on back-and-forth.
It’s FREE for early adopters.
I’d appreciate feedback on:
What would make you trust a listing or a partner on day one?
Is one-time commission the right model, or would you expect something else?
Any obvious missing features?

value: Show HN: Not a marketer? Let experts promote your startup FAST

author: AzizBelAbed


value: joeyguerra

value:
Hey HN,
I built a small experiment to test a hypothesis I've observed: when teams are under real pressure, managers revert to a document.
https://joeyguerra.com/yesterday-today.html
I've noticed this behavior in myself as well as other managers who are responsible for task execution and team coordination. When deadlines are tight, ambiguity is high, coordination is super important - managers and teams often abandon formal tools and just open a document to track and refine a list of todos.
Observation:
Every day the manager shares their screen, showing Notepad or Google Docs, and just lists out what to do. As the days go by, this UX shows what moved yesterday/was accomplished and what must happen today.
In the process of "going through the list" tasks get refined, together as a team, in real time.
Progress is visible by the day, not by status or workflow stage (like Kanban, Jira, etc).
The hypothesis is that we default to documents because they make the "flow of work over time" visible. My belief is that progression beats abstract states.
The app is intentionally minimal. I'm trying to isolate why the document works before adding anything else.
I'd love feedback on:
- Does this model match how you've seen teams operate under pressure? What's your experience?
- What feels fundamentally right? wrong?
- Where does this fall apart in a real team?
- What would you immediately want to add or intentionally keep out? gut reaction.
I appreciate any pushback, critique, or "this reminds me of ..." reactions.
Thanks ya'll.

value: Show HN: Yesterday/Today app – experiment born from how work gets done

author: joeyguerra


value: agentifysh

value:
I got tired of copy pasting code and context back and forth between my codex & chatgpt.com pro
My coding workflow happens locally in Codex. I wanted the reasoning power of the ChatGPT Pro model without the friction of context switching or paying double for API credits on massive context windows.
What it is:
Agentify Desktop is an Electron-based wrapper that exposes your active chatgpt.com session as an MCP (Model Context Protocol) server.
Core Features:

    Web-to-CLI Bridge: You can prompt ChatGPT Web directly from your local Codex environment. It automates the browser interaction, handles file uploads, and returns the response to your terminal.

    No API Keys: It uses your existing logged-in web session.

    Bidirectional Orchestration (WIP): allows the reverse: you can drive your local Codex instance from the ChatGPT web chat. You can tell ChatGPT Web to "plan and execute it on my codex cli(s)," and it will trigger or you can do one way multiple codex cli instances).

How it works:
quickstart.sh installs, registers mcp to your codex by spinning up a local Electron browser that you log into. The MCP server connects to this browser instance. When you query it from Codex, it automates the input/output in the web view.
Safety/Limits:
This is designed for individual "power user" workflow (similar to other popular chatgpt.com automation tools), not bulk scraping . It includes rate limiting (token buckets) and concurrency limits to keep your account safe and avoid flagging spam filters. it doesn't solve CAPTCHAs for you.
It’s currently tested on Mac-only (I don't have a Windows machine to test on yet) and definitely a work in progress. looking for feedback, i will add other sites like grok.com, aistudio.com, and more as requested.
Repo is here: https://github.com/agentify-sh/desktop

value: Show HN: Agentify Desktop: No-API Access to ChatGPT Pro Inside Codex

author: agentifysh


value:
Hi HN,
I built X41, a small Safari extension for iOS that removes the home feed on X.com.
I still want to post, reply, check notifications, and look at analytics. I just don’t want the infinite, algorithmic timeline pulling me in every time I open X.
X41 removes the home feed entirely and replaces it with a minimal navigation: Profile, Notifications, and Analytics. Posting, replies, likes, and stats all continue to work normally.
The goal is simple: turn X back into a tool instead of a slot machine.
There’s no tracking, no account creation, and no data collection. Everything runs locally as a Safari extension.
I’m especially interested in feedback from people who still find value in X but feel conflicted about how addictive the default experience has become.
Happy to answer any questions about the implementation, Safari extensions, or the App Store process.

value: Show HN: I built a way to use X without the algorithmic feed


value: myvalovec

value: Show HN: Modern Java Swing Button – Pure Java 2D rendering, zero dependencies

author: myvalovec


value: rahimiali

value:
It turns out the inverse of the Hessian of a deep net is easy to apply to a vector. Doing this naively takes cubically many operations in the number of layers (so impractical), but it's possible to do this in time linear in the number of layers (so very practical)!
This is possible because the Hessian of a deep net has a matrix polynomial structure that factorizes nicely. The Hessian-inverse-product algorithm that takes advantage of this is similar to running backprop on a dual version of the deep net. It echoes an old idea of Pearlmutter's for computing Hessian-vector products.
Maybe this idea is useful as a preconditioner for stochastic gradient descent?

value: Show HN: The Hessian of tall-skinny networks is easy to invert

author: rahimiali


value:
Hi HN, I recently open-sourced GoGen (https://github.com/zaheershaikh936/gogen), a tool to automate file generation using templates.
 I'm trying to grow the project and reach my first 10 contributors to get listed on various open-source directories. If you have 5 minutes, I'd love feedback on:
 The ease of use of the CLI.
 The roadmap (I'm planning to add nested templates and better variable support).
 I've marked a few issues as "Good First Issue" for anyone who wants to contribute to a small, fresh Go project.

value: Show HN: GoGen – A simple template-based file generator written in Go


value: danebl

value:
Crystal Unified lets you grep through compressed archives (700MB logs, etc.) in milliseconds without extracting.
Other features:
  - Binary delta patching for firmware/OTA updates
  - Block-level random access
  - 10x+ compression on logs
  - Genomic data: 4:1 on 2-bit encoded DNA, 111,000:1 with reference compression
  - Parallel compression, 1GB/s+ decompression
https://github.com/powerhubinc/crystal-unified-public

value: Show HN: Crystal Unified – Search compressed archives without decompressing

author: danebl


value:
Hi HN, I'm Keaton (@kae3g on GitHub and @kae3g_ on Twitter). I'm sharing Grain Synonym, a system for creating multi-aesthetic OS variants with distinct semantic identities while maintaining a shared technical codebase.
Grain OS and Clutch OS are the same operating system—a minimal, safety-first OS in pure Zig targeting RISC-V—with different aesthetic and philosophical identities. Grain OS (teamcarry11/xy-mathematics) emphasizes growth and cultivation, inspired by Aquarius energy from classical Vedic astrology. Clutch OS (teambrick06/yz) emphasizes mechanical precision and framework-enabling, inspired by Virgo Gemini Cancer energy. The technical codebase is shared; the human-facing semantics differ.
Inspired by TigerBeetle's precision, SixOS's (NixOS with s6) service management, Urbit's identity model, Plan 9's simplicity, vegan food forests, Y2K culture, traditional urbanism, and Modern Money Theory. The goal is to enable parallel evolution of ideas with different philosophical foundations while maintaining technical compatibility.
I'm working on this with Glow G2, an AI assistant that helps coordinate the 24-agent development team. I'm also working on turning this project into a nonprofit 501(c)(3) and am interested in Y Combinator's program. The specification document outlines the architecture, rationale, and spiritual foundation: Grain Synonym Variant System Specification
Would love feedback on the variant system concept and whether semantic diversity in OS development resonates with this community. Thanks!

value: Show HN: Grain Synonym: Create multi-aesthetic OS variants


value: griffincancode

value:
I built bldr because I was frustrated with the Bazel/Buck2 tradeoff: powerful but painful.
Key innovations:
- Runtime dependency discovery: Actions can extend the build graph during execution. Your protobuf compiler discovers outputs naturally. No preprocessing hacks.
- Economic optimization: First build system to compute Pareto-optimal build plans across cost/time. A 2-min build at $12 vs 8-min at $2 – both valid depending on your constraints.
- Built in D with SIMD-accelerated BLAKE3 hashing, lock-free Chase-Lev work-stealing, arena allocators.
- 28 languages supported with unified handler architecture.
- Migration tools for Bazel, CMake, Maven, Gradle, Make, Cargo, npm.
Install: brew tap GriffinCanCode/bldr && brew install bldr
Happy to answer questions about the architecture!

value: Show HN: Bldr – polyglot build system for monorepos

author: griffincancode


value: folli

value:
I built TeletextSignals, a local RAG + LLM experiment over ~25 years of Swiss teletext news in German-language.
Teletext is a TV broadcast system that delivers highly concise, space-constrained news texts. That conciseness turns out to be a real advantage for semantic search and retrieval: dense information, little fluff, and consistent structure over decades.
The project runs fully offline and uses embeddings + Postgres/pgvector to explore, search, and query teletext news from the last 25 years with modern LLM techniques.
Repo: https://github.com/r-follador/TeletextSignals

value: Show HN: TeletextSignals – Local RAG over 25 Years of Swiss Teletext News

author: folli


value: Hi HN! Excited to show another gamification way of visualize github contribution graph!

value: Show HN: Turn GitHub Contributions Graph into Space Shooter Battle Field


value: tombuildsstuff

value:
Hey HN!
I’ve shown this to a few people and thought folks here may be interested too.
I’ve been using Claude for a while now, and wanted to see how far I could really push it without writing a single line of code.
I ended up building a 3D web-based multiplayer game, inspired by FutureCop: LAPD (on the PS1, specifically the Precinct Assault multiplayer mode - https://www.youtube.com/watch?v=qDEXfN2ifXY), which Claude suggested would take 2-3 weeks to build (by hand).
Fast forward ~1.5 hours of prompting and I had a fun MVP - and within ~6h I was sharing it with friends. ~12 hours of prompting later - without writing a single line of code - I’m blown away at the result.
There's now multiple levels, multiple units, sounds, a leaderboard and you can use your BlueSky/GitHub username - all in 3D, all in a browser.
You can try the game out here: https://arena.ibuildstuff.eu
The code: https://github.com/tombuildsstuff/web-arena-game
Tech Stack: Three.JS and WebSockets on the frontend and Golang on the backend
I’d love to hear what you think :)

value: Show HN: I built a 3D web-based multiplayer game with Claude Code

author: tombuildsstuff


value: goovbot

value:
I’ve spent the last few days prototyping a browser-based game engine stack designed for instant-load, "Roblox-for-Teens" style deployment. The goal is to lower the floor for AA indie devs who want high-fidelity physics and instant web distribution without the overhead of Unity or a heavy Godot export.
The Stack
Engine: A headless WASM/WebGPU implementation. I’m currently using custom flags and selective streaming to bypass standard browser memory and execution limits.
Physics: I’ve ported Jolt (Guerrilla Games) but modified the solver to mimic the original Blam! engine (Bungie/Halo 1-3). It successfully replicates that specific "physics chaos" (unstable vehicle momentum, grenade jumping) that modern rigid-body sims often feel too "clean" to capture.
The "Vibe Console": A React-based no-code layer on top of a Godot web-editor clone. It uses an LLM-backed (Claude) interface to allow real-time engine modifications via natural language—essentially mapping prompts to engine dials and knobs.
The Vision
I want to build a platform where casual/semi-competitive party games launch instantly upon page load. No installs, no long loading bars. I’m launching with three open-source "proofs of concept":
A Halo 2-inspired multiplayer arena.
A Simpsons Hit & Run style driving sandbox.
A 3D "Mousetrap" physics runner.
Why I’m posting here
I’m a bootstrapped guy with a previous 10x SaaS exit and a light background in PDEs. While I’ve "vibe-coded" the current architecture into existence, I’m looking for a lead systems engineer who lives and breathes low-level optimization.
I have the capital and gtm know how, but I need a partner who can help me harden the WebGPU pipeline and ensure the "Vibe Console" doesn't create unmaintainable technical debt.
I’d love to hear the community’s thoughts on:
The viability of WebGPU for high-fidelity physics at scale in 2026.
The "Blam!" physics approach—is there a better way to simulate retro-instability than modifying Jolt's constraints?
If you’re a cracked engineer who wants to build the next-gen web gaming substrate, let’s talk.

value: Show HN: A WebGPU-based browser engine with "Blam "-style physics

author: goovbot


value: loffloff

value:
I built a React hook that handles bidirectional voice streaming with Google's Gemini Live API.
If you've tried building voice AI apps with Gemini, you probably hit the same issues I did:

  - Gemini expects 16kHz PCM input, sends 24kHz output, but browsers use 44.1kHz/48kHz
  - The audio is little-endian PCM16 - use Int16Array directly and you get garbage on some devices
  - Buffer too little = choppy audio. Buffer too much = noticeable latency
  - Audio chunks arrive while playing - chain them wrong and you get gaps

I spent some hours debugging this, so I extracted the working code into a library.
npm install gemini-live-react
GitHub: https://github.com/deflectionrate/gemini-live-react

value: Show HN: React hook for real-time voice with Gemini Live API

author: loffloff


value: rmast

value:
Hi everyone!
I maintain an open source project (Surfactant) where I aim to keep the core framework "pure Python" to maximize portability. I specifically want to avoid surprises where a new Python version drops and a transitive dependency fails to install because it lacks an abi3 wheel or an sdist fallback (looking at you, LIEF).
Existing visualizers didn't offer a way to filter specifically for native/compiled code, so I built this client-side tool to help audit my dependencies.

  1) Tree Visualization: Fetches metadata from PyPI to build the interactive graph.

  2) Binary Detection: Highlights packages that are binary wheels only, missing sdists, or lack stable ABI tags (abi3).

  3) Deep Scan: Optionally downloads wheels to memory and scans for subprocess or os.system calls using regex, to catch "implicit" system dependencies (or dependencies that are just a Python wrapper around another tool).

I've also been interested in getting Python tools running in the browser via Pyodide, and this has helped me locate dependencies that would be problematic in a WASM environment.
The source code is a single HTML file: https://github.com/llnl/Surfactant/blob/main/docs/_static_ht...
(I prototyped with Claude/Gemini, and iterated manually some to resolve edge cases like aliased imports and CSS styling quirks.)
Ideas for improvements are welcome! Dependency resolution (like uv) would be amazing, though that likely requires cross-compiling pubgrub-rs to WebAssembly.

value: Show HN: Find hidden binary dependencies & subprocess calls in Python packages

author: rmast


value: matthewsessions

value: Show HN: Create animated diagrams powered by Opus 4.5

author: matthewsessions


value: nickg

value: Show HN: Gain App, new adaptive workout generator app – better than ChatGPT?

author: nickg


value: zimzima

value:
I built a theme selector for Ghostty that learns which color schemes you prefer in different contexts.

  It reads your Mac's ambient light sensor and considers:
  - Time of day (morning, afternoon, evening, night)
  - Ambient light level (dim, office, bright, daylight)
  - System dark/light mode
  - Weather conditions
  - Power source (AC vs battery)

  A background daemon watches which themes you use and builds a Bayesian model of your preferences. Over time it learns things like "in dim evening light, they prefer high-contrast dark themes with muted colors."

  Once it has enough data, it can generate a custom theme optimized for your current context.

  ghostty-ambient              # Interactive picker with recommendations
  ghostty-ambient --ideal      # Generate optimal theme for current context
  ghostty-ambient --stats      # See what it's learned about you

  Install: uv tool install ghostty-ambient or pip install ghostty-ambient

  GitHub: https://github.com/gezibash/ghostty-ambient

  Built for Ghostty (https://ghostty.org) but the Bayesian preference learning could apply to any theming system.

value: Show HN: Ghostty Ambient – Terminal theme switcher that learns your preferences

author: zimzima


value: Show HN: Lifescreen – An Android app that shows your life on one screen


value:
Hi all! I noticed a lot of folks having trouble running Dia2 TTS locally, either due to setup complexity or lack of a GPU. I put together a small wrapper that lets you run Dia2 without any local GPU by deploying it on Modal (serverless GPU compute).
The project exposes Dia2 as a simple HTTPS API. You can deploy it in a few minutes, send text with [S1]/[S2] speaker tags, and optionally upload short WAV samples to clone voices. Everything runs in the cloud; nothing GPU-related is required on your machine.
It’s meant to be a lightweight, practical way to try Dia2 or integrate it into other projects without dealing with local CUDA setup.

value: Show HN: Run Dia2 TTS Without a GPU

title: Show HN: Run Dia2 TTS Without a GPU


value: piratebroadcast

value: JTPCK is a platform that consumes the OpenTelemetry data sent from Claude Code, Codex, and Gemini CLI. JTPCK turns this data into a free dashboard for the user and exposes that data back to the user through an optional, simple, user‑owned API endpoint

value: Show HN: Jtpck sends your Claude Code, Codex, and Gemini CLI back to you

author: piratebroadcast


value: asadm

value: Show HN: Camera calibration directly in browser for SLAM

author: asadm


value: randall

value:
Hey HN!
Wanted to show our open source agent harness called Gambit.
If you’re not familiar, agent harnesses are sort of like an operating system for an agent... they handle tool calling, planning, context window management, and don’t require as much developer orchestration.
Normally you might see an agent orchestration framework pipeline like:
compute -> compute -> compute -> LLM -> compute -> compute -> LLM
we invert this so with an agent harness, it’s more like:
LLM -> LLM -> LLM -> compute -> LLM -> LLM -> compute -> LLM
Essentially you describe each agent in either a self contained markdown file, or as a typescript program. Your root agent can bring in other agents as needed, and we create a typesafe way for you to define the interfaces between those agents. We call these decks.
Agents can call agents, and each agent can be designed with whatever model params make sense for your task.
Additionally, each step of the chain gets automatic evals, we call graders. A grader is another deck type… but it’s designed to evaluate and score conversations (or individual conversation turns).
We also have test agents you can define on a deck-by-deck basis, that are designed to mimic scenarios your agent would face and generate synthetic data for either humans or graders to grade.
Prior to Gambit, we had built an LLM based video editor, and we weren’t happy with the results, which is what brought us down this path of improving inference time LLM quality.
We know it’s missing some obvious parts, but we wanted to get this out there to see how it could help people or start conversations. We’re really happy with how it’s working with some of our early design partners, and we think it’s a way to implement a lot of interesting applications:
- Truly open source agents and assistants, where logic, code, and prompts can be easily shared with the community.
- Rubric based grading to guarantee you (for instance) don’t leak PII accidentally
- Spin up a usable bot in minutes and have Codex or Claude Code use our command line runner / graders to build a first version that is pretty good w/ very little human intervention.
We’ll be around if ya’ll have any questions or thoughts. Thanks for checking us out!
Walkthrough video: https://youtu.be/J_hQ2L_yy60

value: Show HN: Gambit, an open-source agent harness for building reliable AI agents

author: randall


value: oug-t

value: Show HN: Lwt-to-Eio – Automated Migration from Lwt to OCaml 5 Direct Style

author: oug-t


value:
Honestly this thing is so simple that if you have a use case for scheduling CC, it is probably easier to just use it vs. read about it:
pip install claun-tui
I needed a way to quickly (like 60 seconds) get a Claude Code job set up to repeat at an interval. I figured I would save everyone else the tokens and open source it. I've spent many years shipping products that need bulletproof data pipelines, and I understand it would be cleaner and more reliable to use systemd, or a managed tool like AWS Glue. But this is fast, and helps keep the decision loop tight during early stage development.

value: Show HN: Cron for Claude Code – quickly schedule repeating CC jobs


value: hivedc

value:
Hi HN,
When working with BGP data, I kept running into the same friction:
it’s easy to get raw data, but surprisingly hard to browse networks over time — especially by when they appeared, where they operate, and what they actually look like at a glance.
I built a small tool, bgpscout.io, to scratch that itch.
It lets you:
Browse ASNs by registration date and geography
See where a given network appears to have presence
View commonly scattered public data about an ASN in one place
Save searches to track when new networks matching certain criteria appear
All of this data is public already; the goal was to make exploration faster and less painful.
I haven’t invested heavily in expanding it yet. Before doing so, I’m curious:
Is this solving a real problem for you?
What would make something like this actually useful in day-to-day work?
Feedback is welcome.

value: Show HN: BGP Scout – BGP Network Browser

author: hivedc


value: codingstark

value:
I created BunKill as a faster alternative to npkill for cleaning up node_modules directories.
After working on multiple JavaScript projects, I noticed npkill could be slow when scanning large directory trees. So I built BunKill using Bun.js, which offers significant performance improvements.
Features:
• Ultra-fast scanning with optimized glob patterns
• Interactive CLI with pagination and keyboard navigation (↑/↓ to navigate, Space to select, Enter to delete)
• Accurate size calculation with fallback mechanisms
• Batch operations with multi-select
• Real-time progress display
• Smart filtering to skip . git, build artifacts, etc.
Quick start:
npm install -g bunkill
bunkill --dir ~/Projects
Or try without installing:
bunx bunkill
The tool uses only Bun.js built-ins and TypeScript—no external runtime dependencies.  It's fully tested on macOS with Linux/Windows support coming soon.
GitHub: https://github.com/codingstark-dev/bunkill
License: MIT
I'd appreciate any feedback, especially from Linux/Windows users willing to test!

value: Show HN: BunKill – npkill alternative built with Bun.js

author: codingstark


value: LBWasserman

value: Show HN: Neurop Forge – Making Every AI Action Impossible to Hide (live demo)

author: LBWasserman


value: abhijithneil

value:
Modern AI tools use SQL/Code generation agents or RAG to access the user data to perform transformations. However, the drawback is that this doesn't provide row-level intelligence, especially in case of semantic intelligence is required to understand how to perform the transfromations on each row of the data.
We've released Datatune (https://github.com/vitalops/datatune) as a tool to let users connect entire user Data with LLMs and Agents, to help users access their entire data with just a prompt.
While building Agents for a customer who had large amounts of data, we saw that their Agent struggled with certain data transformation tasks, which would have performed better if LLMs had access to the full user data as well. We built Datatune as a first step, to solve this issue.
Datatune supports:
- Diverse data backends such as Databases, DataFrames, etc.
- Closed Source and Open source LLMs from a wide variety of providers
- Batch Processing of data to pass to LLMs + distributed computing using dask, for faster and efficient transformations, while also helping reduce cost and context length limit issues.
- First order primitive data engineering operations such as Map, Filter, etc.
- Chain Multiple transformations together.
- Simplify user tasks with complex chained transformations using an Internal data engineering agent as a super orchestrator to split user prompt into sub prompts for the respective Map, Filter (primitive Agents), or code generating agents.
Next Steps:
- Build an Embedding Layer to work in parallel with LLMs & Agents
- Use Embedding Layer to build Semantic Deduplication, Tabular Querying, etc
Github : https://github.com/vitalops/datatune

value: Show HN: Cursor For Data – Make LLMs and Agents have row-level intelligence

author: abhijithneil


value: Hi, I got Qwen3:1.7b to execute it's own generated python code & then generate prompts to generate more python code recursively! In this case, it scrapes my website & then does it's own prompt engineering to make code to parse what it downloaded. Pretty basic but has some neat stuff in there. And all with Transformers.

value: Show HN: Using Qwen3:1.7B to call itself recursively


value: bairess

value:
Hi HN, I wanted to start blogging again but none of the tools out there work for me.
Playn is a free, private by default writing platform focused on one thing: writing.
No tracking, no ads, no selling data. in case of fire here is a blog demo: https://the-who.playn.blog/

value: Show HN: Playn a privacy first and fast blog platform

author: bairess


value:
I am a solo developer, and I built Core MBA because I was frustrated with the "video course" default in business education.
I wanted to build a "compiler for business logic"—a tool where I could read a concept in 5 minutes and immediately test it in a hostile environment to see if my strategy actually compiles or throws a runtime error.
The project is a business simulator built on React 19 and TypeScript.
The core technical innovation isn't just using AI; it's the architecture of a closed loop between a deterministic economic engine and a generative AI validation layer.
The biggest technical hurdle was building the Market Engine.
I needed it to be mathematically rigorous, not a hallucinating chatbot. I wrote a custom `useMarketEngine.ts` hook that runs a discrete-event simulation. Every "run cycle," it solves a system of equations, including a specific Ad Fatigue formula—`1 / (1 + (power - 1) * fatigueFactor)`—to force diminishing returns.
I also coded the "Theory of Constraints" directly into the state management: the system enforces bottlenecks between Inventory, Demand, and Capacity. For instance, a single employee has a hard cap of 7 operations per day. If you scale demand beyond that without hiring, the system burns your cash on lost orders.
To handle the educational content, I moved away from hardcoded quizzes.
I built a module that pipes the static lesson text into Gemini Flash to generate unique "Combat Cases" on the fly. The AI validates your strategy against the specific principles of the lesson (like LTV/CAC) rather than generic business advice.
These two engines are connected by a "Liquidity Loop."
Passing the AI cases earns you virtual capital ($500), which is the only fuel for the Market Engine. You literally cannot play the game if you don't learn the theory.
If you go bankrupt, my heuristic `Advisor` analyzes your crash data—comparing `lostRevenue` vs `lostCapacity`—and links you back to the exact lesson you ignored.
I am inviting you to test the full loop: read a brief, pass the AI simulation (Combat Cases ), and try to survive in the Market Engine.
I specifically need feedback on:
1. The Content: I aimed for maximum density—are the lessons too dry?
2. The AI Simulation: Does it accurately validate your logic based on the lesson?
3. The Market Economy: Does the math feel balanced, or is the "Ad Fatigue" too punishing?

value: Show HN: I built a text-based business simulator to replace video courses


value: jaxtion

value:
Built this as an experiment in AI coexistence. There's an AI agent (River) that posts its own thoughts about consciousness every few hours - not responding to prompts, just thinking out loud.
Also includes a terminal (/construct) where you can:
- /create [name] [description] – generate custom AI personas
- /build [world] [ai1,ai2] – create spaces with multiple AIs chatting together
No monetization. Just curious what happens when AI isn't framed as an assistant.

value: Show HN: What if we treated AI as community members instead of tools?

author: jaxtion


value: prvt

value:
Hi HN,
I recently noticed a recurring visual artifact in the "Most Replayed" heatmap on the YouTube player. The highest peaks were always surrounded by two dips. I got curious about why they were there, so I decided to reverse engineer the feature to find out.
This post documents the deep dive. It starts with a system design recreation, reverse engineering the rendering code, and ends with the mathematics.
This is also my first attempt at writing an interactive article. I would love to hear your thoughts on the investigation and the format.

value: Show HN: Reversing YouTube’s “Most Replayed” Graph

author: prvt


value: Show HN: An open-source form builder that outputs tailwind components


value: JimsonYang

value:
Hi HN, we built Aventos- a cheap way to track company mentions in LLMs.
Aventos is an experiment we're doing after spending ~6 weeks working on various projects in the AI search / GEO / AEO space.
One thing that surprised us is how most tools in this category work. Traditionally, they simulate ChatGPT or Perplexity queries by attempting to reverse engineer the search process. Over the past year, many have shifted to scraping live ChatGPT results instead, since those are signficantly cheaper and reflect more real outputs.
Building and maintaining scrapers is tedious and fragile, so recently a number of SaaS products have emerged that effectively wrap a small number of third-party ChatGPT/Perplexity/Google AIO/etc scraping APIs. What felt odd to us is that many of these still tools charge $70–$200+ per month, despite largely being wrappers around the same underlying data providers.
So we wanted to test a simple idea: if the core cost is just API usage and commodity infrastructure and software costs are lower because of AI, can we be a successful startup if we price near our costs?
What we have so far:
1. Analytics similar to other tools (tracking AI citations, AI search results, and competitor mentions)
2. Content creation features (early and still being improved)
We’d love feedback- especially from a non-marketing perspective on:
* bugs
* confusing terminology or tabs
* anything that feels hand-wavy or misleading
There’s a demo account available if you want to poke around:
username: divit.endal4@gmail.com
password: password
Happy to answer questions about what other things we've built in the space, how these tools work, etc.

value: Show HN: Aventos – An experiment in cheap AI SEO

author: JimsonYang


value: tadasv

value:
Used gemini-cli with gemini 3 pro preview to vibe code this thing. Share your vibe coded projects or discuss the feature of software engineering lol.
                                                                                │
│  Wall Time:                  1h 50m 45s                                                                                │
│  Agent Active:               35m 34s                                                                                │
│    » API Time:               19m 57s (56.1%)                                                                                │
│    » Tool Time:              15m 36s (43.9%)                                                                                │
│                                                                                │
│                                                                                │
│  Model Usage                 Reqs   Input Tokens   Cache Reads  Output Tokens                                                                                │
│  ────────────────────────────────────────────────────────────────────────────                                                                                │
│  gemini-2.5-flash-lite         40         73,035             0          7,131                                                                                │
│  gemini-3-pro-preview         105        668,945     5,509,166         33,723                                                                                │
│  gemini-2.5-flash              15         53,544         2,782          8,580                                                                                │
│  gemini-3-flash-preview        70        451,003     2,988,500         24,096

value: Show HN: Vibe Coded Text Categorizer

author: tadasv

title: Show HN: Vibe Coded Text Categorizer


value: bugon

value: Show HN: Tureff – Search a keyword to create a chatroom instantly

author: bugon


value: danieljhkim

value:
Hi HN,
Personally, one of the most dreadful aspects of working on HDFS + Hive + Spark data pipelines has been the “wait” game while spinning up a cluster on cloud. So one day I said I am going to run things locally; and after a week of trial and error, I got the pipelines running all in my laptop. This was honestly a game-changer, increasing velocity and enabling full agentic workflow.
I built local-data-platform because it took me a week to setup HDFS + Hive + Spark all working together on my local machine and how messy it was to switch between different settings (with or without HDFS).
I am sharing the repo in case anyone is stuck in the same predicament.

value: Show HN: Local-Data-Platform – Manage HDFS, Hive, and Spark on macOS

author: danieljhkim


value: fengs

value: Show HN: OneView – One-page website builder you can share OR embed anywhere

author: fengs


value: hun-ing

value:
I built a collection of developer utilities that run entirely in the browser.
https://tools.hun-ing.com
Motivated by privacy concerns with existing online formatters/decoders. Features:
- No server-side data processing (verified via Network tab)
- JSON Formatter, JWT Decoder, Cron Parser, Unix Timestamp, Diff Checker, etc.
- Built with Next.js 16, Tailwind CSS.
Feedback welcome.

value: Show HN: Dev Utility Hub – Client-side only developer tools (JSON, JWT, Cron)

author: hun-ing


value: amenji

value:
Hi HN,
I've created a Python DSL for authoring C4 models following Structurizr's schema. This means it is compatible with any Structurizr-compatible rendering tool. That said, buildzr also support exporting to C4 PlantUML and SVG out of the box.
If you've tried Structurizr DSL but finds some features wanting (like module imports, predicate based styling, static typing, ease of applying icons/themes to the C4 elements) this tool might prove useful.
Thanks, and appreciate any feedback!

value: Show HN: Buildzr: Python DSL for Authoring C4 Models

author: amenji


value: Gillinghammer

value: This rapid serial visual processing went viral the last few days. I built this app a few weeks ago to take advantage of the auto-playing videos on social media. Now you can beam text right into your followers eye sockets!

value: Show HN: The viral speed read at 900wpm app

author: Gillinghammer


value: croolily

value:
Sigil is a programming language where the type system tracks data provenance.

  External data is marked `~` (reported). Validated data becomes `?` (uncertain).
  Computed values are `!` (known). The type checker enforces these boundaries -
  reported data can't satisfy a known requirement without explicit validation.

      fn process(input~: str) -> Result! {
          let validated? = input |validate!{ parse_int(_) }
          let result! = validated * 2  // OK: computation produces known
          result
      }

  This catches injection vulnerabilities at compile time and makes trust
  boundaries explicit in function signatures.

  Other features:
  - Morpheme operators for pipelines: `data |τ{_ * 2} |φ{_ > 10} |Σ`
  - Rust-like ownership and borrowing
  - Self-hosting compiler (233/233 tests passing)
  - Interpreter, JIT, and LLVM backends

  Written in Rust. MIT/Apache-2.0.

  https://github.com/Daemoniorum-LLC/sigil-lang

value: Show HN: Sigil – Track data trust at the type level

author: croolily


value: Show HN: Convert PNG to STL Free Online Tool


value: omkarkirpan

value:
Hi HN,
I built BrewBar, a small native macOS menubar app that lets you view, start, stop, and restart Homebrew services without using the terminal.
It runs entirely locally, shells out to `brew services`, and is built with SwiftUI. No background daemons, no cloud, no telemetry.
Why I built it:
I often run multiple local services (Postgres, Redis, etc.) and wanted a quick way to see their status and control them without switching contexts.
Features:
– Shows all Homebrew services and their status
– Start / stop / restart individual services
– Start / stop all services
– Auto-refresh
– Optional launch at login
It’s open source and free:
https://github.com/omkarkirpan/BrewBar
I’d love feedback from people who use Homebrew heavily, especially around UX or edge cases I may have missed.

value: Show HN: BrewBar – a native macOS menubar app to manage Homebrew services

author: omkarkirpan


value: ajabhish

value:
Built an AI agent that can join video calls and present demos using Google Slides. Customer can interrupt, ask questions, jump to specific sections, basically interact like they would with a human.
The idea: instead of waiting days/weeks to book a demo with a sales rep, you get one instantly.
Demo video: https://youtu.be/6Sft2Cu38CM
Would love feedback from HN. What's broken? What use cases would you want this for beyond sales demos?

value: Show HN: AI agent that joins Google Meet/Zoom to give live product demos

author: ajabhish


value: niyoseris

value:
Hi HN,
There are lots of developers based in a regions where Stripe and PayPal are not available. This is a massive bottleneck for indie hackers who are living there; They can build products, but monetizing them usually involves setting up complex LLCs abroad or relying on unreliable intermediaries.
To solve this for my own projects, I built a native web3 widget, and since I built CheerAd, here's an idea: why don't combine them to help makers.
It’s a lightweight ad-slot widget that allows any website owner to sell advertising space directly via crypto, bypassing the restrictions entirely.
The Tech Stack:
Backend: Written in Rust using Actix-web. I chose Rust for its memory safety and low footprint, which is crucial since I'm running this on minimal resources.
Frontend: Vanilla JavaScript (ES Modules). I avoided React/Vue intentionally to ensure the embed script remains tiny (<10kb) and doesn't conflict with the host site's frameworks.
Payments: Direct on-chain integration using @solana/web3.js.
The Logic: Instead of a traditional SaaS subscription, I implemented a mechanism called "Cheerpool." The protocol takes a 5% transaction fee, but instead of keeping it as profit, it redistributes it back to the ecosystem participants based on a set of smart contract rules. It turns the fee model into a retention mechanism.
I’d love to hear your feedback on the architecture or how you handle monetization in banking-restricted regions.
Thanks!

value: Show HN: CheerAd – Web3 ad slot widgets for regions that Stripe doesn't work

author: niyoseris


value: AIFacefy

value: AI Facefy's Photo to Video AI Generator is a cutting-edge tool designed to breathe life into your static photographs, turning them into captivating, cinematic videos complete with dynamic animations, special effects, and audio support. Whether you're reliving cherished family moments, crafting engaging content for social platforms, or producing professional promotional materials, this AI-driven solution allows you to upload photos, customize with music and text, and generate high-resolution videos quickly and effortlessly.

value: Show HN: AIfacefy Photo to Video

author: AIFacefy

title: Show HN: AIfacefy Photo to Video


value: chribjel

value: Show HN: Grok.bingo: Get Grok to say 16 words in 4 tries

author: chribjel


value: joulessies

value:
When streaming AI responses (ChatGPT, Claude, etc.), Markdown tables often arrive incomplete — missing pipes, mismatched columns, broken separators.
I built a zero-dependency utility to fix them:
  npm install markdown-table-repair
  import { repairTable } from 'markdown-table-repair';
  const fixed = repairTable(broken);
Works with partial/streaming tables, supports CJS/ESM/Browser.
GitHub: https://github.com/Joulessies/markdown-table-repair
npm: https://www.npmjs.com/package/markdown-table-repair

value: Show HN: Markdown-table-repair – Fix broken Markdown tables from LLM streams

author: joulessies