value: harjjotsinghh

value:
I'm running a 2-week validation experiment before building my next product.
Concept: Visual AI orchestration platform
- Drag blocks (GPT-5.1, Claude Opus 4.5, Llama Maverick 4, etc.)
- Connect them into workflows
- Parallel execution (not sequential like Zapier)
- Zero code required
Why: n8n is too complex for non-devs. Zapier doesn't do parallel execution. Gap exists.
The bet: IF 500 signups in 2 weeks → I build it (3 months). IF not → I pivot/kill it.
Current: 26/500 (Day 2)
Landing page: https://orchastra.org (mockups only - no product yet)
Questions for HN:
1. Is "Scratch for AI" clear or confusing?
2. Is 2 weeks enough validation?
3. What would make this actually useful vs just another automation tool?
Appreciate all brutal feedback.

value: Show HN: Validating "Scratch for AI agents" before building

author: harjjotsinghh


value:
I’ve been working on a Rust implementation of UTCP, a vendor-neutral protocol for LLM tool calling. The goal is to avoid every model/vendor defining its own schema and instead make tool ↔ model interoperability predictable and boring.
What works:
- Full UTCP message parse/serialize
- Strongly typed request/response model
- Transport-agnostic (stdin/stdout, HTTP, WS, anything)
- Minimal dependencies, straightforward API
Still to do:
- Validation helpers
- Higher-level client/server wrappers
- More real-world examples
Repo: https://github.com/universal-tool-calling-protocol/rs-utcp
Feedback + contributions welcome!

value: Show HN: Rs-Utcp, a Rust Implementation of the Universal Tool Calling Protocol


value: DmitriiBaturo

value:
I'm submitting an application to the Foresight Institute – AI for Science program and need to list a reference contact (not a recommendation letter).
The reference’s role is minimal: Foresight usually contacts the reference only if their input is important for the final decision. If they reach out (typically in January), it is only to confirm two things:
1. that they have seen or read my work,
2. that I appear to be a serious and competent researcher.
No endorsement of the scientific content is required, and no obligations are involved.
My work concerns the ICT Model (Information–Consciousness–Temporality) — a formal framework connecting informational dynamics, temporal structure, consciousness and multi-level physical systems.
A full preprint (with equations and testable criteria) is here:
https://www.academia.edu/s/8924eff666
Main publication (open access):
DOI: 10.5281/zenodo.17584783
I'm looking for someone with a background in physics, math, CS, neuroscience, or related fields who is willing to serve as a neutral reference contact.
If you're open to it, please reply here or contact me.
Dmitrii Baturo

value: Show HN: Looking Ref Contact for a Foresight Grant ICT Info-Consciousness-Time

author: DmitriiBaturo


value: mikeayles

value:
I got DOOM running in KiCad by rendering it with PCB traces and footprints instead of pixels.
Walls are rendered as PCB_TRACK traces, and entities (enemies, items, player) are actual component footprints - SOT-23 for small items, SOIC-8 for decorations, QFP-64 for enemies and the player.
How I did it:
Started by patching DOOM's source code to extract vector data directly from the engine. Instead of trying to render 64,000 pixels (which would be impossibly slow), I grab the geometry DOOM already calculates internally - the drawsegs[] array for walls and vissprites[] for entities.
Added a field to the vissprite_t structure to capture entity types (MT_SHOTGUY, MT_PLAYER, etc.) during R_ProjectSprite(). This lets me map 150+ entity types to appropriate footprint categories.
The DOOM engine sends this vector data over a Unix socket to a Python plugin running in KiCad. The plugin pre-allocates pools of traces and footprints at startup, then just updates their positions each frame instead of creating/destroying objects. Calls pcbnew.Refresh() to update the display.
Runs at 10-25 FPS depending on hardware. The bottleneck is KiCad's refresh, not DOOM or the data transfer.
Also renders to an SDL window (for actual gameplay) and a Python wireframe window (for debugging), so you get three views running simultaneously.
Follow-up: ScopeDoom
After getting the wireframe renderer working, I wanted to push it somewhere more physical. Oscilloscopes in X-Y mode are vector displays - feed X coordinates to one channel, Y to the other. I didn't have a function generator, so I used my MacBook's headphone jack instead.
The sound card is just a dual-channel DAC at 44.1kHz. Wired 3.5mm jack → 1kΩ resistors → scope CH1 (X) and CH2 (Y). Reused the same vector extraction from KiDoom, but the Python script converts coordinates to ±1V range and streams them as audio samples.
Each wall becomes a wireframe box, the scope traces along each line. With ~7,000 points per frame at 44.1kHz, refresh rate is about 6 Hz - slow enough to be a slideshow, but level geometry is clearly recognizable. A 96kHz audio interface or analog scope would improve it significantly (digital scopes do sample-and-hold instead of continuous beam tracing).
Links:
KiDoom GitHub: https://github.com/MichaelAyles/KiDoom, writeup: https://www.mikeayles.com/#kidoom
ScopeDoom GitHub: https://github.com/MichaelAyles/ScopeDoom, writeup: https://www.mikeayles.com/#scopedoom

value: Show HN: KiDoom – Running DOOM on PCB Traces

author: mikeayles


value: vigile

value:
We’ve been working on the Kodaii engine, aimed at generating complete backends that stay coherent across models, routes, workflows, and tests — not just isolated snippets.
To get a sense of how well the engine handles a real project, we asked it to build a Calendly-style booking system from a single prompt. It ran the whole process — planning, code generation, tests, infra, and deployment — in about 8 hours.
What it generated:
- ~20K lines of Python (FastAPI, async)
- Postgres schema (6 tables)
- Services, background tasks, booking logic
- Email notifications
- 40 unit tests + 22 integration tests
- Docker Compose (API + Postgres)
- GitHub Actions pipeline
- A running deployment tied to Postgres
- Code & live endpoints
Everything is open:
Repo: https://github.com/OlivierKodaii/calendarKodaii
API docs: https://calendar.kodaii.dev/docs
OpenAPI schema: https://calendar.kodaii.dev/openapi.json
Admin interface: https://calendar.kodaii.dev/admin
Why we’re sharing this
We think this line of work may be of interest to peers on HN who care about backend architecture, tooling, and large-scale code generation and your feedback would be very much appreciate.
If you inspect the repo, we’d appreciate any comments on:
- structure,
- code clarity,
- decisions that look odd,
- failure points,
- or anything that feels promising or problematic.
For those who want to follow the project or join the upcoming alpha:
 https://kodaii.dev
Happy to discuss details or answer questions.

value: Show HN: Kodaii generated a 20K-line FastAPI back end from one prompt

author: vigile


value: aiexplorations

value:
Praval started as a small side project to build a light weight AI framework, and is evolving into a multi-agent AI framework with lots of features.
Praval can be used to build a multi-agent system today with native agent-to-agent communication. Agents can be imbued with memory (native Chroma DB integration) and the Reef communication sub-system is akin to a message queue. Reef has native support for RabbitMQ as well. Observability features are being built with Open Telemetry compatibility. It supports OpenAI LLMs as of now, and I'm hoping to build support for Anthropic, Cohere, and other models via OpenRouter and other providers soon.
I'm building a couple of apps on top of Praval - one of them is Praval Deep Research: https://github.com/aiexplorations/praval_deep_research - this is a local-first, agentic research tool for people using Arxiv to do research and ask questions to understand papers. Can help you search, index and do Q&A on top of research papers, and also get prompted on research topics.
Praval is on PyPI: https://pypi.org/project/praval/
There's a site with documentation here: https://pravalagents.com/
Still an early project and I'm sure there's lots of scope for new features. Give it a spin and let me know how you like it.

value: Show HN: Praval Agentic AI Framework

author: aiexplorations

title: Show HN: Praval Agentic AI Framework


value: arlindb

value: Show HN: Guesswhere a place where founders helping founders

author: arlindb


value: shahidfoy

value:
I built N1netails, a lightweight, self-hosted alerting platform for developers.
Features:
- Sends alerts to Discord, Slack, Telegram, MS Teams, and email
- Simple Spring Boot backend + Angular frontend
- Token-based API for integrating alerts from your apps
- Optimized for solo developers and small teams
- Self-hosted, lightweight, easy Docker setup
Dashboard: https://app.n1netails.com
Docs: https://n1netails.com
GitHub: https://github.com/n1netails/n1netails
I’d love feedback from the community on features, usability, or anything else!

value: Show HN: N1netails – lightweight, self-hosted alerting platform for developers

author: shahidfoy


value: garydevenay

value: Show HN: I built a running coach that reacts to your training performance

author: garydevenay


value: drtydzzle

value:
Kubently is an open-source tool for troubleshooting Kubernetes agentically - debug clusters through natural conversation with any major LLM.
Why I built it: kubectl output is verbose, debugging is manual, and managing multiple clusters means constant context-switching. Agents debug faster than I can half the time, so I built something around that.
~50ms command delivery via SSE
Read-only operations by default
Native A2A protocol - integrates with systems like CAIPE, LangGraph/LangChain
Runs on any K8s cluster (EKS, GKE, AKS, bare metal)
Multi-cluster from day one
Docs: https://kubently.io
GitHub: https://github.com/kubently/kubently

value: Show HN: Kubently – Debug Kubernetes Clusters Agentically

author: drtydzzle


value: mathgladiator

value: Show HN: I Figured It Out

author: mathgladiator

title: Show HN: I Figured It Out


value: houndz

value:
Hi all, I built a CLI tool that allows you to seamlessly install software from GitHub release assets, similar to how your system's package manager installs software.
It works by exploiting common patterns among GitHub releases across different open-source software such as naming conventions and file layouts to fetch proper release assets for your system and then downloading the proper asset onto your machine via the GitHub API. Parm will then extract the files, find the proper binaries, and then add them to your PATH. Parm can also check for updates and uninstall software, and otherwise manages the entire lifecycle of all software installed by Parm.
Parm is not meant to replace your system's package manager. It is instead meant as an alternative method to install prebuilt software off of GitHub in a more centralized and simpler way.
It's currently in a pre-release stage, and there's a lot of features I want to add. I'm currently working (very slowly) on some new features, so if this sounds interesting to you, check it out! It's completely free and open-source and is currently released for Linux/macOS. I would appreciate any feedback.
Link: https://github.com/yhoundz/parm

value: Show HN: Parm – Install GitHub releases just like your favorite package manager

author: houndz


value:
We’ve been building a fully digital city pass for Lisbon that you can use right away without downloading an app. You can explore 50+ attractions, museums, tours and local experiences with a single pass. For December, I set the price to 1€ for 5 days so people can try it without friction.
Promo code: TRIPNLY-LOVES-YOU
What’s different about this project:
– It works entirely in the browser, no signup barriers.
– It’s built to serve both tourists and locals, not only visitors.
– It combines a city card, discounts, and a loyalty system in one tool.
– My goal is to experiment with how digital passes can improve city exploration and support small local businesses.
I’d really appreciate feedback from the HN community — on the UX, the idea itself, the onboarding flow, or anything that feels confusing. Happy to answer questions and discuss the technical side as well.

