value: dongjiewu

value:
Hey HN,
I built this tool because my personal diagramming workflow was broken, and I wanted to automate it.
When creating diagrams, I have two conflicting needs. For logic and structure, I prefer Mermaid.js here. It’s deterministic, version-controllable, and lets me tweak the logic easily until it matches exactly what’s in my head. For aesthetics, I need the final result to look like a high-end infographic for presentations, which Mermaid (and standard tools) are bad at. Before Nanobanana Pro came out, AI image generation cannot generate good visual presentation for diagrams because it always messed up with characters/texts. Now Nanobanana makes everything possible.
My Solution (The Workflow): I built an app that combines Mermaid and Nanobanana into a pipeline:
Step 1 (Draft): I use a lightweight LLM to generate Mermaid syntax. I can edit this code manually to refine the logic until the structure is perfect.

    Step 2 (Render): Once the logic is locked, I pipe it into Gemini 3 Pro (Nano Banana).

Why this works: Unlike standard image generation, this workflow forces the AI to respect the "Logic Layer" from the Mermaid draft while applying the "Vision Layer" for aesthetics. It keeps the original information (text/nodes) accurate but renders it as a professional infographic.
The "Logic" mode is free forever. I charge credits for the "Vision" mode because the Gemini 3 API costs are significant.
Link: https://diagram-generator.com
Feedback on the text legibility in the rendered images would be appreciated!

value: Show HN: I built a dual-engine diagram app to fix my own workflow

author: dongjiewu


value: teimurjan

value:
Hi there,
We've built an avatar library that renders native SVG (not canvas), so it actually works with SSR frameworks.
I've trained some CNN models in Python on CelebA and FairFace to predict hair color, skin tone, etc. from photos, then converted them to TensorFlow.js. Models are ~2MB each, run entirely client-side.
Also ended up building Rsbuild plugins for SVG -> Svelte/Vue conversion because existing tools caused id/mask collisions when rendering multiple avatars.
https://avatune.dev https://github.com/avatune/avatune

value: Show HN: Avatune – SSR-friendly avatars with browser ML for attribute prediction

author: teimurjan


value: kiwicopple

value:
This is a small, framework-agnostic JavaScript/TypeScript client for the Apache Iceberg REST Catalog. It is good for managing the catalog (eg: managing tables), and it's MIT licensed.
The goals:
- Generic: Works with any Iceberg REST Catalog implementation, not tied to any specific vendor
- Minimal: Thin HTTP wrapper over the official REST API, no engine-specific logic
- Type-safe: First-class TypeScript support with strongly-typed request/response models
- Fetch-based: Uses native fetch API with support for custom implementations
- Universal: Targets Node 20+ and modern browsers (ES2020)
- Catalog-only: Focused on catalog operations at this stage
Although Iceberg is becoming very popular, we were surprised that the developer tooling is so nascent. This library is our contribution back to the ecosystem. The goal is to keep it minimal and well-maintained, so that developers can manage their warehouse from any JS server.
We are using it with AWS's new "S3 Tables". If it doesn't support other REST catalogs we'd welcome contributions

value: Show HN: Iceberg-JS, a TypeScript Client for the Apache Iceberg REST Catalog

author: kiwicopple


value: loderunnr

value: Show HN: Zod-file – TypeScript type-safe file persistence

author: loderunnr


value: mscarim

value: Show HN: AI-powered UX linter for web and mobile apps

author: mscarim


value: kevinbaur

value:
Hey HN.
I realized how much time and context teams lose when someone leaves a role. I joined a job once with basically zero onboarding because the person before me was already gone, and it took months to figure everything out.
So I built SkillPass, a tool that interviews people before they leave and turns their answers into a structured onboarding handbook for the next person.
No templates, no writing, no chaos.
Kevin

value: Show HN: I made a tool to fix chaotic handovers and slow onboarding

author: kevinbaur


value: DenisDolya

value: Hello HN! I'm developing ASCII Table Editor — a CLI utility in pure C for working with tables in the terminal. It's something between standard console tools and Excel, but without GUI. The utility supports creating, editing, saving and loading tables, storing them in nice ASCII files. Key feature: two modes — interactive menu for beginners and special syntax for quick table creation. Supports three languages: Ukrainian, English, Russian. Code is a single table.c file, compiles with any C compiler. In the future I plan to add Excel-like features: formulas, calculations, sorting, filtering, database connectivity to create a full-featured CLI table editor for terminal enthusiasts. Project on GitHub: https://github.com/Ferki-git-creator/table I welcome feedback, ideas, and contributions to development!

value: Show HN: Console table editor with special syntax for writing them

author: DenisDolya


value: Aldipower

value: Show HN: I produced a cassette with vintage hardware instruments

author: Aldipower


value: chrisaycock

value: Show HN: Proposal: Copy-and-Fuse Compilation

author: chrisaycock


value: lorey

value:
The Clearbit Logo API finally went down yesterday after the HubSpot acquisition. I relied on it across several projects (heavily), so I built a drop-in replacement:
https://logos.apistemic.com
Key features:
- Free to use, no signup or API key needed
- Both companies and domain names work as input identifiers
- WebP format for smaller payloads and better cache hit rates
Stack:
S3 for storage, heavily cached fastapi, Next.js for the site. Everything's behind Cloudflare for proper CDN/caching. This was the first time I tried to build something end-to-end from idea to deployment with Claude Code (Max) and I have to say, Opus 4.5 took it like a champ!
For the younger folks, here's what the old Clearbit API looked like:
https://web.archive.org/web/20230920164055/https://clearbit....
Happy to answer questions about the implementation or hear your thoughts!
Web: https://logos.apistemic.com
X: https://x.com/karllorey

value: Show HN: Free Logo API – logos for any company or domain

author: lorey


value: davidresilify

value:
I’ve spent 7 years in cloud engineering, and I’m tired of "reactive" FinOps tools (CloudHealth/Vantage) that only tell you about waste 30 days after the invoice hits.
I built Relia to be the "ESLint" for cloud costs. It parses Terraform plans locally and blocks PRs that exceed a budget.
Repo: https://github.com/davidahmann/relia_oss
How it works:
Parses .tf files or JSON plans (Cost estimation logic is in Python).
Maps resources to a bundled SQLite pricing database (works fully offline/air-gapped).
Fails the build if monthly_cost > budget (defined in .relia.yaml).
Why not Infracost? Infracost is great, but I wanted something purely offline and privacy-first. Relia doesn't require an API token, doesn't ping a SaaS, and has no "Enterprise" tier. It’s just a CLI tool you own.
It currently supports AWS (EC2, RDS, Lambda, NAT Gateways). I’d love feedback on the heuristic matching logic.

value: Show HN: Relia – Open-Source "ESLint" for AWS Costs (Python, Local-First)

author: davidresilify


value: Show HN: I built a voice task manager without AI using compromise.js


value: mcclowes

value:
Lea is a functional programming language where data flows left-to-right through pipes. I built it (heavily leveraging Claude, full disclosure) to explore what happens when you make pipelines first-class citizens with their own algebra.
let numbers = [1, 2, 3, 4, 5]
numbers
  /> filter((x) -> x > 2)
  /> map((x) -> x * x)
  /> reduce(0, (acc, x) -> acc + x)
  /> print  -- 50
A few features I like:
- The readability of the syntax
- Pipeline algebra – Pipelines are values you can inspect and manipulate:
- Reversible functions – Define forward and reverse transformations together:
- Reactive pipelines – Automatically recompute when source data changes:
- Compose pipelines
- Decorators for cross-cutting concerns
- VSCode extension with syntax highlighting
Try it out:
git clone https://github.com/mcclowes/lea.git
cd lea && npm install
npm run repl
It's just a pet project, but I'd love feedback on the language design, especially around the readability, direction of type enforcement, reversible functions and pipeline algebra. Are there other operations that would make sense for pipelines as a data type?

value: Show HN: Lea – A pipe-oriented functional language with reversible functions

author: mcclowes


value: unfavalen

value:
I kept running into the same issue whenever starting a new project: the setup phase consumed more time than the actual feature work. Preparing boilerplate, restructuring directories, performing refactors, resolving dependency conflicts, and wiring framework logic consistently took hours before I could write meaningful code. Even with modern tooling, the early-stage workload was nearly identical across projects.
To remove that bottleneck, I built Bleenk, an AI coding agent that operates directly on real repositories. Instead of generating isolated snippets, it performs multi-step modifications across the codebase. It creates branches, edits files, restructures modules, rewrites components, and prepares pull requests. The agent is designed to understand the full repository context, not just the last prompt.
Bleenk uses an isolated Vercel Sandbox environment to execute and validate generated code, ensuring changes run correctly before they ever reach a PR. It also includes Bleenk-Mini, a model optimized for repository-level reasoning, multi-file coordination, and incremental refactoring.
The result is that I can ship full-stack application features in minutes instead of hours. In internal use, tasks that previously required three to five hours of manual engineering now complete in under fifteen minutes with consistent diffs and minimal manual cleanup.
I am interested in technical feedback: which repository-level operations do you think an automated agent should prioritize, and what guardrails or review patterns are most important for safe code modification?

value: Show HN: I built an AI coding agent that ships real apps fast

author: unfavalen


value:
Felix here – founder at ADPList. ADPList is a mentorship platform where developers and designers can book 1:1 video sessions with experienced mentors for free, across topics like systems design, interviews, architecture reviews, and engineering management.
A few years ago, while working as an engineer and building products in a small team, it was surprisingly hard to get practical, unbiased advice from people who had “been there before”. Conference talks and blog posts were too generic, internal mentors were too busy, and paid coaching didn’t scale for early-career engineers or folks outside the US. Yet questions like “How do I design this service?”, “Is my promotion packet strong?” or “How do I move from IC to EM?” come up every week and often decide someone’s trajectory.
ADPList tries to solve this by making it trivial to talk to engineers who have already solved your problem. You browse mentors by stack, company, and topics (e.g. distributed systems, infra, security, data), see their calendars, and book a free session in a couple of clicks. Each session is a video call with notes, resources, and follow‑ups all in one place, so you don’t have to chase links or context across tools. Mentors include senior and staff engineers, EMs, and tech leads from companies like Workday, Swiggy, and others, many of whom run sessions specifically titled “Your career as a software engineer”.
Under the hood, most of the work has gone into scheduling and reliability. Time zones, rescheduling, and no‑shows are handled automatically, with reminders and calendar integrations so both sides actually show up. We’ve also focused on making discovery fast for engineers: instead of browsing marketing pages, you land on human profiles with tech stacks, years of experience, and availability, so you can get from “I need help with my backend design” to “I’m on a call with someone who’s built this before” in minutes. For mentors, there are tools to manage demand, set boundaries, and keep track of mentees over time, since many use ADPList as their main way to give back to the community.
What’s different from typical coaching platforms is that sessions are free for mentees and mentors opt in because they care about teaching and community, not hourly rates. That means quality can be uneven, so we’ve invested in public reviews, transparent profiles, and the ability to try multiple mentors until you find a good fit. The long‑term goal is a global, open mentorship graph where any engineer can find someone a few steps ahead of them, regardless of location or income.
Would love feedback from this community on:
What would make this more useful for you as an developers or EM (APIs, OSS hooks, company accounts)?
What data/controls you’d want if you brought ADPList into your team as an internal mentoring layer.
If you’re curious, you can explore mentors and book a session here: https://adplist.org/

