value: hamzaawan

value:
I’m an indie hacker. Like many of you, I usually have 3 or 4 projects running at once. My biggest frustration with existing email APIs (the Resends and Postmarks of the world) is how they handle domains.
Most platforms restrict you to a single domain on the free tier, and even the initial paid tiers are surprisingly stingy. Whenever I started a new experiment, I had to "kill" the email for a previous project just to reuse the domain slot. If a user tried to sign up or reset a password on an older project, it was effectively dead.
I built Simple Email API to stop this cycle. I wanted an email API that doesn't punish you for experimenting.
Two things I focused on:
1. Multi-domain by default You can add unlimited domains without being forced into a $20/month plan immediately. I’ve optimized the infrastructure to keep costs low so I can provide affordable pricing. You can keep your old projects alive while you build your next one.
2. Native Inbound (not an afterthought) Most APIs are built for outbound, and inbound feels like a complex add-on. Here, every email is "reply-ready" out of the box.
For Production: We have standard webhooks.
For Prototyping: We have a simplified onReceive callback. If you're building an AI agent or a quick script, you don't want to deal with webhook endpoints and secrets. You can get up and running with just an API key.
The goal is to be the simplest possible way to send and receive emails. I’m looking for brutally honest feedback.

value: Show HN: I built an email API because of limited domains and flaky inbound

author: hamzaawan


value:
Gitmore (https://gitmore.io) – makes Git activity accessible to people who don't use Git.
Every commit has a message. Every PR has a title and description. The status update already exists. It's just locked in GitHub.
*Who this is for:*
- Founders updating investors
- PMs writing release notes
- CEOs who want visibility without standups
- Anyone who asks "what shipped?" and waits for an engineer to respond
*What it does:*
Connect your repos. Ask questions:
- "What shipped this month?"
- "Who worked on the billing feature?"
- "Which PRs are stuck?"
Or schedule automated reports to Slack or email. Weekly, monthly, whatever.
*How it works:*
We register webhooks. Git platforms push event metadata – commit messages, PR titles, descriptions, authors, timestamps, file counts.
Every event gets normalized into a structured schema. The AI queries structure, not raw text.
*What we don't do:*
We don't do code review. We don't analyze diffs. We don't compete with Coderabbit or Greptile. Those are for engineers inside the PR workflow.
This is for people outside that workflow who need visibility.
*Security:*
Webhooks only. We never clone repos or access source code.
- Token encryption: Fernet (HMAC-SHA256 + AES-128-CBC)
- Webhook verification: HMAC-SHA256
- 2FA support
Works with GitHub, GitLab, and Bitbucket.
Free for 1 repo: https://gitmore.io
How do non-technical people at your company stay informed on dev progress?

value: Show HN: Ask your repos what shipped in plain English


value: pelmenibenni

value:
I made a site to generate these Mini Figures!
I saw a post, where someone made them with AI and just wanted to make a site for it to make them myself.
Yes it's just a wrapper, but feel free to use it!
https://v0-miniatureself.vercel.app/
Thank you!!
They guy on the picture also has a shop for this beanie if anyone is interested!
https://walkwithgod.shop/

value: Show HN: MiniatureSelf – Transform your selfie into a miniature figure

author: pelmenibenni


value: claeusdev

value: Inspired by Julia Evans' blog post on brag documents.

value: Show HN: Generate brag documents from your Git history

author: claeusdev


value: A simple, colorful CLI wrapper around curl for easier terminal usage.

value: Show HN: A simple colorful CLI wrapper around curl for easier terminal usage


value: A simple resume generator written in Rust that converts declarative .rcv files into beautiful PDFs.

value: Show HN: A simple resume generator written in Rust


value: Evidlo

value:
I wanted to print out some vocabulary flashcards to hand out at my local Esperanto club, so I built this static webapp which converts .apkg files to a printable grid of cards.
Anki decks are a little complicated (XML inside a sqlite database inside a zstd archive), so getting this working in-browser was a bit tricky.
Let me know if it's useful to you!

value: Show HN: Print Your Anki Decks to Paper

author: Evidlo

title: Show HN: Print Your Anki Decks to Paper


value: casmn

value: latest release of dotenv-diff<p>Anyone working with Sveltekit or Next.js who have tried this?

value: Show HN: V2.4.9 – Environment Variable Validation for SvelteKit and Next.js

author: casmn


value: raianpollock

value:
I built this app because Slack's endless notification spam is the modern day cancer of workspaces, and I had this challenge on literally every single job I've ever had.
ThreadPatrol scans incoming messages, determines if it should've been a threaded response instead and if so, discretely messages the author in-thread about it. it gently enforces threading culture without being the bad guy. the result is dramatically less notification spam in Slack.
now that Teams also has a threading feature, we're considering whether to add it.
would love to hear the community's thoughts.

value: Show HN: ThreadPatrol ends messy Slack workspaces by gently enforcing threads

author: raianpollock


value: harran

value: Show HN: AI background remover that runs 100% in the browser

author: harran


value: Show HN: Run and Compile LLMs in PyTorch on WebGPU


value: serengil

value:
DeepFace previously relied on filesystem-based datasets and pickle caches for face search, which made it stateful and hard to expose via APIs.
We introduced register and search functions that store embeddings in a backend DB (Postgres, Mongo, Weaviate, Neo4j).
This makes face recognition stateless, horizontally scalable, and suitable for API use.
For Postgres and Mongo, FAISS is used for ANN search; Weaviate and Neo4j handle vector indexing natively.
Additional databases and vector stores can be added over time.

value: Show HN: DeepFace now supports DB-backed vector search for face recognition

author: serengil


value: bmus

value: BmuS - Back Me Up Scotty can now also be installed in a Docker container and can therefore also be used on Windows or Mac systems, for example.

value: Show HN: BmuS Backup tool now supports Docker

author: bmus


value: jphfa

value: Show HN: Mp3rgain – Lossless MP3 volume adjustment in Rust

author: jphfa


value:
I built a Plex client that runs (almost) everywhere (macOS, Windows, Linux, iOS, Android) because I got tired of transcoding. It uses mpv, so it direct plays pretty much anything - HEVC, AV1, HDR, Dolby Vision, and ASS/SSA subtitles.
You can download media for offline viewing, and do synchronized Watch Together sessions over WebRTC.
Built with Flutter, fully open source. Available on the App Store, Play Store, and GitHub with desktop binaries.

value: Show HN: Plezy – alternative Plex client built with Flutter


value: schappim

value: Show HN: AsciiSketch a free browser-based ASCII art and diagram editor

author: schappim


value:
Something I have been working on for a while. Pet project for my own use that a bunch of people asked me if they could play with.
Chrome extension and desktop widget (Electron) to make it easy to capture notes, screenshots, links, audio, files almost anything. Pushed into your own knowledge base. We apply a little AI to fix typos, pull out topics, people, but of summarisation (needs a lot of work), and relationships to other entries.
You can search, quick and dirty or AI natural language and use grids, kanban and other UIs so sort and interact with whatever you have captured - projects, tasks, knowledge.
Lots of customisation to make it work your way.
There are lots of bugs, issues, and maybe poor design choices. And HN is tough crowd. But I also think there is the bones of something cool here so would love feedback.

value: Show HN: Capture anything you see, here or think in your own knowledge base


value: kotysoft

value: Show HN: Giant JSON Viewer – Open 1GB+ JSON Files on Android (Rust and MMAP)

author: kotysoft


value: BlueSlide

value:
TLDR backstory: Both my late grandfathers had strokes and lived a significant portion of their lives without advanced speech. I wanted to make it easy for them to communicate with their loved ones. Since they passed it’s essential become my charity project.
It’s built using Expo, TTS using expo-speech. I think it’s been feature complete for over a year, but I’ve had no engagement since I stopped using it, at least according to the traffic on the box.
You don’t need to sign up like other AACs, it doesn’t use cookies or ads, should work on most devices, and I haven’t had it audited by an AAC professional, just my grandmother’s requirements.
I appreciate any feedback, and if even one person finds it useful, I’ll be happy to have made a difference.
Thanks for your time

value: Show HN: Speakhelp.org – An AAC tool for those with speech difficulties

author: BlueSlide


value: glennhv

value: Show HN: Free Personal Password Manager

author: glennhv

title: Show HN: Free Personal Password Manager


value: arjunchint

value:
Most of us have a list of URLs we need data from (government listings, local business info, pdf directories). Usually, that means hiring a freelancer or paying for an expensive, rigid SaaS.
We built an AI Web Agent platform, rtrvr.ai to make "Vibe Scraping" a thing.
How it works:
1. Upload a Google Sheet with your URLs.
2. Prompt: "Find the email, phone number, and their top 3 services."
3. Watch the AI agents open 50+ browsers at once and fill your sheet in real-time.
It’s powered by a multi-agent system that can take actions, upload files, and crawl through paginations.
Web Agent technology built from the ground up:
End to End Agent: we built a resilient agentic harness with 20+ specialized sub-agents that transforms a single prompt into a complete end-to-end workflow. Turn any prompt into an end to end workflow, and on any site changes the agent adapts.
Dom Intelligence: we perfected a DOM-only web agent approach that represents any webpage as semantic trees guaranteeing zero hallucinations and leveraging the underlying semantic reasoning capabilities of LLMs.
Native Chrome APIs: we built a Chrome Extension to control cloud browsers that runs in the same process as the browser to avoid the bot detection and failure rates of CDP. We further solved the hard problems of interacting with the Shadow DOM and other DOM edge cases.
Cost: We engineered the cost down to $10/mo but you can bring your own Gemini key and proxies to use for nearly FREE. Compare that to the $200+/mo some other lead gen tools like Clay charge.
Use the free browser extension for login walled sites like LinkedIn locally, or the cloud platform for scale on the public web.
We are thinking it can be a great upstream tool to your CRM to generate lists and enrich data.
Curious to hear if this would make your lead generation, scraping, or automation easier or is it missing the mark?

value: Show HN: Vibe scrape with AI Web Agents, prompt => get data [video]

author: arjunchint


value: Show HN: Free WCAG accessibility scanner – EAA compliance deadline is June 2025


value: subtlesoftware

value: Show HN: Agentic Equities – track ChatGPT sentiment around stocks

author: subtlesoftware


value: jph

value:
If you use Rust and want to learn about the Lettre crate for sending email using SMTP, here's a simple demonstration that can help with Lettre SMTP diagnostics and troubleshooting.
Feedback welcome, especially how to make it even easier for newcomers to diagnose SMTP issues. This code is all hand coded, no AI.
There are three implementations: synchronous, asynchronous with tokio1 rustls tls, asynchronous with tokio1 native tls.
https://github.com/joelparkerhenderson/demo-rust-lettre-sync
https://github.com/joelparkerhenderson/demo-rust-lettre-async-tokio1-rustls-tls
https://github.com/joelparkerhenderson/demo-rust-lettre-async-tokio1-native-tls

value: Show HN: Demo of Rust Lettre crate for sending email using SMTP

author: jph


value: NoraWW

value: Show HN: Neutriva – A personalized health and wellness tracking assistant

author: NoraWW


value: Show HN: Cymatica – Chladni Plate Simulator


value: jellyotsiro

value:
Hi HN,
I built an open-source AI agent that has already indexed and can search the entire Epstein files, roughly 100M words of publicly released documents.
The goal was simple: make a large, messy corpus of PDFs and text files immediately searchable in a precise way, without relying on keyword search or bloated prompts.
What it does:
- The full dataset is already indexed
- You can ask natural language questions
- Answers are grounded and include direct references to source documents
- Supports both exact text lookup and semantic search
Discussion around these files is often fragmented. This makes it possible to explore the primary sources directly and verify claims without manually digging through thousands of pages.
Happy to answer questions or go into technical details.
Code: https://github.com/nozomio-labs/nia-epstein-ai

value: Show HN: OSS AI agent that indexes and searches the Epstein files

author: jellyotsiro


value: AGDNoob

value: Show HN: Axis – A systems programming language with Python syntax

author: AGDNoob


value: I rewrited slsqp solver in rust with help of vibe coding. No harm to create a wasm demo.

value: Show HN: A slsqp solver WASM demo

title: Show HN: A slsqp solver WASM demo


value: pud

value: I previously founded DistroKid. Made Tizzy to help me get stuff done.

value: Show HN: I made a to-do list web app that nags you via text message

author: pud


value: failsafe

value: Show HN: Cachekit – High performance caching policies library in Rust

author: failsafe


value: Show HN: This guy is smarter that two thirds of (You)


value: jupiterglimpse

value: Show HN: Early Compression in High-Dimensional Reality Stops Action

author: jupiterglimpse


value: shevis

value: Show HN: Multiplayer Game of Life

author: shevis

title: Show HN: Multiplayer Game of Life


value: arthurstarlake

value:
Find the exact activity you wish to perform by setting the desired 0/0-10.0 value of how much you need each of these dimensions:
Flow Accessibility
Challenge Alignment
Discovery Amount
Ease of Discovery
Novelty Seeking
Risk/Thrill Level
Interactivity
Response Intensity
Feedback Clarity
Sensory Richness
Randomicity
Repeatability
Perspective Mode
Session Duration
Engagement Frequency
Commitment Level
Entry Barrier
Financial Investment
Collaboration Depth
Competitive Intensity
Teaching/Learning Ratio
Audience Presence
Physical Exertion
Tactile Engagement
Spatial Needs
Physical Accessibility
Cognitive Load
Mindfulness Potential
Intuitiveness
Objective Clarity
Learning Curve
Reaction Speed
Planning Required
Parallelism
Autonomy Level
Personalization Depth
Avatar Agency
Consequence Weight
Mastery Ceiling
Real-World Utility
Skill Transferability
Output Tangibility
Legacy Potential
Cathartic Release
Nostalgia Factor
Root Chakra
Sacral Chakra
Solar Plexus Chakra
Heart Chakra
Throat Chakra
Third Eye Chakra
Crown Chakra
Physiological Need
Safety & Security
Social Belonging
Esteem & Status
Self-Actualization
Activities automatically filter based on the selection. The initial data holds about 100 everyday activities, 60 videogames and 30 movies and series.
There is a selector for how tightly you want to filter selections.
You can add new activities locally, edit dimension values (locally only) and eventually will be able to add new dimensions to filter on. You can also reset any filter or local edit.

value: Show HN: Overengineered recommender (activity/game/series/etc.) (57 knobs)

author: arthurstarlake


value:
Hi all
We just launched a video. It focuses on drafting emails with HITL using Supabase, Gmail and Seer.<p>Curious how are you managing welcome emails at your startup / company / project?

value: Show HN: Open-source welcome email automation: Supabase + Gmail + Seer


value:
Free time project: Pulls in bug reports from Reddit/Sentry/GitHub/etc, clusters similar ones with embeddings, then you can trigger a coding agent to attempt a fix and open a PR.
Super early, breaks constantly. Not sure if the clustering actually works well or if the auto-fixes are useful beyond toy examples.
Curious if anyone else has tried something like this or if it's something that would be useful for you.

value: Show HN: Soulcaster – Cluster feedback, spin up an agent to fix it


value:
hi hn,
i built openwork, an open-source, local-first system inspired by claude cowork.
it’s a native desktop app that runs on top of opencode (opencode.ai).
it’s basically an alternative gui for opencode, which (at least until now) has been more focused on technical folks.
the original seed for openwork was simple: i have a home server, and i wanted my wife and i to be able to run privileged workflows. things like controlling home assistant, or deploying custom web apps (e.g. our customs recipe app recipes.benjaminshafii.com), legal torrents, without living in a terminal.
our initial setup was running the opencode web server directly and sharing credentials to it. that worked, but i found the web ui unreliable and very unfriendly for non-technical users.
the goal with openwork is to bring the kind of workflows i’m used to running in the cli into a gui, while keeping a very deep extensibility mindset. ideally this grows into something closer to an obsidian-style ecosystem, but for agentic work.
some core principles i had in mind:
- open by design: no black boxes, no hosted lock-in. everything runs locally or on your own servers. (models don’t run locally yet, but both opencode and openwork are built with that future in mind.)
- hyper extensible: skills are installable modules via a skill/package manager, using the native opencode plugin ecosystem.
- non-technical by default: plans, progress, permissions, and artifacts are surfaced in the ui, not buried in logs.
you can already try it:
- there’s an unsigned dmg
- or you can clone the repo, install deps, and if you already have opencode running it should work right away
it’s very alpha, lots of rough edges. i’d love feedback on what feels the roughest or most confusing.
happy to answer questions.

value: Show HN: OpenWork – An open-source alternative to Claude Cowork


value: johndimm

value: Show HN: Apps posted here classified by LLM

author: johndimm


value: Show HN: MapMates – A map for expats to find people in new cities


value: csawai

value:
Hi HN,
I built this because I regularly switch between work, personal, and client GitHub accounts and kept committing with the wrong identity.
This is a small CLI that lets you define multiple Git identities and switch them per-repo without touching global config.
It doesn’t manage SSH keys — it focuses only on Git name/email to reduce mistakes.
Would love feedback or suggestions. Happy to answer questions.

value: Show HN: Git-identity-switcher – a CLI to switch Git user identity per repo

author: csawai


value: Gregoryy

value:
We propose a RAG architecture that uses hierarchical semantic chunking and graph-based context exclusion to maximize relevant information while minimizing the total volume of retrieved context.
The system recursively splits documents into a hierarchical tree structure and dynamically selects the most optimally-sized chunk from each branch by identifying and excluding redundant ancestors and descendants during the search process.
This approach ensures a higher relevant-to-total information ratio by retrieving diverse segments from across the document without including overlapping or nested chunks

value: Show HN: RAG Architecture for optimizing retrieval volume/relevancy tradeoff

author: Gregoryy


value: superhuang

value: Show HN: A directory to discover and install validated Agent Skills

author: superhuang


value: deciphergit

value:
I got tired of:
  - .env files committed to Git (seen it happen 100+ times)
  - API keys shared in Slack
  - Wondering who has access to what secrets
So I built Liberty - a CLI tool that replaces .env files with hardware-bound encryption.
How it works:

  $ pip install liberty-secrets
  $ liberty add DATABASE_URL postgresql://...
  $ liberty add STRIPE_KEY sk-...
  $ liberty exec npm start

Secrets are encrypted with a key derived from your machine's hardware (CPU ID
+ machine ID + disk serial). If someone steals your .liberty vault file, it's useless on their machine.
Features:

  - Hardware-bound AES-256-GCM encryption
  - Complete audit trail (compliance-ready)
  - Works offline (no servers, no accounts)
  - Global vault (~/.liberty/ works from any directory)
  - MIT licensed, free for individual use