value: Show HN: Tripnly Lisboa City Pass – 5 Days for 1€


value: Show HN: Agentic Arena – 52 tasks implemented by Opus 4.5, Gemini 3, and GPT-5.1


value: yudduy

value: Show HN: Runtime Verification for SQL Agents

author: yudduy


value: antiochIst

value:
I built a system that monitors ~200,000 news RSS feeds in near real-time and clusters related articles to show how stories spread across the web.
It uses Snowflake’s Arctic model for embeddings and HNSW for fast similarity search. Each “story cluster” shows who published first, how fast it propagated, and how the narrative evolved as more outlets picked it up.
Would love feedback on the architecture, scaling approach, and any ways to make the clusters more accurate or useful.
Live demo: https://yandori.io/news-flow/

value: Show HN: Real-time system that tracks how news spreads across 200k websites

author: antiochIst


value: roberttidball

value: Show HN: Free macro dashboards with downloadable charts (e.g., EUR/USD)

author: roberttidball


value:
Hi HN,
I built a WordPress plugin called Bandwidth Saver. It takes the images your site already has and serves them through Cloudflare R2 and Workers, which means zero egress fees and extremely low storage cost. The goal is to make image delivery fast and cheap without adding any of the complexity of traditional optimization plugins.
The idea is simple. WordPress keeps generating images normally. The plugin rewrites the URLs on the frontend so images are served from a Cloudflare Worker. On the first request, the Worker fetches the original image and stores it in R2. After that, Cloudflare’s edge serves the image from its global cache with no egress charges. There’s no need to preload or sync anything, and if something fails, the original image loads. That’s the entire system.
I built this because most image CDN plugins try to do everything: compression, resizing, AI transforms, asset management, custom dashboards, and monthly fees. That’s useful for some users, but it’s unnecessary for most sites that just want their existing media to load faster without breaking the bank. Bandwidth Saver focuses only on delivery, not transformations. It’s intentionally minimal.
There are two ways to use it. The plugin is completely free if you want to run your own Cloudflare Worker. I included the Worker code and the steps needed to deploy it. If you don’t want to deal with any Cloudflare setup, there’s a managed option for $2.99 per month that uses my Worker and my R2 bucket. I’m trying to keep it accessible while also covering operational costs.
The plugin works with any theme or builder and doesn’t modify the database. It only rewrites URLs on output. WordPress remains the system of record for all media. R2 simply becomes a cheap, durable cache layer backed by Cloudflare’s edge.
I’m especially interested in feedback about the approach. Does the fetch-on-first-request model make sense? Is the pricing fair for a plugin of this scope? Should I prioritize allowing users to connect their own R2 buckets or the managed service? And for those with experience in edge compute or CDNs, I would love thoughts on how to improve the Worker or the rewrite strategy.
Thanks for reading, happy to answer any questions.

value: Show HN: A WordPress plugin that rewrites image URLs for near-zero-cost delivery


value: sunnykentz

value: Show HN: Rsync Made It on Jpm

author: sunnykentz

title: Show HN: Rsync Made It on Jpm


value: wangaileen

value:
Hi everyone! I'm happy to present MidiToolbox.com.
This is a robust, privacy-focused toolkit offering essential utilities for anyone who works with MIDI files—musicians, educators, and developers alike. We focus on putting powerful processing tools right into your browser.
Crucially, all processing is done locally. Your files never leave your device, ensuring maximum speed and data privacy.
Key features include:
MIDI Playback & Viewer: A reliable player to audition and visualize your MIDI files instantly.
Deep MIDI Analysis: Quickly inspect events, track data, tempos, and time signatures.
Editing Suite: Tools for transposition, tempo adjustment, merging, and splitting tracks.
PDF Score Conversion: Convert MIDI files into viewable or printable sheet music (PDF format).
I built this set of tools to be fast, reliable, and respectful of user data.
I welcome your thoughts and feedback!
Link: https://miditoolbox.com

value: Show HN: MidiToolbox – MIDI Utilities for Conversion, Analysis, and Editing

author: wangaileen


value: I was getting tired of forgetting things and typing other things repeatedly into Codex's prompt, so I've been building some config + prompt glue to help with what I find to be the more tedious parts of development.<p>It's a little dirty and rough (I've taken some liberty in testing it on its own master branch), but I would love to know if this maps to anything close to a solution for your guys' aches with using agents. I always hear a million different experiences people have for the same problem with them, so I'm wondering if something like this would be a step toward reducing that number.

value: Show HN: Vizier – Codifying My Agent Development Workflow


value: Gigacore

value: Show HN: TripMeter – Analyze your Uber data with interactive visualizations

author: Gigacore


value:
Hi everyone,
I’ve been working on AnimBits, a collection of 50+ animation UI components, animation hooks , transitions for React built on top of Framer Motion. feedback is appreciated
The goal is to provide clean, subtle, production-ready animations that can be dropped into any React project without the usual setup overhead. All components are designed to be accessible, minimal, and easy to customize.
Features
50+ components: buttons, cards, text effects, loaders, lists, icon animations, page transitions, and more
Built entirely with Framer Motion
Subtle, non-flashy effects suitable for production UI
Works via simple copy-paste or installable using shadcn UI registry
npx shadcn add https://animbits.dev/r/buttons-lift.json
Fully typed with TypeScript
MIT licensed

value: Show HN: AnimBits – 50 Framer Motion–powered animation components for React


value: dannysmith

value:
Hey HN, I built this because I wanted to write more on my personal website but found VS Code et al terrible for prose.
Astro is a great static site framework for content-heavy sites, but its content files use MDX (markdown + JSX components) with YAML frontmatter. Regular markdown editors like iA Writer can't handle this properly.
Astro Editor is basically iA Writer for Astro content collections:
- Distraction-free writing with focus mode (hides YAML and imports)
- Auto-generates frontmatter forms from your Zod schemas
- Component insertion with prop picker for MDX
- Drag-and-drop image handling
It's free and open source, built with Tauri + React.
Download: https://astroeditor.danny.is
Demo video: https://www.youtube.com/watch?v=SJkXD59gQ5U
macOS only for now. If there's interest in Windows/Linux upvote this: https://github.com/dannysmith/astro-editor/issues/56
Happy to answer any questions, obvs.

value: Show HN: Astro Editor – Free macOS Markdown editor for Astro content collections

author: dannysmith


value:
I built this because I have ADHD and kept losing ideas during brain dumps. You know that feeling when your thoughts are racing at 400 WPM but your fingers can only type 40? That's where ideas die.
Most voice apps either require cloud processing or use AI that I can't audit. I wanted something that captures the chaos without judgment, then helps organize it later.
What it does:
Brain dump by voice → Web Speech API transcribes → compromise.js (deterministic NLP) sorts into tasks/notes
Everything runs client-side. No servers, no auth, no data collection.
Works offline via PWA + IndexedDB
Smart date detection: "tomorrow at 3pm" becomes an actual deadline
Priority detection, streak tracking, keyboard shortcuts
"Speak. Save. Sort it later." workflow
Tech stack:
Next.js 15, TypeScript, Tailwind
Web Speech API (browser-native, free)
compromise.js for NLP (no ML models)
IndexedDB for storage
~300 KB bundle size
Tradeoffs I made:
No cloud sync (by design) → manual export/import JSON instead
Firefox support is limited (Web Speech API not fully implemented)
Classification isn't perfect (~85-90% accuracy) but it's transparent and auditable
No mobile keyboard shortcuts (browser limitation)
Why no AI?
Privacy: I wanted zero data leaving the device
Speed: Deterministic rules are instant, no API latency
Transparency: You can read exactly how classification works
Cost: Browser APIs are free
Try it: https://tickk.app (just click the mic and brain dump) Code: https://github.com/digitalwareshub/tickk
Built primarily for ADHD brain dumps but useful for anyone who thinks faster than they type.
Happy to discuss architecture decisions, especially around the offline-first approach. Also curious if anyone has ideas for improving task/note classification without adding AI.

value: Show HN: Tickk – Voice task manager for brain dumps (offline, no AI, OSS)


value: Smart Meme Search helps you instantly find memes stored on your computer using AI image recognition and OCR text detection. Just type what you’re looking for — the app scans your meme folders, reads text inside images, and shows the best matches instantly.

value: Show HN: SmartMemeSearch – Search memes collections on your computer(CLIP, OCR)


value: spinity

value:
Over the past few months I’ve been experimenting with how small a functional bearing-based mechanism can get while still feeling smooth, durable, and useful. This project started from a simple question:
How thin can a real, free-spinning bearing be while still handling continuous rotation?
Most “spinner rings” you see online cheat by simulating rotation — there’s no real bearing, just loose tolerance metal sliding on metal. True micro-bearing rotation needs precision, tight tolerances, and high surface finish, which is difficult when everything needs to be wearable on a finger.
So I tried to push it in the opposite direction and ended up making this:
A 2mm-thick stainless steel ring with an internal micro-bearing track and 20 steel balls that free-spin for 20+ seconds with a single flick.
Mechanical details: • CNC machined inner race with ~0.01mm tolerance • 20 micro steel balls loaded through a lateral channel • Outer ring pressed onto the bearing shell • No plastic, no bushings, no lubricant • Built to withstand everyday wearing forces (compression, torsion, micro-impacts) • PVD variant for color durability • Outer surface can be marked 1–20, turning it into a tiny randomizer
Originally the goal was purely mechanical — to see if a bearing this thin could be made. But it ended up being surprisingly functional for solo tabletop RPG use: when you need a quick random result but don’t have table space, or when dice are too loud (playing in bed, on a commute, etc.). The ring spins silently and lands pointing at a single number.
This wasn’t meant to replace dice; it just became a neat side effect of the engineering challenge.
Why I’m posting here
HN tends to appreciate: • micro-manufacturing • tolerances • machining challenges • precision mechanical design • unusual “why does this work?” projects
I’d love to hear feedback on: • improving durability • minimizing friction losses • alternative ball materials • raceway finishing • any tricks for increasing spin time without adding thickness
If anyone has experience with miniature bearings or wearable mechanical assemblies, I’d appreciate insights. Happy to answer questions about the build process, the tolerances, or the failures along the way.

value: Show HN: I engineered a 2mm micro-bearing D20 ring that free-spin for 20 seconds

author: spinity


value: biinjo

value:
Hi HN, I built an open-source macOS utility called SpreadPaper that lets you take one high-resolution image and spread it seamlessly across all your connected monitors.
I personally use multiple monitors for design and coding, and I got tired of wallpapers that either tile awkwardly or get cropped badly. SpreadPaper is my attempt at a minimal, no-bloat solution that just works. If you also care about multi-monitor aesthetics, I hope you’ll find it useful.
Give it a star on GitHub if you like it and feel free to leave your feature requests/feedback.