value: Show HN: ADPList – free mentorship platform for developers and designers


value:
Hi HN!
I’ve been working on Casky, a tiny, high-performance, append-only key-value store written in C. It’s designed for simplicity, speed, and safety:
* In-memory index with persistent append-only log
* Support for snapshots and incremental backups
* TTL (time-to-live) for keys
* Compact operation to clean expired/deleted entries
* Thread-safe with optional locking
I built it to explore safe persistence patterns for embedded C applications, while keeping the codebase minimal and hackable.
Everything is open-source, and you can check it out here: https://github.com/thesp0nge/casky
I’d love feedback from the HN community—especially on:
* API design for snapshots & persistence
* Trade-offs in append-only logging vs. in-place updates
* Testing strategies for key-value stores in C
Thanks!

value: Show HN: Casky,append-only key-value store with snapshots and incremental backup


value:
I've been building B2B SaaS for 10 years and noticed the same loop: support asks "what's happening with customer X?", eng drops everything to check Grafana, pastes a screenshot in Slack.
Grafana and Datadog are great for devs, but you can't hand them to support (let alone customers).
DashFrog is open-source, customer-scoped observability. It sits on OpenTelemetry, but abstracts away the parts that make non-devs' eyes glaze over.
Two main concepts:
- Flows: Track logical operations across services, not technical spans
- Metrics: Instead of exposing gauges, counters and histograms in the UI, you just have rates, ratios and percentiles.
Lots of ideas (external data sources, helpdesk integrations, alerting, frontend sdk to embed in your app) but would love to hear what you'd want first.
GitHub: https://github.com/towlabs/dashfrog

value: Show HN: Dashfrog – Customer-scoped observability for B2B SaaS


value: zham-dev

value:
Hey HN,
I built Coached because I was tired of watching fitness coaches struggle with the same problem: spreadsheets everywhere. Programs in one doc, nutrition plans in another, check-ins scattered across emails and DMs, progress photos lost in text threads.
Coached brings it all together. Training programs, meal plans, check-ins, supplements, and client management in one place. Coaches get a proper toolkit, and their clients get a clean portal to view plans and submit progress updates.
A few things that make it different:
• Template-to-assignment workflow: Create a program or diet once, then assign customized versions to clients. No more copy-pasting and renaming files.
• Data-driven check-ins: Clients submit photos, metrics, and feedback. Coaches can compare check-ins side-by-side and see trends over time.
• Macro calculations built in: Add ingredients to a meal and watch calories, protein, carbs, and fats update automatically.
• Professional client experience: Clients get their own dashboard instead of digging through shared docs.
I'm a solo founder, so this has been a nights-and-weekends project for a while. Finally at the point where real coaches are using it and I'd love feedback from this community.
Would love to hear:
• What's unclear about the positioning?
• Any features you'd expect that seem missing?
• If you're a coach (or know one), does this solve a real pain point?
Thanks for taking a look.

value: Show HN: Coached – All-in-one platform for fitness coaches to ditch spreadsheets

author: zham-dev


value: Show HN: OpenDataLoader – Safe, Open, High-Performance PDF Loader for AI


value: zylics

value:
Hi HN,
OP here. I built HardwareTest.org because I was frustrated with existing testing tools that required downloading executables or were filled with ads.
It's a pure static site (hosted on Vercel) that runs entirely in the browser.
Features:
Keyboard Test: Includes a real-time Hz polling rate dashboard (I had to fight the browser event loop to get this somewhat accurate).
Dead Pixel Fixer: Uses Canvas to generate high-frequency RGB noise.
Mouse/Audio: Standard diagnostic tools.
I used AI (Vibe Coding) to help build parts of it, which was an interesting learning experience regarding the limitations of AI in handling precise hardware events.
Would love to hear your feedback on the accuracy, especially the Keyboard Polling Rate test!

value: Show HN: Hardwaretest.org – Browser-based peripheral diagnostics (no install)

author: zylics


value: oblonski

value: Show HN: A TSP game I wanted for 10 years - built in 4 hours

author: oblonski


value:
I built Whisper Money, a personal finance app where all your data is end-to-end encrypted and only you hold the keys.
Site: http://whisper.money/
Code: https://github.com/whisper-money/whisper-money
How it works (high-level)
- All sensitive data is encrypted in the browser before it hits the server
- The server only stores encrypted blobs for sync
- Decryption happens only on your devices
Looking for feedback on
- Security model / crypto choices
- Key management UX (backup/recovery)
- Whether this is compelling vs. existing tools

value: Show HN: Whisper Money – End-to-End Encrypted Personal Finance App


value: choc-dev

value:
I built a simple page builder for non-technical users with built-in multilingual support.
The client is vanilla TypeScript - no React, Angular, or Vue because I wanted a smaller runtime, full control over the codebase, and freedom from framework churn.
Components are self-contained and composable (adding new ones doesn't require touching existing code). The backend is C# / .NET 10 with Entity Framework.
This is an early prototype. No account required - sessions use anonymized IP (SHA-256 + salt).
Link: https://dev.tukona.com/
It is self-hosted in my homelab (based in the EU), so it might be slow under load :)
Looking for feedback on the UX. My next goal is adding specialized components for a specific industry vertical.

value: Show HN: Page Builder in Pure TypeScript, No Framework Dependencies

author: choc-dev


value: rhozeta

value:
Hey HN! I built a platform that lets you upload an OpenAPI spec and get an AI-powered chat agent you can embed on your website.
- The motivation:
I kept seeing companies with perfectly good APIs, but their users still struggled with complex UIs or had to read through documentation. Meanwhile, building a custom AI agent requires significant engineering resources most teams don't have.
- How it works:
Upload your OpenAPI/Swagger spec (or paste your API docs)
The system maps out your endpoints and parameters
You get an embeddable widget that understands natural language queries
When users ask questions, the agent translates them to API calls and returns results conversationally
Example: An e-commerce site with an inventory API. Instead of navigating filters, users ask "Do you have running shoes in size 10 under $100?" and get instant results.
- Technical details:
Uses LLM function calling to map queries to API endpoints
Handles authentication (API keys, OAuth)
Rate limiting and caching to avoid hammering your API
Works with REST APIs (GraphQL support coming)
Current state: Functional MVP, testing with a few early users. Still figuring out edge cases around complex APIs and auth flows.
- What I'm looking for feedback on:
Have you encountered this problem? How did you solve it?
Security concerns I should be thinking about?
Is this actually useful or just a cool demo?

value: Show HN: Turn any API into an embeddable AI agent

author: rhozeta


value: YauCheukFai

value: Show HN: Voynich GIS – An interactive parser for the 15th-century manuscript

author: YauCheukFai


value: zhangyiqun

value: Show HN: I built a CLI to translate podcasts for non-native speakers

author: zhangyiqun


value: lubbo

value: Show HN: Rollwave – Zero-downtime secret rotation and builds for Docker Swarm

author: lubbo


value: janijarvinen

value:
Hi HN,
I've been writing software for a long time, and over the years I've felt that most developer principles focus mainly on code structure or architecture. Useful, but only one part of the job.
I wanted something more human-centered -- principles about how we think about long-term consequences, avoid burnout, treat each other, and work responsibly with tools like AI. So I wrote a small set of 12 principles I call the Human Code Principles.
They're not a methodology or a set of rules, just an attempt to articulate values that seem to lead to healthier and more sustainable software work. I don't consider them finished or universal, and I'm interested in critique.
If you think something is missing, unclear, naive, or misguided, I'd appreciate the feedback.
Here's the link again in case the URL field is hidden on mobile: https://humancodeprinciples.org/

value: Show HN: Human Code Principles – 12 principles for human-centered software dev

author: janijarvinen


value:
Hey HN! I built an API for automated image generation. After too many job rejections, I decided to just ship something instead, so I cloned Bannerbear and built my own version.
Design a template once in the visual editor, then render unlimited variations by sending JSON with your text and images.
Use cases: blog thumbnails, certificates, social posts, invoices, receipts, or anything that needs the same design with different content.
How it works:
Drag-and-drop editor to design your template
POST request to modify any layer (text, images, shapes)
Get back production PNG/JPG/WebP(thinking about adding PDF in the nearest future)
Supports bulk generation from spreadsheets
Built with React, Node, and headless Chromium for pixel-perfect renders. Getting sub-second render times with Chromium took some work.
Try it at https://rendria.com/
Would love feedback on the API design or tips on marketing this kind of product!

value: Show HN: Rendria – Automate image generation via API


value: steyeomans

value:
Hi HN! I built this tool because I wanted to answer a simple question for myself: which books come up most often across the podcasts I listen to?
The pipeline is straightforward at a high level: transcribe episodes with faster_whisper running locally on an RTX 3060, run the text through GPT-5-mini to pull out structured book mentions, and store everything in Azure SQL and Blob storage. The frontend is a small Flask app using HTMX, Tailwind, and some D3 for the visualizations.
The part that turned out to be much more time consuming than expected was deduping. Everything else scaled nicely, but normalizing book titles is still the one piece I can’t fully automate without quality drifting. Fuzzy matching gets you most of the way, but the long tail of book names is huge. I ended up building a tiny internal Flask UI just to confirm or split fuzzy matches by hand, it also lets me review the context for the book mention to ensure accuracy. It's the only place in the system where a human is still in the loop.
A few other unexpected issues came up: some podcast RSS feeds randomly duplicate or link to broken episodes, CUDA can crash if I’m not careful with garbage collection between Whisper runs, and LLM extraction occasionally fails if the model doesn’t return exactly the JSON shape I expect.
One surprising pattern emerged: the long tail is enormous. A handful of books are mentioned constantly, but thousands more appear exactly once.
If you want to see the current state of it, the reports and visualizations are here:
https://www.mavensignal.com
Happy to answer anything about the pipeline, LLM prompting, dedupe logic, or the stack in general.

value: Show HN: Tracking book mentions across podcast episodes

author: steyeomans


value: hivetechs

