value: pandaupup

value:
Hi HN,
I built a small, free tool that estimates how long a speech will take based on text length and speaking speed (WPM).
You can paste your script or enter a word count, adjust the speaking pace, and instantly see an estimated duration. I originally made it for preparing presentations and talks where timing matters, but it also works well for narrations, lectures, or video scripts.
The site is intentionally lightweight (no signup, no tracking beyond basic analytics) and works entirely in the browser.
I’d love any feedback on usability, accuracy assumptions, or features you’d expect in a tool like this.
Link: https://speakingtimecalculator.org

value: Show HN: Speaking Time Calculator – Estimate speech duration from text

author: pandaupup


value: eguitarz

value: A workflow tool that breaks down where viewers drop, explains why, and turns the analysis into a ready-to-shoot storyboard.

value: Show HN: Shorta – analyze a YouTube Short → generate a storyboard → re-film

author: eguitarz


value: osoykan

value:
Hey HN!
We have built a testing framework called Stove. The JVM ecosystem has excellent frameworks, like SpringBoot, Ktor, Micronaut, Quarkus etc... But they all require different set of plumbing when it comes to e2e/component/integration testing.
For example integrating physical components (Kafka/Postgres/etc), and finding a way to assert and interact with them. All of a sudden you write a lot of custom helpers just to test one flow.
Stove is a Kotlin-first framework and helps to solve this problem for JVM backend apps. No matter what your framework or language (Kotlin/Java) is, tests are the same and written in Kotlin.
You describe the app and its dependencies in Kotlin and Stove brings them up and you run scenarios against the real system.
It would be great to have feedback on the API and what integrations would be beneficial for the community!
Thanks!

value: Show HN: Stove – Kotlin-first E2E testing for JVM Back end apps(Ktor,SpringBoot)

author: osoykan


value: dremok