GitLab: https://gitlab.com/deciphergit/liberty
PyPI: https://pypi.org/project/liberty-secrets/
Team features (secret sharing) coming soon as paid tier.
Feedback welcome!

value: Show HN: Liberty – Hardware-bound secret manager (no more .env files)

author: deciphergit


value: CzaxTanmay

value:
Hi HN  I’m the creator of Cyber+.
Cyber+ is an open-source programming language designed specifically for cybersecurity tasks like scanning, reconnaissance, and security automation. I built it because general-purpose languages felt too heavy and verbose for quick security workflows.
The project is still experimental, but it’s runnable and includes a basic interpreter and examples. I’d really appreciate feedback on:
- The language design and syntax
- Whether a security-focused DSL is useful in practice
- What features would matter most to you
Repo: https://github.com/TanmayCzax/Cyber-Programming-language-Alp...

value: Show HN: Cyber+ – A cybersecurity-focused programming language

author: CzaxTanmay


value: kingcauchy

value: Go bindings for CoreML that let you build and run ML models on Apple Silicon from Go, no Python required.<p>You construct models programmatically using CoreML's MIL intermediate language, then run them on the Neural Engine, GPU, or CPU. Also works as a GoMLX backend.

value: Show HN: Go-CoreML – Go Bindings for Apple's CoreML with Neural Engine Support

author: kingcauchy


value: osgohe

value: Show HN: Gilda runs multiple LLMs, compares them, and merges the result

author: osgohe


value: ClozeLine

value: Show HN: Drop The Adverb – Replace weak verb+adverb pairs

author: ClozeLine


value: oacikelli

value: Show HN: Serverless GraphQL analytics framework for AWS

author: oacikelli


value: maybe-tomorrow

value:
I’ve been working on a browser-based evolutionary simulation as a personal experiment.
Organisms adapt to environmental pressure over time, and there are no explicit goals or scoring, the system is open-ended and runs continuously.
I built this mainly to challenge myself and to explore how to surface simulation behavior and statistics in a way that stays readable rather than overwhelming. As a side effect, it’s also something my kids enjoys watching run.
Curious what resonates and what doesn’t, and happy to answer questions about the design or tradeoffs.

value: Show HN: A browser-based evolutionary simulation with emergent behavior

author: maybe-tomorrow


value: ntempus