value:
Each AI has strengths - Claude reasons well, Gemini handles long context, Codex integrates with GitHub. But switching between them means losing context.
Built HiveTechs: one workspace where Claude Code, Gemini CLI, Codex, DROID, and 7 others run in integrated terminals with shared memory.
Also added consensus validation - 3 AIs analyze independently, 4th synthesizes.
Real IDE with Monaco editor, Git, PTY terminals. Not a wrapper.
Looking for feedback: hivetechs.io

value: Show HN: I got tired of switching AI tools, so I built an IDE with 11 of them

author: hivetechs


value:
Hi HN,
I recently got the AnkiMobile app for iOS for Mandarin. It was buggy and feature-lacking in my opinion, so I made a nice looking Anki-compatible alternative app, with more features.
It uses a tuned FSRS5 algorithm and supports image occlusion out of the box. You can import your existing Anki decks into it or create a new one. Pretty quick to add cards with the image feature.
I'm using it right now and will add more to it so let me know what you think.
FYI, it has a one-off purchase of $14.99 to unlock it for lifetime (no taksies backsies) after a test period of seven days.

value: Show HN: I made a nice Anki-app for iOS

title: Show HN: I made a nice Anki-app for iOS


value: mimixbox

value:
I built a small trilogy of Go tools:
- fileprep — preprocessing & validation using struct tags (trim, replace, normalize, etc.)
- fileframe — a lightweight, immutable DataFrame for filtering, mapping, grouping
- filesql — run SQL directly on CSV/TSV/LTSV/Excel/Parquet (SQLite under the hood)
Repos:
- https://github.com/nao1215/fileprep
- https://github.com/nao1215/fileframe
- https://github.com/nao1215/filesql

value: Show HN: A 3-Tool ETL Pipeline for CSV/TSV/Excel/Parquet in Go

author: mimixbox


value: keepamovin

value: Show HN: Gemini Pro 3 imagines the HN front page 10 years from now

author: keepamovin


value: ojr

value:
I built an AI Coding tool optimized for my workflow. VSCode forks use too much memory and I am over the idea of having AI Agents rewriting files and also reviewing complicated diffs with the Accept/Reject UI.
I built Isogen which uses as much memory as a Chrome tab instead of a tool that can spike up to 1GB of RAM. You drag and drop or paste files into an isolated context and do fast generations file-by-file. This approach allows me to keep a strong mental model of the codebase. I also added a snapshot feature that keeps the history of the files and the generated output. File copies are saved locally with SQLite.
Bring Your Own Key for inference which allows for unlimited generations. The only models supported now are the fast ones from Gemini, ChatGPT, Claude and Grok.

value: Show HN: Isogen – Lightweight AI Coding Tool (Rust and JavaScript, <50MB, BYOK)

author: ojr


value: Kamilbenkirane

value: Show HN: Celeste – The 'Requests' for AI: Any provider, any capability

author: Kamilbenkirane


value:
Hi HN,
I often use whenisgood.net to help two or more people find a time for a meeting or event that works for everyone. It does the job, but after using it a lot I found the interface involved a bit too much set up and grid clicking, and I wanted a more natural way to express availability.
Schedulegend lets people type their availability in plain English, for example: "next two weeks between 11am and 3pm but not Fridays or weekends"
How it works:
If you’re creating an event:
You open the site, set it up in a few seconds, and share the link with participants.
On the results page, you can see at a glance which times work for everyone.
If you’re a participant:
You open the link, type your availability, and your input is interpreted automatically.
Right now the tool only supports 1-hour time slots, but I’m happy to add other durations if people find it useful.
Goals:
1. Natural-language availability instead of too much grid clicking
2. No login, zero friction
3. Fast, minimal interface
4. Free
I’m curious whether this approach feels smoother than traditional group-scheduling tools.
Feedback very welcome!

value: Show HN: A simple natural-language scheduling tool for finding a time to meet


value: akcho

value:
I built Milkie to make it easy to add Stripe paywalls.
- Designed for Next.js + Tailwind + shadcn
- Works with any auth provider (NextAuth, Clerk, Supabase, etc.)
- Handles UI, checkout, webhooks, subscription status (the boring stuff)
There's still some setup involved, but the docs walk you through it.
Demo at milkie.dev
Happy to answer any questions!

value: Show HN: Milkie – Drop-In Stripe Paywall for Next.js

author: akcho


value: GentoroAI

value: Show HN: Gentoro OneMCP – open-source layer for accurate API calls by AI agents

author: GentoroAI


value:
Hi Hacker News,
I've been relying on the Functional Option pattern to build clean, flexible constructors for my Go projects, but the constant need to write repetitive boilerplate for every struct became tedious and error-prone.
I built *foggo* to solve this pain point.
It's a simple, zero-dependency CLI tool that reads your configuration structs and automatically generates all the necessary, idiomatic Go code for the Functional Option pattern.
### Key Benefits:
* *Massive Boilerplate Reduction:* Eliminates the manual work of writing option functions, making your code more focused on business logic.
* *Consistency:* Ensures all your constructors adhere to the same, robust pattern across the entire project.
* *Speed:* You define the struct, run `foggo`, and the pattern is instantly ready.
I primarily designed this for fellow Go library and package maintainers looking to standardize their configuration setup.
I'd love to hear your feedback on the utility and design of the tool, especially concerning its syntax or how it handles edge cases.
Thanks for checking it out!
*GitHub Repository:* https://github.com/rikeda71/foggo

value: Show HN: Foggo – CLI Tool for Auto Generation of Go's Functional Option Pattern


value: ReauxSavonte

value: Show HN: Consciousness Is Forced Signal Transformation. 7x Validated Framework

author: ReauxSavonte


value: tranhuucanh

value:
I'd like to share FastResize (https://github.com/tranhuucanh/fast_resize), a high-performance image resizing library written in C++. This is my second open-source project after FastQR, and I'm excited to share it with you all.
What it is:
- A fast CLI tool and Ruby gem for resizing images
- Written in C++ with Ruby bindings
- Supports batch processing for handling thousands of images efficiently
- Pre-built binaries included – no need to install dependencies separately
- Available as a Ruby gem on RubyGems: https://rubygems.org/gems/fast_resize
Why I built this:
- I needed an image resizer that was fast, memory-efficient, and could handle batch processing easily. Most existing solutions were either slow or consumed too much memory when processing large batches.
Performance:
- Resizing 1,000 images: ~2 seconds
- Up to 2.9x faster than libvips
- Up to 3.1x faster than imageflow
- Uses 3-4x less RAM than alternatives
Tech stack:
- C++ core using optimized image processing libraries
- Ruby gem for easy integration
- Precompiled binaries for CLI usage
Installation:
- Ruby gem: `gem install fast_resize` or add `gem 'fast_resize'` to your Gemfile
- CLI: Please check from GitHub repository: https://github.com/tranhuucanh/fast_resize
This is my second open-source project, so I'm sure there are things that could be improved or bugs I haven't caught yet. I'd really appreciate it if you could try it out and share your feedback. If you find any issues or have suggestions, please open an issue on GitHub – I'll do my best to fix them quickly.
Any feedback, criticism, or suggestions would be greatly appreciated. Thanks for taking the time to check it out!
GitHub: https://github.com/tranhuucanh/fast_resize
RubyGems: https://rubygems.org/gems/fast_resize

value: Show HN: FastResize – A Fast Image Resizer Supporting Batch Processing

author: tranhuucanh


value: isbeingto

value: Show HN: OMyTree – A visual conversation tree for AI chats

author: isbeingto


value: normally I buy my private leaderboard winner friends AoC merch, but this year I'm an unemployed open source developer.<p>Upload you or a friend's head and give the gift of digital merch for a little holiday joy.

value: Show HN: Unofficial Advent of Code digital gifter


value: mjablons

value: Show HN: I built a TurboTax for immigration forms

author: mjablons


value: fixpointflow

value: Show HN:Designing a programming language with AI, for AI

author: fixpointflow


value: ArseniKipachu

value:
I built Zhok as an internal tool because I couldn’t find a simple, clean way to organize the AI prompts I use daily. Most prompt managers felt cluttered or under-engineered, so I created something minimal and fast.
Zhok now runs on iPhone, iPad, and Mac, making it easy to manage prompts directly on desktop without grabbing your phone.
Would love feedback from the HN community — ideas, critiques, or suggestions for what to build next.

value: Show HN: Zhok – A clean, minimal tool for managing AI prompts

author: ArseniKipachu


value: Nathanadian

value:
Hi HN,
I built Freedom Graph because I wanted an FI calculator that modeled market variability and flexible spending more realistically. Lots of calculators assume constant returns, fixed withdrawal rules, and the "real = nominal – inflation" approximation. That’s fine for ballpark numbers, but not great when you care about sequence risk or decisions like, "should I spend another year working?"
These are the real-world factors I wanted to model explicitly:
* Sequence of Returns Risk: Optional market randomness (mix of positive/negative years, long-run ~10% CAGR) to show how early retirement plans can fail even when the long-term average looks fine
* Correct real-return math: Uses the Fisher equation instead of the linear approximation, which compounds differently over long time horizons
* Adaptive strategies: Model “one more year” scenarios and spending flexibility to see how behavior affects success probabilities
Other QoL things:
* Built with React + Vite; no input data is sent anywhere
* Local storage persists inputs between browser sessions
* FI income automatically adjusts when you hit your target
* Dark/light mode
I’d really appreciate feedback on both the UX and assumption/behavior levers. If you think something’s wrong or misleading, please tell me.
Thanks!

value: Show HN: Freedom Graph – FI calculator that models sequence-of-returns risk

author: Nathanadian


value: arizen

value: Show HN: Open-source reference architecture for AI Agents (LangGraph, Pydantic)

author: arizen


value: taariqserendb

value: We upgraded our open-source database replicator with publisher-subscriber features.<p>The Rust CLI now replicates PostgreSQL databases without requiring wal_level=logical on the source. It uses PostgreSQL's xmin system column to detect changes, enabling CDC-style replication from any managed PostgreSQL service—no configuration changes needed.

value: Show HN: Replicator-Publisher-Subscriber PostgreSQL with Xmin and Rust

author: taariqserendb


value: arnabkarsarkar

value:
OP here.
I built this because I recently caught myself almost pasting a block of logs containing AWS keys into Claude.
The Problem: I need the reasoning capabilities of cloud models (GPT/Claude/Gemini), but I can't trust myself not to accidentally leak PII or secrets.
The Solution: A Chrome extension that acts as a local middleware. It intercepts the prompt and runs a local BERT model (via a Python FastAPI backend) to scrub names, emails, and keys before the request leaves the browser.
A few notes up front (to set expectations clearly):
Everything runs 100% locally.
Regex detection happens in the extension itself.
Advanced detection (NER) uses a small transformer model running on localhost via FastAPI.
No data is ever sent to a server.
You can verify this in the code + DevTools network panel.
This is an early prototype.
There will be rough edges. I’m looking for feedback on UX, detection quality, and whether the local-agent approach makes sense.
Tech Stack:
 Manifest V3 Chrome Extension
 Python FastAPI (Localhost)
 HuggingFace dslim/bert-base-NER
 Roadmap / Request for Feedback:
Right now, the Python backend adds some friction. I received feedback on Reddit yesterday suggesting I port the inference to transformer.js to run entirely in-browser via WASM.
I decided to ship v1 with the Python backend for stability, but I'm actively looking into the ONNX/WASM route for v2 to remove the local server dependency. If anyone has experience running NER models via transformer.js in a Service Worker, I’d love to hear about the performance vs native Python.
Repo is MIT licensed.
Very open to ideas suggestions or alternative approaches.

value: Show HN: Local Privacy Firewall-blocks PII and secrets before ChatGPT sees them

author: arnabkarsarkar


value: llabs

value:
Think of it as a cross between Google Docs, Gist and LLM chat (with tools).
What it does today:
  Editor for GitHub-flavoured Markdown + Mermaid + KaTeX in one place
  Live preview as you type
  LLM Chat enables:
   Drafting an architecture doc from a short description
   Generate or update Mermaid diagrams from text
   Refining a document  Change Tracking (visual or diff)
  Public share links  Integrations (needs tidy up/fixing)    ImageGen - hooked up to flux.1, gen image store in s3    GithubMCP - needs fixing (too many tools/ no private repo support)    Web Search/Fetch
How I got here (14M later):
It started out  as a development platform  with vscode plugin and support for a frontend for docs/design with realtime comms between the two. Decided this was a losing battle as a side gig against cline / cursor etc . This still exists, just isn't exposed and is what I've used to develop AutEng - it's very specialised to my workflow (documents for arch -> phased plan -> progress log).
I switched to Goal Driven Agent, where the LLM generates a json-schema digraph to meet the goal. This was difficult (it works, just not very well), but I still have a workflow automation I can use down the line (e.g. auto create docs from github).
Third and hopefully final pivot to Docs, I was struggling sharing DS conversations and ML architecture proposals I'd had with various LLM's and realised AutEng was capable of this.
What’s next
Kind of depends how things go. Directions I'm thinking:  Proper Github integration / autogen doc from repo  Shared realtime editing (Google docs style)  Support for more niche rendering e.g. chemistry, biology
Check out where I am (LLM Chat needs signup, but still free for a try):
https://auteng.ai (loads straight into the editor, no login).
Example architecture doc: https://auteng.ai/docs/software/architecture/architecture-do...
Example math/physics doc: https://auteng.ai/docs/physics/general/physics-equations-dia...
Feedback would be very much appreciated, particularly:
What would this need to be useful to you?
 For math/physics folks: is this usable for real derivations/problem sets, or what’s missing?
 For the autogen docs and keep them up-to-date, how would you want that to work (e.g. PR to github/gitlab repo)
Happy to answer anything about the journey, product, roadmap etc.

value: Show HN: AutEng Docs – Google Docs x Gist x LLM chat

author: llabs


value: ayarotsky

value: Show HN: Redis Shield – Token bucket rate limiting in Redis at 50K req/s (Rust)

author: ayarotsky


value: ADCXLAB

value: Show HN: Banking-Grade Validators for IBAN, Swift, OFAC and Blockchain Networks

author: ADCXLAB


value: hknyrgnc

value: Show HN: MPL – A Python DSL that transpiles logic to Pine Script

author: hknyrgnc


value: hamzaawan

value:
Hey HN,
for sometime now I am building useful products for the community and every time I build some product I really struggled with collecting feedback for it. I have integrated feedback widgets in the past from posthog and also sent users email from my personal email and much more and mostly no one cared to reply or they ignored the in app widget. So I had to manually send them these email sequences with follow ups to get the feedback out of the users. Because feedback is really important if you want to build a product actually for its users.
And then even if I got the feedback from people from either channel, it was scattered even If I noted it somewhere and if not. Some tasks use to get lost and some half done.
So I built MsgMorph, which is a full end to end AI powered feedback collection pipeline. It has in app widget which can be integrated easily to collect bug reports, feature requests etc and on top of all that it has live chat built into it from where users can talk to you and on your side you have support for orgs and agents to manage customer support easily. AI agents are coming soon as well.
And the third channel it has right now is email, I have built ts sdk and better auth plugin for now so when ever user signs up on your platform, you using the sdk or plugin if you are using better auth will create a contact in msgmorph and will schedule a feedback email to them after the set interval and if they dont reply will send them followup email as well. Because lets be real users dont reply to first email. You can have conversations in the app with out email based conversation interface. here more advanced email sequences and auto replies/conversation is coming soon.
The crazy part here is that all of this feedback collected from any channel is analysed by AI and it extracts actionable tasks from it, which you can manage from our in app tasks boards or you can connect your linear for now so all of your tasks will pushed directly to linear. So you or your dev team and implement all of those tasks and keep track of them.
The goal of MsgMorph is to make the feedback collection easy and automated as much as possible and also provided quick and easy developer experience with multiple language sdks and authentication services and tasks management platforms. So It plugs right into your ecosystem and becomes a part of it.
So what do you think about this? what would you guys like to see in this?

value: Show HN: I built a system to collect feedback more like force it

author: hamzaawan


value: samuxbuilds

value:
Hi HN
I built CapSummarize, a Chrome extension that turns long videos and articles
into multiple usable formats instead of just text summaries.
Current features:
> Video summarization (YouTube, Twitter/X, Udemy, Zoom)
> Generate thumbnails
> Generate mind map images from videos
> Generate Whiteboard-style visuals from videos
Motivation:
Summaries alone weren’t enough for me — I wanted visuals and clips that I could
review, reuse, or share without rewatching the full content.
Links:
Website: https://www.capsummarize.app/
Chrome Store: https://chromewebstore.google.com/detail/capsummarize/lbhdfo...
GitHub: https://github.com/samuxbuilds/capsummarize
I’d love feedback:
– Are visual outputs more useful than text summaries?
– What format would you expect next (PDF, slides, Notion export)?

value: Show HN: CapSummarize – Summarize videos and generate thumbnails and clips

author: samuxbuilds


value: rnmp

value: Show HN: Made an iPad app to sync handwritten notes to Notion

author: rnmp


value: ronibhakta

value:
hey HN — roni here, full-stack dev out of india (ex-gsoc @ internet archive).
spent last weekend hacking ZON-TS because json was torching half my openai/claude budget on dumb redundant keys — hit that wall hard while prototyping agent chains.
result: tiny TS lib (<2kb, 100% tests) that zips payloads ~50% smaller (692 tokens vs 1300 on gpt-5-nano benches) — fully human-readable, lossless, no parse tax.
drop-in for openai sdk, langchain, claude, llama.cpp, zod validation, streaming... just added a full langchain chain example to the readme (encode prompt → llm call → decode+validate, saves real $$ on subagent loops).
quick try:
```ts
npm i zon-format
import { encode, decode } from 'zon-format';
const zon = encode({foo: 'bar'});
console.log(decode(zon));
```
github → https://github.com/ZON-Format/ZON-TS
benches + site → https://zonformat.org
YC’s fall rfs nailed it — writing effective agent prompts is brutal when every token adds up. if you’re in a batch grinding observability (helicone/lemma vibes) or hitting gemini limits like nessie did, what’s your biggest prompt bloat headache right now? paste a sample below and i’ll zon it live.
feedback (harsh ok) very welcome
cheaper tokens ftw

value: Show HN: ZON-TS 50–65% fewer LLM tokens zero parse overhead better than TOON/CSV

author: ronibhakta


value: thinkmoon

value:
With ThinkMoon you can build your own Alpha Arena: plug in models from OpenRouter, OpenAI, Anthropic (or our custom ones), feed them real-time data (candles, order book, ticker) — then send them to trade real crypto (via Binance Futures).
You define the rules: risk limits, which coins (BTC, ETH, SOL, XRP… whatever), even mix different LLMs and compare their performance.
Every move the AI makes is logged — full prompt, reasoning, market snapshot — so you can audit or learn from it.
There’s a live dashboard with P&L, open positions, and the AI’s chain of thought. Alerts via Telegram or Slack when trades happen.
On top of that: stop-loss, take-profit, position limits and a kill-switch if drawdown gets too high.
We’re now testing fine-tuned models like DeepSeek 3.2 Speciale and Grok 4.1 — early results look promising, with more consistent performance than generic models.
Would love to hear what features you’d want in an AI trading assistant.
(LLM orchestration & logic framework: LangChain)

value: Show HN: Thinkmoon.ai – Build your own Alpha Arena, trade crypto with AI Agents

author: thinkmoon


value: ysablewolf

value:
I've spent 20 years building identity and security systems (EA, Nexon IPO, two patents in cryptographic auth). Started building multi-agent pipelines last year and hit a problem: when something breaks, there's no way to know which agent produced what.
MOSS gives agents cryptographic identities and signs their outputs. Each signature includes ML-DSA-44 (post-quantum, FIPS 204), a sequence number for replay detection, and a SHA-256 payload hash.

    pip install moss-sdk

    from moss import Subject

    agent = Subject.create("moss:myapp:agent-1")
    envelope = agent.sign({"action": "approve", "amount": 500})

Keys stored locally at ~/.moss/keys/. No cloud, no account.
Framework integrations: moss-crewai, moss-autogen, moss-langgraph, moss-langchain
Why post-quantum: audit logs need to stay verifiable for years. Chose ML-DSA-44 over Ed25519 for that reason.
Spec: https://github.com/mosscomputing/moss/blob/main/SPEC.md
Site: https://mosscomputing.com
Happy to answer questions on the design.

value: Show HN: Moss – Cryptographic signing for AI agents

author: ysablewolf


value: furisto

value:
Construct is an open-source AI coding assistant that runs as a gRPC service rather than just a CLI tool. You can run it locally on your laptop or on a remote box, connect multiple clients, disconnect and reconnect without losing context, and integrate it into other tools easily. I wanted something I could leave running and come back to and that is easy to run in a sandbox.
Instead of JSON schema, agents write JavaScript to interact with tools. That means they have access to loops, conditionals, error handling, and are encouraged to perform multiple calls in one turn (hundreds in a single turn if needed). There's a video in the README if you want to see what it looks like. The approach was inspired by the CodeAct paper (https://arxiv.org/abs/2402.01030) that found that agents perform better when they call tools with code instead of JSON. I explain the benefits in more detail here: https://github.com/Furisto/construct/blob/main/docs/tool_cal...
It comes with built-in agents for different tasks (planning/implementation/refinement) or you can create your own with custom prompts and model assignments. It's a single Go binary, no need for npm or the like. Works with Anthropic today, other providers coming soon.
Happy to answer questions about the architecture or the tool calling approach.