value:
Hi HN! I built Oubli because I wanted Claude Code to remember me - not just across sessions, but across projects.
To be fair, Claude Code isn't completely amnesiac:
- CLAUDE.md files provide project-specific context
- You can always ask Claude to save things to files manually
But I kept hitting friction:
1. Manual memory management is tedious, you have to ask Claude to save things
2. My identity doesn't carry over when I switch folder
3. No automatic structure for what to remember vs. forget
Oubli automates this with a fractal hierarchy:
- Raw memories consolidate into higher-level insights
- A synthesized Core Memory loads automatically in every conversation (as you've gotten used to from the chatbots)
- Drill down from any insight to the original conversation when you need details
As Claude Code evolves beyond coding into a general-purpose agent (https://x.com/mollycantillon/status/2008918474006122936, https://x.com/claudeai/status/2009666254815269313), having persistent identity context becomes more valuable. I wanted Claude to know my work history, my family, my preferences without re-explaining every session/project.
`pip install oubli && oubli setup` - project-local by default, or `--global` for shared memory across all CC projects.
Yes, Anthropic will probably build something better eventually. But I need this now.
Cheers!

value: Show HN: Oubli – Persistent fractal memory for Claude Code

author: dremok


value: zoooey

value: Show HN: Home Design AI

author: zoooey

title: Show HN: Home Design AI


value:
I’ve been experimenting with AI-generated “slop” videos — short, automated content for YouTube Shorts, TikTok, and Instagram Reels.
Posting them manually was a nightmare, and every content management platform I tried was either absurdly expensive or locked behind enterprise pricing.
So I built QPost, a free tool to schedule and automatically publish videos across multiple platforms, straight from a dashboard or API.
Why it matters:
Even small creators or devs experimenting with AI-generated content can waste hours every week just uploading videos and filling in titles, descriptions, and hashtags. I wanted something that could actually scale without costing hundreds per month.
How it works (short version):
Multi-platform scheduling and automated publishing
Platform-specific metadata handling (titles, captions, hashtags)
Simple REST API for integration into scripts or workflows
The tricky part (why it took so long):
Every platform has its own quirks: TikTok’s creator API, YouTube’s OAuth scopes, Instagram’s Graph API. OAuth verification alone took months.
I also had to migrate from Vercel to a $6/month Digital Ocean droplet because of video size limits and cron job costs.
Tech stack (if you care):
Astro + React frontend, Node.js backend, Prisma + PostgreSQL, Google Cloud Storage, node-cron for scheduled publishing.
I’m curious how other devs automate multi-platform video posting, especially AI-generated content.
Any tips for scaling this, or clever ways to handle platform quirks? Would love to hear your approaches.

value: Show HN: QPost – Free tool for automating YouTube/TikTok/Instagram video posting


value: Show HN: Ginny and Georgia Test

title: Show HN: Ginny and Georgia Test


value: jaycobski

value:
I’m a marketer (6 years in SaaS) who spent the last year learning to build software using purely AI assistance ("vibe coding"). I just shipped my first production app for the Oil & Gas industry.
The Product
BasinCheck (https://basincheck.com) replaces the clipboard/Excel workflow for Safety Managers in the Permian Basin. It handles offline audits, hot work permits, and automates OSHA 300 logs.
The Stack
Next.js (App Router): Monorepo setup lets me spin out features as standalone free tools for SEO/lead gen.
Supabase: The path of least resistance for backend/auth.
Resend: For all transactional/marketing emails.
Stripe: Stuck with the standard despite the Polar/Lemon Squeezy hype. The SDK coverage made it easier for LLMs to generate reliable integration code.
AI: Used for parsing incident descriptions to suggest OSHA codes.
Hard rule: AI is read-only/suggestion mode. A human (Safety/HSE manager) must approve every classification.
The "Vibe Coding" Reality Check
The biggest lesson so far: AI leaves logic gaps.
I asked the AI to "alert me on new signups," which it did—for email/password forms. I missed my first real user for 5 days because the AI didn't intuitively know to hook those same alerts into the Google OAuth callback.
Fix: Moved logic from client-side to Postgres triggers on auth.users to catch everything at the DB level.
Happy to answer questions on the prompting workflow or the "boring" industrial tech stack.

value: Show HN: I built an OSHA compliance SaaS for oilfields using only LLMs

author: jaycobski


value:
Gitmore (https://gitmore.io) – natural language queries across GitHub, GitLab, and Bitbucket.
Instead of filtering PRs, scanning commit logs, or asking engineers for updates:
- "What shipped last week?" - "Who's been working on the API?" - "Which PRs have been open longest?" - "Summarize this month's releases"
Plain English in, plain English out.
How it works:
Connect your repos via OAuth. We register webhooks. Every event gets normalized into a structured schema – commit message, PR description, author, timestamp, files changed.
The AI queries structured data, not raw text. PR descriptions and titles carry context that individual commits often miss.
Automated reports:
Don't want to ask? Schedule it.
Weekly or monthly summaries delivered to Slack or email. Forward to stakeholders or let it run on autopilot.
Other features: - Slack bot: Ask from where you already work - Public changelog: yourcompany.gitmore.io/changelog - Contributor leaderboard
Security:
Metadata only. We store commit messages, PR titles, descriptions, timestamps, authors.
We never access source code, diffs, or file contents.
- Token encryption: Fernet (HMAC-SHA256 + AES-128-CBC) - Webhook verification: HMAC-SHA256 - 2FA support
Verify yourself: check webhook settings after connecting.
Free for 1 repo: https://gitmore.io

value: Show HN: Building this platform for CTO's/devs/founders


value: abishekvenkat

value: A tool that visualizes TV episode ratings as candlestick charts. Each episode is a candle - green if the rating went up from the previous episode, red if it dropped.<p>Search any show and instantly see its "quality trajectory" over time. Built with Next.js and TradingView's charting library, data from SeriesGraph.com/TMDB.

value: Show HN: Watchfolio – TV show ratings as stock market charts

author: abishekvenkat


value: Hi, as the LLM models are getting smarter in coding tasks, we will soon be using agents as co workers, as current tools like github copilot and cursor are not optimized for team collaboration, we began building PhantomX, please give your feedback, if you think we are in the right direction or what should be changed for finding the optimized development workflow which works for both humans and agents.

value: Show HN: What is wrong with the current coding agent workflow


value: pdftl-dev

value: Show HN: Pdftl – pdftk in Python with pipelines, AES-256, geometry and more

author: pdftl-dev


value: Priotecs

value:
I’ve been building and selling software since the early 2000s, starting with classic shareware. In 2011, I moved into the App Store world and built an iOS budget app because I needed a simple way to track my own expenses.
At the time, my plan was to replace a few larger shareware projects with several smaller apps to spread the risk. That didn’t quite work out — one app, MoneyControl, quickly grew so much that it became my main focus.
Fifteen years later, the app is still on the App Store, still actively developed, and still used by people who started with version 1.0. Many apps from that era are long gone.
Looking back, these are some of the things that mattered most:
Starting early helped, but wasn’t enough on its own.
Early visibility made a difference, but long-term maintenance and reliability are what kept users.
Focus beat diversification.
I wanted many small apps. I ended up with one large, long-lived product. Deep focus turned out to be more sustainable.
Long-term maintenance is most of the work.
Adapting to new iOS versions, migrating data safely, handling edge cases, and keeping old data usable mattered more than flashy features.
Discoverability keeps getting harder.
Reaching users on the App Store today is much more difficult than it was years ago. Prices are higher than in the old 99-cent days, but visibility hasn’t improved.
I’m a developer first, not a marketer.
I work alone, with occasional help from freelancers. No employees, no growth team. The app could probably have grown more with better marketing, but that was never my strength.
You don’t need to get rich to build something sustainable.
I didn’t build this for an exit. I’ve been able to make a living from my work for over 20 years, which feels like success to me.
Building things you actually use keeps you honest.
Every product I built was something I personally needed. That authenticity mattered more than any roadmap.
This week I released version 10 with a new design and a major technical overhaul. It feels less like a milestone and more like preparing the app for the next phase.
Happy to answer questions about long-term app maintenance, indie development, or keeping a product alive across many iOS generations.

value: Show HN: An iOS budget app I've been maintaining since 2011

author: Priotecs


value: lassejansen

value: This is hyTags, a programming language embedded in HTML for building interactive web UIs.<p>It started as a way to write full-stack web apps in Swift without a separate frontend, but grew into a small language with control flow, functions, and async handling via HTML tags. The result is backend language-agnostic and can be generated from any server that can produce HTML via templates or DSLs.

value: Show HN: HyTags – HTML as a Programming Language

author: lassejansen


value: Midry

value: You can check some things by your eyes before run the tasks(e.g., before the AI agent executes important tasks).

value: Show HN: Hato – Task Runner with Checklist

author: Midry


value:
Hi HN,
AI is writing a lot of our code now, but here’s what keeps me up at night: AI is great at logic, but terrible at state safety. An LLM can write a perfect-looking function that accidentally nukes your global state or creates a race condition you'll spend a week debugging.
I built Theus because I wanted to stop worrying.
The philosophy is simple: Data is the Asset. Code is the Liability. Theus acts like a "safety container" for your logic (especially code written by AI). It enforces a few strict rules:
Zero-Trust: A process can’t see anything it didn't explicitly ask for in its contract.
Shadow Copies: Code never touches your "real" data directly. It works on copies. If the logic fails or breaks a rule, Theus just throws the changes away.
Audit Gates: You define the "red lines" (like balance can’t be negative) in a simple YAML. The framework blocks any commit that crosses them.
I’ve been using it to build AI agents that I can actually trust with "write" access. It’s not about making code faster; it’s about making it right, and being able to sleep at night.
I'd love to hear what you think about this "Process-Oriented" approach. Thanks!

value: Show HN: Theus – I built a framework to make AI-generated code safe to run


value: Show HN: Junior devs don't know red flags we spot instantly & we never tell them


value: sawirricardo

value: Show HN: Fruito – match-3 puzzle game I made with Claude Code

author: sawirricardo


value: zylics

value: Show HN: High-precision mouse polling rate tester

author: zylics


value: thepoors

value:
I built an offline-first AI system designed for places where you need expert guidance but can't rely on connectivity or cloud APIs — disaster response, remote clinics, field operations.
The core idea: instead of trusting the model to behave, you cage it. The system uses a dual-model pipeline (worker generates, auditor checks) governed by a policy engine that defines what's allowed before inference runs. Every interaction gets logged to an append-only audit trail with checksum chaining.
Key design constraints:
Offline-first with graceful fallback
Policy-driven toggles (operators set capacity limits, not AI behavior)
Tiered key overrides for credentialed users (a nurse sees different options than a paramedic)
Modular "packs" for different domains (medical triage, structural assessment, water safety, etc.)
This started as a question: how would you deploy AI to a hurricane aftermath where there's no internet, no experts, and high stakes? The answer wasn't "better prompts" — it was architecture that assumes the model will try to do things it shouldn't.
https://github.com/thepoorsatitagain/Tutor-to-disaster-exper...
Looking for feedback on the architecture. I'm not from an AI background — I came at this from the ops/deployment side — so I'm sure there are things I'm missing.

value: Show HN: Policy-governed AI system for offline deployment in expertise deserts

author: thepoors


value: debba

value:
I created a Zed extension for Apache FreeMarker templates with tree-sitter-based syntax highlighting. FreeMarker is a Java template engine that's still widely used in enterprise apps, but modern editor support has been lacking.

  The extension handles both angle bracket and square bracket syntax, mixed HTML content, and all FreeMarker directives through a custom tree-sitter grammar rather than regex.

  GitHub: https://github.com/debba/zed-freemarker
  Zed Extensions: Search "FreeMarker"

  Built it mainly for my own projects, but figured others maintaining legacy systems might find it useful.

value: Show HN: FreeMarker Support for Zed Editor

author: debba


value: adilmoujahid

value:
I've been using AI coding assistants (Claude, Cursor, etc.) for the past year and noticed a gap: there's no good central place for people learning to build with these tools to share projects, compare workflows, and find practical guides. So I built MakersHub.dev.
Current features:
- Learning guides focused on AI-assisted development
- Project showcase for sharing what you've shipped
- Discussions section
- HN-style news feed for AI dev content
Stack: Next.js, Supabase, deployed on Vercel. Built most of it with AI assistance, which felt appropriate.
Still early — launched to a small group of subscribers and iterating based on feedback.
Would love to hear what HN thinks, and any advice on growing a community like this from scratch.

value: Show HN: MakersHub.dev – A community platform for people building with AI tools

author: adilmoujahid


value: Show HN: Janus – Anki flashcards from PDFs, videos and notes


value: mattogodoy

value:
I built Nametag because I kept forgetting details about people I care about. Can you remember when you last talked to an old friend? Their partner's name? When their birthday is?
It's like a CRM, but for actual relationships instead of sales prospects. You track people, map how they're connected (family, friends, colleagues), and visualize your network as an interactive force-directed graph.
*Features:*
- Track people with flexible attributes
- Map bidirectional relationships between people (for example, Teacher <-> Student)
- Interactive network graph with zoom/pan/click-to-navigate
- Custom groups for organizing contacts
- Reminders for important dates such as birthdays, anniversaries, etc
- Reminders for getting in touch with people as frequently as you want
- Dark mode, different languages (English and Spanish for now, but more are coming!)
- Mobile-responsive
*Dual deployment model:*
- Hosted at https://nametag.one (free tier: 50 people, paid starting at $1/month)
- Self-hosted using Docker (no limits)
For self-hosting, accounts auto-verify (no email service needed), so you can run it completely offline for maximum privacy. The hosted version helps fund development.
*Why AGPL-3.0?*
I wanted to ensure that if anyone modifies and deploys Nametag, they contribute improvements back to the community and the code stays open. Personal relationship data is sensitive - users should always have the right to inspect and modify the code handling their data.
*GitHub:* https://github.com/mattogodoy/nametag
Happy to answer questions about the implementation, architecture decisions, or graph visualization challenges.

value: Show HN: Nametag – open-source personal relationships manager

author: mattogodoy


value: eamag

value: Show HN: Where do my taxes go in Berlin? A personal receipt generator

author: eamag


value: lalitgehani

value:
Hi HN, I’m the creator of SnackBase.
I built this because I work in Healthcare and Life Sciences domain and was tired of spending months building the same "compliant" infrastructure (Audit Logs, Row-Level Security, PII Masking, Auth) before writing any actual product code.
The Problem: Existing BaaS tools (Supabase, Appwrite) are amazing, but they are hard to validate for GxP (FDA regulations) and often force you into a JS/Go ecosystem. I wanted something native to the Python tools I already use.
The Solution: SnackBase is a self-hosted Python (FastAPI + SQLAlchemy) backend that includes:
Compliance Core: Immutable audit logs with blockchain-style hashing (prev_hash) for integrity.
Native Python Hooks: You can write business logic in pure Python (no webhooks or JS runtimes required).
Clean Architecture: Strict separation of layers. No business logic in the API routes.
The Stack:
Python 3.12 + FastAPI
SQLAlchemy 2.0 (Async)
React 19 (Admin UI)
Links:
Live Demo: https://demo.snackbase.dev
Repo: https://github.com/lalitgehani/snackbase
The demo resets every hour. I’d love feedback on the DSL implementation or the audit logging approach.

value: Show HN: SnackBase – Open-source, GxP-compliant back end for Python teams

author: lalitgehani


value: kokau

value:
Hi HN
I’m the maker of Talkolia, an AI chatbot designed for websites that actually understands your content instead of hallucinating generic answers.
The problem:
Most website chatbots rely on embeddings, manual training, or static FAQs. They’re painful to maintain and often give wrong answers.
What we built:
Talkolia reads your website dynamically (pages, structure, context) and answers users only based on your real content.
Key points:
No embeddings
No manual training
No hallucinations
Setup in under 2 minutes
Works for landing pages, SaaS docs, agencies, e-commerce
It’s early-stage and we’re actively improving it based on feedback.
https://talkolia.co
I’d love to hear what you think, especially from people who’ve tried other website chatbots and were disappointed.

value: Show HN: Talkolia – An AI chatbot that understands your website

author: kokau


value: darkhz

value: Show HN: Haraltd – A cross-platform Bluetooth daemon with a JSON-based RPC

author: darkhz


value:
I built RAGGuard because most RAG systems have a security gap: they filter documents after retrieval, meaning unauthorized data has already hit the retrieval layer. RAGGuard filters during vector search at the database level.
- Works with 14 vector DBs (Qdrant, ChromaDB, Pinecone, pgvector, etc.)
- Integrates with existing auth (OPA, Cerbos, OpenFGA, custom RBAC)
- Drop-in replacement for LangChain/LlamaIndex retrievers
GitHub: https://github.com/maximus242/ragguard
Would appreciate any feedback on the approach or API design.

value: Show HN: RAGGuard – Permission-aware retrieval for RAG applications


value:
Hi HN, I built Aurora, a cross-platform music player focused on local, lossless playback with a clean UI and playlist support. I had a large FLAC library on macOS and couldn’t find a simple player that just works, so I made this.
Features:
- Local playback from your machine
- Supports FLAC, MP3, M4A, WAV
- Basic playlist management
- Open-source on GitHub
Download (macOS):
https://github.com/bbbneo333/aurora/releases/tag/v1.0.0
Windows/Linux builds are being tested. I’m actively looking for feedback and bug reports:
https://github.com/bbbneo333/aurora/issues
Happy to take questions or suggestions!

value: Show HN: Aurora – open-source cross-platform music player (lossless)


value: dpitkevics

value: Show HN: Native app to scaffold and build Cursor-ready Next.js projects

author: dpitkevics


value: unstyledcontent

value:
We built Xweather Live as a public, ad-free demo of our weather APIs and mapping stack at Xweather.
The goal of Live is not to be a consumer weather app, but a way for developers to explore and validate our weather data and visualization tools.
Link: https://live.xweather.com
Feedback welcome!

value: Show HN: Xweather Live – real-time global weather maps rendered with WebGL

author: unstyledcontent


value: bozhou

value: Show HN: Img2img.net – Effortless AI Image Style Transfer Online

author: bozhou


value: Show HN: Swiftward – on-prem policy engine for LLM guardrails and UGC moderation


value: devoxyes

value: Show HN: A dashboard for VS Code extension authors to track search rankings

author: devoxyes


value: steveharrison

value:
Hey HN,
I feel like there is a gap in personal finance apps: local-first options typically have less polished UIs, while those with great design like Monarch Money are not local-first. This app fills the gap by providing a modern UI like Monarch/Monzo along with a database that you can hack around with outside of the app. File > app!
- Local-first: transactions are stored in an encrypted SQLite database on your Mac, so you can read/write to it with Claude Code or your favourite DB client.
- Link transactions to merchants manually or automatically with https://ntropy.com to add sensible merchant names, brand icons, categories, GPS locations (e.g. converting "APPLE STORE R238 R238   SYDNEY" into "Apple Store, Sydney | Electronics | 367 George St, Sydney NSW 2000 | Parent: Apple")
- Map view with clustering to see how much you’ve spent in different locations.
- Enrich Uber transactions with pickup/drop-off details
- macOS inspired UX patterns like dragging transactions into folders or tags. It's an Electron + React app so think 1Password-style UI.
Once you link your transactions to merchants, you can run SQL queries like "What's my total Uber spend this year?" or ask questions about your spending with Claude Code (just get it to decrypt & read the database).
I’m starting with CSV and OFX file import, with syncing (Plaid, etc.) coming next.
You can download the Mac app at https://thefinances.app. To auto-enrich transactions via the API, you can go to Finances > Settings and add this demo licence key, KESC-9QQU-VU0X-EGJP-N373.
Let me know what you think!

value: Show HN: I built a Finances app for Mac where you own the SQLite database

author: steveharrison


value:
Client-side Markdown viewer built for reading and sharing documents with diagrams and math.
It supports GitHub-flavored Markdown, Mermaid diagrams, and LaTeX rendering directly in the browser. The scope is intentionally narrow: viewing Markdown clearly, without turning it into a full editor.
Feedback is welcomed

value: Show HN: A Markdown Viewer for the LLM Era (Mermaid and LaTeX)


value: wosk

value:
TL;DR: weather forecasts but for respiratory disease. Interpret with caution :)
Hey HN,
Every year during the respiratory disease season (winter in the northern hemisphere), the CDC runs challenges where teams -- academics, mostly, but also government and companies -- submit forecasts of the disease burden each week. These are 4-week-ahead forecasts.
We (Emily and I, Joseph) built RespiLens.com as a static website to display these forecasts all in one place with a nicer interface than what is generally provided [1].
Forecasting respiratory disease is challenging, so please interpret forecasts with caution (see how bad it was in the last season).
This website is quite early stage, but we have been using it internally for a year and are starting to build it in public now. We are very much looking for your comments, especially as most folk who have seen it/use it are in the public-health space.
We are not SWEs, so there might be a ton we can improve on the website.
There is also the RespiLens.com/Forecastle, a Wordle-type game to see how good you are at forecasting vs the current state of the art. Interested in what you think of that.
Technically, our GitHub repo is here https://github.com/ACCIDDA/RespiLens, and it's quite straightforward:
* we pull forecasts from each hub GitHub; this is facilitated by the HubVerse, an initiative to standardize these challenges (https://hubverse.io)
* we serve this with a Mantine Web App. Claude Code and other LLMs were heavily used to create the front-end. It is a good use case because we can do QA as know what it should look like as I have dozens of Python scripts for these plots.
Feel free to ask questions! or suggest features.
[1] hubverse provides an automatic dashboard, and the CDC displays forecasts on their website under a set of conditions (good coverage). See RespiLens.com info hub for link.
Best,
Joseph

value: Show HN: Respilens.com displays flu, COVID-19 and RSV forecasts for US states

author: wosk


value: akarenin

value: SiteRant is an anonymous online bulletin board that allows users to rant about specific domains. Simply search up a domain (any domain), and press enter to start finding rants or start ranting. Aside from macro/spam, porn/gambling site advertisements, etc., we allow diverse and unfiltered opinions, allowing users to view, upvote/downvote, and post short comments limited to 500 characters. Overall, I hope that SiteRant becomes large enough to map the internet sentiment, but more than that, I hope the site delivers a light and fun ranting experience.

value: Show HN: SiteRant– Rant anonymously about your (least) favorite sites

author: akarenin


value: yethikrishnar

value:
y0 is different because the agents actually do things — they don't just chat.
You describe what you want in natural language. Then y0 spins up a sandboxed environment and the agent gets to work: browsing websites, writing code, managing files, running shell commands. It streams progress in real-time so you can watch it work.
Unlike chatbots, y0 agents have real execution capabilities. They can navigate complex websites, fill forms, extract data, create documents, run scripts, and chain multiple steps together autonomously. When the agent finishes, you get the actual output — files, data, reports — not just a text response.
The sandboxing means agents can't mess with your local machine. Each session runs in an isolated container with its own filesystem, browser, and shell. You can give agents access to specific tools and APIs without worrying about side effects.
We built y0 because we got tired of copying code from ChatGPT and manually running it. We wanted an AI that could just do the work end-to-end.
There's a free tier to try it out. Would love feedback on what workflows you'd want agents to handle.

value: Show HN: Y0 – Platform for autonomous AI agents that do real work

author: yethikrishnar


value: marcuscodes

value:
Hi HN! I built MockMyData.io - a tool that lets developers generate mock REST APIs.
The problem: When building frontends, I didn't want to hardcode JSON data everywhere. I wanted to build against actual API endpoints and practice the integration work, but spinning up a real backend for every prototype felt like overkill.
Tech stack: Django backend with PostgreSQL and Redis caching, React frontend, multi-tenant architecture with subdomain routing. Built the entire thing in 2.5 months as a solo developer as well
Link: https://mockmydata.io
I Would love feedback on how to improve it!

value: Show HN: I built a SaaS for generating mock APIs (Django and React, 2.5 months)

author: marcuscodes


value: internintern

value:
https://liquidityfm.org
I built this because existing market sonification tools usually just map price to pitch, resulting more noise than music. I wanted a system that translated market sentiment into music that I would actually want to listen to in the background while I work.
THE LOGIC (State Machine)
Instead of raw pitch mapping, I built a deterministic state machine that normalizes live data into 60 distinct audio permutations based on three vectors:
1. Sentiment: Candle color streaks (Doom -> Euphoric)
2. Energy: Momentum/Volatility (Still -> Explosive)
3. Texture: Volume vs 20 MA (Sparse -> Chaotic)
If the market enters a "Doom / Explosive / Chaotic" state, the engine triggers heavy distortion and minor keys. If it flips to "Euphoric / Still," it crossfades into ambient major pads.
THE ENGINEERING
Consensus Engine: Websockets from Kraken, Binance, and OKX to form an aggregated price and filter out "scam wicks". I specifically chose crypto feeds because they offer continuous high-volume stream instead of closing at 4pm but it could really be based on anything.
Audio Pipeline: Two-stage agentic workflow (Generation -> Critique) to create lyrics and style, which are then generated in Suno. To ensure zero latency and to reduce costs, I pre-generated a library of ~500 tracks mapped to the 60 state permutations. The app handles the crossfading between these states in real-time.
Stack: Next.js, CCXT (socket normalization), and Cloudflare R2.
THE "TIME MACHINE"
The part that I actually enjoy the most are the historical playlists. E.g. you can load the FTX crash (https://liquidityfm.org/replay/ftx-collapse-2022) or the Post-Covid rally candle-by-candle to hear what panic or euphoria actually sounds like. I'm also oddly proud of the CRT mode although tbh I rarely run with it.
It is free to use, no signup required. Let me know if you have any questions or suggestions for improvement!

value: Show HN: Deterministic state machine to sonify trading volatility

author: internintern


value: tom-pytel

value: Show HN: Pfst – High-level Python AST/CST manipulation that preserves formatting

author: tom-pytel


value: rlucato

value:
This is a fully managed API to perform inference with pre-trained Small Language Models (SLMs) for various NLP and text processing tasks.
Using SLMs for specific text processing tasks provides three main benefits compared to using LLMs:
- Lower costs: SLMs are much cheaper to run compared to LLMs, making them a cost-effective solution for applications with high inference volumes.
- Improved performance: SLMs are often more accurate and efficient for specific tasks compared to LLMs, which are designed to be general-purpose.
- Lower Latency: SLMs are typically faster to respond compared to LLMs, resulting in lower latency for applications.
This API is meant to provide developers with a simple, efficient and cost-effective way to integrate SLMs into their applications, without the need to self-host them.
All models used in this API were trained by us at Tanaos, are open-source and accessible from the Tanaos Hugging Face page.

value: Show HN: API to perform inference with pre-trained SLMs for various NLP tasks

author: rlucato


value: oug-t

value: Show HN: Zsweep – A Vim-optimized Minesweeper built with SvelteKit

author: oug-t


value: Show HN: An open-source communication layer for AI agents


value:
Hi HN,
I built a TUI for ProtonVPN because I wanted a better way to browse and filter servers directly from the terminal without relying on the GUI.
It's written in Rust using `ratatui` for the interface.
*The experiment:* This project was almost entirely built by AI coding agents. I acted as the architect/product owner, reviewing code and directing the agents, but wrote very little code manually.
Repo: https://github.com/cdump/proton-tui

value: Show HN: Proton TUI – Unofficial ProtonVPN Terminal Client in Rust


value: bartoszhernas

value:
I had problems scheduling company get together. 3 days in next 3 months, 12 people, whats the best date for that? I've build the solution to my problem (human coded haha) and recently is started getting traction which is nice, so we added Slack integration (Claude coded).
WhenNOT flips the question: instead of "when are you available?", we ask "when are you NOT available?"
It's completely free - no premium tiers, no limits. I built it because I needed it for my own team.

value: Show HN: WhenNOT – scheduling longer team events by asking when not

author: bartoszhernas


value: SnackStyle

value:
Hello guys,
As a developer, technical interviews are part of our journey.
But somehow, I have issues to prepare it the right way.
So I decided to build my own technical ITW prep tool.

value: Show HN: Frustrated to fail my 3rd Technical ITW in a row, I Built SharpSkill

author: SnackStyle


value: cranberryturkey

value: Show HN: The Marketplace for AI-Assisted Professionals

author: cranberryturkey


value: notamitgamer

value:
Built a browser-based compiler that supports real server-side execution
with live stdin/stdout via WebSockets.
Includes an LLM-based layer that explains real compiler/runtime errors
instead of synthetic examples.
Live demo: https://compiler.amit.is-a.dev

value: Show HN: Online compiler with real-time stdin/stdout and AI debugging

author: notamitgamer


value: seansh

value:
Hi guys,
With CodeMic, instead of watching a programming video, you can replay sessions *inside your own editor* where you can run the code, explore, and experiment.
Think Asciinema for coding sessions with audio, video, and images.
Record & replay in VSCode. Emacs, Vim, web embedding and more coming soon.
Local first and open source.
No signup required, except for publishing your sessions.
-----
p.s. This is a platform not only for teaching programming, but also for showing human engineering at its best by exploring and discussing incredible open-source projects. Some of my favorites I would like to cover include projects such as FFmpeg, SQLite, LuaJIT, and Emacs.
I believe in human engineering and aim to build the right tools for presenting and communicating code through CodeMic.
Looking forward to hearing your thoughts :)

value: Show HN: CodeMic - replay coding sessions inside your editor, local-first

author: seansh


value: Kaadz

value: Show HN: Built a tool so that you can track where your LLM costs are headed

author: Kaadz


value: ezgrade

value:
Hi HN,

  I built a grade calculator that runs entirely in your browser with no sign-up or data collection.

  Key features:
  - Real-time weighted grade calculation with automatic normalization
  - What-If simulator: calculate what score you need on finals to hit your target grade
  - Multi-course support with localStorage persistence
  - Grade breakdown charts
  - Dark mode

  Tech stack: Next.js 14, TypeScript, Zustand, Recharts. Fully open source (MIT).

  Built this because existing grade calculators either require accounts, show ads, or have clunky UX. Wanted something fast and privacy-respecting.

  Live: https://ezgrade.me

  Would love feedback on the UX and any features you'd find useful!

value: Show HN: Ez Grade – Privacy-first weighted grade calculator with simulator

author: ezgrade


value: prakharjain

value:
Hi HN,
I’ve been experimenting with the latest "computer use" models (like Gemini 3 flash, qwen 3 vl plus, browser use), and while they are impressive, I hit a wall with reliability in production use cases.
The main issue I found is context. When we give agents simple natural language prompts (e.g., "download the invoice"), they often lack the nuance to handle edge cases or specific UI quirks. They try to be "creative" when they should be deterministic.
I built AI Mime to solve this by shifting from "prompting" to "demonstrating." It’s an open-source macOS tool that lets you record a workflow, parameterize it, and replay it using computer-use agents.
How it works:
Record: It captures native macOS events (mouse, keyboard, window states) to create a ground-truth recording of the task.
Refine (The interesting part): It uses an LLM to parse that raw recording into parameterized instructions. Instead of a static macro, you get manageable subtasks where you can define inputs/variables. This constrains the agent to a specific "happy path" while still allowing it to handle dynamic elements.
Replay: The agent executes the subtasks using the computer-use interface, but with significantly higher success rates because it has "seen" the exact steps required.
The goal is to make these agents observable and repeatable enough for actual RPA work.
The repo is here: https://github.com/prakhar1114/ai_mime
I’d love to hear your thoughts on the approach or how you are currently handling state/reliability with computer-use models.

value: Show HN: AI Mime – Record and parameterize workflows for Computer Use agents

author: prakharjain


value: azan-n

value: Show HN: Analyze JUnit test files in the browser

author: azan-n


value: lunarrocket

value:
Hey HN, I'm Andrea from OneView.
Hot take: Google Tag Manager is a technical debt sinkhole, disguised as a no-code tool.
Ever got that email from marketing? "Hey, can you check why our conversions are broken?" A "quick fix" becoming a 10 story points rabbit hole: debug GTM, explain why duct-taping is bad, patch it, repeat in 2 weeks.
Anything that can be customized has to be maintained... and eventually becomes debt.
My philosophy:
1. Marketing should not be an engineer's concern
2. Engineers have better stuff to do than babysitting marketing tools
Over the last year I built a somewhat opinionated platform for the no-man's-land between engineering and marketing (with an unhealthy obsession over data quality).
The tradeoff is intentional: less customizability, less stuff that can break, less to maintain.
Once it's running, there's nothing to optimize. No rules to create. No mappings to manage. No pipelines to debug. Just auth and go.
What it does:
* OneView piggybacks on GA4 protocol, so implementation is super easy
* Built-in retries and self-healing integrations - with 7 days buffer for when APIs go down
* Automatic deduplication - same event, multiple platforms, counted once
* Conversion APIs and consent management - handled automatically
Looking for high-volume teams or weird edge cases. I think this covers >80% of use cases—I've processed millions of events over the last 10 months during alpha—but would love to find the ones that break my assumptions.
Even hotter take: how many of you -know- marketing's losing data but gave up fighting for a fix?
Website: www.oneviewhub.com
Docs: docs.oneviewhub.com

value: Show HN: OneView – Autopilot for Marketing Data

author: lunarrocket


value: anticensor

value: Show HN: DSAT – Data Subject Access Toolkit

author: anticensor


value:
Update on the StatefulSet Backup Operator - a lightweight Kubernetes operator for automated backups using native VolumeSnapshot APIs.
What's new in v0.0.3:
VolumeSnapshotClass is now configurable (was hardcoded before)
Improved PVC deletion stability with proper wait logic
Enhanced test coverage for edge cases
Redis StatefulSet backup/restore fully tested end-to-end
Code quality improvements: clean linting, better error handling
Why this exists:
Velero is great for full-cluster DR, but sometimes you just need fast, snapshot-based backups for StatefulSets without the overhead of external object storage or complex setup.
This operator focuses on:
Scheduled snapshots with cron expressions
Pre/post backup hooks (e.g., database flush before snapshot)
Per-replica retention policies
Point-in-time recovery via CRDs
100% declarative, GitOps-friendly
Current limitations:
Still alpha (v0.0.3). No cross-cluster restore yet, no webhook validation, container selection for hooks needs work. Velero is still the production choice for serious DR needs.
What I'm curious about:
Is there actual demand for this kind of focused tool, or does Velero's flexibility already cover these use cases well enough that alternatives don't make sense?
Tested successfully on Minikube, Kind, and now Redis workloads. Planning to test on GKE/EKS next.
Feedback welcome!

value: Show HN: StatefulSet Backup Operator v0.0.3–Configurable snapshots, Redis tested


value: michielme

value:
Hi! I've built this because I kept reaching for Celery for simple scheduled tasks and it felt like overkill. I just needed "run this function every hour" or "daily at 9am", not distributed workers.
So it's decorators for scheduling (@scheduler.every(5).minutes, @scheduler.daily.at("09:00")), state saves to JSON so jobs survive restarts, and there's an optional FastAPI dashboard if you want to see what's running.
No Redis, no message broker, runs in-process with your app. Trade-off is it's single process only — if you need distributed workers, stick with Celery.

value: Show HN: FastScheduler – Decorator-first Python task scheduler, async support

author: michielme


value: waili

value:
Anthropic just dropped Cowork today – a nicer way to let Claude act as your agent on files without wrestling the CLI.
I've been building something in the same spirit but open-source, cross-platform, and multi-model: AionUi. It's a free desktop GUI (Electron-based) that turns popular command-line AI tools into a unified "Cowork" workspace:  Supports Claude Code, Gemini CLI, Codex, Qwen Code, Goose CLI, Auggie, etc. (auto-detects installed CLIs)
- Custom LLMs – Full support for customizable third-party LLMs.
- Multi-session chats with independent contexts, stored locally in SQLite (data never leaves your device)
- Real-time preview & editing panel for 9+ formats: PDF, Word, Excel, PPT, code diffs, Markdown, images, HTML...
- AI image generation/editing (Gemini-powered, with recognition)
- Smart file management: batch rename, auto-organize, classify, merge
- Parallel multi-tasking (sessions don't interfere)
- WebUI mode: remote access from phone/browser, still local data
- Cross-platform: macOS, Windows, Linux
- Fully customizable UI via CSS
Just like Claude Cowork simplifies Claude Code for non-devs, AionUi aims to do the same for all your CLI AI agents.
GitHub: https://github.com/iOfficeAI/AionUi
(3.5k stars, Star if it looks useful  – no pressure!)

value: Show HN: AionUi – Open-Source Cowork for Claude Code, Gemini CLI, Codex and More

author: waili


value: frodothebrave

value: Show HN: FlexList – A global leaderboard where you pay to own your city

author: frodothebrave


value:
I built a simulator for Dreadmyst (a recent Action RPG) to help players model complex character stats and damage scaling.<p>In these types of games, calculating the final DPS involves a lot of nested multiplicative/additive logic that isn't transparent in-game. I wanted to build a UI that makes this math reactive and visual.
1. Handles complex dependency graphs (e.g., Attribute A → % Defense → Flat Damage).
2. Everything is calculated client-side for zero-latency UI updates.
Even if you don't play the game, I'd love feedback on the UI/UX for handling large sets of interdependent variables!

value: Show HN: A full-scale build simulator for Dreadmyst (Action RPG)


value: artursapek

value: Show HN: Revise – a new canvas-based word processor

author: artursapek


value: sr-white

value:
Hey HN, I built memtui.
It's a terminal UI for Memcached that lets you browse keys organized in a tree
structure, like a file manager. Keys with common prefixes (user:1001:profile,
user:1001:session) automatically group into folders.
*The problem*: Debugging Memcached often means sending raw ASCII protocol commands via
`nc localhost 11211`. There's no easy way to browse what's cached, understand
the data format, or safely edit values without risking overwrites.
*What it does*:
- Tree-structured key navigation using `lru_crawler metadump`
- Auto-detects JSON, gzip/zlib, and binary data
- CAS support for conflict detection during edits
- VS Code-style command palette (Ctrl+P)
- Vim keybindings (j/k navigation)
*Technical details*: Built with Go using Bubble Tea (Elm Architecture).
Requires Memcached 1.4.31+ for the metadump command that enables key enumeration.
Curious to hear:
- How do you currently inspect your Memcached data?
- What features would make this useful for your workflow?
GitHub: https://github.com/nnnkkk7/memtui

value: Show HN: Memtui – A terminal UI for browsing Memcached like a file tree

author: sr-white


value: Leczek

value:
I wanted to create a platform that can universally rate anything imaginable (movies, books, art, architecture, colors, clothing, fonts, programming languages so on and so forth).
The idea is simple- a platform thats not bound by category (such as imdb/Rt for movies)- on Elorate each hashtag is a category and every posted thing is rated globally and within one specific category. To make it more sticky I've added a feature to rate things in Swipe Rate mode (tinder style) or pick one of two shown things- a "Pick one" mode.
As its meant to be rating+social media platform a feature to compare users tastes is coming soon.
iOS https://apps.apple.com/es/app/elorate/id6749582531
Android https://play.google.com/store/apps/details?id=com.elorate

value: Show HN: Elorate- social app to rate anything

author: Leczek


value: drchiu

value: Show HN: Free app store screenshot editor

author: drchiu


value: sparkalpha

value:
When Claude Cowork launched, we were already deep into building Lily.
We had planned to ship yesterday, but decided to take an extra day to polish a few rough edges.
Seeing Claude Cowork ship publicly was less about inspiration and more about validation — it confirmed that this idea resonated beyond our own team.

value: Show HN: We shipped an AI coworker as Claude Cowork launched

author: sparkalpha


value: Hey everyone!  I have a bad habit that I always end up with dozens of browser tabs and apps open at the same time. It gets so messy that finding one specific website becomes a nightmare. So I developed a extension + macOS menu bar app for myself and after using it for a while, I found it is much more better than I expected, so I decided to package it and release it as open source, completely free!<p>I'd love to hear your feedback and looking forward to improve our app together!

value: Show HN: TabDog – Open Source, Manage the browser tabs/apps from menu bar


value:
Hello HN,
Teaching has always been my passion, and I have always wished there were more interactive resources for learning technology concepts. With the rise of agentic development, we can now build these experiences ourselves.
So I built an interactive tutorial to teach Docker internals using Claude Code.

value: Show HN: I built an interactive tutorial for learning Docker


value: alphatesterguy

value:
I built a group chat where every message becomes a node and replies create edges. The conversation turns into an interactive graph as you talk.
The idea came from losing track of discussions in group chats. Threads help, but I wanted to see the whole conversation structure at once - who's replying to whom, which topics are connected via hashtags, etc.
How it works:
- Send a message → it's a node
- Reply to someone → edge connects them
- Use #tags → lighter edges connect related messages across threads
No accounts, rooms auto-delete after 3 hours. There's a demo room you can try without creating anything.
Would love feedback on the UX – specifically whether the graph actually helps or just adds noise.

value: Show HN: Qonvo –Group chat that visualizes conversations as a graph in real-time

author: alphatesterguy


value: ivg-design

value:
I built this because I wanted custom icons for my project folders in Finder's sidebar. macOS supports this via FinderSync extensions, but each icon requires its own app bundle.
SidebarFavorites Manager automates this - pick a folder, choose an SF Symbol (or import a custom SVG), and it generates the icon app for you.
- macOS 13.0+
- Uses native CFBundleSymbolName
- No daemon needed - icons persist after closing the manager
- MIT licensed
Demo video in the README. Happy to answer questions about FinderSync quirks.

value: Show HN: Add custom icons to macOS Finder sidebar favorites

author: ivg-design


value:
Hi HN,
I built DynamicScreen, a free web-based tool for generating dynamic screen colors and lighting effects. No signup or download required.
What it does:
- Creates dynamic color backgrounds for live streaming
- Provides ambient lighting for work/focus sessions
- Generates relaxation/mood lighting effects
5 core modes:
• Hard Cut – instant color switching for parties and beats
• Fade – smooth color transitions for relaxation
• Flash – high-frequency strobe effects
• Breathing – gentle brightness cycles for meditation/sleep
• Solid Color – static ambient lighting with filters
15 preset lighting effects:
- Time-based: Day/night cycle, dusk, dawn
- Seasonal: Spring, summer, autumn, winter themes
- Holiday: Christmas, Halloween, New Year
- Nature: Ocean waves, forest breeze, sunset glow
- Mood: Deep focus, total relaxation
Features:
- 60 preset colors + custom color picker
- Adjustable speed, frequency, and brightness
- Works offline after first load
- 25 languages supported
- Fullscreen mode with floating controls
Demo: https://dynamicscreen.online
Would love feedback from the HN community – especially on what features or effects would be most useful for your use cases.

value: Show HN: DynamicScreen – Free dynamic screen tool for streaming and focus


value:
Built this RSS aggregator based on the 2025 HN Popularity Contest rankings by Refactoring English [1]. If there's interest in other slices (top 10, top 200, etc.), happy to add them.
[1] https://news.ycombinator.com/item?id=46478377

value: Show HN: One RSS Feed for the Most Popular HN Bloggers (2025 Rankings)


value:
I built this because with AI-assisted coding I spend much more time reading unfamiliar code than writing it.
The main friction was comments written in a non-native language: using external translators breaks focus, and many editor tools translate whole lines or buffers rather than actual comments.
This plugin uses Tree-sitter to detect comment nodes precisely and translates them inline on hover, so code reading stays uninterrupted.

value: Show HN: Inline comment translation in Neovim for faster code reading


value:
Yooo!
Papercuts lets you deploy AI agents that flow through your production app like a real user. Just provide a URL and get notified when something breaks.
Modern apps are way too complex for brittle selectors. Honestly, I think the only way to feel safe is to test in production with AI agents that actually perceive and navigate like a human.

value: Show HN: Test in Production with AI Agents


value:
Reddit's API is effectively dead for archival. Third-party apps are gone. Reddit has threatened to cut off access to the Pushshift dataset multiple times. But 3.28TB of Reddit history exists as a torrent right now, and I built a tool to turn it into something you can browse on your own hardware.
The key point: This doesn't touch Reddit's servers. Ever. Download the Pushshift dataset, run my tool locally, get a fully browsable archive. Works on an air-gapped machine. Works on a Raspberry Pi serving your LAN. Works on a USB drive you hand to someone.
What it does: Takes compressed data dumps from Reddit (.zst), Voat (SQL), and Ruqqus (.7z) and generates static HTML. No JavaScript, no external requests, no tracking. Open index.html and browse. Want search? Run the optional Docker stack with PostgreSQL – still entirely on your machine.
API & AI Integration: Full REST API with 30+ endpoints – posts, comments, users, subreddits, full-text search, aggregations. Also ships with an MCP server (29 tools) so you can query your archive directly from AI tools.
Self-hosting options:
 - USB drive / local folder (just open the HTML files)
 - Home server on your LAN
 - Tor hidden service (2 commands, no port forwarding needed)
 - VPS with HTTPS
 - GitHub Pages for small archives
Why this matters: Once you have the data, you own it. No API keys, no rate limits, no ToS changes can take it away.
Scale: Tens of millions of posts per instance. PostgreSQL backend keeps memory constant regardless of dataset size. For the full 2.38B post dataset, run multiple instances by topic.
How I built it: Python, PostgreSQL, Jinja2 templates, Docker. Used Claude Code throughout as an experiment in AI-assisted development. Learned that the workflow is "trust but verify" – it accelerates the boring parts but you still own the architecture.
Live demo: https://online-archives.github.io/redd-archiver-example/
GitHub: https://github.com/19-84/redd-archiver (Public Domain)
Pushshift torrent: https://academictorrents.com/details/1614740ac8c94505e4ecb9d...

value: Show HN: Self-host Reddit – 2.38B posts, works offline, yours forever


value: hankwilliamsjr

value:
I recently found that tools like firecrawl aren’t economical to run at scale to extract structured content or track content changes.
I needed to extract data at scale, and LLM markdown wasn’t useful and destroyed my RAG retrieval metrics.
With this, I build meter for structured data extraction and change detection to keep scraped data in sync.
Free beta - live demo on the site without logging in

value: Show HN: Meter – web scraper that syncs changes & bypasses antibot

author: hankwilliamsjr


value: orzmar

value:
I built this after watching a client site lose most of its organic traffic because someone left a <meta name="robots" content="noindex"> tag in the header component. It was there for two weeks before anyone noticed.
LintPage checks your staging URL for common SEO mistakes that block search engines:
- NOINDEX meta tags
- robots.txt with Disallow: /
- Missing or invalid SSL
- Broken internal links
- Missing title tags, meta descriptions, canonical URLs
- Basic accessibility issues (alt text, ARIA)
It's a simple fetch + parse with JSDOM on the server side. No browser automation, so it's fast.
Tech stack: Next.js 15, Supabase, deployed on Vercel.
I'm looking for feedback on:
1. What other checks would be useful?
2. Anyone have horror stories about staging configs making it to production?
https://lintpage.com

value: Show HN: LintPage – Catches SEO issues on staging sites before you deploy

author: orzmar


value: HyperFoldUK

value:
I've been optimizing ternary operations for BitNet 1.58b and found significant overhead in the current implementation.
I wrote a dependency-free C kernel (sparse-ternary-fma) using 2-bit encoding and AVX-512 instructions.
Benchmarks on Intel Xeon (N=4096):
Throughput (Dense): 2.38x faster (8.21 GFLOPS vs 3.45 AVX2)
Throughput (Sparse 80% zeros): 26.12x faster (23.25 GFLOPS vs 0.89 Scalar)
Memory: 4x denser (2-bit vs 8-bit standard)
This approach packs 4 trits per byte and leverages sparsity-aware FMA to skip zero-valued weights, which is critical for 1.58-bit quantization efficiency.
PR is pending on the Microsoft BitNet repo. Code is open source here:https://github.com/microsoft/BitNet/pull/365

value: Show HN: 26x speedup on BitNet sparse ops with AVX-512 and 2-bit encoding

author: HyperFoldUK


value: wordsunite

value: Show HN: WordsUnite – Synchronized Crowd Chants at Scale

author: wordsunite


value: travisr

value: A simple Typescript RSS client that saves feed items to the browser's local storage. It has a feature to export/import feed data to backup feeds and items or to change devices.

value: Show HN: RSS Reader using the browser's local storage

author: travisr


value:
I built this because I kept running Claude Code, going to the gym,
and not being able to see if it finished or tell it what to do next.
term.stream lets you run `tstream` and get a shareable URL instantly.
Open it on your phone, another laptop, anywhere. View-only by default,
control access with a token.
No SSH keys, no tmux, no port forwarding. Just a link.
Built with Rust (daemon + relay) and a simple web client.

value: Show HN: Term.stream – Stream your terminal to any device via URL


value: jumagrande

value:
Hi HN!
I’m the creator of Gridfy. I built it because I was frustrated with what I call the "No-Code Tax."
Whenever I wanted to publish structured data from Airtable or Notion, I felt trapped between two bad options: spending hours writing custom frontend code, or paying for expensive subscriptions like Softr or Airtable’s premium embeds. Most of these platforms get pricey fast and the customization is often too limited to match a professional brand.
I wanted something in the middle: the speed of no-code but with the flexibility of a custom component. With Gridfy, you connect your data source and get a performant, embeddable widget with search and filtering that actually looks like part of your site.
Key points for fellow builders:
- Customization: Fully tweakable via CSS variables to avoid that "generic widget" look.
- Performance: Lightweight script optimized for Core Web Vitals (no slow-loading blocks).
- Efficiency: Designed for indie hackers who need professional results without the enterprise price tag.
The builder is ready to use so you can see exactly how your data looks. It does require a signup to save your work, but you can get a widget live in under 2 minutes.
I’m curious: Have you felt limited by the pricing or design of current no-code tools? What’s the one feature that would make you switch your current stack to something like this?
Would love to hear your thoughts!

value: Show HN: I built Gridfy – live website widgets from Airtable, Notion and Sheets

author: jumagrande


value: stellarcat

value: Show HN: Zero to One but it's a game

author: stellarcat

title: Show HN: Zero to One but it's a game


value: Show HN: Chains – Word association puzzles that form a loop


value: vishalds

value:
A lot of teams are hesitant to adopt AI customer service bots due to their inauthenticity in replies, hallucination, etc. As a result, they're not able to leverage the speed of LLM's to reduce their customer turnaround time. So instead of replying to the customer directly, Hivinq drafts responses for the customer support team using it's knowledge about the product. If the drafted answers are inaccurate, team members can let it know and it will observe the thread to learn and correct itself.
Please upvote on Product Hunt: https://www.producthunt.com/products/hivinq
Demo video: https://www.loom.com/share/c91ae70326f14cf48b390503f21eb9e7

value: Show HN: Hivinq – Copilot for customer support teams

author: vishalds


value:
I’ve been working on Verdic Guard, a validation layer for production LLM systems where prompts, filters, and monitoring aren’t enough.
In many real deployments (fintech, enterprise workflows, agentic systems), the failure mode isn’t latency or cost — it’s hallucinations that sound confident and pass surface checks. Prompt engineering helps, but it doesn’t scale once systems grow long-running, tool-using, or multi-agent.
Verdic takes a different approach:
Define an explicit intent + scope contract for what the model is allowed to output
Validate LLM outputs before execution, not just inputs
Block or flag responses that drift semantically, contextually, or domain-wise
Keep enforcement deterministic and auditable (not “best effort” prompts)
It’s designed to sit between the LLM and your application, acting as a guardrail rather than another model.
This is still early, and I’m especially interested in feedback on:
Where this breaks down in real systems
How teams currently handle hallucinations beyond prompts
Whether deterministic enforcement is useful or too restrictive in practice
Site: https://www.verdic.dev
Happy to answer questions or share implementation details if useful.

value: Show HN: Verdic Guard – Deterministic guardrails to prevent LLM hallucinations


value:
Hi HN,
I built a lightweight market intelligence layer for Kalshi prediction markets.
Instead of scraping pages, it intercepts Kalshi’s APIs to track:
 • Stateful volume trends (rising / falling)
 • Liquidity depth
 • Basic sentiment signals
It also includes a BYOK AI adapter so users can generate short trader briefs using their own LLM key (ChatGPT, Claude, Gemini, etc.). Designed to run on very low resources (fits Apify’s 1GB free tier).
I built this as part of the Apify $1M Challenge and would love feedback from people interested in prediction markets, market microstructure, or quant-style tooling.

value: Show HN: Kalshi Market Intelligence and AI Signal Analyst


value: smahendrakar

value:
We started building Aristotle after noticing a pattern with a lot of AI tools: they’re great at replacing work, but not always great at helping people grow, especially when it comes to reading and learning.
With reading in particular, so many tools optimize for shortcuts: summaries, takeaways, skipping the hard parts. We wanted to explore a different direction: how AI could make reading more engaging, accessible, and enjoyable without replacing the experience itself.
Aristotle is an in-browser e-reader that supports PDFs + EPUBs, with features like spoiler-free chat, quick explanations, contextual insights, AI-generated illustrations, and speed reading tools to help readers stay immersed and get more out of what they’re reading.
Check it out at: www.aristotlereader.com

value: Show HN: Aristotle, an AI-powered e-reader that helps you read deeper

author: smahendrakar


value: PlagiarismRem

value:
We publish a lot of AI-assisted content.
Manual rewrites were killing productivity.
This is the workflow we ended up with:
1. Draft with AI
2. Structural normalization
3. Semantic preservation pass
4. Final human skim
It reduced rewrite time by ~80%.

value: Show HN: A workflow for publishing AI-assisted content without manual rewrites

author: PlagiarismRem


title: Show HN: Verdic Guard – Deterministic guardrails to prevent LLM hallucinations


value: zacksiri

value:
Hi HN
Memovee is an agentic movie database that lets you explore movies using natural language instead of filters or rigid queries.
You can ask things like:
- “Movies that take place in someone’s mind”
- “Top mystery films on Netflix released in the last 5 years”
- “Slow-burn sci-fi movies with strong world-building”
Under the hood, this isn’t just an LLM wrapper. Memovee uses a structured movie database and an agent layer that translates natural-language intent into deterministic queries and aggregations, then reflects on the results before responding.
The agent implementation used by Memovee is open source:
 https://github.com/upmaru/memovee-tama
This repository shows how intent parsing, query planning, execution, and result refinement are handled step-by-step, rather than relying on opaque prompt chains.
The core engine itself is not open-sourced yet. Memovee is one concrete application built on top of a more general engine whose goal is to make it possible to build systems like this for any enterprise domain — not just movies.
Engine project:
 https://kritama.com
This is still early and focused purely on movies (not TV yet). Coverage and regional availability vary, and there’s a lot left to improve — especially around reasoning depth, evals, and edge cases.
Happy to answer questions about:
- The agent architecture
- How natural-language intent is mapped to structured data
- Agentic vs deterministic tradeoffs
- The path toward a reusable enterprise engine
Looking forward to feedback — especially critical ones.

value: Show HN: Memovee – An agentic movie database

author: zacksiri


value: Show HN: EOS-Energy Optimization System by Nexura


value: uwemaurer

value:
I developed SQG because I had to access a SQLite and a DuckDB database from Java and from Typescript and was unhappy about maintaining the DB access code twice.
Also for larger analytics queries (DuckDB) it was annoying to copy the query out of the code into DBeaver, work on it and then copy it back into the code.
So I thought of a way of keeping the SQL queries in a separate file, compatible in DBeaver format so I can run them there, and also generate the code from it.
This works especially well with DuckDB since it has full type information of the query result, better than SQLite which has it only for fields, not for expressions.
For DuckDB it can also generate code using their Apache Arrow API for very fast access.
I hope you find it useful, I am glad to hear your feedback.
GitHub: https://github.com/sqg-dev/sqg
Docs: https://sqg.dev
Try it online: https://sqg.dev/playground/

value: Show HN: SQG – Compile SQL (SQLite,DuckDB) to TypeScript/Java Code

author: uwemaurer


value: yol

value:
Hi HN,
I'm Bryan. I built an open-source project for debugging your AI applications interactively through a web UI with just a few lines of setup.
You can require user input mid-execution, pause/resume, and look at traces in real time.
Here's a demo of how debugging looks like: https://www.loom.com/share/6d419cfe20884b3994121697377b2a7e
Here's how to setup:
- Start local debug server
`pip install pixie-sdk && pixie`
- Link application to Pixie
```python
# register entry point function or generator
@pixie.app
async def my_agent(query):
    results = await search(query)<p><pre><code>    # Pauses here, prompts for input in web UI
    selection = yield pixie.InputRequired(int)

    return await summarize(results[selection])</code></pre>
```
- Open gopixie.ai to debug
Would this save you time? Would love to hear your thoughts!

value: Show HN: Debug your AI application in web browser

author: yol


value: mcone

value: Show HN: JotBird – publish Markdown documents with shareable URLs

author: mcone


value: msrmdhcc

value: I have a problem with nvidia-smi in Windows, its just so hard to make it realtime, so i build myself. What should i improve? considering this is my first time making a python project.

value: Show HN: NVMI – Open-Source – lightweight real-time Nvidia GPU monitor in Python

author: msrmdhcc


value: Show HN: I made a private ad-free alternative to WeTransfer


value:
Hi HN,
In most codebases I’ve worked on, temporary hacks (“TODO: remove later”, “just for this release”) slowly become permanent. Nobody remembers why they exist, but they keep shipping to production.
I built a small CLI called DebtBomb to make that explicit.
Instead of free-form TODOs, you attach an expiry date to temporary code. When the date passes, CI fails until the code is removed or the expiry is intentionally extended.
Recently I added integrations so expired debt bombs don’t just fail CI — they become visible and owned:
When a debt bomb expires, DebtBomb can automatically create a Jira ticket with file path, owner, reason, and code snippet.
It can also notify Slack, Discord, or Microsoft Teams.
You can configure “expiring soon” warnings (e.g., 7 days before) so it’s not just a surprise break.
Repo: https://github.com/jobin-404/debtbomb
This is still early and I’m mainly trying to validate whether this actually improves how teams handle “temporary” code compared to TODOs, linters, or just creating tickets manually.
I’d especially love feedback from people who’ve dealt with tech debt in long-lived codebases or CI-heavy environments.
Thanks for reading.

value: Show HN: DebtBomb – Make TODOs expire and automatically create Jira tickets


value: maurizzzio

value:
I use the Comprehensible Input method (based on Stephen Krashen's work on Language Acquisition and Comprehensible Input: https://www.youtube.com/watch?v=fnUc_W3xE1w) to learn languages in my free time. I often watch YouTube videos in my target language with subtitles.
This practice led me to wish for a feature that would automatically pause a video at the end of each subtitle. This pause would provide me with time to:
- Process what I just saw and heard.
- Mine words using Yomitan, if necessary.
- Replay the segment to shadow the speaker, ideally triggered through a keyboard shortcut.
- Analyze the sentence structure for deeper insight on complex grammar and cultural nuances.
- Translate the entire sentence in a language I know, if necessary.
To enhance my language learning experience I developed a Chrome Extension called "Subtitle Insights". This extension leverages Chrome's Built-In AI (specifically Gemini Nano) to perform on-device translations and analysis of YouTube subtitles.
Key features:
- On-Device AI Processing. Once Gemini Nano is downloaded by Chrome, all subtitle translations and language insights are processed locally using Chrome's integrated AI capabilities.
- The prompt is customizable and the output can be tailored to match your preferences. If you're learning multiple languages at a time you can create profiles for each one.
- The auto-pause feature pauses the video just before a subtitle segment ends and gives you time to fully process the spoken content.
- The sidebar displays all subtitles and can be used as a video navigation tool. You can jump to any subtitle with a simple click.
- Keyboard shortcuts allow for quick navigation between subtitle segments and easy replay of the current segment.
You can bring your own subtitles and if they're not synced with the audio you can use the extension to sync the audio with the subtitles easily.
It's free. No account / API keys needed. The Gemini Nano model runs on-device thanks to Chrome's Built-in AI.

value: Show HN: Subtitle Insights – Language Learning via YouTube with On-Device Gemini

author: maurizzzio


value: DmitryBochkarev

value:
Hi HN,
I built tsrun, a minimal TypeScript runtime designed for embedding. It runs JavaScript and TypeScript seamlessly. The main use case is config files where you want IDE autocompletion and type checking.
Features:
- Full TypeScript: enums, interfaces, decorators, generics, namespaces
- ES modules, async/await, classes, generators, destructuring
- Embed via C API or WASM (browsers, Node, Go/wazero)
Backstory:
This is a side project of a side project of a side project. Started as an engine for transformation logic in a CLI tool I was building, where I wanted rich autocompletion in the editor. Somehow the interpreter became the main thing.
You can play with it on wasm playground https://tsrun.org/playground/

value: Show HN: Tsrun – A TypeScript runtime for embedding in native and WASM apps

author: DmitryBochkarev


value: drskyle

value:
Hi HN,
I’ve built an open-source CLI tool that identifies wasted cloud resources (AWS) , CLoudSlash , and, more importantly, it helps you delete them without the fear of breaking production.
The Problem:
Most "cloud cost" tools give you a CSV of "unused" resources. But deleting them is terrifying. Is that unattached EBS volume actually a production database backup? Is that idle NAT Gateway the only route for a silent legacy lambda?
I realized that detection is easy, but safe remediation is an unsolved distributed systems problem.
The Solution:
CloudSlash builds an in-memory Directed Acyclic Graph (DAG) of your infrastructure to understand dependencies, not just utilization metrics. It effectively treats your infrastructure as a graph traversal problem.
Key Technical Features:
1. The "Lazarus Protocol" (Infrastructure Undo Button):
   If you choose to delete a resource (e.g., a Security Group), CloudSlash doesn’t just make the API call. It first:
- Snapshots the live configuration.
- Generates a restore.tf file with the HCL definition.
- Generates a precise terraform import command.
If you make a mistake, you can resurrect the resource and bridge it back into your Terraform state in seconds. It turns "destructive" operations into reversible transactions.
2. Graph-Based Forensic Engine:
   Instead of simple rules ("CPU < 5%"), it builds a dependency graph.
- Example: It won't flag a NAT Gateway as waste—even if it has 0 bytes of traffic—if it detects an active Route Table creating a "FlowsTo" edge targeting it.
- The engine is written in Go, using custom string interning and contiguous memory layouts for the graph nodes to handle large enterprise accounts (10k+ resources) without GC thrashing.
3. Bin Packing, Not Just "Right-Sizing":
   For compute optimization, it uses a 2D Bin Packing algorithm (Best Fit Decreasing) to simulate how your current pods/workloads would fit into modern instance types. It visualizes the "fragmentation" of your clusters rather than just looking at average CPU usage.
Why Use This?
- Locally Run: No SaaS, no API keys leaving your machine.
- Heuristics Catalog: All detection logic is open source. You can see exactly why an RDS instance was flagged (e.g., Connections == 0 for 7 days AND SnapshotCreated == true).
- TUI: It includes a terminal UI (using Bubble Tea) for interactive graph exploration.
Repo: https://github.com/DrSkyle/CloudSlash
I’m eager for feedback on the graph traversal logic and the "Lazarus" restoration flow.
:) DrSkyle

value: Show HN: CloudSlash – Graph-based AWS cleaner with Terraform undo

author: drskyle


value: sinned

value:
Hi HN — I built Microwave, a native iOS app for browsing and posting short-form videos, similar to TikTok, but implemented as a pure client on top of Bluesky / AT Protocol.
There’s no custom backend: the app reads from and publishes to existing ATproto infrastructure. The goal was to explore whether a TikTok-like experience can exist as a thin client over an open social protocol, rather than a vertically integrated platform.
Things I’d especially love feedback on:

  - Whether this kind of UX makes sense on top of ATproto

  - Client-only tradeoffs (ranking, discovery, moderation)

  - Protocol limitations I may be missing

  - Any architectural red flags

TestFlight: https://testflight.apple.com/join/cVxV1W3g

value: Show HN: Microwave – Native iOS app for videos on ATproto

author: sinned


value: Show HN: ModernPentest – Continuous automated pentesting for web apps and APIs


value: MKuykendall

value: I got tired of needing llama.cpp bindings or separate tokenizer.json files just to tokenize text, so I wrote a pure Rust library that reads the tokenizer directly from your GGUF model file, the same output as llama.cpp, zero C++ in the dependency tree.

value: Show HN: Shimmytok – Pure Rust GGUF tokenizer (no C++, no extra files)

author: MKuykendall


value: revetkn

value:
Hi, I built the first version of Soklet back in 2015 as a way to move away from what I saw as the complexity and "magic" of Spring (it had become the J2EE creature it sought to replace).  I have been refining it over the years and have just released version 2.0.0, which embraces modern Java development practices.
Check it out here: https://www.soklet.com
I was looking for something that captured the spirit of projects like Express (Node), Flask (Python), and Sinatra (Ruby) but had the power of a "real" framework and nothing else quite fit: Spark/Javalin are too bare-bones, Quarkus/Micronaut/Helidon/Spring Boot/etc. have lots of dependencies, moving parts, and/or programming styles I don't particularly like (e.g. reactive).
What I wanted to do was make building a web system almost as easy as a "hello world" app without compromising functionality and I feel I have accomplished this goal.
Other goals - support for Server-Sent Events, which are table-stakes now in 2026 and "native" integration testing (just run instances of your app in a Simulator) are best-in-class in my opinion.  Servlet integration is also available if you can't yet fully disentangle yourself from that world.
If you're interested in Soklet, you might like some of its zero-dependency sister projects:
Pyranid, a modern JDBC interface that embraces SQL: https://www.pyranid.com
Lokalized, which enables natural-sounding translations (i18n) via an expression language: https://www.lokalized.com
I think Java is going to become a bigger player in the LLM space (virtual threads now, forthcoming Vector API/Project Panama/etc.) If you're building agentic systems (or just need a simple REST API), Soklet may be a good fit for you.

value: Show HN: Soklet, a zero-dependency Java HTTP/1.1 and SSE virtual-threaded server

author: revetkn


value: mfdupuis

value:
Hey HN!
Today we’re launching Fabi 2.0
For the past year we’ve been working with a number of product, eng, marketing and data teams, and the common issue we’ve been seeing with all these teams, especially small and growing teams, is that getting basic answers from their data requires jumping between a bunch of different tools/copy-pasting data and spreadsheets, or building out a full BI stack.
With our latest release, users can not only connect Fabi to databases and data warehouses, but also to applications like HubSpot, Stripe, Shopify etc. We offer hundreds of connectors, and the AI makes it dead simple to start immediately building out analyses or dashboards.
A bit about what’s going on under the hood:
- We use Fivetran to connects to data sources (we tested at a number of different ETL solutions and Fivetran really stood out)
- We pipe the data into a MotherDuck instance for each customer
- We index data and metadata and store in our vector DB to get it ready for the AI. A lot of connectors just work without any further modeling, but some do require a bit of extra modeling. For those we automatically spin up dbt models to do some data wrangling under the hood
- We offer an extra AI config layer for users to provide any additional context about their business and data source which they can write in plain English, which we’ve found to be really important to make it accessible to a wide set of teams
Once the data is ready, you can start talking to it to analyze it like you could before in Fabi with any traditional SQL DB.
You can give it a try here: [https://app.fabi.ai/](https://app.fabi.ai/home)

value: Show HN: Fabi 2.0 – An AI analyst that connects to all your data sources

author: mfdupuis


value: fabsalvadori

value: Show HN: Pic-Standard – Open Protocol for Agentic AI Safety

author: fabsalvadori


value: jeswin

value:
You can see some examples here: https://github.com/tsoniclang/proof-is-in-the-pudding
And a hugo clone (which compiles to native code) here: https://github.com/tsoniclang/tsumo
Linux and macOS for now.

value: Show HN: The Tsonic Programming Language

author: jeswin


value:
I kept making watch lists but rarely watching anything and I spent more time browsing than watching. After stepping away from streaming services for a bit, I realized I missed having a TV schedule.
So, I built this to help me decide what I’m watching ahead of time by auto-scheduling episodes or movies into time slots. So far, it’s worked better than a watchlist. I actually look forward to watching things now.
This is a working early version. I’d love feedback on the UX/UI, how easy it is to use, any criticism, and whether this approach holds up for other people.
NOTE: It is free to use for 7 days and there are no ads.

value: Show HN: I built an auto-scheduler to help me decide what I'm watching


value: gossa

value:
I built The Kitchen Table because I kept trying to journal and always quitting. Writing started to feel like a task with expectations, and when I stopped, I felt worse about stopping. What I actually wanted wasn’t "self-improvement" or structure. I just wanted a place to put thoughts down without feeling like I was doing it wrong.
The idea comes from a simple memory, coming home, dropping my bag, and talking at the kitchen table. No fixing, no goals, just being able to say things out loud and feel listened to. I tried to recreate that feeling digitally.
The app lets you sit down, pick how you’re feeling, and respond to gentle prompts. You can save moments you want to keep and look back on them later. Everything is private and encrypted. There are no streaks, reminders, feeds or social features.
This is still early and mostly a learning project for me. I’d really appreciate feedback on the experience, what feels off, and what feels unnecessary.

value: Show HN: The Kitchen Table – a quiet space to unload your thoughts

author: gossa


value: Show HN: Agent-overseer: manage your army of coding agents in the browser


value:
Hello HN,
I built Titan, a distributed orchestrator, to explore the core primitives of distributed systems (scheduling, concurrency, failure detection, and IPC) without the complexity of Kubernetes or the overhead of HTTP.
I originally built it for my home-lab to orchestrate a mix of long-running services and batch jobs. Static schedulers worked at first, but as workflows grew more complex, I needed the system to adapt its execution plan based on runtime data, not just follow a predefined DAG.
This led me to evolve Titan from a hybrid scheduler into a runtime where execution graphs can be constructed or modified dynamically. It still supports static YAML DAGs, but now exposes a Python SDK that allows user code to:
Construct dynamic DAGs programmatically
Branch or loop execution based on live signals
Spawn new tasks/infrastructure in response to failures (Agentic patterns)
The core engine is written in Java 17 using raw TCP sockets and a custom binary protocol (no HTTP, no external DB, around 90KB JAR). Workers use push-based discovery and application-level auto-scaling by spawning ephemeral JVM processes when saturated.
This is a research project (no Raft or mTLS yet), but building it from first principles was interesting. I later realized I had independently converged on patterns similar to Nomad (scheduling) and Temporal (workflow semantics).
I’d love feedback on the architecture, specifically:
Runtime graph mutation as a scheduling primitive
Push-based worker discovery (vs standard pulling)
Tradeoffs of application-level scaling vs centralized autoscalers.

value: Show HN: Titan – a distributed orchestrator with dynamically mutable DAGs


value:
Hi HN —
I’m sharing an empirical, long-term dataset from a DIY energy-storage project that ended up testing a common assumption in battery design.
Conventional advice says never mix battery brands. That guidance is well-founded for series strings, but there’s surprisingly little data on purely parallel configurations.
I built a 12 V, 500 Ah LiFePO₄ battery bank (1S5P) using mixed-brand cells and instrumented it for continuous monitoring over 73+ days, including high-frequency voltage sampling. The goal was to see whether cell-level differences actually manifest over time in a parallel topology.
What the data shows
No progressive voltage divergence across the observation period
Voltage spread remained within ~10–15 mV
Measured Peukert exponent ≈ 1.00
Thermal effects were small relative to instrumentation noise
In practice, the parallel architecture appears to force electrical convergence when interconnect resistance is low. I’ve been referring to this as “architectural immunity” — the idea that topology can dominate cell-level mismatch under specific conditions.
This is not a recommendation to mix batteries casually, and it’s not a safety guarantee. It’s an attempt to replace folklore with measurements and to define the boundary conditions where this does or does not hold.
Everything is public:
Raw CSV data
Analysis scripts
Full PDF report
Replication protocol
Repo:
https://github.com/wkcollis1-eng/Lifepo4-Battery-Banks
I’m posting this to invite critique — especially around failure modes, instrumentation limits, or cases where this model would break down (e.g., higher C-rates, aging asymmetry, thermal gradients, different chemistries).
Happy to answer technical questions.

value: Show HN: Data from a mixed-brand LiFePO₄ battery bank


value: Aydarbek

value:
Hi HN,
I built Ayder — a single-binary, HTTP-native durable event log written in C.
The wedge is simple: curl is the client (no JVM, no ZooKeeper, no thick client libs).
There’s a 2-minute demo that starts with an unclean SIGKILL, then restarts and
verifies offsets + data are still there.
Numbers (3-node Raft, real network, sync-majority writes, 64B payload):
~50K msg/s sustained (wrk2 @ 50K req/s), client P99 ~3.46ms.
Crash recovery after SIGKILL is ~40–50s with ~8M offsets.
Repo link has the video, benchmarks, and quick start.
I’m looking for a few early design partners (any event ingestion/streaming workload).

value: Show HN: Ayder – HTTP-native durable event log written in C (curl as client)

author: Aydarbek


value: Show HN: PromptStack – Full-stack apps with just text files, Claude Code runtime


value: Renjit

value:
I grew up playing simple games like Pac-Man, Prince of Persia, and Doom.
Those games were intuitive, hard to put down, and taught mechanics through play rather than instruction.
Years later, while working on AI transformation projects for small businesses, I kept running into the same issue.
AI concepts are usually explained through slides, frameworks, and jargon.
Most owners disengage before understanding how these ideas apply to their business.
I decided to experiment with a different approach.
I built a small browser-based game that introduces basic AI transformation concepts through short levels and simple decisions.
Each level maps to a real-world idea.
Examples include process automation, data readiness, and incremental adoption rather than big-bang AI projects.
The mechanics are intentionally simple and do not require prior AI knowledge.
The game was built using Google AI Studio powered by Gemini and deployed on Google Cloud.
It runs in the browser and does not require signup.
As an experiment, the game also issues vouchers as players complete levels.
Those vouchers can be redeemed later for AI transformation work, but the game can be played purely for learning or curiosity.
This is an early version.
The goal is feedback, not polish.
Things I am especially interested in hearing about:
– Whether the concepts are understandable without explanation
– Where the game feels confusing or boring
– Whether gameplay actually helps comprehension
– Ideas for improving the learning flow
You can try it on the link: https://aiquest.futureu.co/

value: Show HN: Simple browser game to teach AI transformation concepts to small biz

author: Renjit


value: pomarie

value:
Hey HN, I'm Paul, the founder of cubic.dev, an AI code reviewer for complex codebases.
Over the past few months we’ve completely rebuilt our detection engine, and I wanted to share a few things we did to get more out of LLMs.
Context: cubic specializes in code reviews for teams with complex codebases, like Better Auth, Cal.com, and PostHog. Our users have high standards. It’s important that reviews have real depth and actually understand the codebase.
In the past, we've sometimes struggled with producing reviews that had deep insight into complex changes. It didn't feel like we were leaving comments that truly understood both the codebase and the intent behind the PR. If we pushed reasoning to the max, it could get there, but it would take ages, often 15+ minutes for a review, which many people disliked.
We've spent the last few months rebuilding our AI review engine from scratch, and we've completely redone how the reviewer works, bit by bit.
Like the Ship of Theseus, cubic ended up so different (and better) that we're releasing it as cubic 2.0.
I should say up front: I’m biased because I work on this, and part of the point is awareness. But the main reason I’m posting is that the work feels broadly useful if you’re building anything LLM-based where you need both quality and speed.
*Why this is a "2.0"*
We were optimizing for two things:
1. Higher signal reviews (comments people actually act on)
2. Lower latency
Quality: 3 months ago, about 20% of comments that cubic left would be addressed by a developer. We measure this by having an LLM look at commits after a cubic comment and judge whether the change implemented what cubic flagged. Today that number is 60%+. For some teams it’s over 90%.
Speed: median time to review a PR was roughly halved; P90 divided by 3.
*What we changed (the parts that mattered)*
1. Pre-mapping the codebase ("AI wiki")
A big inefficiency in LLM code review (and code writing) is that every PR forces the model to rebuild a mental map of the repo from scratch. In large repos, just figuring out "where am I" can consume a lot of context and tokens before you even get to reasoning about the diff.
We built an "AI wiki" that pre-maps the important parts of a codebase and reuses that as context for reviews.
As a side effect, the wiki is also useful to humans (and AIs through an MCP), especially for onboarding or for non-technical people trying to understand a system. Example Firecrawl: https://www.cubic.dev/wikis/firecrawl/firecrawl
2. External context tools, plus getting tool usage under control
We added tools to fetch external documentation when needed. The hard part was not adding the tool, it was getting the model to use it correctly. This took a lot of prompt iteration and guardrails, and it ended up being more important than we expected.
3. Learning loop, with more weight on senior reviewers
We leaned harder into learning from user interactions and feedback. One change that helped a lot recently was identifying the senior reviewers in an org and weighting their feedback more heavily. In practice, that made the system converge faster toward what "good" looks like for that team.
4. Sandbox snapshotting for large repos
On larger repos, we were wasting minutes on setup work (clone time, environment prep), and we were doing it for every PR. We added a snapshotting approach that cut a lot of that overhead.
Anyway, thanks for reading. Happy to answer questions about any of the above. I’d also love feedback from people who’ve tried AI code review tools:
* What made you keep them, or turn them off?
* What metrics would you trust to measure "review quality"?
* Where do current tools fail in ways that are genuinely harmful?
cubic is here (and free for public repos): https://cubic.dev/home

value: Show HN: cubic 2.0 – improving our AI code reviewer (3x more accurate,2x faster)

author: pomarie


value: spookyuser

value: Show HN: Pick a point on Earth and see the last/next total solar eclipse there

author: spookyuser


value: JAnicaTZ

value:
A recursive logic-tree engine for first-order logic, originally built in 2002 as part of a mathematical logic diploma project.
It uses explicit AST/NNF decomposition with De Morgan transformations and a GUI for step-by-step, explainable (XAI-style) reasoning.
Includes propositional logic, CNF/DNF minimization, and FOL proof search.
Source code: https://github.com/JAnicaTZ/TreeOfKnowledge

value: Show HN: XAI-style recursive FOL logic tree engine with GUI (2002)

author: JAnicaTZ


value: aspectrr

value:
Hey HN,
My name is Collin and I built fluid.sh because I wanted AI agents to work on my infrastructure safely and give the boost that Claude Code has given to me, to fellow Infra engineers.
I built this as I work with infrastructure a ton in an enterprise incumbent and wanted to let agents work on our infrastructure rather than suggest stuff.
The problem: We can give AI agents root access to codebases, but not to servers. One bad command on production and you're getting paged at 3 AM. So we limit agents while humans do the actual execution. We don't get the same feedback loops software engineers do.
The solution: Give the agent root access to an isolated VM instead. Let it work autonomously—provision servers, configure firewalls, set up services, deploy applications. Then diff the changes, review what it did, and approve an Ansible playbook to apply to production.
How it works:
1. Clone a golden VM image into an isolated KVM sandbox
2. Agent gets full root access and works autonomously
3. Snapshots checkpoint progress (rollback if needed)
4. Diff snapshots to see exactly what changed
5. Auto-generate Ansible playbook from the agent
6. Human reviews and approves (blocking workflow)
7. Playbook applies to production
Tech stack: Go + libvirt/KVM, React, Python SDK, PostgreSQL
Use cases:
- Autonomous server provisioning and configuration
- Self-healing infrastructure (agent diagnoses and fixes issues)
- Migration automation (agent figures out the steps)
- Compliance remediation
- On-call automation (agent triages and resolves alerts)
Why VMs instead of containers?
- Full OS isolation (not namespace isolation)
- Real networking stack for firewall/routing work
- Snapshot/restore is native to the hypervisor
- Agents can reboot, modify kernel params, install kernel modules
- Closer to production reality
GitHub: https://github.com/aspectrr/fluid.sh
Demo video: https://youtu.be/nAlqRMhZxP0
Happy to answer questions or feedback!

value: Show HN: Fluid.sh – Make Infrastructure Safe for AI

author: aspectrr


value: enaboapps

value:
Hi HN! I built Timberlogs because I was tired of console.log in production and existing logging solutions requiring too much setup.
Timberlogs is a drop-in structured logging library for TypeScript:

    npm install timberlogs-client

    import { createTimberlogs } from "timberlogs-client";

    const timber = createTimberlogs({
      source: "my-app",
      environment: "production",
      apiKey: process.env.TIMBER_API_KEY,
    });

    timber.info("User signed in", { userId: "123" });
    timber.error("Payment failed", error);

Features:
- Auto-batching with retries
- Automatic redaction of sensitive data (passwords, tokens)
- Full-text search across all your logs
- Real-time dashboard
- Flow tracking to link related logs
It's currently in beta and free to use. Would love feedback from the HN community.
Site: https://timberlogs.dev
Docs: https://docs.timberlogs.dev
npm: https://npmjs.com/package/timberlogs-client
GitHub: https://github.com/enaboapps/timberlogs-typescript-sdk

value: Show HN: Timberlogs – Drop-in structured logging for TypeScript

author: enaboapps


value: davelradindra

value: I built Nogic, a VSCode extension currently, because AI tools make code grow faster than developers can build a mental model by jumping between files. Exploring structure visually has been helping me onboard to unfamiliar codebases faster.<p>It’s early and rough, but usable. Would love feedback on whether this is useful and what relationships are most valuable to visualize.

value: Show HN: Nogic – VS Code extension that visualizes your codebase as a graph

author: davelradindra


value: night-slayer

value:
I built a TypeScript CLI for LeetCode that goes beyond basic problem fetching.
Key features:
Interview timer with difficulty-based defaults (Easy: 20min, Medium: 40min, Hard: 60min)
Solution snapshots to save/compare different approaches
Collaborative coding with room-based sessions
Workspaces for isolating contexts (interview prep, contests, daily practice)
Git sync for automatic solution backup
Visual debugging with ASCII visualization for arrays/trees
The goal was to stay in the terminal and practice under interview-like conditions.
GitHub: https://github.com/night-slayer18/leetcode-cli
Built with TypeScript, uses cookie-based auth (you paste session tokens from browser DevTools).

value: Show HN: LeetCode CLI – Interview timer, solution snapshots,collaborative coding

author: night-slayer


value: Nya-kundi

value: Show HN:A bounded work queue in C with explicit invariants

author: Nya-kundi


value: memalign

value:
Hi HN!
I created this web app (with PWA support) because the official Bluesky app lacks the one thing I want: to start me at the place I left off in the chronological timeline.
This is intended as a reader, not a full Bluesky client. I use it in conjunction with the Bluesky app or website. Tap the timestamp of a post to open it in Bluesky.
I’ve tried my best to display stable timeline updates that match what the Tweetie app pioneered so long ago: keeping your visual place in the timeline when refreshing. This was tricky to do in a web app… I wrote more about it here[0].
0: https://memalign.github.io/p/memsky.html

value: Show HN: MemSky: Bluesky timeline viewer web app that saves where you left off

author: memalign


value: oacikelli

value: The motivation for the project is to be able to deploy containerized workflows from GitHub to AWS with fully serverless infrastracture without worrying about CI/CD and be able to download the computed output to local machine with ease using a CLI tool.

value: Show HN: Serverless Compute Platform for AWS

author: oacikelli


value: janbalangue

value: Show HN: Async bulkhead for Java with explicit overload semantics (v0.3.0)

author: janbalangue