value: kamaludu

value:
I built GroqBash, a single‑file Bash client for the Groq API (OpenAI‑compatible).
I wanted something fully auditable, with no dependencies, and that worked reliably on Termux, where /tmp isn’t writable.
Everything lives inside a self‑created groqbash.d directory, and the core script avoids eval, avoids /tmp, and keeps permissions strict.
The project now includes optional extras: additional providers (including Gemini), extended documentation, small security tools, and a tiny test suite.
The core stays minimal and portable; extras are opt‑in.
I’d love to get:
- feedback on the design and Bash choices
- visibility to see if others find this useful
- testing on different environments (Linux distros, macOS, WSL, Termux)
Repo: https://github.com/kamaludu/groqbash
Note: I’m not a native English speaker. I read English fairly well, but I usually rely on automatic translators (and sometimes GroqBash itself) when writing.
Happy to clarify anything if needed.

value: Show HN: GroqBash – Single‑File Bash Client for Groq API

author: kamaludu


value: theantonym

value: Show HN: Beach Report – Real-time beach conditions, weather, and surf reports

author: theantonym


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

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


value: markrai

value: The anonymous boards are a free offering - forever. Featuring a Go backend, the enterprise offering which supports multiple projects + roles + permissions, will be made open-source soon!

value: Show HN: Scrumboy an anonymous paste-bin style Kanban board and Jira alternative

author: markrai


value: Show HN: GitHub Stats Images, in Rust

title: Show HN: GitHub Stats Images, in Rust


value: Intragalactic

value: Show HN: Elo ranking for landing pages

author: Intragalactic

title: Show HN: Elo ranking for landing pages


value: joshcramer