value: Show HN: Construct – API-first coding assistant with CodeAct tool calling

author: furisto


value:
Hey HN! I'm Juan, former reliability engineer at NetApp where I handled 60+ critical incidents per month for Fortune 500 clients.
I built ARF after seeing the same pattern repeatedly: production AI systems fail silently, humans wake up at 3 AM, take 30-60 minutes to recover, and companies lose \$50K-\$250K per incident.
ARF uses 3 specialized AI agents:
Detective: Anomaly detection via FAISS vector memory
 Diagnostician: Root cause analysis with causal reasoning
 Predictive: Forecasts failures before they happen
Result: 2-minute MTTR (vs 45-minute manual), 15-30% revenue recovery.
Tech stack: Python 3.12, FAISS, SentenceTransformers, Gradio
Tests: 157/158 passing (99.4% coverage)
Docs: 42,000 words across 8 comprehensive files
Live demo: https://huggingface.co/spaces/petter2025/agentic-reliability...
The interesting technical challenge was making agents coordinate without tight coupling. Each agent is independently testable but orchestrated for holistic analysis.
Happy to answer questions about multi-agent systems, production reliability patterns, or FAISS for incident recall!
GitHub: https://github.com/petterjuan/agentic-reliability-framework
(Also available for consulting if you need this deployed in your infrastructure: https://lgcylabs.vercel.app/)

value: Show HN: Agentic Reliability Framework – Multi-agent AI self-heals failures


value: moridin

value:
Hi HN,
I built Presently (https://presently.us) because I was tired of managing my holiday shopping in a messy Excel sheet. Every "gift tracker" app I tried was bloated with ads, required a heavy signup, or just tried to upsell me.
I wanted something clean, fast, and focused purely on the logistics of giving: who am I buying for, what is the status (idea -> bought -> wrapped), and how much have I spent?
Key features:
- Visual Status Board: See at a glance who still needs a gift and what needs to be bought/wrapped/given.
- Budgeting: Auto-sums your spending against your budget.
- Mobile Friendly: Works great in the browser while you're actually at the store (PWA feel).
- Frictionless Sharing: Share wishlists with family/friends without forcing them to create an account.
- AI Brainstorming: Integrated Gemini to generate gift ideas based on interests and relationship, for when you're totally stuck.
The Tech Stack: Built with Firebase, React, and Tailwind, hosted on GCP. I focused heavily on a snappy UI and low cognitive overhead (who needs more stress when buying gifts?).
I’d love to hear your feedback on the UX flow. Does it feel faster than your current system?
Cheers, Al

value: Show HN: Presently: A holiday gift tracker that isn't a spreadsheet

author: moridin


value: bhackett

value:
Hi HN, I'm the CEO at https://replay.io.  We've been working on time travel debugging for web development for a while (https://news.ycombinator.com/item?id=28539247) and more recently an AI app builder that uses that debugger to get past problems instead of spinning in circles (https://news.ycombinator.com/item?id=43258585).
We've gotten to where we can pretty easily build apps to replace business-critical SaaS tools, some of which we're now using internally:
* We built our own issue tracker to keep track of all our development projects, tickets, bug fixes, and so on, completely replacing Linear.
* We built a knowledge base for managing internal documentation and the status of ongoing initiatives, completely replacing Notion.
* We built a telemetry system that ingests OTLP events via a webhook and supports custom graphs and visualizations, mostly replacing Honeycomb.
We want to have as much control as we can of the apps we need to run Replay.  We can tailor these apps to our needs, completely own them and their data, and avoid hostile SaaS vendor behavior like per seat pricing, paywalled features, locking us into their platform, and locking us out from accessing our own data.
Today we're launching Builder (https://builder.replay.io/), the tool we used to make these apps, along with the apps themselves and others we've built.  You can copy these apps for free, download the source and self host them if you want, or let us take care of hosting, fixing bugs, and modifying them for your needs.
If you want to just check these out, here are a couple (shared, no login required) copies of these apps:
* Issue tracker: https://16857470-551d-4f50-8e5b-b7d24a4a874a.http.replay.io
* Knowledge base: https://d7e0dff4-f45c-4677-9560-6ea739c00a94.http.replay.io
We're excited for the power of AI app builders to accelerate the pace of software development, unlock the creativity of non-developers everywhere, and especially to help erode the control that so many large companies have over us.  We're continuously building new apps ourselves to help in this endeavor, so let us know what you think!  What are the apps and vendors that frustrate you the most?

value: Show HN: We vibe coded our team's issue tracker, knowledge base, telemetry board

author: bhackett


value: Sharanxxxx

value:
Hi everyone,
I built this because I noticed many early-stage founders struggle with visibility. Even if you have a good product, it’s difficult for Google (and users) to discover it without basic backlinks and citations.
Directory submissions still help, but doing them manually across dozens of platforms takes a lot of time, and most “directory lists” online are outdated or filled with low-quality sites. I wanted a more reliable and consistent approach.
I curated 100+ high-authority directories and built a simple service that submits your startup to all of them manually. The focus is accuracy, consistency, and approval rate—not automation or spam.
If you have thoughts, feedback, or suggestions for other directories I should add, I’d love to hear it.
Happy to answer any questions.

value: Show HN: Tool to Submit Your Startup to 100 High-DR Directories

author: Sharanxxxx


value:
Hi everyone,
I built this because most launch platforms feel noisy and competitive. When I launched my earlier projects, they would get pushed down the feed in minutes, which made it difficult to get meaningful feedback or early users.
Solo Launches is a small platform designed for solo founders and indie hackers. Instead of a crowded feed, you choose a weekly launch slot. Each product gets its own simple page, a backlink, and a chance to receive comments and feedback from builders who browse the weekly batch.
There’s no algorithm and no competition elements. The goal is to create a calmer launch experience where early projects have more room to be seen.
If you have feedback, ideas, or suggestions for improving the platform, I’m happy to hear them.

value: Show HN: A Simple Weekly Launch Platform for Solo Founders


value:
Hi HN,
I'm the solo founder of Signal Labs. I built a tool called CIx because in my previous roles, competitive intelligence and battelcards became outdated in days. Updating them manually was painful, slow, and constantly behind competitors.
The problem we’re trying to solve:
- Competitors launch features daily/weekly but teams only notice months later
- Sales needs fresh intel for calls, not stale quarterly slides
- PMs want to know what competitors are shipping so they can make informed roadmaps decisions
- CI/PMM teams spend hours gathering intel that becomes outdated before anyone uses it
What CIx does:
- Monitors competitor websites, releases, and changes in real-time
- Generates and updates battlecards automatically using CI best-practices.
- Helps PMs, Sales, Marketing and Leadership teams stay aligned
Here’s a 60-second demo: https://www.loom.com/share/cee4b34448684a54b44c9d3ad4619b54
Here’s the deeper blog post on why we built it: https://usesignallabs.com/the-ci-treadmill-is-broken-why-bat...
You can try CIx here (free): https://usesignallabs.com
I'd love feedback, criticism, or ideas, especially from anyone who has dealt with fast-moving competitors or has built similar automation tools.
Happy to answer any questions.

value: Show HN: I built an AI tool that tracks competitor changes in real time


value: craigwrong

value: Been working on a pure swift bitcoin implementation for over 3 years. We recently reached the important milestone of achieving testnet synchronization and now we want to do the same for mainnet. Please send us some love in the form of GitHub stars if you love Swift or Bitcoin or just FOSS :)

value: Show HN: Swift Bitcoin - Experimental full node and dev framework for Swift

author: craigwrong


value: nedhuang

value:
Hi HN,
I built BirthdayInvitation.ai, an AI-powered tool that creates birthday invitations in under a minute and includes a built-in online RSVP form.
Why I made this
I’m a parent of two young kids, and every birthday party meant spending hours searching for templates, hiring designers, or manually collecting RSVPs through texts and spreadsheets. After repeating this every year, I wanted a faster, simpler, and more accessible way for parents to create invitations and track responses.
What it does
 a) Generates unique birthday invitation designs based on any theme (kids, teens, adults).
 b) Creates a shareable online RSVP form automatically.
 c) Guests can reply without signing up or installing anything.
 d) Parents get real-time headcounts and updates.
 e) Also supports a “bring your own design” option for people who prefer to upload their own artwork.
How it works (technically)
 1, The design generation uses a prompt-oriented pipeline with post-processing to ensure text clarity and print-friendly layout.
 2, RSVP tracking runs on a lightweight backend with email/SMS routing for notifications.
 3, The system is optimized to produce invitations that can be printed or shared digitally.
What I’d love feedback on
I want to improve the onboarding flow, the image quality, and the RSVP experience—especially for parents who are not tech-savvy.
 • Is the interface intuitive?
 • Are there moments where you feel “stuck”?
 • What would you expect such a tool to do that it currently doesn’t?
This project is still young, and I’d really appreciate any honest feedback from the HN community. You’ve helped me improve many things in the past, and I’m hoping to make this tool genuinely useful for other parents.
Thanks for reading, and happy to answer all questions.
— Founder of BirthdayInvitation.ai

value: Show HN: AI birthday invitations and free online RSVP (built as a parent)

author: nedhuang


value: Show HN: Quantica: A Hybrid Classical–Quantum Programming Language


value: drob