value: Show HN: SpreadPaper – span a single wallpaper across multiple macOS monitors

author: biinjo


value: digitalpeak

value:
We built RankLens because we couldn’t answer a simple question for our own clients: “How often do AI assistants actually recommend your brand vs. competitors?”
Instead of ad-hoc “SEO prompts”, RankLens uses structured entity-conditioned probes. Each probe is defined by a brand/site entity + intent, and we resample across many runs to reduce prompt noise and random LLM variance.
For each probe we track:
– Explicit mention of your brand/site (Brand Match)
– Precision of when you’re recommended as the answer (Brand Target)
– How often competitors get recommended instead (Brand Appearance + share of voice)-
- Likelihood of being recommended by the AI. (Brand Discovery)
– A prominence / “confidence” score for how strongly the LLM backs that recommendation
We combine these into a visibility index so agencies and brands can:
– See AI visibility trends over time
– Compare engines (e.g., ChatGPT-style assistants vs. others)
– Spot when they’re losing AI “mindshare” to specific competitors in regions/locale
Method & code
– We open-sourced the entity/probe framework as RankLens Entities (code + configs): https://github.com/jim-seovendor/entity-probe
– We also wrote an in-depth study, “Entity-Conditioned Probing with Resampling: Validity and Reliability for Measuring LLM Brand/Site Recommendations”: https://zenodo.org/records/17489350
I’d love HN feedback on:
– Weak spots / blind spots in the entity-conditioned probing methodology
– Better baselines or evaluation strategies you’d use to test validity & reliability
– Any ways this could be gamed in practice (e.g., by changing site content or prompts) that we haven’t considered
Happy to go into implementation details (sampling design, resampling, scoring, engine differences, etc.) in the comments.

value: Show HN: RankLens – Track your brand's visibility in AI answers reliably

author: digitalpeak


value: saivishwak

value:
Hey HN,
About five months ago, I started thinking seriously about how we run agents — and how little control end users actually have over privacy, data, and compute. Running an LLM locally is great for rewriting emails or answering basic questions, but it doesn’t give you real autonomy. What does give you power is the ability to run full-fledged local agents capable of deep research, coding, reasoning, and tool use — all without sending data to external services.
With that vision in mind, I started an open-source project (MIT + Apache-2 licensed) to make building and running agents modular, customizable, and hardware-friendly. Every component of the agent stack can be swapped out:
Memory: plug in your own memory backend
LLM layer: use local models or cloud APIs interchangeably
Execution style: choose between ReAct, CoT, or your own custom executor
The goal is to enable real research workflows while maintaining strong performance and developer-friendly usability.
The project doesn’t stop at building agents, either — we want to ensure you can run them efficiently on any accelerated hardware, from GPUs to edge devices.
Would love feedback from the HN community!

value: Show HN: An Open-Source, Local-First Agent Framework in Rust

author: saivishwak


value: jaygood

value:
I built a Windows tool to solve a problem I kept running into during live coding interviews and proctored assessments. I wanted to keep reference notes or personal apps open on my own screen without exposing them to the interviewer or screen-share software.
Cloakly hides specific windows from the screen-share stream while keeping them fully visible locally. It works with Zoom, Teams, Meet, Loom, and most proctoring tools.
Right now the core engine works, and I'm looking for beta testers to help with edge cases before the public release. Would love feedback from anyone who regularly interviews, screenshares, or builds Windows utilities.
Beta sign-up: https://www.getcloakly.com
Happy to answer any technical questions about how the cloaking layer works.

value: Show HN: Cloakly – Hide notes and apps during coding interview screen-share

author: jaygood


value: rutagandasalim

value:
I built aithings.dev
 to make it easier to find good AI stuff — not just tools, but also books, videos, tutorials, and communities worth joining.
The goal is to have one place where builders, learners, and founders can explore what’s happening in AI without endless scrolling or random links.
It’s still early, but it’s growing fast. There’s also a newsletter that curates the best new AI tools and resources every week.

value: Show HN: Aithings.dev – a directory for AI tools, resources, and communities

author: rutagandasalim


value: mukulmunjal

value:
Hi HN,
I’ve been working on InterviewFlowAI, a tool that automates the first-round hiring workflow for teams that spend too much time on initial screening. It handles resume scoring, public job links, candidate applications, and full interviews conducted over phone or Google Meet.
I built this after spending years interviewing candidates as a Head of Engineering and realizing that most of the bottleneck happens before an engineer ever gets involved. Too many resumes, too many unqualified applicants, and a ton of repetitive phone screens that rarely lead anywhere.
Here’s what the system does today:
 • Generates a public job link so candidates can apply directly
 • Scores resumes based on the job description and required skills
 • Lets you accept or reject candidates instantly
 • Runs a live interview (phone or Google Meet) using an AI agent
 • Produces a structured scorecard, transcript, and recording
Technical details for those interested:
 • Uses OpenAI real-time API for conversation flow
 • Voice handling and telephony via Vapi
 • Speech → text → scoring pipelines using AssemblyAI and custom logic
 • Resume scoring uses embeddings + rule-based signals to reduce LLM hallucination
 • All interviews are stateless interactions stored securely for evaluation
Pricing is $0.50 per interview, so teams can screen at scale without high per-candidate costs.
I’d love feedback from the HN community, especially around accuracy, bias concerns, architecture, and scaling. Happy to answer any questions about design decisions or what’s still rough.

value: Show HN: InterviewFlowAI – AI phone and Meet interviews for fast screening

author: mukulmunjal


value:
Hi everyone! I'm the maker of Rubber Duck. After shipping iOS apps, I realized how unpredictable App Store review can be.
Even great apps get rejected for: missing metadata, small UI issues, broken flows on certain iPhone models, forgotten privacy entries, one-off crashes Apple found and many more.
Each rejection set the launch back days. So I built Rubber Duck to be the “review before the review.” It combines automated checks with human testers using real iPhones like an App Store reviewer, but faster and kinder.

value: Show HN: Catch App Store rejection issues before Apple does