value:
Hey HN!
I have been building NTNT (/in'tent/), an experimental programming language exploring a specific question I have had:
"What would a programming language look like if we assumed AI agents would be the primary writers of code instead of humans?"
The core concept is Intent-Driven Development (IDD). Instead expressing intent through vibe coding or markdown file chains, you (and your agent) define a machine-verifiable .intent file (using IAL - Intent Assertion Language) that serves as an executable contract between human and agent. The agent then maintains, builds and verifies with .intent file driving development.
The language itself is "Rust-flavored scripting" designed to reduce hallucinations and ease strain on agents as they author and manage code.
I'd love your feedback:
1. Does the NTNT flavor of IDD have potential to improve agent based development flows?
2. If I/we extracted the Intent system to work with TypeScript/Go, would you use it?
Repo: https://github.com/ntntlang/ntnt
Website: https://ntnt-lang.org (runs on ntnt)

value: Show HN: Intent-Driven Development with NTNT

author: joshcramer


value:
Good afternoon everyone, spent like 2 weeks straight doom-scrolling Anthropic docs, Arxiv rabbit holes, and Claude blog posts till my eyes bled. Instead of shipping yet another wrapper that "reinvents" the wheel, I just vibe engineered this thing to max out Claude Code's native features. Klaus Baudelaire (https://github.com/blas0/klaus-baudelaire) basically: Routes agents (in parallel/sequence) with through keyword based scoring + prompt length (no fancy external router needed).
Instead of trying to make agentic delegation deterministic by setting keyword variables as a "YOU MUST INVOKE X-AGENT IF THE USER SAYS DELEGATE", keywords = a score, a certain score = a specific system prompt that is injected into the session post UserPromptSubmit. You can read how this works more on the repo: (https://github.com/blas0/klaus-baudelaire)
Delegates built-in agents + some redefined ones (broad general roles + hyper-specific tool callers)
Some agents were built from/around Claude's exposed system prompts and whatever invisible native agents they're hiding behind the scenes.
Bonus: optional memory manager tuned to how Claude actually thinks (not some vector DB cope) to help with managing memory based on: https://code.claude.com/docs/en/memory - doing away with the branded ".memory" directories and such.
Zero external APIs, zero services, zero reinventing (besides context7).
Feels like what Anthropic probably wanted us to do before everyone started LARPing as OpenAI. Plugin version drops late Monday–early Wednesday (this week, Jan 2026).
Video coming day-of with routing/delegation demo + bare Claude Code vs Klaus Baudelaire.
Thoughts? Go ahead and roast or don't! Please, just don't make another 500-line prompt wrapper pls and call it a novel abstraction.

value: Show HN: Klaus – a Claude Code native delegating agentic harness


value: Show HN: BSS Blue Hive Build

title: Show HN: BSS Blue Hive Build


value: zacaryn

value: I built OMIU.ME as a small indie project. Not trying to reinvent profile or link-in-bio sites, rather just approach the same idea with a more predictable editor. I'll continue to iterate on it over time and add features.

value: Show HN: Omiu.me – A WYSIWYG profile builder that uses blocks

author: zacaryn


value: bradleyboy

value:
I use Claude Code heavily and wanted to search through past sessions, see what Claude was doing in long-running tasks, and monitor multiple sessions at once. I also was looking for an exscus to build something end-to-end with just Claude on the implementation.
I had Claude create a task system, hook it up to a `/task` command, then can use `bun ralph` to churn through any open tasks.
Try it out and feel free to contribute!

value: Show HN: Cloister – Local web UI to browse and monitor Claude Code sessions

author: bradleyboy


value: weisser

value: Show HN: SF Microclimates

author: weisser

title: Show HN: SF Microclimates


value:
X-AI recently open sourced their new recommendation algorithm.
I wanted to see exactly how the X "For You" algorithm decides whether to recommend your tweet or not, so I built this 'playable' CRT-styled simulator that runs a simpler version of X's recommendation pipeline right in your browser.
It's a "playable documentary" that allows you to type raw text and watch it physically travel through tokenization, embedding, safety filtering, and final ranking, all based on the X-AI reference docs.
Under the hood it's running real local ML inference (a tiny embedding model using Transformers.js) to generate embeddings and score content on the fly - all locally on your machine.
Would love some feedback!

value: Show HN: Interactive demo of the X "For You" algorithm (runs in browser)


value: josephttd

value: I built Invoice Studios because I was tired of messy invoice templates and subscription tools. It’s a local‑first desktop app: create invoices/quotes, live preview, export clean PDFs. Looking for feedback on the UX and the exported PDF layout.

value: Show HN: Invoice Studios – local first invoicing app (one time purchase)

author: josephttd


value: joshuafkon

value:
I'm the author of a new preprint that tries to resolve why major U.S. sexual behavior surveys appeared to report contradictory trends over the past decade.
The key move is separating never-occurrence from temporary inactivity among the experienced, rather than averaging them together. That decomposition is applied symmetrically across surveys and validated against an independent dataset.
The paper then treats the remaining discrepancy as a debugging problem:
• check distributions for digit heaping and compression
• look for stock–flow reversals consistent with under-reporting
• compare adjacent survey waves for internal consistency
• cross-validate against an external series not subject to the same reporting incentives
Once those diagnostics are applied, the conflicting results reconcile cleanly.
This is a methods/measurement paper, not a causal one. The contribution is showing how small reporting artifacts and aggregation choices can produce large apparent disagreements—even in high-quality surveys—when they aren't handled carefully.
(One note for the methodologically inclined: conditioning on "sexually experienced" looks like it could induce collider bias. Section 4 and Appendix D5 address this directly—the gender gap in sexual debut didn't change differentially, so selection into the analysis sample is symmetric.)
Preprint: https://osf.io/preprints/socarxiv/jcdbm_v2
Replication code: https://github.com/Joshfkon/ResearchPaper_PartnershipGap
Happy to discuss the diagnostics, decomposition logic, or limitations.

value: Show HN: Debugging conflicting U.S. sexual behavior surveys

author: joshuafkon


value: tomstig

value: Show HN: Endfield Calculator – Arknights Factory and Base Planning Tool

author: tomstig


value: kolodny

value: Show HN: Nhx – Node.js Hybrid eXecutor (a uvx inspired tool)

author: kolodny


value: vassilbek

value: Show HN: Crowd Forecasting: Simulate expert debates, get probability estimates

author: vassilbek


value: I built NukeCast because I’ve always wanted a tool that answers one question fast. If it happened today, where would the fallout plumes go and where would you drive to get out of it. NukeCast uses weather forecasts to drive a Lagrangian particle dispersion model with wet and dry deposition. Scenarios are defined by selecting strike site(s) and yield(s); the setup uses preselected US sites and yields based on FEMA emergency data. Outputs are shown as estimated ground level radiation dose at the surface over a 12 hour integration. Free to use with limits, and a paid tier if you want more runs/features because AWS compute time ain’t cheap.

value: Show HN: NukeCast – If it happened today, where would the fallout go


value: daversa

value: Show HN: WhyThere – Compare cities side-by-side to decide where to move

author: daversa


value: vivekkalyanaran

value: Show HN: (29x faster)Rapidvalidators - Python's validators lib rewritten in Rust

author: vivekkalyanaran


value: MrSteaddy

value:
Hi HN,
I'm Cristian, an indie developer from Italy working on tools to make multi-agent AI safer and more debuggable.
When agents talk to each other (CrewAI, LangGraph, AutoGen, custom setups), they quickly develop shorthand, lose context, invent jargon, and propagate hallucinations — all invisible to us.
InsAIts is a lightweight Python SDK that adds observability in ~3 lines of code.
V2 just shipped with:
Anchor-aware detection (set the user's original query as context to reduce false positives)
Forensic root-cause tracing + ASCII chain visualization
Built-in domain dictionaries (finance, healthcare, kubernetes, ML, devops, quantum)
Local (Ollama) decipher mode — translates agent jargon to human-readable (Cloud soon)
Integrations: Slack alerts, Notion/Airtable export, LangGraph/CrewAI wrappers
Privacy-first: local embeddings by default, nothing leaves your machine unless you opt into cloud decipher.
Free tier works without an API key (local only). Also running limited lifetime deals for early supporters.
Quick install:
Bashpip install insa-its[full]
Demos included:
Live terminal dashboard
Marketing team agent simulation (watch shorthand emerge in real time)
GitHub: https://github.com/Nomadu27/InsAIts
PyPI: https://pypi.org/project/insa-its/
Docs: https://insaitsapi-production.up.railway.app/docs
Would love feedback — especially from anyone building agent crews or running multi-LLM systems in production. What’s your biggest pain point with agent observability?
Thanks for checking it out!
Cristian

value: Show HN: InsAIts V2 – Real-time monitoring for multi-agent AI communication

author: MrSteaddy


value: ralfcheung

value: While interviewing for different companies and find Leetcode-like platforms to practice system design, there really isn't any good tools to practice that grill me like an interviewer. I built Scrimm.ai to solve a personal pain point: practicing System Design interviews alone is impossible and expensive (if you want to find a real person). You can read books, but you can’t simulate the pressure of an engineer poking holes in your architecture.<p>It’s in private beta. I’d love for you to try any of the questions and let me know if the AI is too harsh or too lenient.

value: Show HN: Scrimm AI - System design interview practice with AI

author: ralfcheung


value: tarzenyinc

value: Show HN: Deploy backends without the hassle. An Open source alternative

author: tarzenyinc


value: Chatalyst

value:
While testing Gemini, ChatGPT, and other LLMs with local, high-intent queries like:
 • “Where should I advertise my small business in Omaha?”
 • “Best local advertising companies near me”
 • “Who helps small businesses with local marketing?”
we ran a small experiment: we sampled real, active local businesses (with websites, Google profiles, and years in operation) and checked whether they appeared in AI-generated answers.
92% didn’t show up at all.
What stood out was that when businesses did appear consistently, it wasn’t random. The models seemed to have a clearer, more structured understanding of who the business was, what it did, and when it should be recommended.
That led us to build Chatalyst — a way for businesses to intentionally define how they’re represented inside AI systems, instead of relying on models to infer it from scattered web signals.
It’s not ads, SEO, or a directory. It’s closer to providing AI with a clean, machine-readable source of truth: what a business does, who it’s for, what it should (and shouldn’t) say, and when it’s a good fit.
I’m curious how others here think about:
 • AI as a discovery surface vs traditional search
 • Whether businesses should have a first-class presence inside LLMs
 • What defensibility looks like as discovery formats standardize
Happy to answer questions or dig into the methodology.

value: Show HN: We ran a test–92% of local businesses don't show up in AI answers

author: Chatalyst


value: dbhariprakash

value: Show HN: Privacy-first JSON/YAML toolkit – 100% client-side, no server

author: dbhariprakash


value: icstiss

value:
Banana Prompts is an open community gallery dedicated to making AI image  generation transparent and accessible to everyone. We believe the craft behind AI visuals should be shared, not hidden. That's why every image and video in our gallery comes with the exact prompt, settings, and techniques that created it.
Whether you're a professional AI artist, aspiring creator, or curious fan exploring generative art for the first time, Banana Prompts gives you direct access to proven prompts that work. No more guesswork. No more trial and error. Just copy the prompts that caught the community's attention and start creating immediately.
 Browse Curated Prompts
Explore thousands of proven AI image prompts shared by creators worldwide. Each prompt comes with examples and results, helping you visualize what's possible before you try it yourself.
  Curated Collections
Thoughtfully curated collections by our community managers to help you quickly discover prompts of the same type. Whether it's a specific style, scene, or technique, each collection is a handpicked treasure trove of inspiration
 Free Community Platform
Join a thriving community of AI artists and enthusiasts. Share your discoveries, learn from others, and collaborate on creative projects—completely free.
 Learn Techniques
Discover advanced prompting techniques, tips, and tricks from experienced creators. Master the art of crafting effective prompts for stunning AI-generated images.
 Share Your Creations
Upload and share your best prompts with the community. Help others learn and get inspired by showing them what works for you.
 Smart Search & Filter
Easily find the perfect prompt with our intuitive search and filtering system. Browse by style, category, popularity, or specific use cases.
 Trending & Popular
Stay up-to-date with the hottest prompts trending in the community. See what's working best and what others are creating right now.

value: Show HN: A curated library of prompt patterns for Nano models

author: icstiss


value: GLM-Image is an industrial-grade AI model built for cognitive generative exploration, with deep instruction understanding and precise visual rendering. It excels at offering knowledge-rich, text-dense images through advanced text-to-image generation, accurate editing, and flexible style transfer. GLM-Image delivers consistent, high-fidelity visual outputs. Ideal for commercial posters, scientific illustrations, social media graphics, e-commerce displays, and realistic or artistic creation.

value: Show HN: GLM-Image Dense-knowledge AI Generator


value: DeusCodex

value: Show HN: Blockframe v1.0.3 Released

author: DeusCodex

title: Show HN: Blockframe v1.0.3 Released


value: Convert 2D images (products, portraits, objects) into realistic 3D models instantly with Hey Dream AI’s Image to 3D tool, powered by Tripo 3D v2.5. Fast, accurate, and easy to use. Preview online and download in common 3D formats.

value: Show HN: Image to 3D AI Generator – Instant 3D Models from Photos


value:
Hi HN,
I built a small tool that converts API logic written in plain .txt files into real, executable PHP API endpoints.
The motivation was personal: I can design and ship frontends quickly, but backend APIs (setup, boilerplate, deployment) always slowed down small projects and MVPs. I wanted a way to describe inputs, rules, and responses in text and get a working endpoint without worrying about infrastructure.
This is early and opinionated. I’m especially interested in feedback around:
trust and security concerns
where this breaks down
whether this is useful beyond prototypes
Happy to answer questions about how it works.

value: Show HN: Bytepiper – turn .txt files into live APIs


value: Prashasthajain

value: Show HN: Resume Optimization Based on JDs

author: Prashasthajain


value: funcin

value:
Hi Hacker Friends,
I’m sharing AI Compass, a daily AI signal brief built for builders who want facts over hype.
AI moves fast. We track real-time signals across Google Trends and web news, then use AI clustering, denoising, and source attribution to surface what actually matters: model launches, company moves, and emerging terms.
You get a structured daily brief with traceable sources and clear takeaways, so you can understand the landscape in minutes.
Our priorities：
1. High signal-to-noise: only accurate, relevant items. No hype.
2. Objective and transparent: conclusions backed by traceable evidence.
3. Fast to consume: built for developers, PMs, and indie builders.
This is a new launch. Feedback, bug reports, and feature ideas are welcome.

value: Show HN: AI Compass:Daily AI Search Signals and Trends

author: funcin


value: AmruthPillai

value: Now back with version 5, it comes with lots of new updates, but most importantly, better documentation and guides for users, overall app stability and easier self-hosting guides.

value: Show HN: Reactive Resume v5 – A free and open-source resume builder

author: AmruthPillai


value: calebevans

value:
I built a GitHub Action that analyzes workflow failures and correlates them with PR changes. It uses cordon (transformer-based semantic anomaly detection) to reduce massive logs to unusual patterns, then DSPy to orchestrate LLM analysis of failures. Then, it determines whether PR changes likely caused the issue and posts structured root cause reports.
Marketplace: https://github.com/marketplace/actions/github-actions-failur...

value: Show HN: GitHub Action that analyzes CI failures using AI

author: calebevans


value: RupertWiser

value:
A few years ago, I finished up a little game that I thought was really fun. It is a little versus game where each player needs to make a shape. I planed on submitting it to the various mobile app stores but I started a new job and life got in the way.
As a fallback, I thought I would just throw the game on the web so that I could at least still share it but the game engine I used didn't support the web.
I just gave Claude the source code for my game and it happily spit out a clone of my game in roughly 20 minutes. The future is wild. You can try the vibe code port here:
https://benwiser.com/unu/
I wrote a quick brain dump on my blog here:
https://benwiser.com/blog/Vibe-Coding-the-Port---I-gave-up-w...

value: Show HN: Unu – canvas based pattern matching versus game

author: RupertWiser


value:
I built a real-time chat app where every message becomes a node and every reply creates a connection. As you talk, the conversation turns into a visual map.
Try it: https://qonvo.xyz (click "Try Demo" to see it in action)
What it does:
Send a message → it appears as a node
Reply to someone → a line connects the messages
Use #tags → related messages link together
Watch the graph grow in real-time as people chat
No AI. No cloud accounts. No login. Just share a link and start talking. Rooms auto-delete after 3 hours.
Why I built this:
Linear chat is broken for group discussions. Important messages get buried, threads get lost, and you can't see who's actually talking to whom. I wanted to see the shape of a conversation – which topics branched off, what sparked the most replies, where the discussion actually went.
Use cases I'm exploring:
Team brainstorms where you want to see which ideas resonated
Q&A sessions with branching follow-ups
Research interviews where connections matter
Any group chat where "scroll up to find that thing" is painful
Tech: Node.js, Socket.io, D3.js for the graph, Redis for temp persistence. Single HTML file for the frontend.
Would love feedback. What's confusing? What's missing? Would you actually use this?
thank you for your time in testing it.

value: Show HN: Qonvo – Group chat that visualizes your conversation as a live graph


value: twwch

value:
I built a Claude Code Skill that generates flowcharts, architecture diagrams,
data visualizations, mind maps, and math plots from natural language.
Supports Mermaid, DrawIO, ECharts, GeoGebra, and Markmap. Just describe what
you want and get interactive HTML or PNG/SVG output.
GitHub: https://github.com/twwch/multi-chart-draw-skills

value: Show HN: Claude Code Skill for generating any chart with natural language

author: twwch


value: decebals

value: Show HN: PF4J-Plus – ServiceRegistry and EventBus for PF4J Plugin Systems

author: decebals


value: tnsqjahong

value: HeyTraders parses natural language queries into trading logic for instant crypto backtesting and market research

value: Show HN: HeyTraders – Backtest crypto strategies using natural language

author: tnsqjahong


value: nikhonit

value: Show HN: My YouTube API Tool generated 10M transcripts this month

author: nikhonit


value: UtopiaRC

value:
Hi HN,
I built 64K Tools – a collection of 50+ free utilities for both developers and everyday users.
Developer tools:
- JSON/XML/YAML formatters
- Base64/URL encoder/decoder
- Password generator with strength checker
- Hash generators (MD5, SHA, etc.)
Everyday tools:
- QR code generator
- Weather app
- Calculator
- Unit converters
- Live world statistics (births, deaths, CO2 emissions, etc.)
- Random cat gallery (for stress relief!)
Key features:
- Star your favorite tools (stored locally, no account needed)
- All processing happens in browser (privacy-first)
- Available in 18 languages
- Works offline after first load
Tech stack is simple: PHP for templating, vanilla JavaScript, no frameworks. Hosted on Nginx.
Would love your feedback and suggestions for new tools!

value: Show HN: 64K Tools – 50 browser-based tools, no signup required

author: UtopiaRC


value: mugamuga

value: Show HN: An AI-powered minimalist news aggregator for Zimbabwe

author: mugamuga


value: sOwl

value:
Hi HN,
I built Akshen because I was tired of "prompt engineering" lists that were just SEO fluff or didn't work across different models. I wanted a place where the community could post prompts they’ve actually tried and tested.
The Goal: To create a living repository where prompts are treated like open-source snippets—vetted by users and updated as models (like GPT-4o or Gemini) evolve.

value: Show HN: Akshen – A community-driven library for verified AI prompts

author: sOwl


value: utapyngo

value: Show HN: Sentry-MCP – Fast Rust MCP server for Sentry (10x less RAM)

author: utapyngo


value: joyhn

value:
Hey HN,
I’m excited to introduce Panda Meditation Timer, a minimalist, distraction free timer designed to help you focus on your meditation practice.
After struggling with overly complicated meditation apps that added unnecessary features, I decided to create Panda, a simple tool that helps you set your meditation session with ease and stay present during your practice. It’s all about simplicity and mindfulness, without the clutter.
Features:
Simple & Intuitive Design: No overwhelming features, just what you need.
Customizable Timers: Set your own durations for meditation or select from presets.
Gentle Sounds: Bell and Mantra modes.
Cross-Platform: Available on both iOS and Android, so you can practice wherever you go.
Reminders: Daily reminders so you do not miss a session.
Panda is perfect for beginners and experienced who want a tool that helps them focus on their practice, not on setting up complex apps.
Links:
iOS (App Store): https://apps.apple.com/us/app/panda-meditation-timer/id67578...
Android (Play Store):https://play.google.com/store/apps/details?id=com.chromiumon...
Landing Page:https://www.chromiumone.com/apps/en-US/meditation-timer-pand...
Quick preview: https://youtube.com/shorts/KnYKn9zIQhA?feature=share
Feel free to check it out and let me know what you think!  I’d love to hear your thoughts, feedback, or suggestions for future updates.

value: Show HN: Panda – Minimalist Meditation Timer App

author: joyhn


value: AlexRST

value:
Hey HN,
I built a small tool to automate failed payment recovery for Stripe subscriptions.
Context: I run a SaaS on the side and got tired of losing customers to expired cards. Stripe's built-in retries help but the recovery rate is meh. I wanted something that would ping customers via email and SMS right when a payment fails, with a fresh billing portal link.
It's a native Stripe app so setup is just OAuth, no webhooks to configure manually.
Stack is Next.js, uses Stripe's billing portal API to generate session links on the fly (so no expired links).
Still early, looking for feedback from anyone running subscriptions on Stripe. Free access for early testers.
Curious what others are using for this. I looked at Churn Buster and Dunning but they're overkill (and expensive) for small SaaS.

value: Show HN: Rekko – Stripe app to recover failed subscription payments

author: AlexRST


value: justconvert

value:
Hi HN,
I built AffordWhere to answer a question I kept running into: “If I earn X, where can I actually afford to live comfortably?”
The site lets you compare cities based on income, rent, taxes, and day-to-day costs, and see how far a salary realistically goes in each place.
It’s intentionally simple:
Focused on affordability rather than averages
Designed for relocation and remote-work decisions
No account required
I’d appreciate feedback on:
Whether the affordability framing is useful
Missing cost factors you’d expect
Data accuracy or methodology concerns
Link: https://affordwhere.com
Thanks for taking a look.

value: Show HN: AffordWhere – Affordability by City

author: justconvert


value: rsc-dev

value: Malware Museum — a static GitHub Pages site with an interactive timeline of notable malware and security incidents.

value: Show HN: An interactive timeline of computer viruses, worms, and digital threats

author: rsc-dev


value: czheo

value: Show HN: A Neovim plugin to add comments for coding agents

author: czheo


value: beigebrucewayne

value: Show HN: Only 1 LLM can fly a drone

author: beigebrucewayne

title: Show HN: Only 1 LLM can fly a drone


value: theraven

value: Show HN posts p/month more than doubled in the last year

author: theraven


value: I wrote an article about a cloud GPU selection technique that would maximize FLOPs per $.<p>Taking the pre-training of LLMs as an example, it shows how the cost-optimal GPU changes depending on the computational intensity (∝ model size x batch size).

value: Show HN: The Poor Man's Guide to Cloud GPU Selection


value: Brosper

value:
Hi HN
After work I built a small Chrome extension that detects whether a webpage is rendered using Server Side Rendering, Client Side Rendering, or a hybrid approach.
As a frontend developer I often wanted a quick way to check how a site is rendered without opening devtools and digging through network and DOM. This started as a personal after hours project and turned into something I use daily, so I decided to share it.
What it does
• Detects SSR, CSR, or hybrid rendering
• Recognizes frameworks like Next.js, React, Nuxt, Gatsby and others
• Shows basic performance timings like DOM ready and FCP
• Keeps last 10 checks in local history
• Works fully locally with no data collection
Accuracy is based on 15 plus indicators and works surprisingly well across modern stacks.
Everything is open source. No tracking. No external servers. Just a lightweight dev tool.
I recently improved React 18 detection, fixed history display, added better error handling, and cleaned up docs and roadmap.
This is very much a side project made for fun and learning. If it helps even a few devs or SEO folks, I will be happy.
https://chromewebstore.google.com/detail/csr-vs-ssr-detector...
Feedback and suggestions are welcome. Thanks for checking it out

value: Show HN: CSR vs. SSR Detector

author: Brosper

title: Show HN: CSR vs. SSR Detector


value: anzedev

value:
Hi HN,
I built ZigZag, a command-line tool written in Zig that recursively scans source code
directories and generates a single markdown report containing the code and metadata.
It’s designed to be fast on large codebases and uses:
- Parallel directory and file processing
- A persistent on-disk cache to avoid re-reading unchanged files
- Different file reading strategies based on file size (read vs mmap)
- Timezone-aware timestamps in reports
Each directory produces a report.md with a table of contents, syntax-highlighted code
blocks, file sizes, modification times, and detected language.
Repo: https://github.com/LegationPro/zigzag
I built this mainly for auditing and documenting large repositories.
Feedback, critiques, and ideas are welcome.

value: Show HN: ZigZag – Generate Markdown code reports from directories (Zig)

author: anzedev


value: Othrya

value:
We noticed that professional networking is mostly profile-based: you create a static resume and hope the right people somehow discover you. But what actually drives meaningful connections is complementary intent: a founder looking for a technical co-founder, an engineer wanting to join a specific type of early-stage company, an investor actively looking for a certain thesis.
We built Alprina to match people on what they want right now, not just who they are on paper.
On Alprina, you create "intents" in natural language (what you're looking for), join networks (communities where matching happens), and our AI matches you with people whose intents complement yours. You can attach context like pitch decks or profiles so that when you match, the other side immediately understands why you're reaching out.
Would love feedback from the HN community - especially on the balance between match precision and serendipity. Too strict and you miss interesting connections; too loose and it's just noise.

value: Show HN: Alprina – Intent matching for co-founders and investors

author: Othrya


value: CherishRoby

value:
I built SheetSage because "Silent Failures" in spreadsheets are a massive unmanaged risk in finance and ops. Most tools just find broken references (#REF!), but the real killers are logical errors like a VLOOKUP defaulting to approximate match on unsorted data, returning a plausible but wrong value.
The Technical Implementation:
Locale aware parsing: Since Google Sheets doesn’t provide an AST for formulas, I had to build a conservative parser that tracks quotes, parens, and braces to extract function calls without getting poisoned by strings or array literals. It handles localized argument separators (, vs ;) and decimal separators (, vs .) based on the spreadsheet's locale.
R1C1 Clustering: To avoid UI noise, I don't treat every cell as a unique finding. I normalize formulas using getFormulasR1C1() to identify templates that have been copied down. This allows the fix all engine to refactor thousands of cells in one batch.
The systemic softcap scoring: standard penalty per thousand metrics often under react to widespread errors. I implemented a continuous soft-cap model. It calculates union coverage for risks—if a critical error covers 40% of your workbook, your health score is soft-capped regardless of how many other healthy cells you have.
Snapshot & Rollback: Since I’m mutating user data, I implemented a SnapshotService that writes original formulas to a hidden SheetSage_SNAPSHOT sheet before any bulk fix. This provides a native "Undo" even after the Apps Script execution finishes.
Privacy: No spreadsheet data ever leaves the Google environment. The audit engine runs entirely in Apps Script. The only external call is a signed HMAC request to a Vercel/Next.js billing service to verify subscription entitlements via a stable clientId.
I'd love to discuss the heuristics I'm using to distinguish magic numbers from legitimate constants (like 24 for hours), and how I'm handling LockService to prevent race conditions during bulk refactoring.

value: Show HN: SheetSage – A Linter for the Most Dangerous Programming Language

author: CherishRoby


value: ramnete

value:
Hi HN,
I built a small invoice tool for an internal requirement at my company.
We work with several suppliers and providers and wanted to give them a simple way to create invoices directly inside our workflow. The goal was to increase operational visibility: track what’s been created, sent, viewed, and paid, without the need for an accounting system like Xero or QuickBooks if they do not have it.
I extracted it into a standalone tool and built and deployed it in about half a day, fully vibe coded.
Tech stack:
- Next.js, Prisma, PostgreSQL
- Stripe for payments
- Hetzner VPS managed via Coolify
- App and database on the same machine for now
Current infra cost is < €4/month.
What it does:
- Lets suppliers create structured invoices
- Sends them directly
- Tracks status (Draft / Sent / Viewed / Paid) and basic revenue insights
This started as a way to fix a specific internal workflow, and I’m now trying to understand whether this resonates beyond our use case (e.g. small businesses/freelancers).

value: Show HN: A simple invoice tool I built instead of full accounting software

author: ramnete


value: JustinXie

value: Show HN: Robust image-to-video pipeline for pets and dance (Kling wrapper)

author: JustinXie


value: kamranahmedse

value: Show HN: Notemap - Local-first mind mapping for Mac

author: kamranahmedse


value: athrvk

value:
Hi HN,
I built Vayu because I was frustrated with the current state of API tools. Postman has become bloated and forces cloud sync, while high-performance tools like JMeter or k6 often lack a decent GUI for quick debugging.
Vayu attempts to bridge that gap. It is an open-source, local-first API client (like Postman, Insomnia) that includes a high-performance load-testing engine (written in C++20) under the hood.
Key technical decisions:
- Sidecar Architecture: The UI is Electron/React (for usability), but it spawns a separate C++ daemon ("The Engine") to handle actual networking.
- This allows the UI to remain responsive even while the engine is pumping thousands of requests per second during a load test.
- Privacy: It is 100% local. No cloud sync, no accounts required.
- Scripting: Uses QuickJS for test scripts (compatible with the `pm.test` syntax you already know).
I have tested upto 60k rps locally on Macbook Pro M3
It is currently v0.1.1. I have builds for Windows, Linux, and macOS. (PS: macOS requires some extra steps to run via the dmg file, will have to find a workaround)
I am looking for feedback specifically on the "Engine" performance and the developer experience of the load-testing flow, and developers to help me improve the UI.
Repo: https://github.com/athrvk/vayu

value: Show HN: Vayu – A local-first API client with a C++ load-testing engine

author: athrvk


value: levish

value: Axum template with SeaORM, Redis sessions, OAuth2, NATS background jobs, MeiliSearch, E2E tests, and Docker CI/CD. Aimed at getting production-ready faster.

value: Show HN: AxumKit – Production-ready Rust/Axum web API template

author: levish


value: dspraneeth

value:
Hi HN, I built a fully local, execution-aware multi-agent Text-to-SQL system as a learning/research project.
It uses schema grounding (graph-based), multi-model SQL generation, execution sandboxing, and semantic validation instead of relying on prompting alone.
Evaluated honestly on Spider:
• ~55% accuracy on single DB
• ~34% cross-DB zero-shot
No APIs, no fine-tuning, everything runs locally.
Would appreciate feedback on the architecture and evaluation.

value: Show HN: Axiom SQL-Reflex – Execution-aware multi-agent Text-to-SQL system

author: dspraneeth


value: noiv

value: Show HN: Zero – Serverless ECMWF weather visualization (WebGPU)

author: noiv


value: bogdanmp

value:
Built an MCP server that connects ChatGPT to async expert Q&A. When someone asks a professional question needing human judgment, it surfaces relevant experts with pricing and response times.
Working in dev mode, submitted to ChatGPT marketplace.
What we learned building it:
1. ChatGPT requires `search` + `fetch` tools - could not find in MCP spec, undocumented until you hit the error
2. Tool descriptions = discovery. ChatGPT matches user intent to your descriptions. No algorithm docs. Treat it like SEO.
3. Dev Mode is buried: Settings → Connectors → Advanced → Developer Mode
4. Docs are split: Anthropic owns MCP spec, OpenAI owns ChatGPT-specific requirements. You need both.
5. Cold start problem applies: if you return no results, ChatGPT learns not to call you
Stack: TypeScript, Vercel, Xano
Happy to share more on the build if useful.

value: Show HN: MCP server that surfaces human experts inside ChatGPT

author: bogdanmp


value: unayung

value: Show HN: Log Hound – AI-first AWS CloudWatch log search tool in Rust

author: unayung


value: Dragos-Aln

value: Show HN: About Last Night – QR guest photo sharing for weddings (no app)

author: Dragos-Aln


value:
I keep seeing teams use frontier models for tasks a regex or a 4B model could do cheaper and faster.
This repo is a collection of opinionated patterns and heuristics to help you rethink the architecture of your AI workflows and ease the decision-making process while ensuring maximum efficiency.
It covers:
- A decision tree for architectural sanity checks.
- Tradeoffs between JSON and delimiter-separated output.
- Patterns for cascading models (verifying small models before calling big ones).
Open to feedback on other anti-patterns you've seen in production.

value: Show HN: LLM Sanity Checks – A practical guide to not over-engineering AI


value: rsbadger

value:
I kept running into the same annoyance: I want to upload a file from a script and just get a link back — without setting up S3 buckets, auth flows, or SDKs.
I built a small service + CLI to scratch that itch:
https://storage.to
https://github.com/ryanbadger/storage.to-cli
The CLI does the heavy lifting (single PUT vs multipart automatically), so the mental model is just:

  storageto upload huge-file.zip

→ prints a public link you can pass to another step.
It’s very early and intentionally simple:
- Anonymous uploads (no signup yet)
- Public links
- CLI groups multiple files into a collection automatically
This is meant for quick, ad-hoc sharing and scripted workflows where setting up buckets feels like overkill.
I’m posting mainly to sanity-check whether this solves a real workflow problem, or if most people already have a cleaner pattern for this.

value: Show HN: Storage.to CLI, upload a file, get a link

author: rsbadger


value: bensiv

value: Show HN: Luametry – Parametric CAD for Lua Developers (Built on Manifold)

author: bensiv


value: xkbear

value: Show HN: StarSeeker – Find early signals from Reddit, X, and XHS comments

author: xkbear


value: zealer

value: I previously shared a text-only version. I've now released a major update (v2.0) that supports full file attachments and rich text.<p>It packages everything into a single portable `.capsule` file that cryptographically cannot be opened until the future timestamp (using Drand/tlock). Still 100% client-side with no server storage.

value: Show HN: Encrypter v2.0 – Time-lock files and rich text in the browser

author: zealer


value: yankovichv

value:
Hey HN ,
I built JoyScreen, a small macOS menu bar app that combines four screen-related utilities I kept installing separately:
 • Focus View: blur inactive windows (toggle hotkey, adjustable intensity)
 • Brightness Boost: push brightness beyond the usual limit for bright environments
 • Ambient Glow: a subtle “front light” for late-night video calls
 • Keep Awake: prevent sleep during presentations / long downloads
I’d love ruthless but fair feedback .
Website: https://joyscreen.app/
U0NDGXNG — 50% off for HN, valid for about a week .

value: Show HN: JoyScreen – blur distractions, boost brightness, keep awake (macOS)

author: yankovichv


value: lawnchair

value:
GitHub pull requests used to be fast. Now they're brutally slow, especially with large changes. I got tired of this, so I created Argus.
Argus is a fast, static, server-rendered replacement for GitHub pull requests. Pages load immediately. It uses the GitHub API for all reads and writes, so reviews and comments behave the same. This is just a better screen.
This is as-is software. I built it with Claude Code.

value: Show HN: Fast, Static GitHub Pull Requests

author: lawnchair


value: rektlessness

value:
I've been lurking on HN for years. You know the drill: interesting headline, 200+ comments, you dive in thinking "I'll just skim for 5 minutes"... and an hour later you're 36 chambers deep in a thread about memory allocation patterns in Postgres and you've completely forgotten what the original article was about.
I don't just want a "summary" (which usually just shortens the noise). I want the meta-consensus: "What is the actual trade-off being debated? Who is winning the argument? Why does this matter?"
So I built HNSignals. Think of it less like a "summarizer" and more like a Chief of Staff who reads the entire thread for you and hands you a one-page executive brief.
How it works:
1. Filters: Shows trending stories (50+ comments) where the discussion has heated up.
2. Extracts: An AI (Qwen 3 via Venice.ai) reads the top comments.
3. Structures: Instead of a wall of text, you get 4 specific signals:
    - The Hook: Why you should care.
    - The Gist: The core technical facts.
    - The Debate: The actual friction point (e.g., "Rust vs. C++ safety").
    - The Verdict: The community consensus.
Why I'm showing this (Beta): Most AI tools just shorten the text. I'm trying to extract the signal. It's a work in progress - the AI sometimes gets too clever, and I'm still tuning the cache strategy. I'd love feedback on whether this structured approach is actually better than a standard "TL;DR."
Bonus meta-game: If this Show HN gets 50+ comments and makes it onto HNSignals itself, I'll read the AI's analysis of people analyzing my analyzer.
(P.S. Please go easy on the intentional stress testing - my Lambda inference budget is finite!)
Try it: https://hnsignals.com
Example output
The Heartbleed Bug (2014): https://hnsignals.com/signal/7548991
Ask HN: What is the most unethical thing you've done as a programmer? (2018): https://hnsignals.com/signal/17692005
Comparing the Same Project in Rust, Haskell, C++, Python, Scala and OCaml (2019): https://hnsignals.com/signal/20192645
OpenAI's GPT-3 may be the biggest thing since Bitcoin (2020): https://hnsignals.com/signal/23885684
Apple, What Have You Done? (2026): https://hnsignals.com/signal/46763592

value: Show HN: Was tired of drowning in HN comments, so I built an AI Chief of Staff

author: rektlessness


value: pldpld

value:
I built wt to manage the coordination overhead of running multiple AI coding agents (Claude Code, Codex, etc.) concurrently on the same repository.
The problem: I'd spin up 3-4 agents working on different features simultaneously, then conflict on files, and resolving those conflicts burns agent context. Git worktrees solve the isolation problem but the native CLI is verbose, lacks primitives for managing multiple sessions, and I'd have to manage persistence (folders to store the trees) separately.
wt wraps git worktree in an interface designed for this workflow:

  wt new feature/auth    # creates worktree + spawns subshell
  (wt:feature/auth) $ claude
  exit
  git merge feature/auth

Also integrates with tmux to coordinate agent sessions—wt session watch shows which agents are actively processing vs idle by monitoring pane output buffers.
There's a /do skill for Claude Code that implements issue-driven workflows: /do gh 123 fetches the GitHub issue, creates a worktree with a branch derived from the issue, and populates the agent context with the description.
Written in Rust. Binaries for macOS/Linux.
https://github.com/pld/wt
Blog post with more detail: https://peet.ldee.org/general/2026/01/26/wt-git-worktree-orc...

value: Show HN: wt – lightweight Git worktree orchestrator for parallel coding agents

author: pldpld


value: Show HN: Claude Code Hooks – Block dangerous commands, protect secrets


value: hilti

value:
I built NeonAMP, a browser-based MP3 player that runs as a single PHP file.
You drop index.php into a folder of MP3s and it auto-scans the library, reads full ID3 tags, and stores metadata in SQLite. Playback uses the Web Audio API, including DJ-style crossfading between tracks.
The UI is keyboard-driven and intentionally retro. No frameworks on the frontend, no build step, and the whole thing is under 100KB.
Tech: PHP 8.3+, Vanilla JS, SQLite.
Demo: https://github.com/marchildmann/NeonAMP
Curious what people think and where this could be improved.

value: Show HN: A Self-Hosted MP3 Player with 80s Retro Vibes

author: hilti


value: zmactep

value: Show HN: I've spent one weekend with Claude Opus to reimplement PyMOL using Rust

author: zmactep


value: whoisthemachine

value: Adopt the implementations of members in your class and embrace delegation, composition over inheritance, and mix-in style coding in C#.

value: Show HN: Delegation/Mixins C# Source Generators Library

author: whoisthemachine


value: janschwoebel

value: Show HN: Client-side 3D geometry analysis for instant quoting

author: janschwoebel


value: openworldmag

value:
Hey HN,
I’ve been a digital nomad since 2009—long before it was a trendy hashtag. Over the last 15+ years, I realized that the 'freedom' of this lifestyle is often a lie if you're still trapped in a 14-hour grind, just doing it from a different time zone. You're not a traveler, just a person who works from a laptop in co-working spaces in exotic places.
I spent the last two years systemizing how I use AI, biohacking, energy, motivation, and willpower to stay sharp while moving across borders.
I put these frameworks into a manual called UNLIMIT. It covers:
Weaponizing AI: Automating decision-making to save willpower.
Biological Resets: How I fixed my own 14-hour burnout loops.
Flow State Systems: Practical ways to stay focused when your environment is always changing.
I made the book 99 cents because I want it to be accessible to builders currently in the trenches of exhaustion and loneliness. I’m around all day and would love to answer questions about the nomad life or the AI systems I use.
Thanks for checking it out!

value: Show HN: Spent 15 years nomading and wrote a field manual to hack productivity

author: openworldmag


value:
I built Bird to get my web apps out of my browser. I have multiple Google accounts, Slack workspaces, and various SaaS tools — managing them in browser tabs was a mess. The "you're signed into another account" error, and I got tired of it.
Bird wraps any website into a standalone desktop app with full session isolation. Each app has its own partition (cookies, localStorage, cache) — they never interfere with each other or with your main browser.
Beyond isolation:
- URL routing rules (control what opens internally, externally, or gets blocked)
- Smart downloads (auto-open by MIME type, executable and dangerous file detection)
- Kiosk mode with custom escape shortcuts
- User-agent spoofing (test mobile layouts, bypass Electron detection)
- Cache management per partition (max age, max size)
- Ad blocking via Ghostery
For SaaS vendors (WIP): package Bird with a locked config to ship your web app as a branded desktop installer — out of the browser, native feel, ready to deploy.
Coming next: per-app themes, preload script injection for deeper SaaS integration.
Linux + Windows supported, macOS coming. Arch users: yay -S bird-apps-bin

value: Show HN: Bird – Turn any website into an isolated desktop app


value: MakerLabsSv

value: Show HN: LearnFlow – Learn with visual paths, quizzes, and AI tutor

author: MakerLabsSv


value: oldrev

value: Show HN: Borneo – A full-stack open-source aquarium LED controller

author: oldrev


value: yyqyes

value:
Hi HN,
I’m an indie developer and I recently built 1Setter, a macOS menu bar app that lets you quickly access and apply common system settings with a single click. It supports individual actions as well as grouped actions, so you can trigger multiple settings in one step if needed.
The motivation came from the friction of scattered macOS settings: some are buried in System Settings, some require multiple steps, and existing menu bar tools often felt too limited or opinionated. I wanted something lightweight, predictable, and fast.
Under the hood, the app uses official system frameworks where possible, and carefully scoped system-level commands where necessary, with permission checks and state verification to avoid mismatches between the UI and the actual system state. I maintain compatibility across recent macOS versions.
The app is entirely from the menu bar, and follows a simple one-time purchase model. Feedback from macOS users — especially around edge cases, OS compatibility, or actions you wish existed but are painful to access today — would be much appreciated.
You can check it out here: https://www.1setter.app
Thanks!

value: Show HN: 1Setter – One-click access to macOS system settings from the menu bar

author: yyqyes


value: blacktis

value:
L3 Engine is a market surveillance system written in Rust. It doesn't just look at the price; L3 reconstructs the individual order flow (Level 3) to reveal market intent: it detects spoofing, layering, and phantom liquidity in microseconds, before the price moves.
Resources

value: Show HN: L3Elite – Market surveillance engine in Rust with embedded ML

author: blacktis


value: practicalaifg

value: OP here. I realized most LLM explainers are either 'it's magic' or 'here is the PyTorch code.' I wanted to build a visual mental model for the mechanics in the middle (specifically embeddings and attention). I used analogies like 'Grocery Stores' for vector space and 'Workbenches' for context windows. Hope it helps visualize the black box!

value: Show HN: Visualizing the Transformer architecture by tracing a single prompt

author: practicalaifg


value: biosboiii

value:
Hi,
I wrote a low-level HTTP/2 web crawler in Go, which can scrape partial content to save traffic.
Tl;dr e.g. the HTML of a YouTube video contains the video description, views, likes etc. in its first 600KB, the remaining 900KB are of no use for me, but I have to pay my proxies by the gigabyte.
My crawler receives packet per packet, and if I got everything I needed I reset the request, and only pay-for-what-i-crawled.
This is also potentially useful for large-scale crawling operations, where duplicates matter. You could compute a simHash on the fly, and reset on-the-fly before crawling the entire document (again).

value: Show HN: Partial content web crawling using HTTP/2 and Go

author: biosboiii


value: calebevans

value: I built a GitHub Action that analyzes workflow failures and correlates them with PR changes. It uses cordon (transformer-based semantic anomaly detection) to reduce massive logs to unusual patterns, then DSPy to orchestrate LLM analysis of failures. Then, it determines whether PR changes likely caused the issue and posts structured root cause reports.

value: Show HN: I built a tool for automated failure analysis in GitHub Actions

author: calebevans


value:
Hi,
I’m the founder of Chrome-Stats.com, a platform for tracking extension analytics and rankings. Through analyzing many extensions and building a number of them myself, I’ve seen how difficult it is to monetize Chrome extensions. Ads degrade the user experience, and subscription fatigue makes it hard to sell individual "Pro" plans.
That’s why we built App Pass.
The Concept: Think of it like Xbox Game Pass for browser extensions. Users pay a single monthly fee and get premium access to a bundle of high-quality extensions.
Why partner with us?
- Recurring Revenue: You earn a share of the subscription pool based on how much users engage with your extension.
- Discovery: We cross-promote your extension to high-intent users who are already paying subscribers.
- Zero Risk: It’s an additional revenue stream. You can keep your existing Stripe setup for non-App Pass users.
We are looking for extensions developers to join our program.
Learn more and apply here: https://joinapppass.com/partner
I’m happy to answer any questions about the platform, the revenue share model, or the integration process in the comments!

value: Show HN: Monetize your Chrome extensions with "App Pass"


value: machala

value:
Hey HN! I built a small CLI tool to solve my own problem - keeping documentation screenshots up to date.
The idea is simple: point it at any URL, pick what you want to capture, and run one command whenever your UI changes. Just run "npx heroshot" - that's it. Opens a visual picker, you click what you want, it saves the config. Run it again anytime to refresh all screenshots.
Works with light/dark mode, multiple viewports (desktop, tablet, mobile), and sites behind login. I use it in CI so my docs never show outdated UI.
Install options:
- npx heroshot (no install needed)
- npm install -g heroshot
- brew install omachala/heroshot/heroshot
- curl -fsSL https://heroshot.sh/install.sh | sh
- docker pull heroshot/heroshot
It's free and open source. Would love to hear what you think!

value: Show HN: Take screenshots of any website from your terminal

author: machala


value:
I built this as a small side project after getting tired of juggling multiple SSH tabs and repeatedly looking up scp syntax.
heyvm provides a simple terminal UI for listing VMs, connecting to them, and transferring files without leaving the terminal.
Feedback welcome.

value: Show HN: Heyvm – a terminal UI for managing VMs over SSH


value: drbscl

value: Iconify is a great library for using icons in webapps, but the official library makes client-side retrievals from Iconify's CDN at runtime.<p>This was deal breaker while I worked on an offline-first side project, so I built this library which downloads icons and adds it to your app's assets when Vite performs building.

value: Show HN: Iconify-static – Use Iconify without the external CDN

author: drbscl


value: sanifhimani

value:
I wanted to document my Ruby gem without leaving the Ruby ecosystem. Jekyll feels dated, and everything modern needs JS config.
So I built Docyard – Markdown to docs with search and built-in components.
Here's the documentation, built with Docyard: https://docyard.dev

value: Show HN: Docyard – A docs site generator for Ruby projects

author: sanifhimani


value: janczukt

value: Show HN: Lexray – 60 second contract screening for freelancers and SMBs

author: janczukt


value: Show HN: Cmdfy – Generate shell commands locally using Ollama (Go binary)


value: dasfelix

value:
Hey, I’m Felix, an 18-year-old student from Austria. I’ve built a few small SaaS projects, mostly solo, and I kept running into the same small but persistent problem.
Whenever I wanted to understand how things were going, I’d end up jumping between Stripe, analytics, database queries, logs, and cron scripts. I even built custom dashboards and Telegram bots to notify me about certain numbers, but that just added more things to maintain.
What I wanted was something simpler: send a number from my backend and see it on a clean dashboard.
So I built a small tool for myself.
It’s essentially a very simple API where you push numeric metrics with a timestamp, and then view them as counters, charts, goals, or percentage changes over time.
It’s not meant to replace analytics tools. I still use those. This is more for things like user counts, MRR, failed jobs, or any metric you already know you want to track without setting up a full integration.
Some intentional constraints:
- no SDKs, just a basic HTTP API
- works well with backend code and cron jobs
- stores only numbers and timestamps
- flexible enough to track any metric you can turn into a number
It’s still early and very much an MVP. I’m mainly posting to get feedback:
- does this solve a real problem for you?
- what feels unnecessary or missing?
- how would you approach this differently?
Website: https://anypanel.io
Happy to answer questions or hear why this doesn’t make sense.
Thanks, Felix

value: Show HN: I got tired of checking 5 dashboards, so I built a simpler one

author: dasfelix


value: Show HN: Autonoma – a local-first autonomous code remediation engine


value: nsiradze

value:
hey
i just finished my personal website and wanted someone to see it. i've been developing and pixel perfecting this in background as a side thing.
i will be happy to get feedbacks, thanks.

value: Show HN: Personal website, but imagine I'm messaging you

author: nsiradze


value: Show HN: TabSwitch – Vim-style tab switcher for Chrome


value: AllaTurca

value: Show HN: Bloomberg and AlphaSense in One Tool

author: AllaTurca


value: viikka

value: Shopify is lacking personalization features, so I created an app that allows to show different menu for different pages and different menus for different customers based on tags!

value: Show HN: Shopify app to show different menu for different users

author: viikka


value:
Hey HN,
I'm one of two co-founders behind Connexify. We're a marketing guy and a developer who got tired of the same painful workflow: every time a new client signs up, someone has to manually chase them for Google Ads access, Meta Pages permissions, Analytics, Search Console... you name it.
We built Connexify to flip that process. Instead of back-and-forth emails asking clients to "please add this email as admin," we generate a single link. The client clicks it, authenticates via OAuth, picks the accounts they want to share, done. All permissions land in one dashboard.
Tech stack: Next.js, Supabase for auth (magic links + SSO), Stripe for billing, and a lot of painful OAuth integration work with Google, Meta, TikTok, Pinterest, and Amazon.
What we learned the hard way:
Meta's and Google's developer support is essentially non-existent. When you do get a response, it's clearly from someone reading a script who doesn't understand the API.
LinkedIn's API access is a black box. We've been trying for months. If anyone here has navigated their partner program successfully, I'd genuinely love to hear how.
Same story with Google Business Profile (formerly GMB) – the hoops to get API access approved are brutal.
The core product was built before "vibe coding" was a thing, so no AI-generated spaghetti here – just two people solving our own problem.
Would love feedback on the onboarding flow. You can try it without signing up by checking the demo on the homepage. Especially interested in hearing from anyone who's dealt with the LinkedIn or GMB API approval process.

value: Show HN: Got tired of chasing clients for Google &Meta access, so I built this


value: shawarmazgreat

value:
I just launched The Rekord — AI turns world news into point-blank polls, and people around the world answer.
Today, the same questions are asked everywhere in fragmented silos — on Twitter/X in particular, polls are tied to accounts, timelines, and follower graphs — amplifying echo chambers instead of global insight.
The Rekord asks the same question once, translates it across languages, and aggregates responses in one place so people from different platforms vote on the same thing.
I’m posting this here mainly to get feedback from builders: what works, what doesn’t, and what would make this genuinely useful.
I’m considering features like public-figure approval ratings, light gamification (points/badges), richer comments (e.g. short videos), and stronger anonymity — curious what else you’d want to see.
Sample polls to get a sense of the polls:
Did Brahim Díaz miss the penalty on purpose?:
https://www.therekord.ai/polls/cmklv519n00fqle1h59qy0qlo
Is Trump right that Canada lives because of the United States?
https://www.therekord.ai/polls/cmksgwc2q0020l51he6s9vmq2
Should the ICE agents who shot Alex Pretti be charged with murder?
https://www.therekord.ai/polls/cmku7cb10001jl41h1tz6pjlp
Landing page:
https://www.therekord.ai
Built solo with Next.js, hosted on AWS Amplify, vibe-coded in Cursor, using LLM APIs for poll generation and translation.

value: Show HN: The Rekord – Global AI-generated polls for major events

author: shawarmazgreat


value: AmorBielyi

value: Show HN: Playdate handheld + Golang

author: AmorBielyi

title: Show HN: Playdate handheld + Golang


value: Winipedia

value:
Hi HN,
I built pyrig after getting tired of manually keeping configuration files in sync across multiple Python projects. Every time I'd start a new project or update tooling standards, I'd spend hours copying and tweaking pyproject.toml, GitHub workflows, pre-commit hooks, etc.
pyrig treats project infrastructure as declarative code. Each config file (pyproject.toml, .pre-commit-config.yaml, GitHub workflows) is a Python class that:
- Generates the file with working defaults
- Validates existing files against expected structure
- Merges missing values without removing your customizations
- Runs idempotently (safe to run multiple times)
The interesting part is the multi-package inheritance. You can create a "base" package that extends pyrig with your own customized standards, then all your projects inherit those configs automatically:

  pyrig → your-base → service1
                    → service2

Commands, test fixtures, and config files are discovered automatically across the entire dependency chain using a runtime dependency graph built from importlib.metadata.
What makes it different from other scaffolding projects: Pyrig is a system that is kind of living continiously and supports you during code development. You can basically customize everything and tweak almost all behaviour as you see fit.
Quick start:
  uv init
  uv add pyrig
  uv run pyrig init
This generates a complete project: source structure, tests, CI/CD, docs, pre-commit hooks, containerfile, etc. Run it again later to update configs or add missing files.
I'd love feedback on the architecture and this project generally. What do you think? Is this useful or not? I have used it already with many of my projects and it genuinely made things easier and faster for me.
GitHub: https://github.com/Winipedia/pyrig
Docs: https://winipedia.github.io/pyrig

value: Show HN: Pyrig – a tool to automate project setup, configuration and development

author: Winipedia


value: markbuilds

value:
Hi HN, I’m building Recal to help teams avoid losing decisions and follow-ups after meetings and Slack discussions.
It automatically summarizes conversations, extracts action items, and lets you chat with your past meetings and messages to find context later.
I started this after my own team kept missing things that were “said in a meeting” or buried in long Slack threads.
I’d really appreciate feedback on whether this solves a real problem for you, and what feels missing or confusing.

value: Show HN: Recal – Turn meetings and Slack threads into actionable tasks

author: markbuilds


value: rachpradhan

value:
Hi HN! I built dhi, a data validation library that uses Zig to compile to both native C (Python) and SIMD WASM (TypeScript).
Key points:
- Drop-in API compatibility with Pydantic (Python) and Zod (TypeScript)
- Python: 24.9M validations/sec (520x faster than Pydantic V2)
- TypeScript: up to 77x faster than Zod on invalid data
- 28KB WASM bundle, zero JS runtime overhead
I'd love feedback on the API surface, benchmarks, and real-world integration pain points. If you're curious, the repo has full benchmarks and examples.

value: Show HN: Dhi – 520x faster data validation for Python, 77x faster for TypeScript

author: rachpradhan


value: mvpasarel

value: I built an on device AI offline translator that runs entirely on-device with 55 languages, Apple Vision for camera translation, and speech recognition

value: Show HN: OffLingua on Device AI Translator

author: mvpasarel


value: arctanx

value:
Hey HN, I built this because I liked the idea of agents controlling a computer (like Clawdbot), but I was uncomfortable giving them unrestricted shell access.
So I build Chord, it uses the same underlying agent framework as Clawdbot, so it can do most of the same jobs. The key difference is that I added a security layer. Commands are analyzed by an AI before execution. This does use extra tokens, but you can run the analysis with cheap models (e.g. Gemini Flash) to keep costs low.
The security layer can block risky commands and provides a security audit log of everything the agent tries to do.
Right now, Chord only supports Telegram as the control interface. I’ve built all the core parts, and I’ll add smaller features next.
I’d really appreciate any feedback.

value: Show HN: Chord: Clawdbot alternative with a security layer

author: arctanx


value: avidcoder

value: I built ehAye Engine, a local-first AI system that turns LLMs into real teammates, not chat boxes.<p>Shipping what I actually use. Making Claude Code talk to you.

value: Show HN: EhAye Engine – Give your AI a voice

author: avidcoder


value: davvie

value:
I kept failing at habit apps. I'd add 6 habits, miss a day, feel guilty, stop opening the app entirely.
So I built the opposite: an app that only lets you track one habit at a time.
The idea is that one habit done beats ten habits planned. Pick one thing, show up daily, and only move on when it's automatic.
It's free with ads. Would love your feedback on whether this constraint feels liberating or limiting.
iOS: https://apps.apple.com/app/id1549454193
Android: https://play.google.com/store/apps/details?id=com.davvie.hab...

value: Show HN: a habit tracker that only lets you track one habit

author: davvie


value: githacker

value: High-performance, in-memory NoSQL database server that allows you to write database queries directly in JavaScript. Built on ASP.NET Core 8.0, it combines the flexibility of a document store with the power of a full JavaScript runtime.

value: Show HN: High-performance NoSQL DB written in C#

author: githacker


value:
I built WLM, a 70B parameter model trained on 847M text message arguments to decode relationship communication.
Key contributions:
- Infinite Grievance Memory™ with O(1) retrieval and zero decay rate
- Subtext Attention Mechanism that attends to what was NOT said
- "You Should Know Why" solver using Guilt-Weighted Retrospective Search
- Partner-Specific Fine-Tuning on your SO's message history
- MoodNet classifier for availability prediction
Achieves 94.7% accuracy on the "It's Fine" Benchmark vs 14.7% male human baseline. Paper includes ablation studies, architecture diagrams, and a failure cases section noting that "Where Do You Want To Eat?" remains NP-hard.
License: MIT (Marriage Is Tough)
GitHub: https://github.com/gabewillen/wlm

value: Show HN: WLM – A 70B model trained to decode "I'm fine" with 94.7% accuracy


value:
With Malan Chat, you can learn over 60 languages through AI-powered conversations, grammar correction, and integrated FSRS flashcards. The chat allows users to practice speaking and listening, get instant corrections, and build your vocabulary with our intelligent language tutor. Users may import readings into the Reader, look up words and annotate the article, and discuss the reading with the chat. To practice longer form writing, you may go into the writing hub and see your text marked up with corrections.
I built Malan to make speaking practice feel like a real conversation instead of a clunky exercise. It’s a chat-first language coach that listens, responds, and nudges you toward more natural phrasing without breaking your flow, so the learning process stays light and fast, it feels more like texting than studying. It’s strongest for people who already know some of the language and want to go from 1 → 100. There isn’t a true 0 → 1 path yet (onboarding for complete beginners is coming), so right now it’s best for learners who can form basic sentences and want consistent practice with real feedback.
Coming soon: YouTube (and possibly Spotify) integration so you can get listening practice from real sources that you want to engage with. This is your journey, and you are a distinct individual with your own tastes. I want you to have fun while you're going through the arduous task of learning a new language! Also in the works are custom exercises based on your own needs.
I've still had very limited user feedback, so please tell me what you like or don't like about the platform and I will do my best to remedy it!

value: Show HN: Malan Chat, a full immersion language learning app for 62 languages


value: dannytatom

value:
hey there.
at every job i’ve had, people paste secrets into Slack and delete them really fast. i wanted a quick, secure way to hand off a credential that wasn’t that, so I built 30s.
it’s a CLI that generates a local keypair and uses envelope encryption so the server never sees plaintext. you send to a recipient’s email, they decrypt locally, and secrets expire automatically (default 30s, maximum 24h).
free to use, 50 secrets/month.

value: Show HN: A simple way to send secrets between teammates

author: dannytatom


value: aliasxneo

value: Show HN: Sign and Attest Kubernetes Manifests

author: aliasxneo


value: sjorsfest

value:
Hi HN
I built Donkey Support, a lightweight support widget for web apps that routes customer chats into Slack, Discord, or Telegram threads, so you can reply from the tools you already use instead of checking another support dashboard.
I originally built this because the last early-stage SaaS I worked on was full of bugs. We were moving fast, review wasn’t great, and things broke a lot.
What saved us wasn’t perfect code. It was fast support.
We had a little support widget on the site, and the second something broke, users could message us. Most of the time they’d tell us exactly what went wrong, we’d fix it quickly, and they actually loved it. It turned frustration into “wow, these people care.”
That made me realise that fast support isn’t just a nice-to-have. It keeps users from churning when things are still rough around the edges.
The setup is quite simple. You just add the widget to your site (script tag or React component), connect Slack, Discord, or Telegram, and each new conversation becomes a thread in your chosen channel/server. The  replies there sync back to the widget instantly
Would love feedback (Feel free to dunk hard on me):
* Does this solve a real pain for you?
* What would you want to see before using it in production?

value: Show HN: Donkey Support –> Reply to Support Chats from Slack/Discord/Telegram

author: sjorsfest


value: Beefin

value:
We built a production-grade multimodal inference server in Rust for serving vision–language models (image + text → streamed text).
The goal was to explore what a Rust-native control plane looks like for modern multimodal inference: continuous batching, KV-aware admission control, predictable behavior under load, and proper streaming semantics.
The system exposes an OpenAI-compatible API, supports multi-image inputs, and is designed to degrade gracefully under overload rather than OOM or stall. It’s organized as a single monorepo with a gateway, GPU workers, scheduler, and pluggable engine adapters.
We’ve also included a benchmark suite focused on real-world scenarios (TTFT, cancellation, overload, fairness) rather than synthetic tokens/sec numbers.
Would love feedback from folks building or operating inference infrastructure.

value: Show HN: a Rust-based multimodal inference server

author: Beefin


value:
Hey HN, we're excited to share Cua-Bench ( https://github.com/trycua/cua ), an open-source framework for evaluating and training computer-use agents across different environments.
Computer-use agents show massive performance variance across different UIs—an agent with 90% success on Windows 11 might drop to 9% on Windows XP for the same task. The problem is OS themes, browser versions, and UI variations that existing benchmarks don't capture.
The existing benchmarks (OSWorld, Windows Agent Arena, AndroidWorld) were great but operated in silos—different harnesses, different formats, no standardized way to test the same agent across platforms. More importantly, they were evaluation-only. We needed environments that could generate training data and run RL loops, not just measure performance.
Cua-Bench takes a different approach: it's a unified framework that standardizes environments across platforms and supports the full agent development lifecycle—benchmark, train, deploy.
With Cua-Bench, you can:
- Evaluate agents across multiple benchmarks with one CLI (native tasks + OSWorld + Windows Agent Arena adapters)
- Test the same agent on different OS variations (Windows 11/XP/Vista, macOS themes, Linux, Android via QEMU)
- Generate new tasks from natural language prompts
- Create simulated environments for RL training (shell apps like Spotify, Slack with programmatic rewards)
- Run oracle validations to verify environments before agent evaluation
- Monitor agent runs in real-time with traces and screenshots
All of this works on macOS, Linux, Windows, and Android, and is self-hostable.
To get started:
Install cua-bench:
% pip install cua-bench
Run a basic evaluation:
% cb run dataset datasets/cua-bench-basic --agent demo
Open the monitoring dashboard:
% cb run watch <run_id>
For parallelized evaluations across multiple workers:
% cb run dataset datasets/cua-bench-basic --agent your-agent --max-parallel 8
Want to test across different OS variations? Just specify the environment:
% cb run task slack_message --agent your-agent --env windows_xp
% cb run task slack_message --agent your-agent --env macos_sonoma
Generate new tasks from prompts:
% cb task generate "book a flight on kayak.com"
Validate environments with oracle implementations:
% cb run dataset datasets/cua-bench-basic --oracle
The simulated environments are particularly useful for RL training—they're HTML/JS apps that render across 10+ OS themes with programmatic reward verification. No need to spin up actual VMs for training loops.
We're seeing teams use Cua-Bench for:
- Training computer-use models on mobile and desktop environments
- Generating large-scale training datasets (working with labs on millions of screenshots across OS variations)
- RL fine-tuning with shell app simulators
- Systematic evaluation across OS themes and browser versions
- Building task registries (collaborating with Snorkel AI on task design and data curation, similar to their Terminal-Bench work)
Cua-Bench is 100% open-source under the MIT license. We're actively developing it as part of Cua (https://github.com/trycua/cua), our Computer Use Agent SDK, and we'd love your feedback, bug reports, or feature ideas.
GitHub: https://github.com/trycua/cua
Docs: https://cua.ai/docs/cuabench
Technical Report: https://cuabench.ai
We'll be here to answer any technical questions and look forward to your comments!

value: Show HN: Cua-Bench – a benchmark for AI agents in GUI environments


value:
I don’t believe agents should “think” without being allowed to check their work. So I built a CLI agent that can actually run code while it reasons.
Subconscious handles the reasoning and tool-calling while actively pruning context as it goes, so the agent runs faster, costs less, and has more tokens available for complex tasks.
Code runs in one of the fastest sandboxed environments available using E2B, keeping execution quick while your local machine stays clean, organized, and protected from prompt injection.
The result feels less like a language model and more like working with a tool that can verify its own work, stay disciplined, and generate real reports and charts.
Run it with:
npx @subcon/e2b-cli
If you care about reliable agents, CLIs, or running code safely without touching your local machine, this is worth a look. Especially if you are tired of deleting random .md files.

value: Show HN: A CLI agent that runs code while it reasons (Subconscious and E2B)


value: studiousbunt

value:
Hi HN,
For years I’ve had a bad case of analysis paralysis. Not just for big life decisions, but also for small ones: product direction, feature prioritization, even trivial choices.
My default mode is to model every possible outcome, enumerate risks and edge cases, and then… do nothing.
Eventually I realized something uncomfortable: I was spending more time optimizing decisions than actually shipping.
So I built a small AI-assisted tool for myself: SpinForClarity.
What it does:
- You describe a problem in plain English
- An LLM generates candidate options
- The options are visualized in a decision wheel
- You spin it to deliberately introduce randomness and force a commitment
- The system then generates a short rationale for the selected option to reduce second-guessing
Under the hood:
- Frontend: Next.js + React + TypeScript
- Backend: Python (FastAPI)
- Auth & DB: Supabase
- AI: OpenAI API (for option generation and explanations)
I don’t think this replaces thinking or proper analysis. For me, it acts more like a forcing function — a way to break deadlock and bias toward execution.
I’m sharing this here mainly to learn:
- Is this a real problem for others or just me?
- In what situations would you actually use something like this?
- Does this feel like a useful tool or a gimmick?
- What would you remove, simplify, or redesign?
App: https://spinforclarity.com
Thanks for reading. I’d really appreciate honest feedback — especially critical feedback.
Sagar

value: Show HN: I built SpinForClarity to escape decision paralysis

author: studiousbunt


value: olivdums

value: Show HN: React and NextJS lessons and exercises embedded in VSCode / Cursor

author: olivdums


value: lowercasename

value:
My wife recently started her PhD and while she uses Zotero as a citation manager, she was really missing a tool for keeping track of what she's reading right now/has already read/needs to read next. This overwhelming experience might be familiar to other researchers working on a niche field where every paper is called pretty much the same thing
So I built her Paperstack. It's basically Goodreads, but for research papers:
- Save articles to familiar To Read/Reading/Read stacks
- Tag articles with logical projects/chapters/whatever your system is
- Get AI-generated summaries so you can quickly decide if a paper is worth your time
I would love feedback from any students and researchers managing paper overwhelm!

value: Show HN: I built Goodreads for academic papers to help my wife survive her PhD

author: lowercasename


value: alexcloudstar

value: Show HN: Makers Page – A clean "Proof of Work" profile for software builders

author: alexcloudstar


value: codeviewer

value: The main idea behind this project was to visualize the AST of python files to make detecting maintainability hotspots (= spaghetti code) easier. This works both on a project as well as on file level (see complex files and sections of complex code within a file). If you want to test the graph features please make sure to contact me and I will unlock them free of charge.

value: Show HN: Using ASTs to visualize complex codebases

author: codeviewer


value: aconchillo

value: And any MCP-compatible clients. Talk to your AI agents from anywhere, anytime!

value: Show HN: Pipecat Meets Claude Code

author: aconchillo

title: Show HN: Pipecat Meets Claude Code


value: jlowin

value:
Hi HN — I'm the creator of FastMCP and wanted to share a new project we've open-sourced called Colin.
I obviously love MCP, but I also use skills extremely heavily in my day-to-day work. Being exposed to both has made me very aware of a tension:
- Anything with dynamic information, I ship over MCP. This takes work to set up and requires conversational boilerplate to refresh in every conversation.
- Anything behavioral, I put in skills. They're lightweight, used automatically, and feel great. But I would never put dynamic information in a skill because keeping it up to date is a pain. And yet the idea of having an agent skill that includes relevant and timely data is so appealing!
So: think of Colin as a skills-native templating engine. The goal is to compile context documents from dynamic sources (GitHub, Linear, Notion, MCP servers, etc.) in a way that makes them easy to automatically update. Colin traces dependencies to determine staleness and has intelligent caching to minimize the burden of recompiling. It's general purpose, but it turns out to be extremely useful for writing skills that contain dynamic knowledge and need to stay current.
We've just released it. It's experimental and early, but it's a direction I'm actively exploring and would love feedback.
Here's a post with more background, if interested: https://www.jlowin.dev/blog/colin

value: Show HN: Colin, a context engine for keeping agent skills fresh

author: jlowin


value: eshaangulati

value:
Hey! I'm eshaan and I'm building Ourguide -an on-screen task guidance system that can show you where to click step-by-step when you need help.
I started building this because whenever I didn’t know how to do something on my computer, I found myself constantly tabbing between chatbots and the app, pasting screenshots, and asking “what do I do next?” Ourguide solves this with two modes. In Guide mode, the app overlays your screen and highlights the specific element to click next, eliminating the need to leave your current window. There is also Ask mode, which is a vision-integrated chat that captures your screen context—which you can toggle on and off anytime -so you can ask, "How do I fix this error?" without having to explain what "this" is.
It’s an Electron app that works OS-wide, is vision-based, and isn't restricted to the browser.
Figuring out how to show the user where to click was the hardest part of the process. I originally trained a computer vision model with 2300 screenshots to identify and segment all UI elements on a screen and used a VLM to find the correct icon to highlight. While this worked extremely well—better than SOTA grounding models like UI Tars—the latency was just too high. I'll be making that CV+VLM pipeline OSS soon, but for now, I’ve resorted to a simpler implementation that achieves <1s latency.
You may ask: if I can show you where to click, why can't I just click too? While trying to build computer-use agents during my job in Palo Alto, I hit the core limitation of today’s computer-use models where benchmarks hover in the mid-50% range (OSWorld). VLMs often know what to do but not what it looks like; without reliable visual grounding, agents misclick and stall. So, I built computer use—without the "use." It provides the visual grounding of an agent but keeps the human in the loop for the actual execution to prevent misclicks.
I personally use it for the AWS Console's "treasure hunt" UI, like creating a public S3 bucket with specific CORS rules. It’s also been surprisingly helpful for non-technical tasks, like navigating obscure settings in Gradescope or Spotify. Ourguide really works for any task when you’re stuck or don't know what to do.
You can download and test Ourguide here: https://ourguide.ai/downloads
The project is still very early, and I’d love your feedback on where it fails, where you think it worked well, and which specific niches you think Ourguide would be most helpful for.

value: Show HN: Ourguide – OS wide task guidance system that shows you where to click

author: eshaangulati


value: psyentist

value:
MCP server open-sourced, suggestions welcomed
Github: https://github.com/Lcontext/Lcontext

value: Show HN: MCP server that gives AI coding agents user behavior context

author: psyentist


value: joshuafkon

value:
In Tetlock's 20-year Expert Political Judgment study, domain experts performed no better in their own field than outside it — and "hedgehog" specialists actually did worse when predicting within their specialty. The Good Judgment Project (Tetlock & Mellers) later found that superforecasters weren't dramatically smarter than average participants — what separated them was thinking style.
What predicts accuracy? Calibration, Bayesian reasoning, and willingness to update beliefs. These traits beat raw intelligence and domain knowledge.
I built a 10-minute test that measures them:
Bayesian updating: Commit to a probability, receive new evidence, update. Tests whether you move the right direction and magnitude.
Calibration: When you say 80% confident, are you right 80% of the time?
Replication prediction: Predict whether famous psychology studies replicated. Instant feedback since outcomes are known.
Free, no signup. Results show where you're calibrated vs. overconfident, and how you handle disconfirming evidence.
Looking for feedback on questions and scoring. Research basis is Tetlock, Mellers, Baron, and Stanovich — but I'm sure there are improvements to make.

value: Show HN: The Forecaster Test- based on Tetlock's superforecasting research

author: joshuafkon


value: ykhli

value: Show HN: TetrisBench – Gemini Flash reaches 66% win rate on Tetris against Opus

author: ykhli


value:
TL;DR An SDK for running AI on-device with even the most non-standard hardware.
Hey, I’m one of the maintainers of RamaLama[1] which is part of the containers ecosystem (podman, buildah, skopeo). It’s a runtime-agnostic tool for coordinating local AI inference with containers.
I put together a python SDK for programmatic control over local AI using ramalama under the hood. Being runtime agnosti you can use ramalama with llama.cpp, vLLM, mlx, etc… so long as the underlying service exposes an OpenAI compatible endpoint. This is especially powerful for users deploying to edge or other devices with atypical hardware/software configuration that, for example, requires custom runtime compilations.
```
from ramalama_sdk import RamalamaModel<p>runtime_image = "quay.io/ramalama/ramalama:latest"
model = "huggingface://ggml-org/gpt-oss-20b-GGUF"<p>with RamalamaModel(model, base_image=runtime_image) as model:<p><pre><code>    response = model.chat("How tall is Michael Jordan?")

    print(response["content"])
</code></pre>
```
This SDK manages:

  - Pulling and verifying runtime images
  - Downloading models (HuggingFace, Ollama, ModelScope, OCI registries)
  - Managing the runtime process

It works with air-gapped deployments and private registries and also has async support.
If you want to learn more the documentation is available here:
https://docs.ramalama.com/sdk/introduction.
Otherwise, I hope this is useful to people out there and would appreciate feedback about where to prioritize next whether that’s specific language support, additional features (speech to text? RAG? MCP?), or something else.
1. github.com/containers/ramalama

value: Show HN: Python SDK for RamaLama AI Containers


value: Kuruitinoji

value: For too long, LLMs have been treated as unpredictable black boxes. This framework redefines inference as a dissipative dynamical system, providing a "thermometer" for AI stability and a mathematical blueprint of thought flow.

value: Show HN: The "Structural Formula" of LLMs – No more black boxes

author: Kuruitinoji


value:
The problem: I want to use my tools. You want to use yours. The contractor we hired uses yet another set of tools. This causes unnecessary friction for all participants.
Ideon is a self-hosted visual workspace designed to bridge this gap. It doesn't replace your existing stack (GitHub, Figma, Notion, etc.) but provides a shared context where all these pieces live together on an infinite canvas.
We built this because projects often die from fragmentation—code is in one place, decisions in chat logs, and visuals in design tools. Ideon aims to keep the project "mentally navigable" for everyone involved.
Key features:
- Visual Blocks: Organize Repositories, Notes, Links, Files, and People spatially.
- State History: Track how decisions evolved with workspace snapshots.
- Multiplayer: Real-time collaboration.
- Self-hosted: Docker-based and AGPLv3 licensed.
Tech stack: Next.js, PostgreSQL, Docker.
Would love to hear your feedback on the approach!

value: Show HN: Ideon – An open source, infinite canvas for your project's segmentation


value: Show HN: GlobalWatch – Find where movies are streaming globally


value: luftaquila

value:
Hi HN,
For Student Formula (FSAE) and Baja SAE teams, data logging is critical but commercial products are often expensive and outdated.
So I built Monolith, an open-source (and open-hardware) wireless telemetry and data logging platform released under the Beerware License.
The hardware costs under $50 and handles CAN 2.0, GPS and IMU data, digital and analog signals.
I also built a web dashboard for real-time monitoring and data offloading that works completely wireless.
There is no need to install heavy desktop software.
Full documentation is at https://v2.monolith.luftaquila.io. I'd love to hear your feedback. Thanks!

value: Show HN: Monolith – DIY wireless telemetry/data logger for Student Formula

author: luftaquila


value: gabztoo

value:
Hi HN,
Over the last months, we kept running into the same production issues with LLMs:
– Provider outages and partial degradation
– Silent retries multiplying cost
– Hard coupling to a single vendor
We built Perpetuo, a thin gateway that sits between your app and LLM providers.
It routes requests based on latency, cost and availability, applies automatic failover, and keeps billing predictable — all using your own API keys (no reselling, no lock-in).
This is early, but already running in real workloads.
I’d really appreciate feedback from people running LLMs in production — especially what you’d expect from this kind of infrastructure layer.
Happy to answer any technical questions.

value: Show HN: A reliability layer that prevents LLM downtime and unpredictable cost

author: gabztoo


value: eropatori

value: Shows rendered preview for unfocused lines and raw markdown for the line or block being edited.

value: Show HN: Hybrid Markdown Editing

author: eropatori

title: Show HN: Hybrid Markdown Editing


value: simullab

value:
Hi HN, I’m the creator of PillarLab. I noticed that most people betting on prediction markets like Polymarket or Kalshi were either guessing or using generic LLMs that hallucinate data.
I built PillarLab to solve the 'black box' problem of AI. It uses 1,720+ proprietary 'Pillars' (analytical frameworks) to guide the AI through rigorous logic, things like Sharp Money tracking, xG soccer models, and Line Movement.
I’d love your feedback on the reasoning. Does the weighting of factors make sense to you? I'll be here to answer questions all day!

value: Show HN: PillarLabAI – A reasoning engine for prediction markets

author: simullab


value: promptfluid

value:
I’ve spent the last year building a "Cognitive Substrate" that manages its own technical debt and evolves itself in shadow mode. It’s a 131,000 LOC operating system designed for recursive autonomy - not just another LLM wrapper, but a kernel for long-term digital intelligence.
The system is built on a 4-layer architecture with 13 specialized modules. What makes it different from standard agent frameworks:
Self-Improvement Loop:
The MODERNIZER module scans the codebase, proposes upgrades, and tests them in a parallel "Shadow Mode" before production deployment.
Cognitive Circuit Breakers:
The CORE kernel implements the circuit breaker pattern at the logic level. If a cognitive module (like BRAIN or DECODE) starts to drift or fail, the kernel isolates it to prevent system-wide instability.
Multi-Tier Memory Graph:
BRAIN uses a Hot/Warm/Cold storage strategy. It searches its own knowledge graph and local memory tiers before ever hitting an external API, drastically reducing latency and dependency.
Infrastructure Arbitrage:
I built NEXUS to route requests across free-tier AI providers, essentially "mining" compute to build a permanent, proprietary knowledge base for $0/mo.
As a solo founder, I wanted to see if recursive self-improvement could replace a traditional engineering team. The result is a "Digital Organism" that handles its own health monitoring, security (via a cognitive firewall), and learning cycles.
I’ve published the full architectural deep-dives and live system evidence on Zenodo.
I'm curious to hear what the HN community thinks about the "Shadow Mode" approach to autonomous refactoring and the viability of cognitive circuit breakers.
Scientific Documentation & Artifacts:
https://zenodo.org/records/18379258
Here’s a link to the live system and our template marketplace so you can create models that don’t drift and apps that learn and dream as well.
Free SDK for anyone wanting to check it out:
https://CMPSBL.com
This is v5.5.0 and I have a little more work to do before the system can fully autonomously evolve itself, but it does propose, verify, and build its own patch’s and allies successfully to shadow mode reliably.
Let me know what you think HN!

value: Show HN: Cmpsbl OS v5.5.0 – A Self-Hosting Cognitive Substrate (131k LOC)

author: promptfluid


value: acenji

value:
I kept running into the same problems across web projects — JS errors silently breaking pages, no visibility into
  per-page SEO or performance, and Lighthouse only auditing one URL at a time. So I built ScaleLighthouse.

  It's a config-driven platform that runs Lighthouse audits, Playwright smoke tests (JS errors, missing DOM
  elements, broken flows), and CrUX real-user metrics across your entire site. Works on localhost, staging, or
  production — including authenticated pages. No test code to write.

  pnpm monorepo, Vue 3 dashboard, MIT licensed.

value: Show HN: ScaleLighthouse – Bulk Lighthouse, Playwright smoke tests, CrUX metrics

author: acenji


value: Show HN: Poast – Publish Quickly from Claude, Cursor, ChatGPT


value: Beefin

value: Show HN: VLM Inference Engine in Rust

author: Beefin

title: Show HN: VLM Inference Engine in Rust


value: ldrrp

value:
Hi HN,
I built Filameter because I kept losing track of filament spools across multiple printers and didn’t want a spreadsheet or a cloud-only SaaS.
Filameter is a local-first web app for managing 3D printing filament inventory:
Track spools by material, color, brand, and remaining weight
Runs entirely in the browser using local storage
Optional device sync (manual or automatic)
Open source
The goal was something lightweight that works on desktop and mobile, doesn’t require an account, and still scales beyond a couple of spools.
Site: https://filameter.com
Source: https://github.com/SiloCityLabs/filameter.com
Thanks for taking a look.

value: Show HN: FilaMeter – Local-first filament inventory management for 3D printing

author: ldrrp


value: Show HN: Minima – Open-source micro-learning LMS (alternative to Moodle)


value: justvugg

value:
Hi everyone,
I added a skills system to PolyMCP to solve a common issue with MCP servers at scale.
When the number of tools grows:
 • Agents burn tokens loading raw schemas
 • Tool discovery becomes noisy
 • Different agents need different subsets of tools
 • Orchestration logic leaks into prompts
Skills are curated, structured sets of MCP tools with documentation.
Agents load only the skills they need instead of full tool schemas.
Skills are generated by discovering tools from MCP servers and auto-categorizing them.
Example: generate skills from a Playwright MCP server:
polymcp skills generate --servers "npx @playwright/mcp@latest"
HTTP MCP servers:
polymcp skills generate \
  --servers "http://localhost:8000/mcp" \
  --output ./mcp_skills
Stdio MCP servers:
polymcp skills generate \
  --stdio \
  --servers "npx -y @playwright/mcp@latest" \
  --output ./mcp_skills
Enable skills in an agent:
agent = UnifiedPolyAgent(
    llm_provider=llm,
    skills_enabled=True,
    skills_dir="./mcp_skills",
)
Benefits:
 • Smaller agent context
 • Scales to large tool sets
 • Reusable capabilities across agents
 • Tool access control without prompt changes
 • Works with HTTP and stdio MCP servers
Repo: https://github.com/poly-mcp/Polymcp

value: Show HN: PolyMCP Skills – Scalable Tool Organization for MCP-Based AI Agents

author: justvugg


value: Show HN: Graviton: Create Complex Generative AI pipelines, auto-export as API