value:
Hi HN, tl;dr we built a bug finder that's working really well, especially for app backends. Try it out and send us your thoughts!
Long story below.
--------------------------
We originally set out to work on technical debt. We had all seen codebases with a lot of debt, so we had personal grudges about the problem, and AI seemed to be making it a lot worse.
Tech debt also seemed like a great problem for AI because: 1) a small portion of the work is thinky and strategic, and then the bulk of the execution is pretty mechanical, and 2) when you're solving technical debt, you're usually trying to preserve existing behavior, just change the implementation. That means you can treat it as a closed-loop problem if you figure out good ways to detect unintended behavior changes due to a code change. And we know how to do that – that's what tests are for!
So we started with writing tests. Tests create the guardrails that make future code changes safer. Our thinking was: if we can test well enough, we can automate a lot of other tech debt work at very high quality.
We built an agent that could write thousands of new tests for a typical codebase, most "merge-quality". Some early users merged hundreds of PRs generated this way, but intuitively the tool always felt "good but not great". We used it sporadically ourselves, and it usually felt like a chore.
Around this point we realized: while we had set out to write good tests, we had built a system that, with a few tweaks, might be very good at finding bugs. When we tested it out on some friends' codebases, we discovered that almost every repo has tons of bugs lurking in it that we were able to flag. Serious bugs, interesting enough that people dropped what they were doing to fix them. Sitting right there in peoples codebases, already merged, running in prod.
We also found a lot of vulns, even in mature codebases, and sometimes even right after someone had gotten a pentest.
Under the hood:
- We check out a codebase and figure out how to build it for local dev and exercise it with tests.
- We take snapshots of the built local dev state. (We use Runloop for this and are big fans.)
- We spin up hundreds of copies of the local dev environment to exercise the codebase in thousands of ways and flag behaviors that seem wrong.
- We pick the most salient, scary examples and deliver them as linear tickets, github issues, or emails.
In practice, it's working pretty well. We've been able to find bugs in everything from compilers to trading platforms (even in rust code), but the sweet spot is app backends.
Our approach trades compute for quality. Our codebase scans take hours, far beyond what would be practical for a code review bot. But the result is that we can make more judicious use of engineers’ attention, and we think that’s going to be the most important variable.
Longer term, we think compute is cheap, engineer attention is expensive. Wielded properly, the newest models can execute complicated changes, even in large codebases. That means the limiting reagent in building software is human attention. It still takes time and focus for an engineer to ingest information, e.g. existing code, organizational context, and product requirements. These are all necessary before an engineer can articulate what they want in precise terms and do a competent job reviewing the resulting diff.
For now we're finding bugs, but the techniques we're developing extend to a lot of other background, semi-proactive work to improve codebases.
Try it out and tell us what you think. Free first scan, no credit card required: https://detail.dev/
We're also scanning on OSS repos, if you have any requests. The system is pretty high signal-to-noise, but we don't want to risk annoying maintainers by automatically opening issues, so if you request a scan for an OSS repo the results will go to you personally. https://detail.dev/oss

value: Show HN: Detail, a Bug Finder

author: drob

title: Show HN: Detail, a Bug Finder


value: colinds

value:
Hi HN,
Over Thanksgiving weekend I wanted to build an AI agent. As a design exercise, I wrote it as a set of React components. The component model made it easier to reason about the moving parts, composability was straightforward (e.g., reusing agents/tools), and hooks/state felt like a reasonable way to model behavior that changes over time.
As I kept experimenting, I realized I was more interested in the framework (and it was a good excuse to explore React’s internals) than in the agent I originally planned, so I built this project instead.
In this framework:
- Agents are React components.
- Agents have <Message>, <Tools>, … and even other agents as tools via <AgentTool>.
- You can mount/unmount tools based on React state, and tools can set state to change what tools are available on the next turn.
- There is a <Condition when="<natural language>" /> component that allows changing behavior based on the conversation history.
- Built-in support for code execution, web search, memory, and MCP servers through Anthropic’s API.
This is still a WIP project, but I’d love any feedback.
---
Repo: https://github.com/colinds/agentry
Selected examples:
- Hooks: https://github.com/colinds/agentry/blob/main/packages/exampl...
- Subagents: https://github.com/colinds/agentry/blob/main/packages/exampl...
- Conditions: https://github.com/colinds/agentry/blob/main/packages/exampl...

value: Show HN: Agentry – AI Agents as React Components

author: colinds


value: pseudometa

value: I built out a library of UX patterns that help build and maintain trust between users and Agentic AI.

value: Show HN: Designing Trustworthy Agentic AI Applications

author: pseudometa


value:
I've been spending my time working on https://synthchat.netlify.app. It's a technical communication platform where people can share their thoughts and ideas and have technical discussions about engineering without the baggage or disruption that comes with social media. I wanted the UI to be simple, straightforward, and just stupid easy to use overall.
I built this because I feel like most platforms mix technical content with noise, algorithms, and engagement farming, which makes real discussion harder than it should be. Sometimes you just want a clean space to think, ask questions, and exchange ideas with other engineers. My hope is that Synth Chat gives people a place where the conversation is the main feature-- no harsh moderation and snarky replies(cough cough Stack overflow). I'm wondering what features would take the app to the next level and improve discussion around thought provoking ideas. Let me know if you have any suggestions.

value: Show HN: I'm exhausted by social media chaos. This is my solution


value: MartinTale

value: Show HN: Numle = Numbers and Wordle but Easier

author: MartinTale


value:
RAG systems return different context for the same query. This makes debugging impossible and outputs unpredictable.
AvocadoDB guarantees determinism - same query, same context, verifiable by SHA-256 hash.
- 100% deterministic (not probabilistic top-k)
- Pure Rust, 40-60ms latency, local embeddings
- 95%+ token utilization (vs 60-70% typical)
- Exact file + line citations
- $0 cost (no API required)
Install: cargo install avocado-cli
https://avocadodb.ai
https://github.com/servesys-labs/avacadodb
Built this after burning too many hours debugging
inconsistent RAG outputs. Happy to discuss the architecture.

value: Show HN: AvocadoDB – Deterministic RAG (same query, same context, every time)


value: rohitghumare

value: Build AI Agents, Workflows, Backend systems live every day for 30 days.

value: Show HN: Advent of Back Ends

author: rohitghumare

title: Show HN: Advent of Back Ends


value: mikehanol

value: Show HN: DepsShield – Real-time dependency security for AI coding agents

author: mikehanol


value: bredren

value:
Contextify is a native macOS application that provides a private, searchable timeline of your AI coding sessions.
Video demo: https://www.youtube.com/watch?v=FvrvRGp4C9M
I built Contextify after I realized Claude Code automatically deletes your transcripts after 30 days.
Contextify is a native macOS HUD - a private, searchable timeline of your AI / agentic coding sessions.
* It provides a unified timeline of Claude Code and Codex CLI conversations.
* You can search the history across all your projects.
* It generates summaries of your exchanges with the AI locally using Apple Intelligence.
* It discovers new projects automatically and lets you organize them for easy access. Even has hotkeys to switch (Shift-Command-[ or ])
I learned a lot building this application and would be happy to answer any questions about how it works or uh...the journey.

value: Show HN: Contextify – Searchable History for Claude Code and Codex CLI

author: bredren


value: Show HN: Make Everything OK – A whimsical holiday website with SVG animations


value: lascauje

value: Show HN: Pyvert – visualize classical mechanics/electromagnetism in pixel art

author: lascauje


value: kylemathews

value:
Hey, I'm a co-founder at ElectricSQL. Durable Streams is the delivery protocol underneath our Postgres sync engine—we've been refining it in production for 18 months.
The core idea: streams get their own URL and use opaque, monotonic offsets. Clients persist the last offset they processed and resume with "give me everything after X." No server-side session state, CDN-cacheable, plain HTTP.
We kept seeing teams reinvent this for AI token streaming and real-time apps, so we're standardizing it as a standalone protocol.
The repo has a reference Node.js server and TypeScript client. Would love to see implementations in other languages—there's a conformance test suite to validate compatibility.
Happy to dig into the design tradeoffs—why plain HTTP over WebSockets, etc.

value: Show HN: Durable Streams – Kafka-style semantics for client streaming over HTTP

author: kylemathews


value: nizarmah

value:
I've been playing around with rendering pixel text using only CSS. No JS in the final result, and no per-pixel DOM elements (too heavy).
The demo page is rendered as a long list of CSS linear-gradients. Each letter is an 8x8 matrix. Each pixel becomes a tiny background image.
Demo: https://taktek.io
Gallery/Debugger: https://taktek.io/gallery
Code: https://github.com/taktekhq/taktekhq.github.io
At first, I wrote each linear-gradient pixel manually... When I came to resize each pixel's size, I wrote the generator script.
1. It takes the text -> 2. breaks it into letters -> 3. gets its matrix -> 4. returns the linear-gradients list.
It chooses a variant based on the context window. For example, a period after a sentence ("hello.") should look different than inside a domain ("example.com").
My workflow now is: open the gallery -> generate the CSS in the console -> copy the result into the static page.
It's very small and a dumb tool, but I want it for an upcoming project.
If you have any feedback, maybe some pitfalls, or a better approach, I'd love to hear them.

value: Show HN: Pixel text renderer using CSS linear-gradients (no JavaScript)

author: nizarmah


value: litcontent

value:
Hey HN,
Founder of LitContent here.
I'm excited and also slightly nervous to be sharing this on here, as I'm aware this might come off as another 'AI content creation' SaaS, and whilst in pure labels, that's technically the case, in functionality and in how I designed it to work, I believe it functions/feels different, and has the potential to save time and hassle during the content creation process, particularly for small - medium business owners with existing websites.
The largest pain points I designed LitContent to help with were the constant battles between maintaining context awareness and generating truly on-brand content, which can then become more complex when working with a team. To handle this by default, I implemented a process starting with the user submitting their website's sitemap URL (we also try to find sitemaps automatically and present to the user).
After scraping the sitemap, the full page contents are stripped down to their base text. This not only helps eliminate excessive token usage costs, but also enables our internal AI prompting strategies. For example, pre-existing URLs and page content are sent as negative AI prompts for features like generation post title suggestions. This is extremely useful for our new page content creator, where you don't want the AI to constantly recycle your existing pages, unless there's a good reason to do so.
Beyond the AI integration itself, I decided to also focus on the team collaboration workflow. For instance, when viewing a team member's revision for a specific piece of content, you can click our 'Smart Merge' feature. This sends both your current revision and your team member's selected revision to the AI, which automatically merges them into a consolidated draft in your editor. This process, which is trivial for AI, can save two human editors a significant amount of time and back-and-forth.
I know this is a bit long, so I won't list off any other features here. I would genuinely appreciate any criticism or feedback. Feel free to check out our walkthrough page (https://litcontent.com/walkthrough) even if you're not interested in signing up. If there's anyone reading this who is currently managing content workflows, I'd love to hear about any specific pain points you might be dealing with in that process.
Thanks so much, Benji

value: Show HN: LitContent – AI content designed to match your brand voice

author: litcontent


value:
When we set out to build AI tools for healthcare, we were forced to integrate with tons of legacy software lacking available APIs. We tried Computer Use Agents (CUAs). Here is what we found:
- Overhyped
- Too slow
- Too expensive
- Contemplate their existence when confronting date pickers
This is why we build Vectorly! A new way to access data hiding behind UI interactions and closed APIs. Our solution is simple:
Record your interaction with any website.
Tell our AI agent what data/API you need.
Reuse the automation as an API endpoint or MCP tool
Our approach has no secrets, we open source our reverse engineering method: https://github.com/VectorlyApp/web-hacker
Check out our demo: https://youtu.be/xX4ycRAU5dA
We made it very easy to reverse engineer web apps! Give it a go: https://console.vectorly.app
We are excited for you to try out Vectorly and look forward to your feedback :)

value: Show HN: No API? No Problem! Unlock web data behind clicks, searches, and UI


value: Show HN: Client-side file tools – PDF, images, crypto, all in-browser