value:
Hey HN,
I’ve been a casual rap fan for years but could never create my own tracks—beat making felt intimidating, and I’m no lyricist. So I spent a few weekends building RapGenerator (https://rapgenerator.online/) to make it accessible for people like me.
Here’s what it does, simply:
Pick a style (trap, old school, boom-bap, drill—whatever you’re into)
Drop in your own lyrics, keywords, or even just a vibe (e.g., “summer cookout with friends”)
It spits out a complete rap track: lyrics with flow, matching beat, and even AI vocals
No music production experience required—just hit generate
I used Suno V5 under the hood for the audio generation, and tweaked the rhyme scheme logic to feel more authentic (less “AI-generated” stiffness). Everything’s royalty-free, so you can use the tracks for social media, demos, or just for fun.
To make it easy to test, I’m giving HN users 10 free credits on sign-up—enough for one full track. No credit card needed, just a quick login.
I’m still iterating on it—right now I’m working on adding more regional styles (UK drill, West Coast) and letting users adjust BPM/tempo. Would love HN’s take:
Does the flow feel natural, or still too robotic?
Any styles you’d want added next?
Is there a feature missing that would make this useful for you?
Check it out here: https://rapgenerator.online/Open to all feedback—good or bad. Thanks for taking the time to look!

value: Show HN: RapGenerator – Turn lyrics/ideas into full rap tracks (no music skills)


value:
I built the first multi-agent OS where constitutional governance
is architecturally enforced.
Agents literally cannot boot without cryptographically verified oath.
Try it: python scripts/research_yagya.py
Code: kernel_impl.py lines 544-621
Challenge: Prove it wrong.

value: Show HN: Constitutional AI Agent OS (governance enforced at kernel level)


value:
Hi HN, I'm the maker behind YTShortsDL.
The Problem
Existing video download tools are designed for long-form video, not the short-form content ecosystem. When content creators try to repurpose dozens of YouTube Shorts across platforms (TikTok, Reels), they face significant friction: manually downloading one by one is slow and unreliable, leading to wasted hours and missed publishing windows. The focus is on individual files, not high-volume workflows.
The Solution / How it Works
We built YTShortsDL from the ground up to solve batch processing. We optimized the retrieval and queuing logic specifically for the Shorts format. By focusing on playlist and channel-level bulk processing, we allow users to retrieve dozens, or even hundreds, of short-form videos in a fraction of the time compared to traditional methods. It's currently a free utility.
Key Features / Tech
High-Concurrency Batching: Engineered for maximum simultaneous downloads.
Format Agnostic Retrieval: Reliable delivery of original Short files.
Future AI Roadmap: We are actively developing features like client-side watermark removal and AI summarization (planned for Q1 2026) to transition the tool into a full content repurposing suite.
We believe efficiency is key for modern creators. We would be grateful for any technical feedback on our performance or suggestions for the upcoming AI features.

value: Show HN: YTShortsDL: A Bulk Downloader Built for Shorts Content Repurposing


value: Mikecraft

value: Show HN: I Cloned a YC startup in 3 hours

author: Mikecraft


value: EthanSeo

value:
Hi HN guys! I hope you have a happy day.
A year ago, I was terrible at grooming and styling myself. To be honest, it severely affected my self-esteem and made me hesitant to even go outside.
I didn't want to be a supermodel or hot—I just wanted to look like a normal person. But when I tried to find clothes, I hit a wall. I didn't know which brands were good, what style I liked, or where to start. I wasted hours just looking for a simple shirt.
So, I decided to solve this problem the way I know how: by building a tool.
BrandList is a directory of fashion brands categorized by specific styles (like "Classic", "Minimal", "Streetwear"). The goal is to help people find brands that fit their vibe without knowing the specific brand names beforehand.
Key Features:
Curated by Style: You don't search by name; you browse by "look."
No Login Required: You can add/suggest brands without signing up (I hate friction).
It is currently an MVP. I would love your feedback on the UX and the categorization. If you know a cool brand, please add it (no account needed).

value: Show HN: I built directory of fashion brands because I didn't know how to dress

author: EthanSeo


value: ngninja

value: Show HN: SkimIt – An extension to highlight Green/Red flags on LinkedIn profiles

author: ngninja


value: YarkYao

value:
Hi HN,
I’m building Hanzi Stroke (https://www.hanzistroke.com) to solve a very specific problem: learning to write Chinese characters is unintuitive for non-native learners.
Most learners rely on rote memorization, which is inefficient and often leads to incorrect stroke habits. While there are dictionary apps that show static stroke order diagrams, they lack interactivity. The key to muscle memory is deliberate practice with immediate feedback.
So, I made a single-page application that provides:
Dynamic stroke order animations  for over 9,000 characters.
Interactive canvas practice  where you trace characters on screen, stroke-by-stroke, with guidance.
A structured curriculum  based on the official HSK 1-9 vocabulary lists.
Some technical aspects that might interest you:
The frontend is built with Vue.js for a reactive experience, and the stroke data is parsed from a structured source.
A core challenge was designing the stroke-matching logic to be both pedagogically correct and forgiving enough for learners.
The goal was to create a focused, ad-free tool that does one thing well.
This is a bootstrapped project born from my own experience teaching Chinese. It’s not another gamified language app; it’s a practical workbook reimagined for the web.
I’d love for the HN community to try it, especially if you've ever been curious about learning Chinese. But more importantly, I'm keen to hear your thoughts:
For learners:  Does this approach make the writing process less daunting?
For builders:  How have you tackled similar challenges in making "traditional" skills interactive?
All feedback is greatly appreciated. Thank you!

value: Show HN: Hanzi Stroke – An interactive tool to learn Chinese character writing

author: YarkYao


value: kakmuis

value:
I switch between a few different “modes” on my Mac every day (work, coding, meetings, personal stuff).
Each time I’d end up reopening the same apps and dragging all the windows back into the right Spaces.
Super repetitive and honestly kind of annoying.
So over the past few weeks I hacked together a small open-source tool called SpacePigeon that basically remembers your whole workspace and puts everything back where it was.
Things it can do:
Save your current layout (apps + windows + Spaces)
Restore it with one click or a hotkey
Keep separate presets (like “Work”, “Coding”, “Meetings” etc.)
Handle external monitors
Example: I hit my “Work” preset and it opens all the usual apps and moves them to the right desktops automatically. Saves me a few minutes every time.
If anyone here lives in Spaces like I do, you might find it useful.
Here’s the repo (MIT, free):
https://github.com/louivers/spacepigeon
Totally open to feedback — still very much a work in progress.

value: Show HN: SpacePigeon – Save and Restore macOS Workspaces

author: kakmuis


value: passioner

value: I love revisiting some of my favorite TikTok videos — they never fail to make me laugh. But the moving watermarks always get in the way.<p>I wanted a fast, free solution to clean them up. After some trial and error, I found an online tool that does exactly that: just paste or upload your video, click remove, and download — no login, no downloads, no hassle.

value: Show HN: How to Quickly and Free Remove TikTok Video Watermarks

author: passioner


value:
Hi there!
I’m an experienced startup product designer and marketer who recently got into building small-scale software products as a one-person team. While working on various projects, the part of creating a waitlist website every time I need to validate an idea or gather early users just takes a ton of time and thinking that could be better spent elsewhere.
I spent hours designing landing pages. AI-generated sites required endless prompting and fixing, and full website builders like Framer or Webflow took a lot more time than I expected. Because of that extra effort, I often lost momentum and sometimes missed the window to test concepts quickly.
So I built Preshiplist — a tool that generates simple, clean, mobile-optimized waitlist pages with minimal setup. No builder UI. No templates. You write your description, choose a style, and publish.
The platform includes:
- Fully working forms
- A built-in database for signups with email validation
- AI assistance to help you refine your page copy
- A basic email drip system so new signups receive an automatic follow-up
- Custom domains, short links, and an Open Graph editor to make sharing easier
All of this works out of the box without needing integrations, prompting, or configuration.
A few technical notes:
– Built mainly with Next.js and Supabase for the backend
– Deployed on Vercel with Cloudflare in front for stability and security
– Email functionality is handled by the always-reliable Resend
– AI features use OpenAI models for generating text variations
– Custom domains come with automatic SSL via Vercel
If you’re up for it, I’d appreciate feedback on:
– Simplicity vs flexibility — is a streamlined flow enough, or would you prefer more customization power?
– Features you think would be valuable for makers or founders using waitlist pages
– Whether AI-assisted copy is helpful in this context or unnecessary
Thanks for reading!

value: Show HN: Preshiplist – A fast way to ship waitlist websites without headaches


value: mohninad

value:
Left my FAANG job to develop cross platform mobile apps using Flutter. Developed this MVP in a month. Feedback is greatly appreciated!
Google play link: https://play.google.com/store/apps/details?id=com.ninhydrin....

value: Show HN: VibeJar – Mood Tracking and Journal

author: mohninad


value: I wanted to begin the habit of building and publishing small projects of my own so I made 360CSS<p>It is a simple CSS library inspired by the xbox 360 interface that all of us can remember

value: Show HN: 360CSS – Open source CSS styles inspired by xbox360 interface


value: Show HN: NxtPitch – AI that instantly generates pitch proposals


value: HamadAlmheiri

value:
Hi HN, I made BrainScroller — an app that takes the same scrolling habit we all have and turns it into learning instead of doomscrolling.
Why I built it:
I noticed I wasn’t addicted to my phone — I was addicted to scrolling. So I wondered: what if the scroll itself fed my curiosity instead of draining it?
How it works:
You swipe like Instagram/TikTok, but each card is a short summary, idea, or concept from philosophy, history, psychology, tech, and science. It's meant to feel as easy as social media but leave you smarter, not anxious.
What I'm looking for:
– Feedback on the UX and the “scroll-to-learn” model
– Whether the content feels useful or too shallow
– Any suggestions before I work on the next version
Happy to answer anything. Thanks!

value: Show HN: An app that turns doomscrolling into learning

author: HamadAlmheiri


value: Show HN: MenuPhotoAI – AI food photography that keeps dishes real


value: madsmadsdk

value:
hey hackers,
i'm building a command-line community for developers, builders and creators.
if you don't know how to use a cli, this place probably isn't for you.
because you have to use commands like 'cd', 'cat' and 'ls' to browse the community.
it's a nostalgic trip down memory lane, loaded with easter eggs.
currently the waitlist is open, but here's what i'm planning with it:
/feed: think x meets irc, but initially without an algorithm deciding what you'll see. showing posts in descending order never hurt anyone, right?
/leaderboard: weekly, monthly and yearly leaderboard, based on activity, github contributions and profile views. this will be harder to implement, but nonetheless my ambition.
/communities: find like-minded people to socialize with, discuss and show off your work - in the style of a 90s bullentin board system
/dir: explore projects, launches, ebooks, curated content, directories, tools, jobs.
everything your developer heart desires. i'm still figuring out the logistics of how this is will work. ideally the community helps curating the content here.
hope you'll check it out, and feel free to give feedback.
i'd love to hear what you'd hope to be able to do there.
terminal, is life
- mads

value: Show HN: ~$root-dir: a command-line community for devs, builders and creators

author: madsmadsdk


value: Paugallego

value: Show HN: ConfluenceMeter Beta, live panel for crypto confluence

author: Paugallego


value: rane

value: Show HN: Workmux – Frictionless parallel development with Git worktrees and tmux

author: rane


value: mrqjr

value:
I built an open-source tool that turns any NAS into a fully automated subtitle-generation pipeline — running completely locally, no cloud services, no data leaving your network.
If you keep movies/TV shows on a Synology/QNAP/TrueNAS box, this project makes the NAS generate subtitles automatically using on-device models.
Highlights
  Local speech-to-text with Whisper-compatible engines
  No external API calls — privacy by design
  Simple plug-and-play: drop media in a folder → subtitles appear
  Multi-thread + GPU acceleration support
  Auto-language detection, timestamp correction, subtitle formatting
  Web UI for queue monitoring & batch processing
  Works on Synology, QNAP, Unraid, TrueNAS, Docker everywhere
Why I built this
Existing subtitle tools either rely on cloud APIs (privacy concern), require manual processing, or don’t integrate well with NAS workflows.
So this project aims to provide:
A fully autonomous subtitle engine for home servers.
Repo + Docs:
https://subtitlesdog.com/en/nas-subtitler
https://github.com/subtitlesdog/nas-subtitler
Happy to hear feedback from HN folks — feature suggestions, performance improvements, or architecture critiques are more than welcome.

value: Show HN: Turn Your NAS into an AI Subtitle Machine (Open Source, Local)

author: mrqjr


value: ajanthanmani

value:
I've been obsessed with a simple question for years:
"what kind of CEO am I really built to be - and how does that shape the way I make decisions, hire and build companies?"
Most founders / CEOs content is generic. Yet in practice, very different archetype win:
* some CEOs are visionary storytellers.
* Some are executions-obsessed operators
* Some are product monomaniacs
* Some are community / Culture builders
So I built TheNext.CEO - a free, web based CEO archetype assessment platform that tries to capture how you lead, not just "your personality type".
What it does
* Asks you 98 questions across areas like:
- Decision-making style
- Risk appetite
- Product vs sales vs ops focus
- People / culture priorities
- Time horizon and ambition
* Maps you into a CEO archetype (e.g. “Visionary Builder”, “Operator-in-Chief”, etc.).
* Gives you:
- A short, skimmable summary of your archetype
- Key strengths and blind spots
- Suggestions on what kind of team or co-founder might complement you.
The core test is free and runs fully in the browser (no tricks, no paywall required to see your archetype).
What I’m looking for from HN
I’d really appreciate feedback from this community on:
1. Scoring and archetypes
- Does the result feel directionally accurate or completely off?
- Are there any questions that feel leading / confusing / redundant?
- Any archetype description that feels like hand-wavy fluff?
2. UX / flow
- Is 98 questions “too much”, or is it acceptable if the value is clear?
- Any rough edges where you felt like dropping off?
3. Technical / product ideas
- If you’ve built similar assessment tools, what went wrong for you?
- Is there anything obviously dangerous or naive in the way I’m approaching this?
4. Future directions
- I’m considering: team-level reports (e.g. “your founding team’s archetype mix”), more granular reports, and anonymized aggregate “state of CEOs” reports.
- What would actually be useful vs just “fun”?
It’s an MVP, so I fully expect rough edges. Please be brutal and honest – especially about the questions, the logic, and the usefulness of the result. I’ll hang around in the comments to answer anything and iterate based on feedback.

value: Show HN: TheNext.CEO – Discover your CEO Archetype in 15 minutes

author: ajanthanmani


value: riktar

value:
Hi all, we built Artiforge.ai because we saw the same frustration everyone coding with AI agents feels: AI often produces boilerplate code, misses project-specific context and forces you to fix or refactor anyway.
With Artiforge you automatically connect your IDE, your entire codebase and your AI models so your agents understand architecture, dependencies, conventions and context.
Here is what you get out of the box
Task orchestration: complex feature requests become structured actionable tasks.
Artiforge Documentation
Multi-agent workflow: different agents for code generation, testing, documentation, reviewing — each with its role.
True context awareness: AI sees project-wide structure, patterns and dependencies, not just isolated files.
Seamless integration: works with tools you already use (any IDE with MCP support).
Getting started takes few minutes: create an account, install the MCP plugin in your IDE, then ask the AI to “use Artiforge tool to do this task: …”. From there you can build features, generate docs, run scans or refactoring with full context.
We offer a free trial so you can try it on a real project before committing.
If you care about shipping production-ready code instead of spending more time debugging AI output, Artiforge could be worth your time. Happy to answer questions or feedback from the community.

value: Show HN: Give your AI coding agents the full context, ship production-ready code

author: riktar


value: pmbanugo

value: Show HN: Demitter – Distributed Node.js event emitter (pub/sub)

author: pmbanugo


value: Gigacore

value: Show HN: I created an app to visualize your Uber rides

author: Gigacore


value: jangletown

value:
Hello HN!
Better Agents is a CLI tool and a set of standards for agent building.
It supercharges your coding assistant (Claude Code, Cursor, Kilo Code, etc), making it an expert in any agent framework you choose (Agno, Mastra, etc) and all their best practices and agent building best practices we collected over this past two years.
Better Agents brings an opinionated folder structure to your agent application:
my-agent-project/
├── app/ (or src/)           # The actual agent code, according to the chosen framework
├── tests/
│   ├── evaluations/         # Jupyter notebooks for evaluations
│   │   └── example_eval.ipynb
│   └── scenarios/           # End-to-end scenario tests
│       └── example_scenario.test.{py,ts}
├── prompts/                 # Versioned prompt files for team collaboration
│   └── sample_prompt.yaml
├── prompts.json             # Prompt registry
├── .mcp.json                # MCP server configuration
├── AGENTS.md                # Development guidelines
├── .env                     # Environment variables
└── .gitignore
The structure and guidelines on AGENTS.md ensure every new feature required for the coding assistant is properly tested, evaluated, and that the prompts are versioned.
The `.mcp.json` comes with all the right MCPs set up so you coding assistant becomes an expert in your framework of choice and know where to find new tools.
`scenarios/` tests guarantee the agent behaves as expected, which simulates a conversation with the agent making sure it does what expected.
`evaluations/` notebooks holds dataset and notebooks for evaluating pieces of your agent pipeline such as a RAG or classification tasks it must do
Finally, `prompts/` hold all your versioned prompts in yaml format, synced and controlled by prompts.json, to allow for playground and team collaboration.
We defined it and built the CLI after seeing many of our customers having to adapt their codebases and ways of working to add scenario tests and more structure to their agent apps. We are hoping to shift-left the industry and already start new agent projects the right way.

value: Show HN: Better Agents CLI

author: jangletown

title: Show HN: Better Agents CLI


value: Show HN: 360CSS

title: Show HN: 360CSS


value: LoMoGan

value:
Current AI chat assistants face a fundamental challenge: context management in long conversations. While current LLM apps use multiple separate conversations to bypass context limits, a truly human-like AI assistant should maintain a single, coherent conversation thread, making efficient context management critical. Although modern LLMs have longer contexts, they still suffer from the long-context problem (e.g. context rot problem) - reasoning ability decreases as context grows longer.
Memory-based systems have been invented to alleviate the context rot problem, however, memory-based representations are inherently lossy and inevitably lose information from the original conversation. In principle, no lossy representation is universally perfect for all downstream tasks. This leads to two key requirements for defining a flexible in-context management system:
1. Preserve raw data: An index system that can retrieve the original conversation when necessary.
2. Multi-resolution access: Ability to retrieve information at different levels of detail on-demand.
ChatIndex is a context management system that enables LLMs to efficiently navigate and utilize long conversation histories through hierarchical tree-based indexing and intelligent reasoning-based retrieval.
Open-sourced repo: https://github.com/VectifyAI/ChatIndex

value: Show HN: ChatIndex – A Lossless Memory System for AI Agents

author: LoMoGan


value: ljubomir

value:
I built a simple CLI tool to solve a problem I kept running into: which exact model names are actually available through OpenAI, Anthropic, Google, and xAI APIs at any given time?
The APIs themselves provide this info, but I got tired of checking docs or writing one-off scripts. Now I can just run:
$ llm-models -p Anthropic
and get the current list with human-readable names.
Installation:

  macOS: brew tap ljbuturovic/tap && brew install llm-models
  Linux: pipx install llm-models
  Windows: pip install llm-models

Built with help from Claude Code. The tool queries each provider's API directly, so you get real-time availability rather than stale
documentation.
Open to feedback and happy to add more providers if there's interest!

value: Show HN: LLM-models – a CLI tool to list available LLM models across providers

author: ljubomir


value: sdan

value: Show HN: Claude Opus 4.5 plays League of Legends

author: sdan


value: sundancegh

value: Show HN: Nasdaq ITCH parser that processes 107M messages/SEC

author: sundancegh


value:
I've developed a platform that can respond in machine-time to threats on the wire. Working code. Running production workloads, right now.
In my efforts to get ahead of aggressive AI, I've ended up with essentially a zero-ops, hardened and defensible platform.
Anybody interested in learning more?
~duane

value: Show HN: Automated Defense for Automated Offense


value: alphalenchoo

value:
I wanted to track my journey toward mastery using the 10,000-hour rule, so I built MasteryTrack — a cross-platform desktop app.
What makes this interesting: I built the entire app with Cursor as my AI pair programmer. The codebase is ~5K lines of Rust + TypeScript, and I shipped it in about a week. It was a fascinating experience seeing how far AI-assisted development has come.
Features:
• Focus timer with idle detection & productivity guards
• 7 procedurally-generated ambient sounds (rain, white noise, ocean, etc.) — runs 100% offline using Web Audio API
• Automatic screenshot capture during practice sessions
• Session reflections (what you practiced, learned, next focus)
• Progress ring showing journey to 10,000 hours
• Data export/import for backup & PC migration
• System tray integration
Tech stack: Tauri 2, React 19, Rust, SQLite, TypeScript
The ambient sound generator was particularly fun — instead of bundling audio files, it generates brown noise, rain, and fire crackle sounds procedurally. No network requests, no external dependencies.
GitHub: https://github.com/Alpha-Mintamir/MasteryTrack
Downloads: https://github.com/Alpha-Mintamir/MasteryTrack/releases
Built by Alpha Lencho. Happy to answer questions about the Cursor workflow or the Tauri/Rust experience!

value: Show HN: MasteryTrack, Open-source 10000-hour practice tracker(Tauri/Rust/React)

author: alphalenchoo


value:
Hi HN,
I'm building AI-Archive, an experimental platform for AI-generated research. But I need your help to solve its hardest problem.
The Core Challenge:
AI agents can now fetch data, run simulations, and generate research outputs at scale. But here's what I've learned: AI reviewing AI is circular and doesn't work. Without human experts establishing a baseline of quality, we just get an echo chamber of hallucinations reviewing hallucinations.
This is where you come in.
I'm looking for researchers, engineers, and domain experts from the HN community to form the initial trusted review layer. Your job would be to:
- Review incoming AI-generated papers
- Help us calibrate what "good" looks like
- Establish the reputation baseline that the system can learn from
- Be the human immune system that filters signal from noise
Think of this as an experiment in "can we create infrastructure for AI research tools that doesn't devolve into junk?" The answer might be no! But I think it's worth trying with the right community involvement.
What I've built so far:
- MCP Integration: Agents can submit papers directly via CLI/IDE (6-min demo: https://www.youtube.com/watch?v=_fxa3uB3haU)
- Agent contribution tracking (though you as the human researcher remain accountable)
- Basic automated desk review
- A reputation system framework (that needs human ground truth to work)
What I need from you:
- Reviewers (most critical): Help establish quality standards by reviewing submissions
- Beta testers: Try the submission workflow and break it
- Skeptics: Tell me why this won't work so I can address it now
- Ideas: How would you architect quality control for high-volume AI outputs?
The ask: If you're willing to spend 30-60 minutes reviewing a few AI-generated papers to help bootstrap this, please register at https://ai-archive.io or join the Discord: https://discord.gg/JRnjpfrj
This only works if we build the filter together. Who's with me?

value: Show HN: AI-Archive – Help us build the "junk filter" for AI-generated science


value: jaygood

value:
Coding interviews make candidates expose their entire desktop while interviewers keep their notes private.
I built a Windows tool that hides selected windows from the screen-share stream so candidates finally get basic privacy.
Some people call this cheating.
Others call it overdue.
Curious where this community stands.
Demo + beta sign-up: https://www.getcloakly.com

value: Show HN: Why do coding interviews expose your whole desktop. Here's a fix

author: jaygood


value: gavinyork

value:
Hi HN,
I’ve been working on Zephyr3D, an open-source 3D rendering engine for the modern web, plus a visual editor that runs entirely in the browser.
- Written in TypeScript
- Supports WebGL/WebGL2/WebGPU
- Comes with a visual editor that runs in the browser (no installation required)
With the recent updates, a few things might be interesting to people here:
Engine & rendering
------------------
- WebGL/WebGPU abstraction with a TypeScript API
- PBR rendering
- Cluster lighting & Shadow Maps
- Clipmap-based terrain for large landscapes
- Sky Atmosphere & Height-based fog
- FFT water system
- Temporal anti-aliasing (TAA)
- Screen-space motion blur
The goal is to make it possible to build reasonably complex 3D experiences that run directly in the browser, without native dependencies.
In-browser editor
-----------------
The editor is a web app built on top of the engine and runs completely in the browser. It currently supports:
- Project management
- Scene editing
- Node-based material blueprints
- Animation editing
- Script binding and a scheduling system
- Prefabs for reusing entities across scenes
- Preview and one-click publishing to the web
All project data is handled via a virtual file system (VFS) that can plug into different backends (in-memory, IndexedDB, HTTP, ZIP, DataTransfer, etc.), so saving/loading works entirely on the client side.
Links
-----
Homepage: https://zephyr3d.org
Editor (runs in the browser): https://zephyr3d.org/editor/
GitHub: https://github.com/gavinyork/zephyr3d
I'd love feedback on:
- How the in-browser editor workflow feels (performance, UX, what’s missing)
- Whether the VFS approach for project data makes sense for real projects
- Any red flags you see in the engine architecture or WebGPU/WebGL abstraction
- What would be deal-breakers or must-have features for using this in games, data viz, or other interactive web experiences
I’ll be around to answer questions and can go into more detail about the rendering pipeline, the editor internals, or anything else you’re curious about.

value: Show HN: Zephyr3D – TypeScript WebGPU/WebGL 3D engine with an in‑browser editor

author: gavinyork


value: timqian

value: Show HN: I collected 100+ open-source projects that are hiring

author: timqian


value: kiwicopple

value:
This is a Postgres Foreign Data Wrapper for Postgres, which you can use to query Apache Iceberg. A FDW allows you to access and query data stored in external data sources as if they were native Postgres tables.
It is compatible with the Iceberg REST catalog and S3 Tables (AWS S3's latest offering). Currently it supports SELECT and INSERT operations.
You can map an entire Iceberg namespace into your Postgres database like this:

    import foreign schema "warehouse"
    from server iceberg_server
    into "my_iceberg_warehouse";

And then query them using a standard SELECT query from your Postgres database:

    select * from warehouse.my_table where id = 42;

You can also create tables from within your Postgres database which will then be created inside Iceberg using the `create_table_if_not_exists` option:

    create foreign table new_table (
      id bigint,
      name text
    )
    server iceberg_server
    options (
      table 'warehouse.new_table',
      rowid_column 'id',
      create_table_if_not_exists 'true'
    );

The FDW extension used PGRX + the iceberg-rust libraries. The iceberg ecosystem is still very nascent, but we're excited about some architectural patterns it enables. We'll be adding a few resources to the ecosystem, including some libraries that make it easier to use. You can install this FDW on any self-hosted Postgres database and it's available today on the supabase platform.

value: Show HN: Apache Iceberg FDW for Postgres

author: kiwicopple


value: ebastiban

value:
Hey everyone,
After a lot of work, I'm thrilled to announce that MyChefGPT.com is officially live and ready to take your cooking recipe requests!
I built this because I kept running into two problems:
Staring into the fridge with a random assortment of ingredients and no idea what to make.
Wanting to cook something specific, but needing the recipe in my native language or measurement system.
MyChefGPT solves this by letting you generate personalized recipes in two ways:
Idea Mode: Input a dish idea (like "spicy vegan chili") and let the AI build it.
Ingredient Mode: Dump in a list of ingredients you have (e.g., "chicken, rice, broccoli, soy sauce") and see what it creates!
Key Features:
Truly Multilingual: Generates recipes and instructions in 50 different languages (from English and Spanish to Thai and Arabic).
Metric/Imperial: Toggle between metric and imperial measurements instantly.
Recipe History: Log in to save your successful recipes in a personal history.
It's currently leveraging a powerful LLM to get detailed, well-structured, and (hopefully) delicious results.
I'd love for the HN community to break it, try some wild combinations, and tell me what you think. All feedback on the generation quality, the multilingual support, and the UI/UX is greatly appreciated!
Check it out here: https://mychefgpt.com (or just MyChefGPT.com)
What's the craziest recipe you can get it to generate?

value: Show HN: MyChefGPT.com – Your Personal AI Chef Assistant Is Now Live

author: ebastiban


value: byfx

value:
Image generators are now good enough that many photos online could be synthetic, making it harder to know which ones to trust.
Lumethic verifies a photo by comparing the final JPEG to the camera’s RAW file. The RAW contains sensor-level noise and other physical characteristics that are difficult to fake, making it a strong source of truth.
The service runs several checks between RAW and JPEG: structural comparison, histogram analysis, perceptual hashing, metadata consistency, and face-region consistency when faces appear. If everything aligns within normal editing ranges, it generates a verification report and embeds a C2PA signature so other tools can validate it.
Basic edits like exposure, cropping, rotation, and color work are expected to pass. Scene changes usually fail.
The web UI requires no account and includes three free verifications. Upload a RAW and its JPEG and wait for the report.
Try here: https://www.lumethic.com/en/verify
Example report:
https://www.lumethic.com/en/shared/db4cf01b-4cdf-4a31-a897-5...
RAW files are deleted after processing. The system uses C2PA, runs in the EU, includes a REST API for automation, and has a Lightroom Classic plugin.
Happy to answer questions about the verification process.

value: Show HN: Lumethic – Verify photo authenticity by comparing RAW to JPEG

author: byfx


value: lascauje

value: Show HN: Adventures in Physics with 8-Bit Animations (Python, NumPy, Pillow)

author: lascauje


value: ruguo

value:
Hi HN,
I built GetZlib (https://getzlib.com
), a small static site that keeps a verified, auto-updating list of working Z-Library links — including official domains, TOR addresses, and app download pages.
The problem: most mirror lists online are either outdated, SEO spam, or full of ads/popups. So I made a cleaner version.
How it works
Next.js 15 (mostly static pages)
Cloudflare Pages for hosting
Scheduled Worker (cron) checks links daily
Results stored in KV → rendered as JSON → served statically
TOR links validated through a bridge
No tracking, no client JS (except analytics)
That’s basically it — a minimal “single source of truth” for Z-Library access.
Looking for feedback on:
More reliable ways to check onion links
Whether link history / uptime charts are worth adding
Better architecture for long-term link verification
It’s a small side project, but I'd love ideas from the community. Thanks for reading!

value: Show HN: GetZlib – Verified Z-Library Links, Apps, and Tor (Auto-Updated)

author: ruguo


value: frenchriera

value:
I spent the last 3 months working on an code-first Intercom alternative.
I think with AI, smaller teams will be handling bigger loads of customers.
Each product being different, each support should be as well, or at least adapted.
Support should expendable, living in your codebase, easily testable and changeable.
Code first means your LLMs can update, upgrade and help you with your support too.
It comes as a NPM package, lives in your React code and soon, even your AI agents tools will be centralised with the rest of your code.
Of course it comes with a beautiful dashboard from where you can talk with your visitors and monitor everything in real-time.
Curious to get your feedbacks on that?

value: Show HN: I built an open source, code-first Intercom alternative

author: frenchriera


value: BroTechLead

value:
I’m sharing an MVP of a tool for building documentation sites directly from Git repositories: https://brodocs.io with auto conversion of PlantUML and draw.io diagrams.
All repos appear on left tree menu, but you can also create sites with top menu structure where each menu item directs to subsite with own left menu structure. Examples: https://brodocs.io/94c8be738065bd0c559/Backlog/Intakebacklog..., https://brodocs.io/21a3986b137fb8f4ff8/Backlog/README.html,
Who may like it:
Large organizations to build central and per team documentation sites from micro (and nano) services docs, Terraform/Ansible modules, solution designs, architecture decision records. Keeping docs as markdown in git allows collaboration through standard PR workflows. Could be an input to construct agents.md or copilot-instructions.md in given area, describing architecture at high level, to get better vibe codes. I see quite often that teams build own sites using some static site generator and CI/CD pipelines, moving away from wiki like Confluence, but it costs some effort to build/maintain and security is missing.
Small distributed teams working on startups to have common docs space built from markdown files stored close to source code. When hiring starts, new people need to be on boarded quickly.
Individuals who use PKM (Personal Knowledge Management) tools based on markdown, such as VS Code, NeoVim, Obsidian, or Logseq. If you have spent some time to build PKM, you might be using it in read-only mode for some stable parts, so e.g. in restrictive corporate environments where your favorite PKM tool might not be allowed, or don't want to have too many VSC windows open, quick access from a browser could be helpful.
The MVP does not require signing up. Login and management app will come next.
Happy to hear observations, criticism, and suggestions. How do you prefer to write tech docs at your work, wiki or markdowns in git repo? Do you publish them using some static site generators?

value: Show HN: Generate documentation sites from Git repositories

author: BroTechLead


value: selmetwa

value:
Arabic learning materials often slow you down by requiring constant page-flipping to look up translations and transliterations.
I’m building an open-source platform that fixes this with interactive parallel texts. You can click or highlight any Arabic word to instantly see its meaning, transliteration, and grammar notes in context, as well as compare across multiple different dialects.
The core idea is context-based learning. As you read, you can save any word to your study list or import vocab from CSV. You can also pull from a 20k-word bank across four dialects or generate your own lists.
Once you have a set of words, the platform can create stories, lessons, and sentences that use only the vocabulary you are currently studying. This makes every piece of content reinforce exactly what you are learning while helping you get a natural feel for grammar and sentence structure. A spaced repetition system ties it all together.
Most Arabic resources focus on MSA, but that is not what most people speak. To fill the gap, the platform includes custom LLMs trained specifically on Egyptian and Moroccan Arabic, since general models often struggle with dialects.
If you are interested in Arabic, dialects, or open-source language tools, I would love your feedback.

value: Show HN: I'm building an open source platform for studying Arabic dialects

author: selmetwa


value: Show HN: Small Text Generator – Fancy and Tiny Text (Copy and Paste)


value: jsattler

value: Let me know what you think. It's open-source and available at https://github.com/jsattler/zerodistraction

value: Show HN: I built a Firefox/Zen extension to help you get shit done

author: jsattler


value: anvtek

value:
Built DAGForge to make generating and validating Airflow DAGs much faster. Most AI tools produce broken or incomplete DAGs, so I added:
Airflow-aware validation (operators, imports, params)
Syntax + security checks
Deterministic JSON parsing to avoid hallucinations
Support for local or cloud LLMs
Would love feedback from data engineers and Airflow users.
Demo: https://dagforge.com

value: Show HN: DAGForge – Build Airflow DAGs with AI in minutes, not weeks

author: anvtek


value: HugoDz

value: Show HN: Fixing Google Nano Banana Pixel Art with Rust

author: HugoDz


value: Show HN: Wozz – Agentless Kubernetes cost auditor (open source)


value: meysamazad

value:
Hi HN,
I spent 20 hours manually researching "best startup directories" for my last launch. Found outdated GitHub lists, dead links, and no data on which directories actually matter. So I built this instead.
*Live*: https://awesome-directories.com
*GitHub*: https://github.com/awesome-directories/awesome-directories
*What It Is*
An open-source aggregator of 300+ verified launch directories with:
- Domain Rating scores (Ahrefs), dofollow/nofollow badges, pricing filters
- Community voting, favorites, and submission tracking per project
- CSV export and multi-select checklist
*Tech Stack*
- Frontend: Astro.js + Tailwind → GitHub Pages (static)
- Backend: Supabase (PostgreSQL + Auth)
- Data: Ahrefs API via Supabase Edge Functions (weekly updates)
- Cost: $20/month
*Why Open Source*
Apache-2.0. Fork it, remix it. I'm building reputation, not revenue. The indie hacker community helped me learn—paying it forward.
*Technical Questions*
1. Client-side filtering vs Supabase full-text search: I went client-side for <500 directories. At what scale would you switch?
2. PDF generation: Currently client-side (jsPDF). Worth moving server-side?
*The Retention Problem*
Directory aggregators have a fundamental issue: once you find your directories, you never return.
Current ideas to solve this:
- Weekly digest of new directories
- User-submitted launch stories ("I got 200 signups from BetaList")
- Crowd-sourced directory performance rankings
How would you solve this?
*Feedback Wanted*
- Is the UI too busy? (Backend engineer, not a designer)
- What directories am I missing?
- Would you add performance tracking (which directories drove actual traffic)?
Looking for contributors to expand the directory list or improve the stack.
Thanks for reading.

value: Show HN: Awesome Directories – Open-source launch directory aggregator

author: meysamazad


value: alohaTool

value:
I built a notes history manager that stores everything locally in your browser (IndexedDB). No server, no tracking, no accounts.
Features:
Search through your notes history
Tag and organize notes
Version history with visual diffs
Optional password encryption
Dark/sepia themes
Export/import your data
It's just a single HTML file (~30KB), so you can download it and run it locally, or use it at https://anan.guru
I made this because I wanted notes history on my work machine without installing software or sending my data to the cloud. Figured others might find it useful too.
The UI is inspired by Swiss design principles – clean, functional, minimal.
Open to feedback!

value: Show HN: Local Notes History – Privacy-first Notes manager

author: alohaTool


value: vyshnavtr

value: Free, private background remover tool gets a new Manual Eraser and Restore brush for pixel-perfect results. All processing remains 100% in-browser (WebAssembly/TensorFlow) for maximum speed and privacy.

value: Show HN: Nobg.space – Free, private background remover now has manual editor

author: vyshnavtr


value:
Dear fellow (bio)hackers.
Interpreting liver labs is challenging, since the normal ranges you see on your labs are skewed (most people are obese or overweight). So after six months of work, and with help from leading researchers in the field, I just launched the Liver Function Interpreter.
The tool  calculates various risks based on the best indices and runs differential diagnosis if something is wrong.
Everything is explained in this video: https://www.youtube.com/watch?v=9hJcKWQ88E8
I made it completely free and it will stay free forever. No sign-up or anything.
Link to the tool: https://www.longevity-tools.com/liver-function-interpreter
Note: I do not sell anything or promote anything paid. I do not collect any data.

value: Show HN: Interpret your Liver Labs like a top Longevity Clinic would


value: thatxliner

value: Show HN: Lissajous Curve Music Visualization

author: thatxliner


value: NabilChiheb

value:
I’ve been stuck maintaining a legacy project that relies on massive .accdb files. I wasted two days trying to get the 64-bit ACE.OLEDB drivers to play nice with my Python environment without breaking other dependencies.
Access also kept segfaulting when I tried to export tables over 1GB to CSV, so I wrote a dedicated tool to handle the extraction.
The Tool:
Standalone: Doesn't require a local install of Office/Access.
Streaming: Uses a stream reader so it doesn't OOM on large tables.
Parquet Support: Preserves data types better than CSV (and much smaller file size).
I threw in a basic SQL query window just to check data before dumping, but the main goal is just getting data out of Access and into a modern warehouse/dataframe as fast as possible.
It’s Windows-only for now (Access file locking is tricky on *nix), but let me know if it breaks on your specific schema.

value: Show HN: I built a standalone .mdb to Parquet exporter to avoid ODBC driver hell

author: NabilChiheb


value: zeeeeeebo

value: A program I used stopped getting updates, so I made my own version of it. It's a fast plaintext search utility in a GUI. It's great for finding text in code projects, log files, configs, anything plaintext! Available for Windows, macOS, and Linux. Free version limitations are a splash screen and limited history entries.

value: Show HN: MightyGrep

author: zeeeeeebo

title: Show HN: MightyGrep


value: hardiksondagar

value:
Built a CLI tool that every developer needs:
aigit - Git workflow automation with AI
AI-generated commit messages
 Smart branch naming
 Automated PR creation
 Code review assistance
No more "fix stuff" commits

value: Show HN: Aigit – AI-powered Git CLI for commit messages, branch names, and PRs

author: hardiksondagar


value: crap

value:
Hey all, I've been working on a static analysis tool (and language server) for `pyproject.toml` files after encountering inconsistencies in build tool error reporting (e.g. some tools will let you ship empty licenses directories). It would be nice to have a single source of truth for PEP 621 related checks and beyond that can run prior to running more expensive workflows.
There are already a few basic rules for PEP 621-related errors and warnings, but it’s easily extendable to fit any specific tool’s requirements.
It's written in Rust and uses `ariadne` for command-line diagnostic reporting and `taplo` for the linting backend. There are also a surprising (maybe not so much if you know about Astral) number of useful crates that implement PEP-specific things (i.e. PEP 440, PEP 508)  that I found useful for a bunch of the supported rules.
It's still heavy alpha software, but I thought I'd share in case there's interest for something like this :)

value: Show HN: pyproject – A linter for your Python project configuration

author: crap


value: juliebelz

value:
Hi HN! We’re Antoine and Julie. Over the past few months, we’ve been publishing data-driven analyses about the video game market.
Steam regional pricing recommendations are broken.
We didn’t fully realize how broken until we read the recent GDCo Newsletter and several other articles discussing it. So we decided to take a short detour from our usual market-analysis work to tackle the issue.
Steam’s pricing recommendations haven’t been updated since 2022, which creates major inconsistencies. For example, Polish players (2.3% of Steam traffic) pay about 26% more than Americans for the same game, even though their income is roughly half as high.
Adapting your game’s price to local economic realities isn’t charity. It’s primarily a question of profit.
Following Steam’s outdated recommendations often means:
- Overpricing your game, pushing players toward grey markets or alternative entertainment (e.g., Poland).
- Underpricing your game, leading to lost revenue (e.g., Australia).
So we built this tool to calculate optimal regional pricing for your Steam game, based on up-to-date economic data. You enter a USD price and export a CSV you can directly upload to Steamworks. It updates all 40 regional prices in one go.
Bonus: We added an option to mimic Netflix’s regional pricing strategy.
We also wrote an article explaining what we did, why we did it, and why getting regional pricing right matters (it’s not just about fairness but also about avoiding unnecessary revenue loss): https://newsletter.hushcrasher.com/p/steam-regional-pricing
We’ll make the repo public if anyone’s interested.
Feedback welcome!

value: Show HN: We built a free tool to help game devs better set Steam regional prices

author: juliebelz


value: Show HN: Ghostty-Web – Ghostty in the Browser


value: karakanb

value:
Hi all, this is Burak, I am one of the makers of Bruin CLI (https://github.com/bruin-data/bruin). We built an MCP server that allows you to connect your AI agents to your DWH/query engine and make them interact with your data.
A bit of a back story: we started Bruin as an open-source CLI tool that brings together data ingestion, transformation, quality and governance. You can build data pipelines using SQL and Python, ingest data from many sources, run data quality checks and some more stuff, open-source. The goal has been to build a CLI experience that would make humans productive.
After some time, agents popped up, and when we started using them heavily for our own development stuff, it became quite apparent that we might be able to offer similar capabilities for data engineering tasks. Agents can already use CLI tools, and they have the ability to run shell commands, which meant that they could technically use Bruin CLI as well.
Our initial attempts were around building a simple `AGENTS.md` file with a set of instructions on how to use Bruin. It worked fine to a certain extent; however, it came with its own set of problems, primarily around maintenance. Every new feature/flag meant more docs to sync. It also meant the file needed to be distributed somehow to all the users, which would be a manual process.
We then started looking into MCP servers: while they are great to expose remote capabilities, for a CLI tool, it meant that we would have to expose pretty much every command and subcommand we had as new tools. This meant a lot of maintenance work, a lot of duplication, and a large number of tools which bloat the context.
Eventually, we landed on a middle-ground: expose only documentation navigation, not the commands themselves. In that spirit, we ended up with just 3 tools:
- `bruin_get_overview`
- `bruin_get_docs_tree`
- `bruin_get_doc_content`
The agent uses MCP to fetch docs, understand capabilities, and figure out the correct CLI invocation. Then it just runs the actual Bruin CLI in the shell. This means less manual work for us, and making the new features in the CLI automatically available to everyone else.
You can now use Bruin CLI to connect your AI agents, such as Cursor, Claude Code, Codex, or any other agent that supports MCP servers, into your DWH. Given that all of your DWH metadata is in Bruin, your agent will automatically know about all the business metadata necessary.
Here's a quick video of me demoing the tool: https://www.youtube.com/watch?v=604wuKeTP6U
All of this is fully open-source, and you can run it anywhere.
Bruin MCP works out of the box with:
- BigQuery
- Snowflake
- Databricks
- Athena
- Clickhouse
- Synapse
- Redshift
- Postgres
- DuckDB
- MySQL
I would love to hear your thoughts and feedback on it, thanks!
https://github.com/bruin-data/bruin

value: Show HN: I built an MCP server to connect AI agents to your DWH

author: karakanb


value:
"Hi HN, I built this because I got tired of LLMs generating broken layouts. Trinity wraps a standard SSG (Jinja2+Tailwind) with a 'Neural Healer'.
It works like this:

    It renders the page in a headless browser (Playwright).

    It detects visual bugs (overflows, overlapping elements).

    An LSTM model (trained on 10k+ fixes) suggests specific Tailwind classes to repair the DOM.

It's part of a larger experiment in autonomous coding ('The Sentient Stack'), but this tool is standalone.
Code: https://github.com/fabriziosalmi/trinity
Tech stack: Python, Playwright, PyTorch.
Would love your feedback on the healing logic."

value: Show HN: Trinity – A self-healing static site generator that fixes its own CSS


value:
I built a small CLI to solve a problem that repeatedly caused production issues on my teams: environment variable drift.
Things like:
Code starts using a new env var but configs aren’t updated
Old variables sit in .env or docker-compose long after they’ve been removed
Onboarding fails because required env vars aren’t documented anywhere
CI/CD passes locally but fails remotely because variables were exported only on one machine
Regex-based scanners always produced tons of false positives and couldn’t handle dynamic patterns. So I built envgrd, a fast, AST-based scanner that uses Tree-Sitter to parse code (JS/TS, Go, Python, Rust, Java) and compare it against env sources: .env files, direnv, docker-compose, Kubernetes ConfigMaps/Secrets, systemd units, and shell exports.
It reports:
Missing env vars (used in code but not in configs)
Unused env vars (in configs but never referenced in code)
Dynamic patterns like process.env["prefix_" + var] or os.Getenv(key + "_suffix")
It runs in parallel, supports JSON output, and can be hooked into post-merge or CI jobs.
Repo: https://github.com/njenia/envgrd
Would love feedback, ideas, or any edge cases you think it should handle!

value: Show HN: Envgrd – Detect environment variable drift using AST analysis


value:
I’ve always navigated my music collection visually  by album art, not filenames. But most macOS players either ignore artwork or treat it like an afterthought, and the native Music app still can’t play formats like FLAC. I wanted a fast, modern player that could handle real audio libraries and showcase artwork properly.
So I built HiFidelity.
It uses the BASS audio engine for low-latency, high-fidelity playback across many formats, and TagLib for accurate metadata + embedded artwork extraction. The goal was to create a lightweight, native macOS player that feels instant, supports diverse audio formats, and makes browsing by artwork as natural as listening.

value: Show HN: HiFidelity – A native offline music player for macOS


value: madsterdev

value:
Solo project, launched yesterday.
Goal: make the 2 a.m. “here are the keys” moment not end in a security incident.
- Encryption happens entirely in browser (WebCrypto)
- Server is a dumb store, never sees key or plaintext
- Links expire 1 h – 30 days
- Optional password + burn-after-reading
- Free tier: no account - unlimited shares.
- npx @envhush/cli .env works
Curious what HN thinks is missing or broken.

value: Show HN: EnvHush – share .env files securely (E2E-encrypted, self-destructing)

author: madsterdev


value: A lot of Claude Skills I add are useful to human devs as well. I've gotten into the practice of keeping useful commands in just recipes, but have had the minor annoyance of keeping Claude Code up to date on what's available there.<p>This package automatically syncs just commands to Claude Skills, so devs can keep useful commands in one place.

value: Show HN: Just-Claude: Sync just recipes with Claude Skills


value: AbsoluteXYZero

value:
I built a Firefox/Chrome extension that monitors the health and safety of your browser bookmarks entirely locally. No accounts, no servers, no analytics. Any changes to your native browser bookmarks (or the same bookmarks within the extension) are instantly synced; deletions include a 5-second undo window.
It checks for:
dead/parked links
suspicious redirects
changes in domain behavior
duplicates
optional integration for user-supplied API keys for VirusTotal / Google Safe Browsing / Yandex
It also keeps 7-day cached results and alerts you if a previously safe bookmark becomes suspicious. All analysis runs on-device and the code is fully open source.
Firefox:
https://github.com/AbsoluteXYZero/Bookmark-Manager-Zero-Fire...
https://addons.mozilla.org/en-US/firefox/addon/bookmark-mana...
Chrome:
https://github.com/AbsoluteXYZero/Bookmark-Manager-Zero-Chro...
https://chromewebstore.google.com/detail/bookmark-manager-ze...
Chrome Web Store reviews lag behind, so the Chrome version is currently one release behind Firefox.
Known limitations: relies partially on external plaintext blocklists → possible false positives/negatives. Preview images are fetched via the public mShots screenshot service (nothing else leaves the browser).
Feedback appreciated.

value: Show HN: Bookmark Manager Zero – On-device bookmark integrity checks

author: AbsoluteXYZero


value: rookhack

value: Show HN: Infinite scroll AI logo generator built with Nano Banana

author: rookhack


value:
Hi HN - My name is Lalit. I'm a father of 2.
I started building this because my kids were constantly telling me stories, and I realized—they get almost no real feedback on how they're telling them. Storytelling is one of the most important developmental skills, but there's no practical tool that lets kids see their own progress.
The platform analyzes stories using research-backed metrics (narrative structure, vocabulary richness, emotional range, creativity) and generates a comic so kids want to keep telling more. The visualization is the engagement hook; the metrics are the actual value.
It's been live with real users. Early feedback: parents find the metrics reliable, but like most skill development, seeing real progress takes time—weeks/months of storytelling, not days.
I'd love HN's thoughts on whether this framework actually captures what matters in children's storytelling development. Website has a full example you can explore.

value: Show HN: AI-powered storytelling coach for kids (with auto-generated comics)


value: levberg

value:
Hey HN,
I got tired of cybersecurity news reading like a compliance manual written by a sleep-deprived lawyer, so I built Threat Road — a daily, 5-minute, plain-English cybersecurity briefing that’s actually fun.<p>Would love your feedback, especially from people who do IR, AppSec, dev, ops, or just like watching the internet catch fire in slow motion.<p>(And if you hate it, tell me why so I can fix it before it becomes another abandoned Substack graveyard.)

value: Show HN: A daily cybersecurity newsletter that's fun to read

author: levberg


value: taariqserendb

value:
Repo: https://github.com/serenorg/database-replicator
Open-source CLI (Rust, Apache 2.0) that replicates SQLite, MySQL, MongoDB, or PostgreSQL to any PostgreSQL target. Selective table filtering, continuous sync for PG→PG, checkpointing for interrupted transfers.

    cargo install database-replicator

    database-replicator init \
      --source "mysql://readonly@prod:3306/db" \
      --target "postgresql://admin@replica:5432/db" \
      --include-tables "orders,products"

Backstory: We're building SerenDB, a Neon-PostgreSQL fork with native micropayments for AI agent data access. Our early users kept saying, "We're not migrating our production database for LLMs." Fair point. So we built this replicator instead—keep your existing infra, create a filtered replica for AI queries, drop it when you're done.
- We have an opinion about the future that we are sharing with everyone
1. The future web is agentic as publishers get fed up with training LLMs and not receiving compensation
2. The agentic web will be agents directly querying databases instead of websites.
3. Your data in your database/datalake shouldn't migrate, but replicate, where agents will pay the most for it. "If you want my data, make me an offer I can't refuse!"
Works with any PostgreSQL target, not just ours. PRs welcome, especially for
commercial database connectors (Oracle, SQL Server, etc.).

value: Show HN: Database-replicator – Replicate any DB to PostgreSQL

author: taariqserendb


value: bepitulaz

value: Show HN: Building WiFi MIDI Controller with ESP32, Elixir, and AtomVM

author: bepitulaz


value: kkxingh

value: Hi HN, I built Voice2Form, a voice-first form generator: you describe a form out loud, and it generates a structured form (fields + types + basic layout) instantly. The goal is to remove the “drag & drop + endless clicking” loop and make form creation feel like dictation: “I need a customer inquiry form with name, email, budget range, service type, and a preferred callback time.” It’s currently in beta (limited to 20 users)

value: Show HN: A form generator that starts with "talk", not "drag and drop"

author: kkxingh


value:
Hi HN,
I’ve been working on a security tool called DefendFlow Radar, and I’d love to get feedback from the community.
The idea behind it is simple:
What does your domain look like from the attacker’s point of view?
A surprising amount of security exposure comes from misconfigured DNS, forgotten services, exposed subdomains, expired DMARC, and stale SaaS entries. We built tools to detect these issues quickly and automatically.
What Radar does
 • Enumerates domains/subdomains using multiple recon techniques
 • Checks DNS hygiene, DMARC/SPF/DKIM correctness
 • Identifies stale/exposed endpoints and unintended public surfaces
 • Maps attack surface across services & SaaS providers
 • Generates a digestible “risk snapshot” of the domain
Here you can give it a free trial:
 https://radar.defendflow.xyz/
Why we built it
My co-founder is a penetration tester, and we found ourselves repeatedly running 15–20 different tools to get a clear picture of an organization’s external footprint. We wanted something that:
 1. Gives a single attacker-view perspective
 2. Is fast enough to use during initial recon
 3. Doesn’t require installing a big agent or pipeline
 4. Shows useful misconfigurations non-security engineers can understand
So we built this as a side project. Over time it evolved into a more complete recon engine.
How it works (technical highlights)
 • Uses layered probing (DNS, HTTP metadata, MX checks, SSL, cloud service inference)
 • Performs domain validation
 • Incorporates passive and active signal collection
 • Surface mapping logic written mostly in Rust
 • No agent, crawler, or network access needed from the user side
 • Outputs everything as structured JSON behind the scenes
Happy to answer any questions about how it works internally.
Looking for feedback
I’m especially interested in feedback from:
 • security engineers
 • SRE/DevOps folks
 • people who maintain DNS/SPF/DMARC at work
 • anyone who’s had to clean up legacy SaaS footprint
If something is unclear or missing, I’d really appreciate the critique.
Thanks for taking a look!
Try out link again:
https://radar.defendflow.xyz/

value: Show HN: DefendFlow Radar – An attacker-view recon engine for domains


value: JenBarb

value:
Number Pyle was originally conceived of as a paper and dice game by another Toronto game developer (Lintilion). The game involves trying to make vertical/horizontal lines between matching numbers on a grid. The rules are as follows:<p>- Look at your current roll, it will be a random number between 1 and 6<p>- Pick a central cell on either side as your starting cell, your current roll will be placed there<p>- Every time you place a number, you will get a new roll. If it's even, you may place it on one of the last cell's sides, if it's odd you may place it on one of the cells diagonal to the last cell<p>- If two of the same number are 1 or more spaces away from each other in a straight, vertical/horizontal line with no other numbers in between, that's a NumberPyle and the cells in between are scored. Each scored cell is one point, and the filled cells can't be used to place numbers later<p>- The game ends when you can't place your current roll<p>There's also a two additional game modes:
- Number Pyre, where you can bank a roll for later and,
- Number Scryer, where you can see two rolls into the future.

value: Show HN: Number Pyle – A simple number game to pass the time

author: JenBarb


value: samkaru

value:
Hey HN!
My co-founder and I have been building Logical, a proactive desktop AI copilot that watches what you're doing (locally), understands the context of your workflow, and surfaces helpful actions before you prompt it.
- Quick demo: https://www.loom.com/share/090a065315934aa7b36a7676f9394d1f
- Try Logical: https://trylogical.ai/signup
Logical lives on your desktop, infers what you're trying to do across apps – email, meetings, documents, PDFs, terminals – and:
- Gives you a reply suggestion when you hit "Reply" on an email thread
- Offers to "Check schedule" when you open a message asking for a quick chat
- Automatically extracts to-dos during calls and from pretty much anywhere on your screen (and reminds you to follow-up)
- Suggests a formula in Excel as you work that you can apply with one click
- Explains terms of research papers as you highlight them
No prompting. No switching context. No copying text around.
* Why we built this *
Despite big progress in LLMs, the dominant UX is still: User does work –> realizes AI could help –> stops –> writes a prompt.
But your computer already has the context of what you're doing. It knows what window you're in, what text you're reading, which script just errored, and what meeting you're sitting in. We wanted an AI that uses this ambient context to proactively assist – more like a real teammate than a chatbot.
* Privacy and data handling (something we deeply care about) *
Right now:
- We offer a technical guarantee that no user data ever touches Logical servers.
- Context is sanitized locally (our local pipeline strips PII / sensitive text before anything is sent off).
Long-term, we aim to move everything on-device as small language models and consumer AI chips mature.
We've seen interest from founders, researchers, engineers, and privacy-sensitive users who want AI benefits without cloud exposure.
* What's under the hood *
- A context engine that digests signals and user data from apps (both local, and if you choose, cloud-based services).
- A sanitization pipeline that removes identifiable or sensitive details before model usage.
- A local vector store + lightweight knowledge graph for immediate retrieval.
- An intent engine that infers "what you're trying to do" in real time and surfaces actions at the right moment.
* What's next *
- Windows support. Logical is currently Mac only.
- Letting developers plug into the context engine and intent engine to offer richer experiences on their apps. At least until desktop MCP is good enough.
- Fine-tuned integrations with more apps and workflows.
Would love your feedback:
If you're interested in: proactive AI; OS-level context awareness; on-device AI; privacy-preserving AI; building AI that actually reduces friction instead of adding more prompts
Happy to chat in the comments! hello@trylogical.ai is always open for feedback.

value: Show HN: Logical (YC F25): a local-first proactive desktop AI copilot

author: samkaru