value:
Hello HN,
I built Nix because I needed a fast, secure way to share environment variables and API keys with my team without creating accounts or worrying about server logs.
The Problem: Most "pastebin" tools are either not encrypted, require a login, or are closed source (so you have to trust them blindly). I wanted something that did one thing well: encrypt data in the browser so the server never sees the key.
How it works:
Client Side Encryption: Nix uses the Web Crypto API (window.crypto) to encrypt your text or files with AES-256-GCM.
The URL Hash: The decryption key is part of the URL fragment (#key). Since fragments are never sent to the server, I literally cannot see your data even if I wanted to.
Ephemeral: You can set expiration times (5m, 1h, 24h) or "Burn on Read."
The Stack:
Next.js / React
Tailwind CSS
Web Crypto API (No external crypto libraries)
Repo: https://github.com/ntempus/nix
It’s free, no ads, and no tracking. I’d love to hear your feedback on the security implementation or the UX.

value: Show HN: Nix – open-source, zero-knowledge secret sharing

author: ntempus


value: pythongiant

value: If you’ve ever been curious about how GPT actually works under the hood, I built a small project you might find interesting. I implemented a GPT-style transformer from scratch in a single notebook—covering tokenization, embeddings, causal self-attention, training, and autoregressive text generation without relying on high-level abstractions. The focus was on mechanistic clarity rather than scale or performance, and the notebook is structured to read more like a technical walkthrough than an experiment log. Feedback from people who’ve built or studied transformers would be very welcome.

value: Show HN: I built GPT from scratch to understand how it works

author: pythongiant


value: analyses-web

value:
Hi HN,
I built *Abuse Signals API*, a small API that returns *deterministic, signals-only* abuse indicators for a domain or an email (domain extracted). It’s meant for signup/onboarding pipelines where you want a transparent triage signal without a black-box model.
What it does:
- Input: `domain=...` or `email=...` (exactly one)
- Output: `abuseScore` (0–100), `abuseLevel`, a list of triggered `signals`
- Optional `explain=1`: returns per-signal explanations (severity + category + note)
- Fixed OpenAPI contract (`v1`): stable schema for integrations
Why I built it:
- I wanted something deterministic and explainable (same input → same output), with explicit “lookup_failed_*” transparency signals when external lookups time out.
Endpoints:
- `GET /abuse-signals`
- `GET /usage` (monthly quota usage for the API key)
Quick try (requires an API key):
curl "https://abusesignalsapi.analyses-web.com/abuse-signals?domai..." \
  -H "X-API-Key: YOUR_API_KEY"
Example response (truncated):
{
  "input": { "email": null, "domain": "fake-buy-info-product-example.shop" },
  "abuseScore": 75,
  "abuseLevel": "high",
  "signals": ["disposable_domain_pattern","low_domain_age","many_hyphens_or_digits","lookup_failed_rdap"],
  "version": "v1",
  "meta": { "cached": false, "processingMs": 944, "cacheHours": 24, "scoringPolicy": "2026-01" },
  "explanations": [
    { "signal": "disposable_domain_pattern", "severity": "high", "category": "risk", "note": "Matches disposable/temporary patterns." },
    { "signal": "lookup_failed_rdap", "severity": "info", "category": "warning", "note": "RDAP/WHOIS lookup failed; no score impact." }
  ]
}
Docs / Pricing / OpenAPI:
- Docs: https://abusesignalsapi.analyses-web.com/docs.html
- Pricing: https://abusesignalsapi.analyses-web.com/pricing.html
- OpenAPI (fixed contract): https://abusesignalsapi.analyses-web.com/openapi.yaml
Examples repo (Node / Python / C#):
- https://github.com/ulissse/abusesignalsapi-examples
Limitations (by design):
- This API provides automated indicators based on infrastructure signals only.
- It is not a verdict, not a probability, and does not provide advice.
I’d love feedback on the contract shape, the “explain mode” format, and whether the signals list/bands are useful for real-world signup abuse triage.

value: Show HN: Abuse Signals API – deterministic domain/email abuse indicators

author: analyses-web


value: MakeMilk

value:
Hi guys,
I tried to have a different approach in tech itw preparation.
Hope to have some feedbacks.
HNY

value: Show HN: I gamified technical interviews Process – SharpSkill

author: MakeMilk


value:
Hey HN,
I'm building an AI tool that helps non-lawyers and busy procurement/legal teams quickly review vendor/client contracts, NDAs, employment agreements, etc. — without uploading sensitive data to the cloud (offline/local-first option) or replacing lawyers.
Background: As someone who's wasted days manually hunting for risky clauses, vague terms, hidden overrides in amendments, or unfair liability language in vendor deals, I decided to prototype this after seeing how much time/money gets burned on basic reviews.
What it does right now (early MVP/beta):
- Upload PDF/Word/plain text contract
- Scans for common risks: indemnity caps missing, auto-renewals, one-sided termination, IP ownership traps, liability exceeding fees, non-compete overreach, etc.
- Flags issues with plain-English explanations + confidence score
- Suggests safer alternative clauses (based on standard templates/best practices)
- Basic redlining/highlighting output (exportable)
- Offline mode using local models (no data leaves your machine)
Tech stack (simple & transparent):
- Frontend: React + Tailwind
- Backend: Python + fine-tuned open models (e.g., Llama-3 or similar legal-tuned variants) + some rule-based checks for accuracy
- No cloud LLM calls in core flow (privacy focus); optional Grok/Claude integration for deeper suggestions
- Processes docs locally via Ollama or similar
Current status:
- Tested on ~50 real-ish contracts (NDAs, SaaS agreements, freelance templates)
- Average time: 2-5 minutes vs. hours/days manual
- ~75-85% of obvious risks caught (still misses nuanced stuff — not lawyer-grade yet)
- Free beta, no signup required (just drag & drop on the demo page)
I'm looking for brutal feedback, especially from:
- In-house counsel/procurement folks: What clauses cause you the most pain/headaches?
- Developers/freelancers/small biz owners: Would you trust this for quick scans before signing vendor deals?
- Anyone who's used Spellbook/LegalFly/Ironclad: How does this compare? What gaps do you see?
- Trust/accuracy concerns: Hallucinations, false positives, liability disclaimers?
Happy to share more on training data approach, offline setup, or why I focused on negotiation basics vs. full lifecycle.
Thanks for any thoughts — this is day-early, so roast away!

value: Show HN: AI Contract Reviewer – Flags Risks and Suggests Fixes in Minutes


value:
Hi HN,
I built a web interface for the GLM-Image architecture (by Zhipu AI). Unlike standard diffusion models, it uses a hybrid approach (Autoregressive Transformer + Diffusion) which makes it surprisingly good at rendering coherent text and following complex spatial instructions.
Running it Locally: Since this is an open-source model, you can run it yourself if you have the hardware. It requires about 24GB+ VRAM (e.g., RTX 3090/4090 or A100). I wrote a detailed guide on how to set it up here: https://glmimage.online/docs/how-to-install-glm-image
The Cloud Version: For those without a GPU cluster, I wrapped it into this SaaS so you can try it instantly in the browser. It supports native bilingual prompts (English/Chinese).
I'd love to hear your thoughts on how the typography quality compares to Flux or Ideogram!

value: Show HN: GLM-Image Online – 16B AR+Diffusion model for accurate text


value:
Hey HN! I’m Ashwin, co-founder of ContextFort (https://contextfort.ai/). We provide visibility and controls for AI browser agents like Claude in Chrome through an open-source browser extension.
Browser agents are AI copilots that can autonomously navigate and take actions in your browser. They show up as standalone browsers (Comet, Atlas) or Chrome extensions (Claude).
They’re especially useful in sites where search/API connectors don’t work well, like searching through Google Groups threads for a bug fix or pulling invoices from BILL.com. Anthropic released Claude CoWork yesterday, and in their launch video, they showcased their browser-use chromium extension: https://www.youtube.com/watch?v=UAmKyyZ-b9E
But enterprise adoption is slow because of indirect prompt injection risks, about which Simon Willison has written in great detail in his blogs: https://simonwillison.net/2025/Aug/26/piloting-claude-for-ch.... And before security teams can decide on guardrails, they need to know how employees are using browser agents to understand where the risks are.
So, we reverse-engineered how the Claude in Chrome extension works and built a visibility layer that tracks agent sessions end-to-end. It detects when an AI agent takes control of the browser and records which pages it visited during a session and what it does on each page (what was clicked and where text was input).
On top of that, we’ve also added simple controls for security teams to act on based on what the visibility layer captures:
(1) Block specific actions on specific pages (e.g., prevent the agent from clicking “Submit” on email)
(2) Block risky cross-site flows in a single session (e.g., block navigation to Atlassian after interacting with StackOverflow), or apply a stricter policy and block bringing any external context to Atlassian entirely.
We demo all the above features here in this 2-minute YouTube video:  https://www.youtube.com/watch?v=1YtEGVZKMeo
You can try our browser extension here: https://github.com/ContextFort-AI/ContextFort
Thrilled to share this with you and hear your comments!

value: Show HN: ContextFort – Visibility and controls for browser agents


value: Show HN: I got PyTorch models running on WebGPU without ONNX export


value: almonerthis

value:
Hey HN, I built Lore because I was frustrated with context loss when using AI coding agents.
Git tells you who changed code and when. Comments (hopefully) tell you what the code does. But neither captures why it was written that way, the reasoning, the alternatives that were rejected, the trade-offs considered. Would love feedback on the approach.
Website: https://avraammavridis.github.io/lore/
GitHub: https://github.com/avraammavridis/lore

value: Show HN: Lore – A reasoning engine that stores the "why" behind code changes

author: almonerthis


value:
Hi HN,
I’m an indie developer and I recently shipped my first iOS app, PhotoCraft. It’s an AI-powered photo editor focused on enhancement, avatars, and creative edits.
This project started mainly as a way for me to learn how to take an idea all the way from development to passing App Store review and shipping something real. The hardest parts for me weren’t the models or the UI, but scope control, onboarding decisions, and dealing with review feedback.
A few things I learned along the way:
“Good enough to ship” is harder to define than expected
App Store rejections are more about clarity and UX than code
Cutting features early saved me a lot of time later
I’m sharing this mostly to get feedback from people who’ve built and shipped products before. I’d especially appreciate thoughts on:
First-time user experience
Whether the feature set feels focused or bloated
Monetization flow (what feels fair vs frustrating)
Happy to answer any questions about the build, tooling, or App Store review process.
Thanks for taking a look.
— Deva

value: Show HN: PhotoCraft – an AI photo editor I built and shipped as my first iOS app


value: xohails

value: Show HN: I built free calculators for THC, alcohol, and caffeine detox timelines

author: xohails


value: tenngoxars

value: Show HN: Imago – open-source AI portrait generator with guided creation

author: tenngoxars


value: stardeltaio

value:
I kept running into the same problem: SVGs from Figma/Illustrator with offset viewBox values that break when converting to PNG or using in icon systems.
Existing "crop" tools just adjust the viewBox attribute. But if your paths have coordinates like "M 150 200 L 180 230", the viewBox crop doesn't fix the underlying issue.
SVGFix actually translates all path d attributes so coordinates genuinely start at 0,0. Then it normalizes the viewBox to match.
- Runs entirely in browser (no uploads)
- Auto-processes on drop
- Shows before/after size savings
Built with Astro + Vue, open source: https://github.com/stardeltaio/svgfix.net
Would love feedback from anyone who's dealt with this SVG coordinate nightmare.

value: Show HN: SVGFix – transforms SVG path coordinates to origin, not just viewBox

author: stardeltaio


value:
remio is designed to free you from being a manual data porter for AI. By syncing your full context, it builds a zero-effort Second Brain that understands your work as well as you do.
We call this AI knowledge base "remio", because we want to build a local first app to "remember every input and output". As knowledge workers, we are stuck copy-pasting context just to get a decent answer. We spend more time digging through scattered Slack threads, Google Docs, and local files than actually doing the work.
So here is what we made:
1. Connect once: It automatically indexes your full context—web history, local files(PDF/Word/Slides...), Slack messages, emails, meetings, and more.
2. Maintenance-free: Forget manual tagging or organizing. Just ask remio to do the dirty work: find anything in seconds, generate your daily recap, or recall details you’ve forgotten.
3. Local-first by design: No more vendor-lockin and cloud leaks. All data is stored locally on your device, and you also enjoy 100% data security with BYOK.
Stop organizing, start chatting. Get tailored answers with your second brain today!
And feel free to comment on what you think about remio. We love to hear from you.

value: Show HN: AI second brain without headaches


value: jelmervnuss

value:
I built Play Console Translation Assistant, a Chrome extension that fixes a very specific time-consuming problem: Google Play Store listing machine translations that exceed character limits.
When localizing apps, translated titles and descriptions often end up just a few characters too long. Play Console then blocks saving, and the usual workflow becomes manual rewriting, counting characters, retrying, and copy-pasting between tools.
This extension runs directly inside Google Play Console and:
- Detects all available languages in your store listing
- Extracts titles, short descriptions, and full descriptions
- Identifies only the fields that exceed character limits
- Generates rewritten versions that fit within limits
- Lets you review and deselect any changes
- Applies fixes back into Play Console in one click
Nothing is changed automatically. Everything is reviewable before applying.
I’d love feedback on:
- Whether this solves a real pain point for you
- Edge cases you’ve run into with Play Console translations
- Anything that feels confusing or unnecessary
Happy to answer any questions.

value: Show HN: Auto-fix Google Play Store translations that exceed character limits

author: jelmervnuss


value:
Hey,
when I was looking for a new step counter app I noticed to my surprise that I couldn't find any that I liked.
I just wanted something simple. Something without bloat. Everything seemed either full of junk, low quality or expensive.
So I build my own step counter app for Android focused on minimalism.<p>People really like it so I'd like to keep improving it. The challenge is to improve it without making it too cluttered. It's easy to just add features but it needs to stay minimalist.
I'd love to hear your feedback.

value: Show HN: A NO-BS step counter app that actually works


value: troysk

value: Hey folks! I have worked remotely for almost 20 years and one tool which I have used a lot is screen recordings. They do tell more than text when you have to explain a feature to a remote colleague in a different timezone. Loom was great but it kept nagging me with updates and the 5 minute limit was also hard. So I created ScreenRecord.in a no limits, local first screen recording solution. You don't need to install any additional hardware. Just open your browser and hit Record! The recordings are stored in your local storage and you can even add a PiP of your webcam. Please try it and share feedback with me!

value: Show HN: Screenrecord.in – A browser based local-first screen recording solution

author: troysk


value: nikbar

value:
Hey HN,
I built Yapper because I love the accuracy of Whisper, but I was frustrated that the best native macOS wrappers required monthly subscriptions.
The premise is simple: If the model runs locally on my hardware (Apple Silicon), I shouldn't have to pay rent on the software.
Yapper is a native macOS app that runs entirely offline. You press a hotkey, speak, and it types into any text field (VS Code, Slack, Notes, etc).
How it works: It’s built on WhisperKit and optimized for the Apple Neural Engine. Because it runs locally, your voice data never leaves your machine.
Features:
- 100% Offline: Zero latency issues, total privacy.
- No Subscription: A simple one-time purchase.
- Optional AI Polish: While transcription is offline, I added a "Bring Your Own Key" feature (supports Claude, OpenAI, Gemini). If enabled, it sends the text (not audio) to the LLM of your choice to fix grammar or restructure rambling before pasting it.
I’m launching this with a lifetime license for $24 (usually $49) to get early feedback. I tried to build the exact tool I wanted to use: fast, private, and paid for once.
I’d love to hear your thoughts on the implementation or features you’d like to see next!

value: Show HN: Yapper – Offline macOS dictation. One-time purchase, no sub

author: nikbar


value:
Hi HN,
Dodo is a PDF reader I’ve been building to scratch my own itch.
I use it daily for reading papers, and as a PhD researcher it’s
been personally useful by focusing on features I couldn’t find
in existing readers without a lot of extra complexity.
The project is actively developed and still evolving.
Feedback and suggestions are welcome.

value: Show HN: Dodo – A fast, configurable PDF reader built using MuPDF and Qt


value: I made this to monitor the world's progress, it's updated in real time (mainly thanks to ourworldindata's great work!)

value: Show HN: World CEO Cockpit

title: Show HN: World CEO Cockpit


value: naughtyfinch

value:
I built a small self-hosted tool to record Twitch live streams automatically.
You give it one or more Twitch channel names, it monitors them, and when a channel goes live it records the stream to disk using Streamlink. It runs entirely in Docker, has a minimal web UI, and saves files locally — no twitch login required, no accounts, no cloud, no video player.
I built this mainly for personal use. The existing solutions I found were either heavy, cloud-based, or did not fulfill my requirements. This app is intentionally minimal and single-user by design.
It’s open source, Docker-first, and meant to be easy to run and forget about. Happy to hear feedback or suggestions.

value: Show HN: TLD – a minimal, self-hosted, Twitch live stream recorder

author: naughtyfinch


value: yelston

value:
Hi HN,
I built Pomo - a small, free tool for adding simple banners to websites (announcements, promos, alerts).
I kept running into this problem while building small projects: I just wanted a clean banner, but existing tools were either expensive, overly complex, or bundled with features I didn’t need.
So I built something intentionally minimal:
- quick setup
- clean UI
- no heavy scripts
- free to use
It’s designed for builders, indie founders, and small teams who want something that “just works.”
Would love feedback—especially on what feels unnecessary or what you’d expect from a tool like this.

value: Show HN: I built a lightweight banner tool because existing ones felt overkill

author: yelston


value: nativeforks

value: Show HN: Tiny FOSS Compass and Navigation App (<2MB)

author: nativeforks


value:
Hi HN!  I’m excited to share Tizo, a lightweight web tool that makes time zone conversions and global time tracking friction-free.
I built Tizo to help anyone who deals with multiple time zones — whether you’re scheduling meetings across continents, planning travel, or coordinating with teammates around the world. Too often time zone tools are clunky or overloaded with features; Tizo strips everything down to the essentials:
Instant time zone conversions between any two regions
Current time display for any selected zone
Multiple date & time formats supported
Responsive and easy to use on desktop or mobile
Whether you’re a remote worker, traveler, or just juggling international friends, Tizo helps eliminate confusion  and saves you a bunch of mental math. It’s free and web-based — no install, no signup.
I’d love to hear how you use it and what else would make it even more useful.
— Elston (Maker of Tizo)

value: Show HN: Simple time zone converter and world clock for everyone


value:
Gitmore (https://gitmore.io) – Git visibility for people outside the engineering team.
Think about it: engineers already document their work. Every commit, every PR, every merge. The information exists.
But it's in a UI that only developers understand. So we schedule standups, write status emails, and sit in syncs – just to transfer information that's already written down.
*What Gitmore does:*
Connect your repos. Ask in plain English:
- "What shipped last week?"
- "What's the team working on?"
- "Any PRs stuck in review?"
Or schedule reports. Weekly summary to Slack. Monthly digest to email. Forward to your board.
*Who uses it:*
- Founders who need investor updates
- Execs who want visibility without meetings
- Anyone tired of asking "what's the status?"
*How it works:*
Webhooks only. Git platforms push event metadata to us – commit messages, PR descriptions, authors, timestamps.
Every event normalized into a structured schema. AI queries structure, not raw text.
*What we don't do:*
No code review. No diff analysis. No competition with tools like Coderabbit. Those are for engineers inside the PR.
This is for everyone outside.
*Security:*
We never access source code. Metadata only.
- Encrypted tokens (Fernet)
- Webhook signature verification
- 2FA support
GitHub, GitLab, Bitbucket – one dashboard.
Free for 1 repo: https://gitmore.io
What's your current workaround for keeping non engineers informed?

value: Show HN: What shipped this week? now you can just ask


value: NeverBugFree

value: Show HN: Sharpie, the C# Fantasy Console Disguised as an Emulator

author: NeverBugFree


value: samitugal

value:
For a while, I was looking for a note-taking app that really fit how I work, but nothing fully clicked.
So I turned this into a weekend project.
That’s how bytepad came to life.
I like taking notes in Notepad++ — simple, fast, retro — but there’s no cross-device sync.
Notion feels overwhelming.
Todoist handles tasks well but lives in its own silo.
Obsidian has a great knowledge graph, but it didn’t match my workflow.
I wanted something:
as simple as Notepad
not limited to a single use case
with multiple functions and a knowledge graph feel
So I built bytepad.
It combines:
notes, tasks, and habits
global search
a lightweight knowledge graph
an optional AI assistant that helps plan the day and create tasks
local-first storage with GitHub Gist sync
fully open source
It’s become part of my daily workflow, so I decided to share it.
If this sounds interesting, I’d love to hear your thoughts.
Contributions, ideas, and feedback are very welcome — feel free to explore the repo, open issues, or suggest improvements.

value: Show HN: Bytepad – a minimal, no-nonsense, open-source note-taking app

author: samitugal


value: yassershkeir

value:
I recently released v1.0.1 of a new rate limiting library for Django.
The Problem: Existing libraries were either unmaintained, lacked proper async support, or didn't handle backend failure gracefully (taking down the app if Redis timed out).
The Solution:
Algorithms: Implements Token Bucket, Sliding Window, and Fixed Window.
Resilience: Built-in Circuit Breaker. If Redis/Mongo is down, it fails open (or closed) to keep the app responsive.
Concurrency: Native support for async def views via coredis.
Backends: Redis, MongoDB, and in-memory.
It's type-safe (mypy strict) and designed as a drop-in replacement for django-ratelimit.
Repo: https://github.com/YasserShkeir/django-smart-ratelimit
Docs: https://pypi.org/project/django-smart-ratelimit/

value: Show HN: Django Smart Ratelimit – Async, fault-tolerant rate limiting for Django

author: yassershkeir


value: pablopang

value:
I got tired of figuring out how to add an MCP server over and over to various clients...so I've built mcp-add.
A CLI that knows the right questions to ask and where to put the info in most clients.
You can run it in interactive mode with `npx mcp-add@latest` or by passing args to do it in one go!
https://github.com/paoloricciuti/mcp-add

value: Show HN: MCP-add` a CLI to add your MCP server to various clients with ease

author: pablopang


value: rittermax

value:
Hi HN,
I've been using Claude Code for a few months and kept running into the same issues:
1. No enforcement of TDD or quality checks - Claude writes untested code if you let it
2. Context window fills up mid-feature, losing all the understanding Claude built up
3. Starting fresh sessions means re-explaining the codebase all over again
4. Setting up a good configuration takes time and effort to keep up with everything
I built Claude CodePro to address these for my own freelance work. Sharing it in case others find it useful.
---
TWO WAYS TO WORK
1. /spec "your feature" - For larger work
   - Creates an implementation plan as markdown
   - You review and approve before implementation
   - TDD enforcement via pre-edit hook
   - Verification step at the end
2. Quick Mode - Just chat
   - No planning overhead
   - Quality hooks still run
   - Good for bug fixes and small changes
---
ENDLESS MODE
One of the main features is automatic context continuation. When you hit ~90% of the 200K context window, the system:
- Saves current state to a continuation file
- Captures observations via Claude Mem (persistent memory MCP)
- Wrapper automatically triggers a session restart
- New session reads the saved state from hooks and files and continues
I've had features span multiple session handoffs without manually managing anything.
---
QUALITY HOOKS
Post-edit hooks run automatically:
- Python: ruff, basedpyright
- TypeScript: eslint, tsc, prettier
- All languages: QLTY
Pre-edit hook warns if you're modifying code without a failing test first.
---
DEV CONTAINER
Everything runs in a Dev Container. Advantages:
- Consistent environment across all machines and operating systems
- Complete isolation from your host system
- Complex toolchain (LSP servers, semantic search, linters) just works
- No manual installation of dependencies
- Easy onboarding - works immediately after container starts
- Reproducible setup every time
---
INCLUDED TOOLS
- Vexor: Local semantic code search
- Claude Mem: Persistent memory across sessions
- Context7: Library documentation retrieval
- Firecrawl: Web scraping
- agent-browser: Headless Chromium for browser automation
- mcp-cli: CLI for custom MCP servers
---
LINKS
GitHub: https://github.com/maxritter/claude-codepro
Website: https://claude-code.pro

value: Show HN: Claude CodePro – Professional Development Environment for Claude Code

author: rittermax


value: davekiss

value: Show HN: Burnboard – Track and compare your AI coding assistant usage

author: davekiss


value: antoineMoPa

value: Show HN: Plane Clock – Displays plane corresponding to hour

author: antoineMoPa


value: da-x

value: A Chrome extension that removes algorithmically-driven "For You" sections and distracting navigation elements from popular websites.

value: Show HN: Anti for You

author: da-x

title: Show HN: Anti for You


value: tomgreef

value:
Hi HN! I, Tom, am a founder of hirebetter and I’d love to share what we’ve been working on and get feedback from the community.
hirebetter is a set of AI-driven tools designed to take over repetitive manual tasks that recruiters and solo founders often face when hiring. At a high level, it helps with things like drafting outreach messages, filtering candidate profiles, and generating tailored interview prompts, all with the goal of saving time and making the hiring process consistent across candidates.
My co-founders have spent years in recruiting and hiring for small teams, and found themselves constantly doing the same manual work — customizing templates, digging through resumes, juggling tabs and tools. A lot of that felt like busy work that could be automated intelligently, so I started building hirebetter to fill that gap.
The current tools are: Job Description, Candidate Summary, Interview Questions, Job Ad Rewriter, Position Benchmarking, Social Media Job Posts (with Image), Outreach Messages, Infopack, Hiring Process, Boolean Search, Candidate Persona, Job Board Suggestions & Rejection Letter.
We’re thinking of working on a Google Chrome extension so you can use hirebetter's tools directly while browsing LinkedIn, job boards, or applicant trackers, without switching tabs. The extension will bring this functionality right where you already work.
The product is live at the link above. We’d love to hear:

   - What’s confusing or unclear?
   - What tasks in hiring do you hate the most?
   - How would you use something like this in your workflow?

Happy to answer any questions and iterate based on your feedback!

value: Show HN: Hirebetter.io – AI tools to reduce manual recruiter work

author: tomgreef


value: DailySpace

value:
Hi HN,
I’ve always been fascinated by space and how much is happening beyond what we usually see day to day. I wanted a simple way to explore space photography and learn what I was actually looking at, without jumping between lots of different sites or long articles.
So I built DailySpace, an Android app for exploring a large collection of space photos with short and clear explanations. You can browse thousands of images of galaxies, nebulae, planets, stars, black holes, Earth, and different NASA missions organized into categories or found through search.
As I kept using it myself, I added things I thought were missing elsewhere, like a rocket launches and space mission tracker where you can see upcoming launches, revisit past missions, and read about their goals, vehicles, agencies, and timelines.
I’d love feedback on:
What features are missing?
Would you use such an app?
Is the app works smoothly on your device?
Link: https://play.google.com/store/apps/details?id=com.daily.spac...
Happy to answer questions!

value: Show HN: DailySpace, Android app for exploring space photos and rocket launches

author: DailySpace


value: hasibhaque

value: Show HN: Most app ideas fail, so I built a list of apps that work

author: hasibhaque


value: guyskk

value: Show HN: Claude Code Supervisor – Auto review and prevent agent stop

author: guyskk


value: SRMohitkr

value:
I built a small browser-based image resizer that runs entirely client-side, so images never leave your device.
It supports quick resizing, format conversion, and instant downloads with no signups or tracking.
Made mainly for
write the with -SR.Mohitkr

value: Show HN: Arche Resizer – a fast browser tool to resize images without uploads

author: SRMohitkr


value: mheap

value:
I've been looking for a way to run LLMs safely without needing to approve every command. There are plenty of projects out there that run the agent in docker, but they don't always contain the dependencies that I need.
Then it struck me. I already define project dependencies with mise. What if we could build a container on the fly for any project by reading the mise config?
I've been using agent-en-place for a couple of weeks now, and it's working great! I'd love to hear what y'all think

value: Show HN: Run LLMs in Docker for any language without prebuilding containers

author: mheap


value: daviducolo

value: Show HN: GitHug – Discover new GitHub users

author: daviducolo


value: ParleSec

value:
Identity is not built on platforms - it is built on protocols.
I built ProtocolSoup because I was tired of protocol diagrams that relied on theoretical explanations without tactility or transparency.
So I built a sandbox where you run real flows against real infrastructure.
Live platform: https://protocolsoup.com
GitHub: https://github.com/ParleSec/ProtocolSoup
The core features are the Looking Glass and SSF Sandbox. WebSocket-powered inspectors that show raw HTTP traffic in real-time as you step through a flow.
See exactly what your browser sends, what comes back, and decode every token along the way.
Supported protocols:
- OAuth 2.0 (authorization code, PKCE, client credentials, device code, refresh)
- OpenID Connect (ID tokens, userinfo, discovery)
- SAML 2.0 (SP-initiated, IdP-initiated, SLO)
- SPIFFE/SPIRE (X.509-SVID, JWT-SVID against real SPIRE infrastructure)
- SCIM 2.0 (user/group provisioning with integrated test application)
- SSF (Shared Signals Framework - CAEP + RISC events)
Everything runs against a built-in Mock IdP, a real SCIM-integrated application, and a dedicated SPIRE server. Nothing to configure.
Stack: Go backend, React frontend, WebSocket for real-time inspection. You can run locally as well through Docker.
Feedback is welcome and greatly appreciated whether you're an experienced in navigating auth protocols or are just starting to learn auth protocols.

value: Show HN: ProtocolSoup – Interactive Sandbox for OAuth, OIDC, SAML, Spiffe, SSF

author: ParleSec


value: sammylis

value: My first blog post! Please leave behind a drawing in the guestbook if you like it

value: Show HN: My Own AWS

author: sammylis

title: Show HN: My Own AWS


value: pinus-cembra

value: Show HN: Commentix – A lightweight, customizable alternative to Disqus

author: pinus-cembra


value: alessandrodiano

value:
Hi HN, I built Unbubble News (https://unbubble.news).
Paste an article link or upload a screenshot and it generates a short report with verified key facts, missing context, and how different viewpoints frame the same story. It’s meant to help you form unbiased opinions and fight polarization.
If you try it, I’d really appreciate blunt feedback and examples of articles where it gets things wrong.
Specific things I’d love feedback on:
1. What’s the most valuable section in the analysis for you?
2. How do you currently deal with news content that feels off and leaves you skeptical?
3. In which other cases do you see yourself using a tool like Unbubble News?

value: Show HN: Unbubble News – analyze bias and verify facts for any news article

author: alessandrodiano


value: bbx

value:
I've always wanted to practice playing piano chords on my computer, so I built this simple game that gives you a random chord to play.
The game supports input from a computer keyboard, a mouse, a touchscreen, and even a MIDI keyboard.
There is a training mode that will highlight the notes to play.
You can also adjust the difficulty, the oscillator type, and the root note of the generated chord.
Built with React/TypeScript.

value: Show HN: ChordsCrush, a free musical chord training game

author: bbx


value:
Hey HN,
I'm Abhishek, a solo founder. In my previous SaaS, I lost thousands silently to Stripe issues like failed payment retries, broken dunning, missing webhooks, etc., stuff that's hard to spot without manual digging.
Built BillingEngine to fix that: Paste a read-only Stripe key, run an AI scan in ~5 minutes, get a PDF report with:
- Billing Health Score (0-100)
- Prioritized fixes by revenue impact
- At-risk subscribers + recovery queue
- Benchmarks
It's $99 one-time (no sub), read-only key (never stored), and first 20 users get a free 15-min founder call to implement fixes.
Would love honest feedback, bugs, missing features, or if you've seen these leaks in your own setup.
Try it: https://billingengine.tech

value: Show HN: BillingEngine, AI Stripe Revenue Leak Diagnostic 5 min, $99 one-time


value: GamaTeker

value: Show HN: Teker – Free, offline PE analysis tool with risk scoring (C++/Qt6)

author: GamaTeker


value: funnycoding

value: Show HN: Nanobanana Pro – AI image generator that renders perfect text

author: funnycoding


value: tanimasa

value:
I built OpenSlots, a zero-knowledge scheduling application that works without a trusted server.
Most scheduling tools (When2meet, Doodle, Calendly, even self-hosted ones) leak significant metadata: who meets whom, when, and how often. OpenSlots treats scheduling as a client-side protocol rather than a hosted service.
Key ideas:
- No trusted third party:
  Runs as a browser-based thick client. Nostr relays are used only as untrusted storage.
- End-to-end encryption (NIP-44):
  All room data and availability are encrypted with ChaCha20-Poly1305.
- URL fragment key distribution:
  The symmetric room key lives only in the URL fragment and is never sent to servers or relays.
- Blinded indexing:
  Room identifiers are indexed on relays via HMAC-SHA256(room_id, key), preventing trivial enumeration or mapping by relays.
Relays can observe ciphertexts, tags, and timing, but cannot read meeting content or recover room identifiers without the key. This removes the central database as a point of trust.
This is not full anonymity: IP addresses and timing remain observable. The goal is trust minimization and metadata reduction, not network-layer anonymity.
Demo and documentation:
https://openslots.pages.dev
Technical Details:
https://github.com/tani/openslots
Feedback is welcome, especially on the threat model, blinded indexing design, and usability trade-offs of URL-as-bearer-key approaches.

value: Show HN: OpenSlots – Trustless, Privacy-Preserving Scheduling over Nostr

author: tanimasa


value: henrikdev

value:
I’m a solo developer and I just launched Beam, a desktop-style browser for iPad.
Most iPad browsers still feel like stretched phone apps. Beam was built to feel closer to a real desktop productivity browser, with features like:
- Persistent sidebar with vertical tabs
- Spaces, favourites and pinned tabs
- Command bar and full keyboard shortcut support
- Memory-efficient tab lifecycle (active, warm, suspended tabs)
- Desktop-grade tab management designed specifically for iPad hardware limits
A big part of the work went into managing web views efficiently. iPads have much tighter memory constraints than desktops, so Beam unloads inactive tabs while keeping switching between active ones instant.
It’s a paid app ($4.99) with no subscriptions, no accounts, and no tracking beyond basic anonymised usage metrics.
App Store link:
https://apps.apple.com/us/app/beam-browser/id6756218494
I’d really appreciate any feedback, especially from people who use iPads heavily with keyboards.
Happy to answer questions.
More info: beambrowser.app

value: Show HN: Beam – A desktop-style browser for iPad built by a solo developer

author: henrikdev


value: KingOfCoders

value:
I announce rinku to the world!
With people looking less and less at code,
why not choose a language with better
runtime characteristics instead of the
one you wanted to write code in before?
As a Go coder I have migrated several of my small tools to
Rust, as Rust is faster, uses less memory and has no
GC latency (wish Go had arenas).
The main obstacle was mapping third party dependencies like open
source libraries.
As a solution I have created 'rinku'. You give it a Go dependency
and it gives you a Rust dependency.
> $ rinku lookup https://github.com/spf13/cobra
> https://github.com/clap-rs/clap
Prompt now becomes (real prompt is more complicated)
> Translate the project from Go to Rust. For dependencies migration use rinku.
The library of mappings is not yet extensive, but
migration is now much easier.
https://github.com/marvai-dev/rinku

value: Show HN: Convert Go to Rust

author: KingOfCoders

title: Show HN: Convert Go to Rust


value: SpicyG

value:
I kept seeing the same failure pattern across systems that look unrelated on the surface: autoscaling that flaps, alert storms that resolve on their own, retraining pipelines that chase noise, and failover logic that makes things worse before they get better.
In each case, nothing was obviously “wrong.” The metrics were real. The thresholds made sense. The logic was locally defensible. What broke was timing.
To make this concrete, I built a tiny toy system with a feedback loop. It reacts immediately to a noisy signal by taking action, and that action feeds back into the signal. There’s no bug in the logic, just immediacy.
Conceptually, it looks like this:
signal = noisy_input()
if signal > threshold:
    take_action()
When this runs inside a feedback loop, the system oscillates. Not because the threshold is bad, but because the decision happens before the signal has stabilized.
Now add one constraint: the decision is only allowed to exist if the condition persists over time.
window = recent(signal, N)
if mean(window) > threshold and variance(window) < limit:
    take_action()
No prediction, no learning, no global state. Just persistence.
The oscillation disappears.
What surprised me is how often this shows up in real systems. Treating decision timing as an architectural concern, rather than a tuning problem, seems to explain a lot of brittle behavior I’ve seen in production.
I’m curious how others here handle this in practice. Do you rely on hysteresis, persistence windows, explicit “not-yet” states, or something else entirely? And where have you found immediate reaction to actually be the right choice?

value: Show HN: A minimal example of why reactive systems oscillate

author: SpicyG


value: mythz

value: Show HN: llms.py OSS ChatGPT CLI and Web UI with Tool Calling, RAG, Extensions

author: mythz


value:
Hey HN, I’m the solo builder behind LogiCart.
I recently refactored my frontend to use a Generative UI pattern (inspired by Google's new A2UI framework) because I realized a static chat interface fails for complex shopping intents.
The Problem: A user buying a single item needs a completely different UX than a user planning a complex project. A standard "list of cards" doesn't work for both.
The Solution: I built an Intent-to-UI engine where the LLM decides the interface structure based on the query.
How the Logic Works:
Intent Classification: The LLM first classifies the prompt into one of three modes.
Dynamic Rendering: It returns a JSON schema that my custom React renderer maps to specific components:
Single Item Intent (e.g., "Best Gaming Monitor"): Triggers a Comparison View. It renders a "Best Match" card with detailed specs alongside 3 alternatives for quick comparison.
Bundle Intent (e.g., "Build an AMD Gaming PC"): Triggers a Grouped View. It clusters products by category (CPU, GPU, RAM) to ensure the build is complete.
DIY/Project Intent (e.g., "How to build a deck"): Triggers a Plan View. It renders a step-by-step timeline mixed with the required materials. The number of steps and product complexity dynamically adjusts based on the user's stated experience level.
The Stack:
Backend: Node.js / TypeScript
Search: pgvector (PostgreSQL) for semantic retrieval of Amazon/Retailer SKUs.
Frontend: React (with a custom renderer for the A2UI schemas).
Context: I pivoted to this "deep complexity" approach after Microsoft Copilot launched their generic shopping agent 24 hours after my initial beta. I realized I couldn't compete on generic search, so I’m focusing on the complex/messy projects that require dynamic UI adaptation.
It’s live in Beta. I’d love feedback on the "Intent Router"—try breaking it by asking for something ambiguous like "Coffee" vs "Coffee Station" to see if the UI adapts correctly.
Link: https://logicart.ai

value: Show HN: LogiCart – Agentic shopping using Generative UI (A2UI pattern)


value: mronus

value: Show HN: Spec – A language-agnostic IR for LLM agents (live demo)

author: mronus


value: ededft

value:
Hi HN,
When something breaks in production, fixing the issue is only half the work. Teams also have to explain what happened — to users, to teammates, and sometimes to the public. Turning raw alerts, timestamps, and chat logs into a clear incident postmortem usually takes hours and is easy to get wrong.
I built IncidentPost to make this easier. You paste a raw incident timeline and it produces a structured postmortem with an executive summary, chronological timeline, root cause, mitigations, and action items, all formatted in a way that’s ready to share.
The goal is not marketing language, but a calm, technical, and transparent record of what actually happened.
Live platform:
https://incidentpost.vect.pro
It’s a simple pay-per-incident tool — no accounts or subscriptions — designed for teams that need to communicate clearly after outages.
I’d really appreciate feedback from engineers, SREs, and founders who’ve had to write or read postmortems under pressure.

value: Show HN: A faster way for SaaS teams to publish credible outage postmortems

author: ededft


value:
After 30 years of development, I've finally cracked the index-free search performance problem.
The usual tradeoff:
- Indexed search (Lucene, dtSearch) = fast queries, slow setup, storage overhead
- Direct search = no setup, too slow for >10GB
My approach: Multi-threaded direct search with intelligent caching. Result: 50GB searched in ~20s on a mid-range Ryzen 5 (5600, 16GB, SSD).
Technical details:
- Format-agnostic byte-by-byte text extraction (finds text regardless of file format)
- Producer-consumer pattern for directory traversal
- PDF/OCR cache (0.2% overhead vs. 2-5% for full indexes)
- Recursive archive handling (ZIP in ZIP in email)
- Scales linearly with CPU cores
Benchmark vs. commercial tools on 50GB real-world archive:
- Findit: 201 files, 20s, no prep
- dtSearch ($199): 182 files, <1s but 15min indexing
- FileLocator ($150): 132 files, 4min + 51min indexing
- DocFetcher: 82 files, instant but 79min indexing
Full results: https://www.dateisuche.de/en/comparison6.html
Free to use indefinitely (WinRAR-style), $39 one-time to remove nag screen.
Stack: VB.NET (legacy from 1995), Tesseract for OCR. Windows only.
Looking for feedback on the architecture and performance on different hardware configs.

value: Show HN: Index-free full-text search that's fast enough for practical use


value: cosinusalpha

value:
Hi HN, I built webctl because I was frustrated by the gap between curl and full browser automation frameworks like Playwright.
I initially built this to solve a personal headache: I wanted an AI agent to handle project management tasks on my company’s intranet. I needed it to persist cookies across sessions (to handle SSO) and then scrape a Kanban board.
Existing AI browser tools (like current MCP implementations) often force unsolicited data into the context window—dumping the full accessibility tree, console logs, and network errors whether you asked for them or not.
webctl is an attempt to solve this with a Unix-style CLI:
- Filter before context: You pipe the output to standard tools. webctl snapshot --interactive-only | head -n 20 means the LLM only sees exactly what I want it to see.
- Daemon Architecture: It runs a persistent background process. The goal is to keep the browser state (cookies/session) alive while you run discrete, stateless CLI commands.
- Semantic targeting: It uses ARIA roles (e.g., role=button name~="Submit") rather than fragile CSS selectors.
Disclaimer: The daemon logic for state persistence is still a bit experimental, but the architecture feels like the right direction for building local, token-efficient agents.
It’s basically "Playwright for the terminal."

value: Show HN: Webctl – Browser automation for agents based on CLI instead of MCP

author: cosinusalpha


value: txmxr

value:
Hello HN! I built Dockyard, a terminal UI for managing Docker containers on
resource-constrained servers.
I made this because I was running a bunch of containers on cheap VPSs (the
$5-10/month tier) and existing Docker management tools were surprisingly
heavy. Portainer needs 500MB+ just to run, and even CLI tools like ctop
would stutter on my 2GB droplets when polling stats from multiple containers.
Dockyard is written in Rust with an async architecture that fetches container
stats concurrently and keeps the UI responsive without blocking.
Some things it handles:
- Real-time container monitoring without the overhead
- Parallel stats collection (no sequential polling lag)
- Works well on ARM (Raspberry Pi, etc.)
- Non-blocking UI that stays snappy even under load
The project is in it's infancy...I've been running it on my own servers for a few
months, but I'd love feedback on the UX and whether the async approach
actually makes a difference on your setups.
GitHub: https://github.com/905timur/dockyard

value: Show HN: Dockyard – Fast Docker CLI Alternative Written in Rust

author: txmxr


value: jsimonrichard

value:
I got tired of reading raw markdown strings inside JSON files (which often happens in AI benchmarks, evals, logs, etc.) so I created https://ad-hoc-lens.dev.
It's a client-only web app built on top of DuckDB-WASM that can query those JSON files and render the returned string as markdown.
OSS Repo: https://github.com/jsimonrichard/ad-hoc-lens
Features:
- JSON(L), TSV, CSV, and Parquet files are all supported
- Strings annotated with the `md(...)` macro will be rendered as markdown
- The data you upload never leaves the tab
I'd love to hear your feedback, especially on
- the general user experience
- performance limits
- any features that would make your life better!
You can respond here or create an issue on the GitHub repo.

value: Show HN: Query Jsonl in the Browser (DuckDB‑WASM) with Markdown Preview

author: jsimonrichard


value: csressel

value:
Hi HN, my name's Clifford and I'm one of the creators of Nori. I’ve been using Claude Code heavily since last summer, and after understanding some of the tradeoffs with their TUI implementation, I knew I couldn't see myself living for years with this interface as one of my daily-driver tools.
It is not a hard problem to make monospace text output performant, so why does Claude Code suffer from flicker and strobing in the terminal (https://github.com/anthropics/claude-code/issues/1913)? Even after they've released multiple improvements for this, I still see the issue in terminal splits with fewer rows, or in less performant emulators, and even within a virtual TTY (the absolute simplest environment to run an interactive program in). After digging in throughout the past half year, the issue is mostly inevitable because Claude reprints full terminal history without using alt screen mode and uses a React-based framework (Ink) to render and style their text. That's great for JS+CSS being "on distribution" for LLMs in order to vibecode the continued development of Claude Code, but it doesn't deliver the experience I'd like. The frameworks they've chosen also have limitations around [terminal input parsing (i.e. the shift enter issues from last year: https://github.com/anomalyco/opencode/issues/1505#issuecomme...). Great terminal interfaces I've lived with for years (neovim, btop, helix, Cataclysm DDA, etc) don't sacrifice user experience as a tradeoff for development convenience. They build resilient terminal interfaces on languages more appropriate for this problem, like C or C++ or Rust.
Finally, while I'm definitely rooting for Anthropic to continue improving their products, I can't see myself coupling a commandline tool I use often with a single LLM provider. It would be insane if pushing my code to GitHub required me to edit it in VSCode — I want my tooling to do one thing well, and that's display the read-eval-tool-loop from talking to an agent. Opus 4.5 has been stellar, but it's nonnegotiable to me that I can try out varied providers with the same tools I plan to use everyday. Claude Code will not be working long term on how best to interface with multiple agents, from varying providers, in one terminal pane, and that makes perfect sense for their business. However based on our other experiences building out profiles and skillsets for agents, deeper customizations of agent instructions and subagents, and parallel worktrees for local agents, we have a lot of vision for how to handle local agentic work. And with the current design to integrate at the agent-level, we don't plan on working around the OAuth flows or spoofing the system prompt outside of the Claude Code SDK (like with the OpenCode situation), and risk the tools coming into conflict with the providers.
These were the main considerations that went into designing Nori CLI. It's a very thin and very fast TUI wrapper around multiple agent providers. It integrates with providers at the agent level, instead of the model level. Not only does that provide better performance in our experience, but that is also *compliant with current ToS for subscription based usage.* This is a very early version, but given the timing this week it might give you a flicker-free way to code with Claude Code!
The project is open source, and built on the stellar work by folks at Zed (on the abstraction over varied coding agents), and the folks working on Codex CLI (who have put together one of the nicest proprietary terminal experiences).
I'm very curious:
What are the Claude Code features you couldn't give up, to make the switch to a tool like this?
What are the Claude Code features that work as intended, but you can't stand?

value: Show HN: Nori CLI, a better interface for Claude Code (no flicker)

author: csressel


value: anhphong

value: Show HN: HotspotPeek – Track iPhone hotspot data usage from Mac menu bar

author: anhphong


value: joggez

value:
Hi HN,
You know that feeling when you have a brilliant idea at 2am, buy the domain immediately, and then never touch it again?
Last month I sat down to figure out how much money I've been bleeding on domain renewals, and honestly, I was scared to look. I had domains scattered across GoDaddy, Namecheap, and a few other registrars I barely remember signing up for.
I did what we all do: I built a tool for it.
It's basically "Spotify Wrapped" but for all those domains you bought and forgot about. Connect your registrars manually, and get:
- How many domains you have
- Total renewal costs
- Estimated portfolio value
- Domains added in 2025
- How much you're spending on unused domains
No DNS configuration. No API keys. No registrar access.
Just import your domains via CSV or add them manually. Tried to make it as intuitive as possible.
Curious to hear your feedback, and how many you registered last year :)
Try it out: https://domained.app/wrapped
--
Tech-wise: Nothing fancy. Just Next.js + Supabase. BUT the design process was interesting. I used Figma Make with Gemini 3 Pro for all the initial iterations and honestly, it's pretty impressive. If you pay $20 you get unlimited usage until March or something, which is insane value if you need to pump out a lot of design variations quickly. Highly recommended.

value: Show HN: Your Domains Wrapped - A 2025 domain recap

author: joggez


value: jsxyzb

value: Histoday is a professional historical events platform combining comprehensive chronological databases with AI-powered image generation. Browse historical events by date, create high-quality visual content through text-to-image and image-to-image technology, and publish custom historical entries. Designed for educators, content creators, and researchers seeking reliable tools for historical exploration and visual storytelling.

value: Show HN: Histoday – On This Day in History

author: jsxyzb


value: hoxihan

value:
I built a small site that posts the daily solution for the LinkedIn Pinpoint puzzle:
https://www.pinpointanswers.online
It updates every day automatically, includes step-by-step clues, and has a minimal UI with no ads or tracking.
Made it because I couldn’t find a clean, fast reference for Pinpoint players.
Feedback on speed, clarity, or features would be appreciated.

value: Show HN: Daily LinkedIn Pinpoint Puzzle Answers (PinpointAnswer Today)

author: hoxihan


value: gokh

value: Show HN: Sommo – AI-native wine learning app

author: gokh


value: runkids

value: Show HN: Skillshare – Sync skills across AI CLI tools

author: runkids


value: aliclark

value:
Hey!
I'm Ali, and I built a tool to help me learn Spanish. There's a good amount of info in the about page, but the short version is that I found apps like Duolingo completely useless. In theory they're designed to help you speak a language but I found it mostly helped my muscle memory tap the right parts of a screen without really learning to say anything. Or more importantly prepare me for how fast a native Spanish speaker speaks!
After giving up on Duolingo I tried a few different things; Pimsleur, Paul Noble and Language Transfer. These are all great in different (but similar) ways and after listening to them in the car for a few months, the next time I went to Spain I was able to hold (very) basic conversations and even book a table at a nearby restaurant over the phone without saying a single word of English.
I also tried ISSEN (a YC startup I saw posting here that advertises itself as an AI language tutor) and found it to be... underwhelming. It spoke at much too high a level for me and I think asked me about pets or something? When I said I didn't have a dog it completely ignored that and asked what breed of dog it was. I've used a few different "voice-native" AI agents and even the ones in English left a lot to be desired in terms of interruptions, understanding and memory. It also doesn't help with the one time in my life that I actually have time to learn Spanish, which is when I'm driving my car.
So I decided to try and recreate the Language Transfer/Paul Noble style learning approach, but letting you write an AI prompt to create a lesson suited to your interests and learning level.
https://cadencespanish.com/
Any feedback would be great!
In terms of tech stack, I used Lovable and Supabase. I wrote some of the copy by hand but none of the code. I use ElevenLabs for the realtime speech-to-text and Google Cloud for the text-to-speech (it's an awful lot cheaper and sounds quite good). I am a software developer (I work for a totally unrelated YC backed startup) but I've somewhat fallen in love with Lovable for how fast I can go from "huh, I wonder if this would work" to something in production. And ironically I learned the most about React and react-router-dom from a previous time when Lovable built something that went so wrong I had to dig into the code and rewrite bits of it.

value: Show HN: Cadence Spanish – AI audio lessons to learn Spanish

author: aliclark


value: newswangerd

value:
Hi Everyone,
Digital Carrot is a programmable and pluggable app blocker. It lets you block websites and apps on iOS, Mac and Windows until a set of conditions or goal is met. For example you can block Reddit, Instagram and Steam until your Apple Watch reports that you have walked 5000 steps.
The app works by collecting data via plugins that you can use to create goals for yourself. Goals are all represented by expressions that return true or false based on the data you provide. For example, if you want to create a goal to finish all of the tasks in your to-do list you could do something like `data.apple_reminders.due == 0`.
The blocking system is also pluggable. That means you can block items via DNS with services as Pi-hole[3]. It also means that the app is not just limited to website blocking! In fact you could write a plugin to control anything that is available via a REST, such as locking a smart lock on your snack cupboard or cranking up the AC in your office until you go outside.
Keeping security and user privacy is a top priority for this app (given that it's literally designed to collect information about you). Because of that:
- We do not collect or share any information that the app gathers.
- Our sync feature is fully end to end encrypted using AES256 and the secure remote password protocol.
- All plugins are sandboxed. They cannot access data provided by other plugins and have no external access unless granted by the user.
- The app is transparent about the data it has. All of the data that is available to use for goals is browsable in app.
Like many of you, I've been dismayed by big tech's lack of concern for our privacy, so keeping these guarantees is personally very important to me. One of the fun things about this project has been that I can kind of flip the script by taking all of the information that has been gathered about me and use it to help cut down on the distractions in my life :)
Anyway, I had to walk 4km to unblock HN in order to post this, so I hope you find it helpful!
[1] Technical overview: https://www.digitalcarrot.app/docs/overview/
[2] Plugin repository: https://github.com/digital-carrot-app/plugins
[3] Pi-hole plugin: https://github.com/digital-carrot-app/plugins/tree/main/piho...

value: Show HN: Digital Carrot – Block social media with programmable rules and goals

author: newswangerd


value: helro

value:
Hi HN,
I built utter, a macOS + iOS dictation app that focuses less on raw transcription and more on what happens after dictation.
Standard dictation is fast, but the output usually needs cleanup. Utter lets you define custom prompts that transform your spoken input before it’s inserted — e.g. removing filler, adding structure, formatting as bullet points, emails, or notes.
It works system-wide: press a hotkey, speak, and the processed text is inserted at the cursor in any app (Notes, editors, terminals, browsers, etc.).
A few details:
- Works out of the box with no setup using built-in cloud models
- Optional local models or BYOK for those who prefer that path
- Transcripts can be saved locally in formats like Markdown
- iOS companion app with iCloud sync
- No accounts, no login, no data retention
I built this primarily for my own workflows (notes, writing, coding prompts) and would love feedback on what’s missing or where it breaks down. One of my favorite uses is dictating prompts for agentic coding workflows, which are then post-processed using a custom prompt that includes a repository file map for semantic search and automatic @file tagging.
Link: https://utter.to
Happy to answer questions.

value: Show HN: Utter – system-wide dictation with prompt-based post-processing iOS/Mac

author: helro


value:
Hi HN,
Like many of you, I've been exploring the new Claude Cowork capabilities. While the official docs are great, I found that practical examples, working prompts, and configurations are scattered across GitHub issues, Twitter, and various blogs.
I built Awesome Cowork to aggregate these resources in one place.
Currently, it includes:
- Prompts for file management and web scraping.
- A list of troubleshooting tips for common errors.
It's still a work in progress. If you have any scripts or use cases you've tested, I'd love to add them to the list (or feel free to submit a PR to the GitHub repo).
Hope this saves you some setup time!

value: Show HN: Cowork – A curated list of resources for Claude Cowork


value: oqba

value: High-performance, AI-native server built from scratch in C + Assembly — handles heavy AI payloads with minimal latency.

value: Show HN: NeuroHTTP – AI HTTP server written in C/َAssembly

author: oqba


value: keepamovin

value: Show HN: Control local CLI agents (Claude, Gemini, Copilot) via email

author: keepamovin


value: seancze

value:
Recently, I tried LeetCoding on my phone while heading back home. The experience was worse than expected because of frequent typos. Hence, I built a browser extension that allows you to write your solutions in English instead. It will automatically convert your logic into Python 3 syntax and paste it into LeetCode’s code editor.
To assist with debugging, the extension has a separate “Test” button. This feature evaluates your current code snippet. If erroneous logic is identified, it generates and adds a single test case.
The extension is free as it uses my personal OpenAI API key, which is stored on Vercel. If you would like the OpenAI call to run directly from your browser, you can pass in your own OpenAI API key.
Finally, to use the browser extension on mobile, you have to use Microsoft Edge. Google Chrome does not support extensions on mobile.
Hope this helps someone!

value: Show HN: Browser extension to LeetCode easily on mobile

author: seancze


value: soaringmonchi

value:
Hi HN
We built YASP because the existing free/open-source status pages were either dated, ugly, or too restrictive (no custom Twilio/SMTP, rigid notifications, limited customization).
YASP is a modern, self-hosted status page built with Next.js + Payload CMS, and it’s fully open source (MIT).
What makes it different:
- Full CMS flexibility via Payload – customize almost everything without touching code
- Review & edit every notification (SMS/email) before it’s sent
- Bring your own Twilio and SMTP accounts
- OAuth2 / OIDC capable
- Beautiful dark & light themes out of the box
- Incident updates, maintenance windows, service groups, subscriber management
- One-click deploy on Vercel, or self-host anywhere
Tech stack: Next.js, TypeScript, Tailwind, Payload CMS
Open source & free forever
Would love feedback from folks who’ve run status pages in production.

value: Show HN: YASP – Open-source, modern status page with full CMS control

author: soaringmonchi


value: ymodulo

value:
Melker is a Deno/TypeScript runtime and library for creating rich terminal UIs using an HTML-like document model.
Apps are single .melker files with XML-like syntax and embedded TypeScript.
The idea: TUI apps should be inspectable like web pages.
Before running, the source and permissions are visible. Network calls or file access must be declared.
Key features:
- Embedded permission policy (sandboxed subprocess)
- Run from URL with first-run approval
- F12 Dev Tools (view source, inspect document tree, logs, ...)
- Flexbox layout, 20+ components, including images and markdown viewer
- No build step, TypeScript runs directly
Motivation: Sharing TUI tools shouldn't require asking people to trust arbitrary code.
Also, I really wanted a typescript playground for graphical terminal apps.
Requires Deno 2.5+.

value: Show HN: Melker – Terminal UIs you can read before you run

author: ymodulo


value: websku

value:
Who you meet the most.
Busiest day of week.
And many more details.

value: Show HN: Yearly Calendar recap. Google and Outlook calendars only

author: websku


value: parevo

value:
Hi HN,
I built dgdoc to automate document generation without relying on slow interop tools or complex XML manipulation. It’s a high-performance Go library (and CLI) that populates Office templates using JSON data.
It goes beyond simple text replacement:
DOCX: Converts HTML to native Word elements (tables, lists) and supports logic ({#if}, {#loop}).
XLSX: Preserves formulas while populating cells and duplicating rows.
PPTX: Handles slide text replacement and content duplication.
It compiles to a single binary, making it easy to generate reports, contracts, or presentations in serverless/container environments.

value: Show HN: Dgdoc – Go Office Templating

author: parevo

title: Show HN: Dgdoc – Go Office Templating


value: cvbox

value: Show HN: SheetsToLabels – Visual label designer for Google Sheets

author: cvbox


value:
I wanted to query Google's AI Mode programmatically, and there's no official API. So I built a browser extension that gives you a private API endpoint tied to your browser.
Install the extension → it connects to a relay server → you get a unique, private endpoint. Send POST requests from your scripts/terminal. Your browser receives the query, the extension fires up AI Mode, executes the query, returns JSON with the answer, follow-ups, and sources.
The endpoint is private (only you can query it). Extension only touches the AI Mode page, nothing else in your browser.
Demo video: https://youtu.be/IIn-WsVBtnU - first 2 minutes is a live demo, rest is technical walkthrough.
Built for research and monitoring use cases. Rate limits apply since this runs through your browser session. Free to use, planning to open source the server code soon.
Docs/API ref: https://aimodeapi.com/docs

value: Show HN: AI Mode API – Turn Big G's AI Mode into an API


value: melezhik

value:
Yes, it’s does not use yaml, only general programming languages
https://github.com/melezhik/DSCI

value: Show HN: DSCI – Dead Simple CI

author: melezhik

title: Show HN: DSCI – Dead Simple CI


value: gabordemooij

value: Show HN: Xoscript

author: gabordemooij

title: Show HN: Xoscript


value: tonyww

value:
Hi HN,
This is an integration between browser-use and Sentience SDK, where Sentience acts like Jest for AI web agents: it lets agents assert what changed on the page, instead of guessing when they’re “done”.
Most web agents today rely on screenshots or raw DOM dumps and hope the model infers layout, state, and completion correctly. That can work for demos, but it’s expensive, brittle, and very hard to validate or debug.
Sentience takes a different approach.
The goal isn't to replace vision models, but to avoid paying for them when geometric processing of page structure is sufficient for most web pages.
At each step, Sentience builds a semantic snapshot of the page that captures what matters for interaction, not pixels or raw DOM:
* interactive elements (links, buttons, inputs)
* roles + normalized text
* bounding boxes + relative position
* dominant groups (main lists / feeds)
* ordinal structure (“first”, “top”, “last”)
This snapshot is passed to the agent as structured text (≈ 0.6–1.2k tokens per step in practice), which enables:
* browser-use agents to run without screenshots by default
* text-based local LLMs (e.g. Qwen 2.5 3B) to work reliably using text-only prompts
* Jest-style assertions over semantic state (e.g. “main list exists”, “first item clicked”, “task complete”)
In short:
* browser-use acts
* Sentience SDK asserts
That separation makes agent behavior inspectable, debuggable, and testable, instead of opaque and heuristic-driven. It also reduces reliance on vision models when they aren’t strictly necessary.
Sentience SDK includes an agent runtime with per-step and task-level assertions, so agents can explicitly verify progress rather than relying on implicit “done” signals. On assertion failure after retries, Sentience SDK will trigger a fallback to vision models.
Example (browser-use + local LLM): Multi-step agent using Qwen 2.5 3B with semantic assertions: https://github.com/SentienceAPI/browser-use/pull/6/files
Example for failed task assertion logs: https://justpaste.it/lixt2
Example for successful task run logs: https://justpaste.it/izg2y
Full write-up with design rationale, tradeoffs, and examples: https://medium.com/@rcholic/beyond-clicking-how-we-taught-ai...
Open source SDK:
Python: https://github.com/SentienceAPI/sentience-python
TypeScript: https://github.com/SentienceAPI/sentience-ts
browser-use integrations:
Jest-style assertions for agents: https://github.com/SentienceAPI/browser-use/pull/5
Browser-use + Local LLM (Qwen 2.5 3B) demo: https://github.com/SentienceAPI/browser-use/pull/4
Token usage comparison (semantic snapshots vs screenshots in browser-use): https://github.com/SentienceAPI/browser-use/pull/1
Happy to answer questions or share minimal examples if you’re curious how this works in practice.
ShowHN screenshots from the test runs: https://jpcdn.it/img/small/435580414b5e9bc2236ca025573f3724....

value: Show HN: Browser-use, Qwen 2.5 3B, Sentience – Jest assertions for AI web agents

author: tonyww


value: helloiamvu

value:
Hi HN, we built this.
The NBA Edge Index uses pre-game win probabilities from Polymarket (real-money prediction markets). After each game finalizes, we compare the outcome to the pre-game odds. Beating expectations moves a team's rating up; underperforming moves it down. Each team starts at 2000, and ratings accumulate game-by-game throughout the season. Updates happen automatically after games finalize.
A few data points we found interesting:
Polymarket odds are pretty accurate on average: teams priced at 80%+ won 82% of the time (119 games), and teams priced 60–69% won 63%.
Biggest overperformer: Phoenix Suns, +14.7% vs expectations (market gave them 45.8% avg odds; they won 60.5%).
Most overrated by market: Cleveland Cavaliers — 55.8% win rate but market gave them 67.4% implied. They've lost 12 games as heavy favorites.
Biggest called upset: Utah Jazz beat Cleveland on Jan 13 with 18.5% market odds; our edge model gave Utah 70.9%.
Stability: After ~40 games per team, rankings start to diverge meaningfully and early noise smooths out.
We're working on more indices like this. The core idea: prediction market data is fragmented across hundreds of contracts that expire and disappear. We turn it into persistent, trackable indices.
Two patterns we use:
Composite — Blend related markets into one number. Our Global Conflict Risk Index combines ~15 Polymarket contracts (Ukraine, Taiwan, Iran) into a single number.
Rolling — Auto-replace expiring contracts. For example our weather indices track 6-city temperature deviations by rolling forward daily.
Curious to hear feedback or suggestions of ideas for other indices.
The live NBA Edge index is here: https://attena.xyz/nba

value: Show HN: How NBA teams perform vs. prediction market expectations

author: helloiamvu


value: karibash

value:
Hi HN,
I built byethrow (@praha/byethrow), a Result type library for TypeScript/JavaScript.
Highlights:
- Tree-shakable (bundle only what you use)
- Plain-object Result (no classes)
- Same API for sync Result<T,E> and async Promise<Result<T,E>>
- pipe + andThen/andThrough
- Type-safe validation helpers
Docs: https://praha-inc.github.io/byethrow
Repo: https://github.com/praha-inc/byethrow
Would love thoughts from people who’ve used Result/Either in production: what’s missing, what’s annoying, what would you change?

value: Show HN: Byethrow – Result handling focused on DX (tree-shakable, unified async)

author: karibash


value: WanderZil

value:
Hi HN, I made StarRupture Calculator, a free web tool for the game StarRupture.
StarRupture is a sci-fi survival and factory-building game. As the factory grows, it becomes hard to calculate production chains, building counts, and power usage. I built this tool to make planning easier.
With StarRupture Calculator, you can:
 • Calculate production chains and required buildings
 • See visual production flows
 • Compare different recipes
 • Check power consumption
 • Save and export your plans
All data comes directly from the game files, so the numbers are accurate. The tool runs fully in the browser, is free, and has no ads. This is a fan-made, non-official project.
Website:
https://starrupturecalculator.com/
Feedback is welcome. Thanks!

value: Show HN: StarRupture Calculator – A Simple Production Planner for StarRupture

author: WanderZil


value: andix

value: Show HN: AI slop: A todo app built in bash with microservices

author: andix


value: ianseyler

value: Show HN: A 10KiB kernel for cloud apps

author: ianseyler

title: Show HN: A 10KiB kernel for cloud apps


value: Show HN: CogDB - Micro graph database for Python