value: FlorinDobinciuc

value:
Hey HN,
I’m a frontend dev who got tired of rebuilding the same SaaS UI for every project — billing, dashboards, teams & roles, etc.
I built UIforSaaS.dev: a set of production-ready React + Tailwind components and templates focused on common SaaS screens.
What’s inside:
– Billing: pricing tables, usage, invoices
– Accounts: teams, roles, API keys
– Analytics: dashboards, charts, activity
– A few full-page templates (billing, analytics, launch tracker)
Link: https://uiforsaas.dev
I’d love feedback on:
– What’s missing for you to actually use this?
– Any high-leverage screens I should add next?
Happy to answer questions or go into implementation details in the comments.

value: Show HN: UIforSaaS – Production-Ready SaaS UI Kit for React and Tailwind

author: FlorinDobinciuc


value: phrocker

value:
I have a project I've used for a couple of years that helps me refine prompts that are auto generated by agents that I score and refine based on a few given criteria. I've put it into a site: https://agentictuner.ai. I'm incorporating the same feature to scan JIRA and Github Tickets.
I highly doubt this is of use to anyone, so I was cautious about posting; however, if there is use and feedback to drive toward a better offering please let me know.
I've already encountered issues, so we have some refinements to make internally -- so I can't promise a fully working product yet ;) It's a rapid dev side project of a side project.
API to come.

value: Show HN: Prompt tuning with compliance and risk assessment.

author: phrocker


value: pinpointed

value:
I noticed wine e-commerce has terrible UX - customers don't know what to choose and bounce. Built a chat widget where they can ask "what wine for steak?" instead of filtering by appellation/body/tannins.
Stack: Cloudflare Workers, JWT auth, WooCommerce REST API, GPT-4 for recommendations
Demo: https://vinoadventures.eu (click chat bubble)
Free plan: 30 chats/month
Would love technical feedback on the architecture or pairing logic.

value: Show HN: AI Sommelier for WooCommerce Wine Stores

author: pinpointed


value: chiengineer

value:
took me a little over a month to do all this from scratch. made over 500 individual sites / components / different variations of sites / different stacks / I tried a lot of stuff
and this combo is the most capable, static anything I have ever built since I got github co pilot pro plus which lets me use agents to code on vs code directly its amazing and im making more things of course.
Hosted on github because its free and I made it possible so you can download the repository and plug and play for your own git hub pages
looking for any feedback if anyone has any ideas!
- goal was to showcase the capability of the different models quality of code production
- how much time coding vs cleanup vs babysitting
- Gemini 3 is legit crazy and the new base line for everything
- I attempted to code this like a full web app not sure if that part of it is 100% but it does look really good on mobile works great

value: Show HN: Astro and Tailwinds and TypeScript static 3D animations Demo

author: chiengineer


value: yehors

value: Meet silkworm-rs: a fast, async web scraping framework for Python built on Rust components (rnet and scraper-rs). It features browser impersonation, typed spiders, and built-in pipelines (SQLite, CSV, Taskiq) without the boilerplate. With configurable concurrency and robust middleware, it’s designed for efficient, scalable crawlers.

value: Show HN: Async web scraping framework on top of Rust

author: yehors


value: markhallen

value:
Hi HN,
I built DevReplay because I kept forgetting what I actually shipped. With AI speeding things up I’m multitasking more than ever, jumping between branches, experiments and side projects. A week later I couldn’t remember what I’d changed or why.
DevReplay connects to GitHub and gives you a simple “developer memory”:
 • Free tier: shows a clean event list (commits, PRs, comments)
 • $5/month: AI-generated daily summaries
 • Explore what you shipped by day
 • Understand what changed and why
 • Helpful for context switching and async work
It’s also surprisingly useful for indie projects and build-in-public updates (I’ve been using it to remember what I worked on across multiple side projects).
Link: https://devreplay.com
I’d really appreciate feedback:
 • Anything confusing?
 • Does the pricing feel reasonable?
 • What would make this more useful for teams or indies?
Happy to answer technical details (Rails 8, Hotwire, SQLite, etc.).
Thanks for reading!

value: Show HN: DevReplay – Developer memory for GitHub (free tier, AI summaries $5pm)

author: markhallen


value: pedroscosta

value:
I've created a visual flow editor to build parametric color palettes, meaning you can build a full palette based on a few inputs and change them afterwards to get a totally new palette.
I was inspired by this Linear blog post: https://linear.app/now/how-we-redesigned-the-linear-ui#2.-ap...

value: Show HN: Chromaflow – flow editor for parametric color palettes

author: pedroscosta


value:
We originally set out to solve complex debugging headaches and useless alerts caused by traditional security scanners in our own projects. Static Analysis (SAST) flagged too much noise because it couldn't verify runtime context, while Dynamic Analysis (DAST) missed internal logic bugs because it treated the app like a black box.
We built a CLI tool to bridge this gap using grey box testing from a red team approach. We use internal knowledge of the codebase to guide parallel execution, allowing us to find complex or hidden logic errors and attack paths standard linters/scanners miss.
The Tech (Grey Box Graphing & Execution):
- Internal Graphing (The Map): It ingests the codebase to build a dependency graph of the internal logic.
- Parallel Execution (The Test): The code is then tested on parallel engines. We spin up copies of your local dev environment to exercise the codebase in thousands of ways. This is the validation that proves a bug is real.
- Logic Error Detection: Because It understands the intended architecture (the graph) and sees the actual behavior (execution), we can flag Logic Errors, (ex. race conditions, state inconsistencies, memory leaks etc).
- Tainted Flow Mapping: We map tainted control flow over the dependency graph. This highlights exactly how external input threads through your logic to trigger a vulnerability. It then spins up a local instance to replay this flow and confirm the exploit.
How it runs: It runs locally via CLI to maintain privacy with secure repos and ease. Generates remediation via MD reports pinpointing the line of the error and downstream effects.
The Trade-off: This approach trades power for speed and deep testing. This testing engine is recommended for more sophisticated systems.
Try it out: We are currently opening our beta VS extension for early users.
Optimized for (Rust, C++, Go, Java) and IaC (Terraform, Docker, K8s). Also supports Python, TS/JS, C#, PHP, and (20+ other languages).
P.S. We are happy to run this ourselves on repos. If you maintain a complex project and want to see if our engine can find logic or security holes, drop a link or reach out via the comments/site and we’ll do it and send the results.

value: Show HN: Bloodhound – Grey-box attack-path discovery in Rust/Go/C++ binaries


value: theolivenbaum

value:
I got tired of shelling out to dotnet-gcdump to investigate memory leaks, so I made a tiny C# library that lets you trigger .gcdump captures programmatically. Useful for debugging memory leaks, taking snapshots before/after operations, or grabbing dumps automatically in CI.
Repo: https://github.com/curiosity-ai/memory-introspect
Package: https://www.nuget.org/packages/Memory.Introspect

value: Show HN: Library to help find memory leaks for C#

author: theolivenbaum


value: Quickz

value:
A neat little application that allows you to draw on your screen. Use it from anywhere you want - be it your desktop, while browsing internet or even while in a video game.
Quick preview: https://streamable.com/j7aklk
Any feedback much appreciated!

value: Show HN: An app that allows you to draw over everything

author: Quickz


value: ybceo

value: Show HN: We built a no-logs cloud provider where users are just a 32-char token

author: ybceo


value: GermanJablo

value:
Hi everyone! After two years of development, I’m excited to announce DocNode: a type-safe, fast, ID-based Operational Transformation (OT) framework for conflict-free collaborative editing. CRDT mode is in progress.
Along the way, I learned a ton. I rewrote the library several times. Sometimes because I was obsessed with the API, other times for technical reasons. I moved from CvRDT to CmRDT, and finally to ID-based OT.<p>Happy to answer questions!

value: Show HN: DocNode, A TypeScript OT library for local-first apps

author: GermanJablo


value:
There's no "authentication" step. You just generate a key pair and send the public key via pigeon.
I built this because I needed dynamic image examples for a learning app, i'm working on. I wanted to load them using standard  tags, which makes sending Authorization headers impossible.

value: Show HN: Monetizing an API using private keys


value: kaicbento

value: A small tool I built for personal use suddenly reached thousands of users. The technical part was simple; the real challenge was handling expectations, feedback, growth, and the psychological pressure of open-source visibility. I wrote a breakdown of what actually happens behind the scenes.

value: Show HN: My small tool blew up unexpectedly

author: kaicbento


value: petarsubotic

value:
I built a small web based activity to help kids (7–10 years old) develop a basic sense of “digital immunity” the skill of recognizing when a headline is neutral versus when it’s written to manipulate attention. Kids get a short description of an event, then choose which headline most accurately reflects what happened. After each choice parents can talk with them about why some headlines feel more dramatic or sensational.
Demo: https://submerge.rs/news
My goal was to make the first step of media-literacy training lightweight, practical, and something parents can actually do with kids without needing prep or prior expertise. I’d appreciate any feedback on:
- does it flow nicely
- is stated goal clear and achieved
- content types
- UI/UX or accessibility issues you notice
Thanks for taking a look.

value: Show HN: Parent-child activity to help kids spot clickbaits and doom-content

author: petarsubotic


value: mpingu

value:
I’ve worked in operations and SRE for years, mostly in environments where outages, oncall fatigue and recurring incidents were normal. Like many here, I’ve been through the 3 AM pages, the tribal knowledge, the fixes that disappear in scrolling Slack threads, and the runbooks nobody touches until it’s too late.
I also live with Type-1 diabetes. That forces me to run extremely disciplined systems in my personal life: continuous monitoring, feedback loops, automated corrections, stability under stress. It shaped how I think about infrastructure in an unexpected way.
I have oncall in my blood literally. My blood sugar is basically a live monitoring system.
And that made me notice something strange about current observability stacks:
We measure everything except the one thing that actually resolves incidents: the human problem-solving process.
Every outage generates knowledge, but most of it evaporates:
- shell history disappears
- Slack conversations drift away
- senior engineers fix silently
- runbooks rot
- context is lost
- the same incident happens again and is solved again
So I’m exploring a new layer for the SRE stack: an Incident Intelligence Layer.
High-level idea (no deep tech here):
- troubleshooting sessions become structured, anonymous traces
- each incident type gets a shared knowledge feed
- engineers upvote or downvote solutions
- a local LLM summarizes recurring patterns
- a sanitized layer allows safe use of a public LLM
- repeated successful solutions gradually become recommended actions or potential automation candidates
The goal is simple: every outage should make the system smarter, not just the engineer who fixed it.
I’m working on an early MVC:
- a minimal session recorder that emits structured JSON
- basic incident-type feeds
- voting
- a first pass of local LLM summarization
Not a full product. Just exploring the space and validating whether others see the same gap.
Would love to talk with people who:
- work in SRE or oncall
- build observability or internal tooling
- have tried to reduce repeated incidents
- think about AI-assisted remediation
- or have built infra startups before
If this resonates, feel free to DM me here on HN. Happy to share more privately.

value: Show HN: An Incident Intelligence Layer that learns from real oncall work

author: mpingu


value: glouwbug

value: Show HN: I Simulated an Inline Internal Combustion Engine in C

author: glouwbug


value: benbreen

value: Show HN: Gemini 3 imagines Hacker News as a HyperCard stack in 1994

author: benbreen


value: damidare

value:
Last year I built an app for event discovery but I completely botched go-to-market.  I did get some traction with influencers, except the process of vetting them was painful.
I spent way more time on Instagram than I ever wanted to. Even when I finally had a few people in mind, with my constrained budget, I was seeking asymmetric outcomes and wanted to find creators “on the rise”.  I'd find a creator that i think might fit,  then burn 45 minutes watching their stuff trying to see if I liked their tone of voice.
So I built something that addresses some of these challenges, It fetches video content at query time for a creator, uses gemini’s multimodality to extract aspects you might find useful and returns a set of  attributes you can then apply your brand statement or filter criteria against.
It takes 2-3 minutes per creator to get an evaluation or a brand fit report. But you can get some really in-depth analysis and define any criteria you like.
[https://thehypebridge.com](https://thehypebridge.com/)
Please share your thoughts. And if you want some free tokens beyond what the free plan allows,  please let me know.

value: Show HN: Gemini powered natural language search over influencer content

author: damidare


value: AlexDenisov

value:
Around 9 years ago I wrote a blog-post looking for scientific papers in OpenJDK [0].
Back then I simply greped the source code searching for PDFs and didn't even know what a DOI is.
Since then, whenever I entered a new domain or worked in a new codebase, I wished I could see the papers referenced in the source. For example, PyTorch has great papers [1] describing implementation details of compilation and parallelization techniques. Reading those papers + the code that implements them is incredibly helpful for understanding both the domain and the codebase.
I finally decided to build PaperGrep as a simple tool for this. The biggest challenge wasn't parsing citations (though that's hard) - it's organizing everything in a useful way, which I'm still figuring out.
So far, the process is semi-automated: most of the tedious parts such as parsing, background jobs, metadata search is automated, but there is still a lot of manual work to review/curate the papers coming from ambigous or unclear citations.
Yet, I've already found some interesting papers to read through, so the effort was definitely worth it!
Current selection of repos is biased based on my interests - what domains/repos am I missing?
[0] https://news.ycombinator.com/item?id=13022649
[1] https://papergrep.dev/repository/pytorch/pytorch

value: Show HN: PaperGrep – Find academic papers referenced in production code

author: AlexDenisov


value: cpojer

value: Show HN: Fate, a new data framework for React and tRPC, inspired by Relay

author: cpojer


value: Giviberidze

value:
Hey folks,
In KLIPY - a localized GIF API library - and we just shipped an AI Emojis feature. It is an API endpoint plus a large emoji library that lets your users generate, search and share AI emojis in real time while messaging, creating content, etc.
If you are building a messaging app, keyboard, or creator tool and want to try this out, I am happy to share early access and more details.
More info: https://klipy.com/en-US/emojis
Create yours for free: https://klipy.com/create
If you want free gif api or sticker api feel free to check out our developers page - https://klipy.com/developers

value: Show HN: AI Emojis API for Apps

author: Giviberidze

title: Show HN: AI Emojis API for Apps


value: rvranjan

value: Show HN: Briddle – Guess the AI's semantic path between two words

author: rvranjan


value: cipz

value:
NekoDJ let's you generate Spotify and YouTube playlists based on a mood, experience, or anything that's passing on your mind.
It's free to try and the playlists are public (no login required).
Browse through the existing playlists, try it out and if you have any feedback, reach out!

value: Show HN: NekoDJ – Turn what's on your mind into a Spotify and YouTube playlist

author: cipz


value: illdynamics

value:
I’ve been working on an open-source project called QonQrete and would like feedback from HN.
What it is
QonQrete is a local-first, agent-based orchestration system for code generation. It coordinates multiple LLM “agents” to plan, write, and review code, while keeping execution inside a sandbox on your own infrastructure. Think of it as a construction yard for AI-assisted development that you run yourself.
Why I built it
Most multi-agent demos I saw had two issues:
– Security: generated code often runs in the same environment that’s orchestrating it.
– Observability/control: long agent chains become opaque, and it’s hard to insert human checkpoints cleanly.
I wanted a setup where:
– Agent-produced code runs in isolated containers.
– The orchestration layer never directly executes that code on the host.
– You can choose between fully automatic cycles and human-in-the-loop approval.
Architecture
Current pipeline:
– InstruQtor: takes a high-level task and breaks it into an execution plan.
– ConstruQtor: follows the plan and generates code/artifacts.
– InspeQtor: reviews outputs, flags issues, and can request another iteration.
Under the hood, each agent is just an LLM API call with a different role. Execution happens in containerized “microsandboxes” (Docker today). The host only sees artifacts that passed through the review step.
Security model (current state)
The prototype:
– Runs generated code in throwaway containers with specific volume mounts.
– Keeps orchestration separate from the execution sandbox.
– Treats all agent-generated code as untrusted.
It’s not a formal sandbox or a security product; it’s a pragmatic attempt to avoid “let the LLM directly edit your repo and run scripts on your laptop”. I’d be very interested in feedback from people with stronger threat models or prior art here.
Execution modes
Two modes:
– Autonomous: agents can run through multiple cycles without input until a stopping condition.
– User-gated: the system pauses at checkpoints (after plan, first implementation, etc.) and waits for you to approve, adjust instructions, or stop.
LLM providers
The orchestration layer is provider-agnostic. You can configure different providers per agent (e.g. smaller model for planning, stronger model for implementation, reasoning-focused model for review). It currently supports OpenAI, Gemini, Claude, and DeepSeek via API keys.
Local-first
QonQrete doesn’t host anything. You run it on your own machine or server:
– No external service or managed backend.
– Your API keys stay local.
– Artifacts live in your filesystem/Git.
The repo includes a basic CLI and example flows.
Status
Early-stage:
– Core three-agent pipeline works.
– Microsandbox execution is functional but evolving.
– A TUI for inspecting cycles is in progress.
I’m not claiming this is the right way to do multi-agent systems; it’s an experiment in making them more observable and less risky to run.
What I’d like feedback on
– Does the orchestration vs execution separation make sense?
– Are the agent roles (plan → build → review) structured in a sane way?
– Thoughts on the sandboxing approach and likely failure modes?
– Does this add enough value over simpler “single-agent with tools” setups?
Repo
Code, setup instructions, and examples:
https://github.com/illdynamics/qonqrete

value: Show HN: QonQrete – Local-first multi-agent system for sandboxed code generation

author: illdynamics


value: maoaeiou

value: Show HN: OCIdol – AI OC maker and studio for original characters

author: maoaeiou


value: olivato

value:
Look, I just wanted to send logs to Telegram, Discord, and Slack without having to always spend 15min reading docs.
Usually it goes as following:
Discord wants the webhook in format A
Telegram needs a bot token AND a chat ID
Slack wants everything wrapped in JSON origami
And the docs for all three look like they were written by different species.
I looked at existing solutions. They all seemed to require too much config or they were part of a bigger alerting software. I wanted something stupid simple.
So I made Crystal Sage. It's a 14.8MB Go binary. Yes, I KNOW. 14MB just to make HTTP requests.
You only configure one single config.yaml
Then curl ( or use whatever thing to make a http request ) once and it hits everything:
curl -X POST localhost:8080/prod-alerts -d "content=Server is on fire "
That's it. One YAML file. All your messaging platforms. Multiple channels per platform if you want.
Docker: https://hub.docker.com/repository/docker/olivatooo/crystal-s...
GitHub: https://github.com/olivatooo/crystal-sage

value: Show HN: Crystal Sage, I got tired of fighting with webhooks

author: olivato


value: Show HN: OG Image API – Generate social preview images from JSON


value: jjuliobit

value:
Hi HN,
I’m building Fluxentra, a real-time on-chain analytics tool for Uniswap liquidity providers.
With just a wallet address, users can instantly track:
- Active liquidity pools
- Fees
- Liquidity positions
- Real on-chain profit & loss
No trading signals, no simulations — only direct blockchain data.
I built this to solve my own problem as a liquidity provider and would love feedback from other LPs and DeFi builders.
Thanks!

value: Show HN: Real-time on-chain PnL tracking for Uniswap liquidity providers

author: jjuliobit


value: BSTRhino

value: Show HN: Beelines - a travelling salesman game, but with bees

author: BSTRhino


value: Jeannen

value: Hey!<p>It always annoyed me to manually try to figure out the best winning ads from competitors, so I created my own ads library that automatically calculates it

value: Show HN: An an Ad Library/Competitor Tracking for B2B SaaS

author: Jeannen


value:
I love the Wordle game, but one puzzle a day feels way too slow if you're actually trying to get better. So I built wordles.org - a simple unlimited Wordle practice site.
It also has one extra thing I always wished the original had: you can create your own 4–10 letter word and share a link so friends can guess it.
I'm not sure if people actually want a practice tool like this or if I'm just the kind of person who plays 10+ rounds a day.
Curious what others think:
Is unlimited Wordle useful or just noise?
Are custom puzzles fun or annoying?
If something feels off, tell me straight. I'd rather get blunt feedback than polite silence.

value: Show HN: An unlimited Wordle practice site I built


value:
Qyavix is a tiny DOM runtime with a React-like state hook (`u`) and a simple render function (`r`).
The entire framework is only 155 bytes (minified, no gzip).
I built it for benchmarks, experiments, and micro-UI systems.
The official website (https://qyavix.pages.dev) is fully rendered using Qyavix itself.
Features:
 155 bytes total size
 Zero dependencies
 Works with plain DOM nodes
 Hooks-like state system
 Fast re-rendering (full refresh)
 Pure JavaScript, no build tools needed
Would love feedback from the community!

value: Show HN: Qyavix – A 155-byte DOM runtime inspired by React hooks


value: binsquare

value: Built a community-driven database for inference hardware. All results are submitted by users and validated by volunteers.

value: Show HN: Inferbench, collect/share datapoints on GPU's inference performance

author: binsquare


value: snasan

value: The entire interview process is almost entirely conducted by AI, except for the final step which involves a human review.

value: Show HN: AI Interview-to-Offer Agent Network

author: snasan


value: A really good AI video website. I like its design style and interaction method very much

value: Show HN: AI Art Platform: Video and Image Creator – VGenie