value: niyoseris

value:
I've built *HoldTheFile* - a Flask-based secure file sharing application that prioritizes security and simplicity while solving the common problem of safe file distribution.<p>## The Problem
Most file sharing solutions either require complex authentication, alpha-numeric combinations or sacrifice security for convenience. I needed something that could handle flexible situations, provide real-time upload progress, and ensure files are always downloaded (never previewed in browser) while maintaining security.<p>## The Solution
HoldTheFile combines phrase+PIN authentication for security features:<p>### Key Features:
- *Zero Login Required*: Access via phrase + PIN only. You might think it's a security bottleneck but you can use any word combinations or sentences even paragraphs as phrase
- *Unlimited File Uploads*: No size restrictions
- *Real-time Progress Bar*: Live upload speed and percentage tracking
- *Forced Download*: All files download directly - no browser preview (critical for security)
- *Shareable Links*: Secure download links without authentication and without leaking your secure folder
- *Drag & Drop File Management*: Move files between folders intuitively
- *Double-Hash Security*: MD5 workspace + SHA256 file verification<p>### Security First:
- *XSS, RFI, Path Traversal Protection*: Comprehensive input sanitization
- *SQL Injection Prevention*: Full ORM implementation
- *Security Headers*: CSP, X-Frame-Options, X-Content-Type-Options
- *File Isolation*: MD5-based workspace separation
- *No Preview Execution*: HTML/JS files never run in browser<p>### Tech Stack:
- *Backend*: Flask + PostgreSQL
- *Security*: Werkzeug, custom sanitization utils
- *Frontend*: Vanilla JavaScript with real-time upload tracking<p>## Cost & Infrastructure
Currently running alongside my other projects on a VDS panel. Storage costs are manageable at this scale - the application is lightweight and PostgreSQL handles file metadata efficiently while actual files are stored directly on the filesystem. The unlimited upload feature hasn't caused storage issues yet, but I'm monitoring usage patterns.<p>## Real-World Use Cases
HoldTheFile solves everyday file sharing challenges:<p>- *Cross-Device Transfer*: Send files from phone to computer without cables or cloud accounts. Don't have to log in to your accounts on foreign computers.
- *Team Collaboration*: Share project files without setting up user accounts
- *Classroom Materials*: Teachers distribute course materials instantly
- *Event Photo Sharing*: Wedding guests upload/download photos using a shared phrase
- *Tech Support*: Share logs and screenshots with support teams instantly
- *Family File Vault*: Share important documents with family members securely<p>Would love to hear feedbacks.

value: Show HN: HoldTheFile: A File Sharing Solution with Zero Login Required

author: niyoseris


value: iromanika

value:
Hi HN,
I’m building Feato, a developer-first feature flag service focused on real-time delivery without polling.
The core idea is simple:
applications establish a persistent connection and receive configuration changes as events, instead of repeatedly fetching flags on an interval.
Why I built this:
In many projects I’ve seen feature flags implemented via polling, which adds latency and unnecessary traffic.
At the same time, most mature real-time solutions are optimised for large enterprises and can be hard to justify for small teams or solo founders.
I wanted something simpler: real-time delivery, predictable behaviour, and pricing that makes sense for early-stage products.
What Feato does:
- Real-time flag updates via Server-Sent Events (no polling)
- Environment-scoped flags (dev / staging / prod)
- Lightweight SDKs (React and Angular so far)
- Fail-safe behaviour: if a project is blocked or connectivity is lost, flags resolve predictably
What it does not try to be:
- Not an experimentation platform
- Not an analytics product
- No fake demos or client-side simulations
The landing page explains the delivery model step by step and shows real console screenshots:
https://feato.io/
Docs:
https://feato.io/docs/getting-started
Pricing is transparent and intentionally simple.
I’d really appreciate feedback on:
- The real-time delivery approach
- Whether this solves a real pain point for you
- What would block you from using this in production
Happy to answer any technical questions.

value: Show HN: Feato – Real-time feature flags without polling

author: iromanika


value: sohanmanju

value:
I kept running out of disk space and never knew where it all went. Paid apps exist for this, but paying $10-30 just to see what's eating your disk felt wrong. So I built an open-source alternative.
Yeet finds stale coding projects (detects by package.json, pyproject.toml, Cargo.toml, etc.), scans for large files, clears caches (browsers, npm, pip, cargo, Docker, Homebrew - 60+ locations), cleans up Xcode on macOS (simulator runtimes are sneaky - 5-10 GB each), and has an interactive disk explorer with vim keybindings.
Technical bits: uses native du instead of Python's os.walk for ~5x faster size calculation, parallel scanning with ThreadPoolExecutor, and moves to trash by default so you can recover mistakes. Had a fun bug where sparse files (VM disk images) showed 16 TB instead of actual size.
Install: pip install git+https://github.com/sohanmanju/yeet.git (or uv tool install if you use uv). Requires Python 3.10+. Works on macOS, Linux, Windows. MIT licensed.
Found about 40 GB on my machine I didn't need.

value: Show HN: Yeet – CLI tool to find and reclaim disk space

author: sohanmanju


value: recibook

value: Show HN: ReciBook – Extract recipes from TikTok/Instagram automatically

author: recibook


value: rachelle-r

value: Show HN: Recipe Shelf – A recipe manager I built after a year of solo dev

author: rachelle-r


value:
I made a hex based logic puzzle where you place different coloured terrain hexes to terraform various planets and moons across the system.
To solve you have follow the numbered labels indicating how many of a terrain type appear in each row as well as the shape rules for each terrain type.
So far I have created:
- Mars
- The Moon
- Ganymede
- Venus
- Titan

value: Show HN: Terraforming Puzzle – Terraform the solar system, incl Venus and Mars


value: NicholasCrumb

value:
I built this after getting frustrated with digging through Google Search Console tables and exports just to decide what to work on next to do the SEO of my first project (recipe mobile app).
ChatSEO connects to Google Search Console and lets you ask questions in plain language (e.g. pages close to page 1, keywords losing traction, or what actions are likely to have the biggest impact).
Under the hood, it combines GSC data with external keyword and SERP data to prioritize SEO actions instead of just showing dashboards.
It’s still early: onboarding is basic, recommendations can be noisy, and pricing isn’t final.
I’d love feedback from people who actively use GSC on whether this approach is useful or what feels wrong.

value: Show HN: I built an agent that analyzes your Google Search Console data

author: NicholasCrumb


value: kodefreeze

value:
Hi HN, sharing a product that I built since I didn't want to manual test our app.
The approach used is a multi-agent system that uses an augmented vision based approach for interacting with the UI, rather than relying on the DOM. The goal is to mimic how your users would naturally use the UI, rather than following a predefined path.
I built this because I got tired of doing manual QA for my last SaaS product. I couldn't trust automated UI tests (Selenium/Playwright) because they were flaky, broke whenever the DOM changed, and missed obvious usability bugs.
Happy to answer any questions about it here, and would love your feedback.
Thanks!

value: Show HN: I built a product to test webapps like a user would

author: kodefreeze


value: weixei

value:
Hi HN,
I’m an indie developer and recently released a small project called Calm White Noise.
I built it because most white noise / sleep apps I tried felt overcomplicated — ads, subscriptions, too many controls, or features I never used. I wanted something extremely simple: open the app, choose a sound, set a timer, and sleep.
Key ideas behind the app:
– Minimalist UI, focused on one thing only
– Carefully curated and cleaned nature sounds
– Seamless looping for long sessions
– Sleep timer support
– Completely ad-free
The app currently includes 14 nature sounds like rain, seaside, forest, night ambience, campfire, train, coffee shop, and more.
This is my first public release and I’d really appreciate any feedback — especially from people who care about simplicity, focus, or audio UX.
Google Play link:
https://play.google.com/store/apps/details?id=calm.whitenois...
Thanks for reading!

value: Show HN: I built a minimalist white noise app because most of them felt bloated

author: weixei


value: vood

value:
Built a scraper over a few days, spent a few hundred dollars on API costs. Queried 1,300 keywords across 26 industries against Google and several AI search platforms.

  Google Search results:

  - Reddit in 83% of product-related queries
  - 62% of those in positions 1-3
  - Commercial intent queries ("best X", "X vs Y"): 93.6%

  AI Search was more interesting:

  - ChatGPT: ~20% Reddit citations
  - YouTube cited more often than Reddit
  - Perplexity: nearly zero

  That last one surprised me until I remembered Reddit sued Perplexity in October 2025. External research from Q2 2025 showed 47% Reddit citations on Perplexity. My data from January 2026 shows it's basically gone.

  My hypothesis on why Google is doing this:

  74% of new webpages now contain AI-generated content. Google seems to be responding by weighting sources that are harder to fake. Reddit has real users with post history. YouTube requires actual video production. Both are expensive to game at scale.

  This isn't necessarily good — Reddit has its own problems with astroturfing and mod capture. But the signal-to-noise ratio is apparently still better than the open web.

  Raw data and methodology - follow the link.

  Curious if others are seeing similar patterns, or if my methodology is flawed somewhere.

value: Show HN: I analyzed 1,300 Google searches – Reddit appeared in 83%

author: vood


value: rokontech

value: Show HN: Sumoffy (macOS) – Offline Document Intelligence You Can Trust

author: rokontech


value: labterminal

value: Show HN: Reticle – Debug MCP Tool Calls from Claude/Cursor (Rust)

author: labterminal


value: danielfalbo

value: Show HN: picturephone.c – ASCII video-conferencing in the terminal [video]

author: danielfalbo


value: jakubb

value:
Throughout my career as a software engineer, I noticed that for senior roles, communication often becomes the primary bottleneck for talented engineers. Especially for non-native English speakers who struggle to communicate concisely and effectively.
Most language apps rely on "ordering a coffee" or "booking a flight" scenarios. I found these extremely boring, so my app pulls the latest news (Tech, Science, Business) and turns them into speaking prompts.
How does it work?
1. Read a summary of a current event.
2. Record your opinion/summary.
3. Get feedback on your grammar, pacing, filler words ratio, tone, etc.
You can try a demo on a generic topic without logging in: https://www.orratio.com
It is still in very early stages, and I would love some feedback!

value: Show HN: Practice spoken English by discussing real news articles

author: jakubb


value: SongDeYu

value: Show HN: BrowserScan.org - Browser fingerprinting and privacy analysis platform

author: SongDeYu


value:
Supertonic now supports 5 languages:
한국어 · Español · Français · Português · English
It’s built to run locally across a wide range of setups—from browser-based inference with WebGPU to small devices like mobile phones and Raspberry Pi.
Here are key features:
(1) Lightning fast — RTF 0.006 on M4 Pro
(2) Lightweight — 66M parameters
(3) On-device TTS — Complete privacy, zero network latency
(4) Flexible deployment — Runs on browsers, PCs, mobiles, and edge devices
(5) 10 preset voices —  Pick the voice that fits your use cases
(6) Open-weight model — Commercial use allowed (OpenRAIL-M)
We hope Supertonic is useful for many applications.
Thank you!
Demo: https://huggingface.co/spaces/Supertone/supertonic-2
Model: https://huggingface.co/Supertone/supertonic-2
Code: https://github.com/supertone-inc/supertonic

value: Show HN: Supertonic 2 – Lightning-fast, On-Device, Multilingual TTS


value: amadeuspagel

value: Show HN: Milkyboard – Synth Keyboard with Milkdrop Visualizer

author: amadeuspagel


value: SherlockShi

value:
Hi HN
Months Ago, we set out with one mission: make high-quality image creation feel effortless for developers, creators, and designers alike. Over countless nights of code, iterations, and real-world testing, we built Imgity, a new kind of AI image platform that blends generation and editing into one seamless experience.
At its core, Imgity is powered by Nano Banana Pro — a reasoning-focused engine that gives us unusually high-fidelity results: physics-accurate lighting, studio-grade details, and textures that hold up even in large prints or professional workflows.
But what really got us excited was solving the stuff people struggle with most:
· Readable typography & complex text in images — historically a weak spot in generative models.
· Consistent characters over multiple generations — great for storyboards, brand visuals, character design.
· Surgical precision editing — smart object removal, fine light control, and context-aware inpainting.
How Imgity Works
1. Pick a mode: whether you’re starting from scratch with Text → Image, or refining existing work with Image → Image.
2. Drop in your prompt or reference. Be as detailed or wild as you like.
3. Let Nano Banana Pro plan and render your creation with quality you’d expect from a studio.
4. Preview, tweak, download high-res — ready to use wherever you need it.
Everything is designed to be fast and intuitive — from social sized ratios to cinematic and print outputs — so you can focus on the idea, not the tool.
Why We Built This
Our team comes from design, AI research, and production backgrounds. We were repeatedly frustrated by tools that either generated art you couldn’t use professionally, or that forced you into endless manual fixes. With Imgity, we wanted to build something that respects both creative freedom and precision control.
Try It & Give Feedback
https://imgity.com
We’re early — and we’d love your feedback on:
· quality vs. traditional generators
· editing workflows
· edge cases we haven’t thought of
If you test it, drop your thoughts here — we’re actively reading replies and iterating daily.
Thanks!

value: Show HN: Imgity – AI Image Creation and Editing Using Nano Banana Pro

author: SherlockShi


value: Notefy is an AI meeting assistant that turns recordings into notes, summaries, and ready-to-share presentations. Upload a meeting securely to get accurate multilingual transcription and an AI chatbot trained on your meeting so you can ask questions and get instant answers. Instantly share outputs with teammates and connect via integrations like Slack and Discord.

value: Show HN: Turn Meetings into Presentations with AI


value:
I frequently use epochconverter in my day to day work.
Sick of old UI, i created new website. Completely redesigned the epoch converter with modern UI elements.
Check out - https://epochconverter.dev/
Let me know if you have any improvement to it. Upvote if you liked it.

value: Show HN: Is this the best epoch converter?


value: logicallee

value: This is a light broadcase medium in which peers send along the video stream p2p (like YouTube Live except p2p.)<p>Feel free to join me for a planning session right now, at the link above.

value: Show HN: Utopia Planning Session

author: logicallee

title: Show HN: Utopia Planning Session


value: Sbrefe

value:
I built The Zone to solve the "noise" problem in software discovery.
Most directories suffer from infinite scroll and bot inflation. My hypothesis is that scarcity creates focus.
The mechanics:

    Strict Limit: Only 9 projects compete per 24-hour cycle.

    Elimination: Based on voting (verified via X-Auth), the "Safe Zone" shrinks.

    SEO Value: The winner takes the archive spot, securing a permanent, high-quality backlink for their domain authority.

    Monetization Experiment: I added a feature where sponsors can "bet" on a card to get visibility if that card wins.

Registrations are open today for the first batch starting tomorrow.
Stack: Next.js + PostgreSQL. Curious to hear your thoughts on the elimination mechanic.

value: Show HN: The Zone – A Daily Battle Royale for SaaS Launches

author: Sbrefe


value: arcquesar

value:
Most other widget apps I tried were bloated, full of ads and overwhelming.
So I tried building something simpler, and it somehow turned into a monster
Texget is a fully customizable widget maker:
Freeform canvas
Multiple text and image layers
Custom fonts, spacing, alignment, rotation
Widget actions to launch apps or shortcuts
Think Canva, but for creating iOS widgets.
It’s free to use, with optional in-app purchases for unlimited layers and custom fonts. No ads. Works on iPhone, iPad, and Mac.
This is still early and I’m very much figuring things out. I’d genuinely love feedback. If you try it and have thoughts, please tell me what’s good, what’s confusing, or what’s missing.
App Store link:
https://apps.apple.com/us/app/texget/id6756565331

value: Show HN: Probably the most customizable and powerful iOS widget maker

author: arcquesar


value: keepamovin

value: Show HN: Bloggers witout Borders – AI parodies of pg, Dan Luu, Krebs, and Gruber

author: keepamovin


value: vinkupa

value: Show HN: Finally, PR Reviews That Don't Suck

author: vinkupa


value:
For months I wandered the wilderness like Frodo without a map. Every Claude Code session began with the same ritual — re-explaining my stack, my patterns, my conventions. Context lost to the void.
I thought this was the way. I was a fool of a Took.
Started handcrafting skills and agents manually. 40+ hours of writing markdown scrolls. Mass trial and error — what structure works, what Claude actually reads, what gets ignored. It worked — Claude transformed from "helpful tavern stranger" to a wizard who actually knew the realm.
Then I thought: why am I forging this ring by hand every time?
Built a CLI that scans your codebase and summons the entire .claude/ structure:
CLAUDE.md — your project's sacred text
/skills/ — deep lore for your stack (React patterns, API conventions, DB schemas)
/agents/ — your fellowship (debugger who tracks bugs to their lair, reviewer who enforces your guild's conventions)
Important bit: the outputs are generated, but they're built on top of handcrafted prompts, skill templates, and agent structures that took weeks of iteration to get right. Not just "throw your codebase at an LLM and pray." The scaffolding is battle-tested — the CLI customizes it to your specific project.
It reads your package.json, tsconfig, actual source files, folder structure — then generates context specific to YOUR project.
Not generic boilerplate from the Mines of Moria.
On the toll: $99 one-time, limited launch price — goes up once this window closes. I know HN has thoughts on paid tools — speaking friend and entering upfront. Solo dev here, mass time invested. The 40+ hours of trial and error I went through? You skip all of it.
Anyone else deep in the skills/agents rabbit hole? Curious what setups the council is using.

value: Show HN: SummonAI Kit – One CLI to rule your .claude/ folder


value: walmsles

value: Show HN: Run-MCP – Run MCP servers securely in containers

author: walmsles


value: failsafe

value:
Hi HN,
I want to share Ferrite, an open-source OLTP database engine written in Rust that prioritizes clarity, correctness, and modern concurrency design over chasing feature-completeness or benchmark wars.
Ferrite is not trying to be a drop-in replacement for Postgres or SQLite. Instead, it’s designed as:
The smallest, clearest, well-documented OLTP engine showing how ACID, recovery, and concurrency work internally.
A learning and experimentation platform with code you can reason about
A solid foundation for future academic or production-grade work
PS it's my first HN post, so I hope you enjoy it and go easy on me.
Check it out here:
https://github.com/OxidizeLabs/ferrite
Why I Built Ferrite
Most DBMS systems today:

  * Hide internals under complex codebases
  * Accrue decades of legacy design decisions
  * Make it hard to see exactly how correctness is achieved, especially in Rust
  * Mix distribution, analytics, and OLTP orthogonally

Ferrite’s focus is pure OLTP, with readable code, tight documentation, and reproducible demonstrations of key DBMS concepts like concurrency control and ARIES-style crash recovery.
Core Capabilities:
Ferrite implements a traditional layered DB architecture with:
Storage & Recovery:

  * Write-Ahead Logging with ARIES-style recovery semantics
  * Buffer pool with an LRU-K replacement policy

Concurrency & Transactions
  * Two-phase locking with deadlock detection
  * ACID transactions with multiple isolation levels
Indexes:

  * B+ Tree indexes with latch crabbing for safe concurrent access

SQL Support:

  * DDL/DML, queries with joins, aggregations, and some window functions

All implemented in Rust, with safety and minimal unsafe code.
Technical Highlights:

  * Memory safety by default (Rust) with minimal unsafe code
  * Async I/O via Tokio, enabling backpressure and non-blocking execution
  * Hybrid deployment modes: use Ferrite as an embedded library or in client-server mode
  * Explicit documentation: architecture diagrams, module descriptions, and evidence of correctness

What It’s Not:
Ferrite deliberately doesn’t (yet):

  * Aim for full Postgres/SQLite compatibility
  * Support distributed consensus
  * Try to chase every benchmark out there

Fully complete SQL features — some are planned for the roadmap
This “non-goals-first” clarity helps keep the codebase approachable and educational.
Some Background
It all started with CMU 15–445 Introduction to Database Systems – https://15445.courses.cs.cmu.edu/spring2026/,
a brilliant course for those wanting to learn about DBMS internals (so mucho gracias Andy Pavlo and Jignesh Patel).
They had built BUSTUB for the course as a way for students to use as a learning tool, but it was written in C++ and I wanted to try Rust.
At first It was just going to be a learning project, the company I was working for was being taken over, and in the chaos,
I had some extra time on my hands, and then LLM started to get really good, so I decided to try and extend the project to something akin to a real DBMS.
Then I got made redundant and had a lot of time on my hands, so the project got a lot more ambitious. A lot of the code was written by LLMs, with myself acting more as an architect, with some fixes by myself.
So if anything, it can act as a demonstration of how much a single person can output with current LLM (for better or worse).
Some Caveats:

  * The project is in a "just about working" state, and I'm not planning on adding any new features.
  * The code is not optimized for performance, although the caching layer is probably too complex for the projects aims.
  * as many tests were written by LLMs, I expect many of them to be utter garbage, so, I need to go through them and clean them up.

value: Show HN: DBMS OLTP written in Rust – prioritises clarity and correctness

author: failsafe


value: asavaratakar

value: Show HN: intnt – Your life visualized as 1080 months

author: asavaratakar


value: tilyupo

value:
Replane is a self-hosted config manager for feature flags and app settings.
It's a self-hosted config manager with real-time updates via SSE, version history, and instant rollback. Changes propagate in under a second. Override rules let you target by custom properties - evaluated client-side so nothing sensitive leaves your app.
Single Docker image, MIT licensed, works with or without Postgres. SDKs for JS, Python, .NET.
https://github.com/replane-dev/replane
Would love feedback on the SDK API design and what's missing for your use case.

value: Show HN: Replane – dynamic config for apps and services with real-time sync MIT

author: tilyupo


value:
Hi HN,
Titan Planet is a JavaScript-first backend framework that lets you write backend logic in JavaScript and deploy it as a single native Rust binary.
Today, I’m sharing a major update:
What’s new
1. V8 runtime (no more Boa)
Titan Planet now uses V8 to execute JavaScript bundles.
This significantly improves execution speed, compatibility with real-world JS libraries, and overall runtime stability — while still keeping Node.js completely out of production.
JavaScript is bundled ahead of time and executed inside an embedded V8 runtime. Rust continues to own networking, async I/O, concurrency, and deployment.
2. Expanded runtime APIs
Titan now ships with a growing set of built-in runtime APIs designed for backend workloads:
t.log(...) – structured logging
t.jwt – JWT sign / verify helpers
t.password – hashing & verification helpers
t.fetch – HTTP requests
File access, env access, and more
These APIs are implemented on the Rust side and exposed safely to JavaScript, keeping the runtime controlled and predictable.
3. Same core philosophy
No Node.js
No Node event loop
No JS tooling required in production
One native binary output
JavaScript scoped strictly to application logic
Docs
Documentation (architecture, runtime APIs, examples):
 https://titandocs.online
Titan is opinionated by design and won’t fit every use case — but if you’re interested in a Rust-owned backend with JavaScript ergonomics and a V8 runtime, feedback is very welcome.
Happy coding.

value: Show HN: Titan Planet – JavaScript back end framework now powered by V8


value: BLGardner

value:
Hi HN, I'm Barry and I've built Prism.Tools (https://blgardner.github.io/prism.tools/) – a collection of client-side developer utilities that respect your privacy.
Many of these tools were used way back in the days when I ran a BBS and started my communities first ISP, serving three local communities with Dial-Up Internet, Web Hosting etc. The tools have been refined to reflect the changes in tech since then and designed for the Novice and Pro alike. As I locate more tools others may find useful I will refine and add them to the collection. Use them, Share them, or not. They will be here if you need them...
40+ dev tools (JSON formatters, regex tester, base64 encoder, Git command helper, etc.) that run entirely in your browser.
Zero tracking, zero analytics, zero data collection – everything processes locally.
Self-contained HTML files with no build process or frameworks.
I realized I had a lot of tools/utilities I've built over the years for my own use. I lothe having to 'sign-up' just to access/use simple utilities that I can create myself. I've refined them and put them in one safe place so I could easily access them if/when needed. I decided to make them available via Github Pages for anyone that may find them useful. Prism.Tools is the result.
Each tool is a standalone HTML file with embedded CSS and JavaScript. No frameworks, no npm packages, no build steps – just open the file and it works.
The entire toolset:
- 100% client-side processing – your data never leaves your browser.
- No external dependencies except for specific libraries from cdnjs.cloudflare.com (marked.js for markdown, exifr for image metadata, etc.)
- Consistent dark UI – every tool follows the same design language for familiarity.
- Vanilla JS where possible – only reaching for Public CDN Resources when necessary.
The constraint of "single HTML file" was intentional. It forces simplicity and ensures tools remain maintainable. It also means users can inspect, modify, or self-host any tool trivially.
These tools have helped me with debugging production issues, Quick formatting tasks, learning Git commands (the Git command helper has been particularly helpful)
Just visit https://blgardner.github.io/prism.tools/ and try any tool. No signup, no install.
What tools are missing that you find yourself needing?
Any performance issues with specific tools?
UI/UX friction points?
All tools follow the same privacy-first philosophy...
Your data stays in your browser. No accounts, no tracking, no servers processing your information.
The project is also a demonstration that you don't always need React, Vue, or complex build pipelines – sometimes vanilla JavaScript in a single HTML file is exactly the right tool for the job.
Vanilla JavaScript (ES6+)
CSS3 with CSS Grid
Minimal external libraries: marked.js, exifr, highlight.js, sql-formatter (all from CDN)
No frameworks, no bundlers, no npm
Hosted on Github Pages
Happy to answer questions about the technical implementation, design decisions, or specific tools!
All tools are inspectable – just view source on any page to see exactly how they work!

value: Show HN: Prism.Tools – Free and privacy-focused developer utilities

author: BLGardner


value: jansonlau

value:
Like many of you, I liked the idea of selling premium. It feels like a great strategy for passive income. But despite trading for years, I was still my own worst enemy and I kept seeing people in this sub asking for a way to automate trading because, let’s be honest, the manual grind is brutal. I noticed three things that kept me suffering:
Time sink: Checking prices, monitoring delta, watching for assignment risk, deciding when to roll or close. I was spending 10+ hours a week managing positions. That’s not "passive" income; that’s a second job.
Emotional decisions: When I saw extra premium, I’d pick strikes out of greed. When I was winning, I’d want to hold longer. And when the market moved, I didn’t want to miss out. I knew the rules and still broke them.
Gatekeeping: I’d see screenshots of huge gains with zero explanation. Just a P/L flex. I don’t think most people are malicious but the end result is the same: outcomes without process.
I stopped trying to trade better and started trying to remove myself from the equation. I built a systematic tool called PutHouse to automate the mechanics of covered calls and cash-secured puts.
What I’ve learned since running PutHouse across different market conditions:
Time is the real ROI: Getting back ~10 hours a week to live life and have it managed for you has been the biggest win.
Systematic > intuitive: A boring, repeatable strategy beats a gut feeling every single time.
Transparency matters: I need to know what the data is telling me because metrics such as IV, RV, RSI, OI, and delta are important.
I’m opening this up because I want to stress-test the logic with people who actually trade this way. I’m not looking to sell you anything. I genuinely want feedback on what I’ve built:
What would you not trust about an algorithmic approach to selling premium?
For those who trade manually, what’s the "edge case" or market condition that would make you worry about an automated system?
What metrics are you looking at that I might be missing? (Currently: IV, RV, RSI, OI, Delta, DTE, Min Volume, Min Price, Bid/Ask Spread).
The goal isn't a "money printer". It's consistency and risk management. If you’ve built something similar or have thoughts on the mechanics, I’d love to hear what you would be most worried about.

value: Show HN: PutHouse – The AI Options Trader

author: jansonlau


value:
Hi HN,
We’ve been building [memU](https://github.com/NevaMind-AI/memU), an open-source memory framework for AI agents that supports both classic RAG and LLM-based direct file reading.
RAG has become the default in LLM systems, but many of its failures don’t come from the model — they come from the retrieval assumptions. Embedding-based retrieval is fundamentally an approximation over semantic similarity. It works well for fuzzy recall, but it often breaks when relevance ≠ correctness, which is common in real systems.
From a retrieval perspective, RAG struggles with:
- Time- and version-sensitive facts (embeddings don’t encode validity or order)
- Structured, canonical knowledge like configs, policies, or agent state
- Multi-step reasoning, where incomplete or slightly wrong context compounds errors
In practice, RAG often returns plausible but incorrect context — especially harmful for agents that act over long horizons.
memU takes a different approach.
Instead of trying to make embedding search smarter, we ask: what should not be retrieved via embeddings at all?
Retrieval in memU starts at a Memory Category Layer:
- memory is organized into semantically stable categories
- each category is stored as a readable Markdown file
- these files act as long-term, canonical memory
When a query arrives, the LLM reads the relevant memory files directly, using semantic understanding rather than vector similarity. Only when this layer is insufficient does memU fall back to item-level retrieval, optionally using embeddings for speed.
This design treats the LLM as what it’s increasingly good at: reading, reasoning, and maintaining structured knowledge, not just ranking vectors. Using Markdown files is deliberate — similar to ideas like `skills.md` — making memory explicit, inspectable, and stable over time.
Compared to existing approaches:
- [mem0](https://github.com/mem0ai/mem0) is fast and simple with classic RAG, but can struggle with temporal accuracy and precise state changes.
- [Zep](https://github.com/getzep/graphiti) uses graphs, which handle structure well but add complexity and maintenance overhead.
- [memU](https://github.com/NevaMind-AI/memU) uses non-embedding retrieval to address RAG’s structural limits in accuracy, stability, and long-term consistency — without replacing RAG entirely.
For long-running agents, retrieval needs to provide reliable premises for reasoning, not just relevant text. In those settings, direct LLM reading over structured memory often aligns better with how models actually reason.

value: Show HN: A file-based agent memory framework that works like skill


value: tbrannan

value:
I built DDL to Data after repeatedly pushing back on "just use production data and mask it" requests. Teams needed populated databases for testing, but pulling prod meant security reviews, PII scrubbing, and DevOps tickets. Hand-written seed scripts were the alternative slow, fragile, and out of sync the moment schemas changed.
Paste your CREATE TABLE statements, get realistic test data back. It parses your schema, preserves foreign key relationships, and generates data that looks real, emails look like emails, timestamps are reasonable, uniqueness constraints are honored.
No setup, no config. Works with PostgreSQL and MySQL.
https://ddltodata.com
Would love feedback from anyone who deals with test data or staging environments. What's missing?

value: Show HN: DDL to Data – Generate realistic test data from SQL schemas

author: tbrannan


value: kmewhort

value:
I created at app where you can play with the physics of prisms, lenses and mirrors -- then ride a photon in 3D that takes you through your optical obstacle course.
For a deeper dive, I'm also working on a companion series of blog articles: https://artepants.fun/posts/spectral-lab-2/

value: Show HN: Ride a Photon

author: kmewhort

title: Show HN: Ride a Photon


value: pyeri

value: Show HN: Abhyasa – Modular Quiz and Assessment Engine

author: pyeri


value: julienreszka

value:
4th pivot of this app
Discover and share positive experiences with others. Post plans to replicate what you're grateful for and see what resonates with the community. Toss coins to show your interest in growing the same positive experiences.
Who uses CoinFountains?
Early adopters
Find and share what's working before everyone else.
Entrepreneurs
Help grow and scale what's already working.
Visionaries
See potential in what's working and help it grow.

value: Show HN: CoinFountains – Let's replicate and scale what we are grateful for

author: julienreszka


value: kuberwastaken

value:
I just had this really fun idea of making a playable version of DOOM on my GitHub profile after building "Doom" in a QR code last year (https://news.ycombinator.com/item?id=43729683) and I finally stopped procrastinating to try and build it.
DoomMe is DOOM E1M1 map that can run on GitHub's markdown viewer which doesn't support javascript, web assembly or even iframes
it works with a stateless engine with a capture of every possible position in the map (with 64 unit distance) captured in 4 directions and stitched together using graph logic with 8000+ WebP images and markdown files
Because of it being stateless, I had to manually edit the WAD file to "open" the gates of E1M1 to use omgifol later to capture all valid positions inside the map!
Open Source with MIT License and current version is <190 mb in size with all assets
- Play it on my profile: https://github.com/Kuberwastaken
- Blog post covering most of the process, implementation and failed tries: https://kuber.studio/blog/Projects/How-I-Made-DOOM-Run-Insid...

value: Show HN: Doom (1993) Playable in a GitHub Readme

author: kuberwastaken


value: Show HN: Specil – A minimal and helpful tool for Spec-Driven Development


value: netmute

value: Show HN: Better-than-nothing LSP for many languages, based on ctags

author: netmute


value: svenmalvik

value: Show HN: Vissper – Real-time macOS transcription in Rust, not Electron

author: svenmalvik


value: Show HN: Ctx – CLI to print your codebase structure (folders, files, exports)


value: nsemikey

value: I built "Gamma for Excel Spreadsheets". Create excel files with 1 Prompt.

value: Show HN: Gamma for Excel Spreadsheets

author: nsemikey

title: Show HN: Gamma for Excel Spreadsheets


value: Show HN: HexPickr – Extract Tailwind and CSS variables from images


value: anhphong

value:
Hey HN,
I built a menu bar utility to monitor VPN status and detect leaks on macOS.
The problem: macOS doesn't make it obvious when your VPN silently disconnects,
and even when connected, DNS or IPv6 traffic can leak outside the tunnel
without you knowing.
VPN Peek shows your connection status at a glance and runs leak detection:
- DNS leak detection: checks if your DNS queries go through your VPN or leak to your ISP
- IPv6 leak detection: detects if your real IPv6 address is exposed
- Shows current public IP and location
- Notifications when VPN drops or leaks are detected
- Auto-refreshes on network changes
Works with any VPN provider – it monitors at the system level, not tied to
any specific app.
Built with SwiftUI/AppKit hybrid for native macOS feel. Runs locally,
only reaches out to check your public IP for leak detection.
$3.99 on Mac App Store, no subscription.
Feedback welcome – especially from anyone who's dealt with VPN leak issues.
Link: https://apps.apple.com/us/app/vpn-peek/id6757384027

value: Show HN: VPN Peek – macOS menu bar app with DNS and IPv6 leak detection

author: anhphong


value:
Hi HN,
I’ve been living in Thailand for a couple of years and, despite understanding quite a bit, I always struggled to actually speak Thai - especially getting the tones right.
Classes felt rigid, tutors felt stressful, and most apps don’t let you just… talk.
So I built SpeakLanguageOnline: a calm, call-style Thai speaking practice where you speak, it listens, and it speaks back.
No lessons, no gamification, no pressure — just voice practice.
It’s early and intentionally minimal. I’m mainly sharing this to get feedback on whether the two-way voice flow feels natural and useful. It’s free to try with a short practice window.
Happy to answer questions.

value: Show HN: SpeakLanguageOnline – calm two-way voice practice for expats


value: puzer

value:
GitHub profile analysis
 - Build your embedding from your Stars
 - Compare and discover popular people with similar interests and share yours
 - Generate a Skill Radar
 - Recommend repositories you might like

value: Show HN: Similarity = cosine(your_GitHub_stars, Karpathy) Client-side

author: puzer


value: mbilalarshad

value:
I wanted to enable local markets for discovery & quick delivery, most of the stuff that is being delivered to us from other cities & states already exists within our reach, the problem is discovery and last mile connection.
Hyperzod gives you the full stack: ordering apps, driver tracking, merchant tools, dispatch automation, everything you need to deliver anything, ultra fast. No code. No delays. Just real time local commerce.

value: Show HN: Shopify for Quick Commerce: Launch a Local Delivery Biz in Minutes

author: mbilalarshad


value: pooriayousefi

value: Show HN: Intellistant, a 10-50x faster C++ alternative 2 LangChain 4 AI agents

author: pooriayousefi


value:
Hey HN!
I’m Collin, a 20 year old law student from Amsterdam. I built Cited AI, an AI that gives accurate and verifiable answers from your documents/context.
As a law student who uses AI a lot, I know how important it is that answers are actually accurate and verifiable. I remember many instances where I'd ask a chatbot like ChatGPT or Claude about case law or long documents, and it would either hallucinate facts that didn't exist, or fail to give me the exact passages from my source documents so I could verify its answers. Even when specifically asking for exact quotes, finding that passage in the original document is still a hassle. That's why last November I started building Cited.
It should work with all types of content, complex PDFs (including math heavy ones) and long documents up to 75k words. No RAG or chunking is used, to make sure the full document is in the LLM's context.
I would love to hear your feedback!

value: Show HN: I built an AI that gives verifiable answers


value: Spent Christmas break making a map of open source SaaS alternatives (every stage of the startup journey, not just the dev stack, but also CRM, legal, finance, and exit marketplaces). No newsletters, no paywalls, just a GitHub repo. Hope this helps some of you save on server costs this year!

value: Show HN: Bootstrapper Roadmap – Building and exiting with an OSS stack


value: amortka

value:
Hey HN!
3-4 weeks ago I was trying to record a webinar for another side project. Screen recording, full screen presentation, talking through slides — should be simple.
Except I kept forgetting what I wanted to say. And every time I glanced at my notes, it was obvious on camera. Worse — when recording full screen, there's nowhere to put notes without them being captured.
Tried a few teleprompter apps. They either covered half my screen, scrolled at a fixed speed I couldn't match, or showed up in the recording.
So I thought: I've been a full-stack dev for 20+ years. Never touched Swift or SwiftUI. Can I actually build a native Mac app?
Turns out — yes. Took about 4 weeks of evenings and weekends. Claude helped me get past the Swift learning curve when I got stuck, but the architecture and problem-solving was mine.
What it does:
- Sits in the MacBook notch area (right below camera)
- Scrolls based on voice — speak and it moves, pause and it waits
- Invisible during screen sharing/recording (uses a specific NSWindow level that screen capture APIs ignore)
- Runs 100% locally, no cloud
The technically interesting bits:
- Voice detection uses just audio input, mic — just detecting audio levels, not transcribing
- The "invisible during screen share" trick is just the right window level + excluding from capture
- SwiftUI made the UI surprisingly fast to build coming from React/NodeJS
The biggest surprise: Launched on Product Hunt on Dec 31st. No prep, no audience, no hunter — just posted it myself. Hit #4 for the day, got into their newsletter (1M+ subs), 75 sales so far. Wild.
For a niche utility I built to scratch my own itch, this exceeded every expectation.
Curious if others here have jumped into unfamiliar stacks for side projects. How steep was the learning curve?
Site: notchie.app

value: Show HN: I'd never touched Swift. Built a Mac app in 4 weeks

author: amortka


value: Show HN: Build a Directory in 7 Days with Vibe Coding (Free Roadmap)


value: Show HN: I built a CLI-first pipeline that turns Wikipedia into narrated videos


value: piebro

value:
I wanted to use DuckDB using SQL to query Wikidata locally on my laptop. So I converted Wikidata's N-Triples dump (~8 billion rows) into Parquet files.
The dataset includes the full truth triplets (~60GB) and some pre-extracted datasets for YouTube channels, Letterboxd films, GitHub users and more.
There's also a small website to explore random entities using DuckDB WASM: https://piebro.github.io/wikidata-extraction/random.html

value: Show HN: Query Wikidata with DuckDB Instead of Sparql

author: piebro


value: marcoaapfortes

value:
Author here! Some context: I published this 48 hours ago and it was auto-listed on MCPMarket (the MCP tools directory). Got 700+ organic downloads with zero marketing—developers were actively searching for exactly this solution.
The "Git Accelerator" optimization story:
Initially used a file walker that took 6.6s on Chromium. Profiling showed 90% was filesystem I/O. The fix: git ls-files returns 480k paths in ~200ms. Added smart heuristics for untracked files (only scan dirs <50k files), bringing total to 0.46s.
Why this matters: Agents can't wait 10 seconds for search. Sub-500ms makes it feel instant, changing how they explore codebases.
Installation:

  Cursor: npx mantic.sh@latest
  VS Code: npx mantic.sh@latest
  CLI: npm i -g mantic.sh

Limitations: Mantic is optimized for precise queries ("find stripe webhook") where structure matters. For fuzzy exploratory search, traditional embeddings may still be better. Curious if HN has ideas for hybrid approaches.
Happy to answer questions!

value: Show HN: Mantic.sh – A structural code search engine for AI agents

author: marcoaapfortes


value: yosalama

value:
BuzzBear monitors Reddit and alerts you when people post about topics you care about. It uses semantic matching, so you can describe what you're looking for in plain English, and it finds relevant posts even when people use completely different words.
Example: Search for "CI/CD tools" and catch posts like "our deployment process is a nightmare"
https://buzzbear.ai/ (free tier available)
---
How I avoided cloud GPU costs:
I needed ML inference for text similarity. Cloud GPU pricing is $700-1000/mo for instances that would sit idle most of the time. "Scale to zero" sounds great until you want a generous free tier.
My solution: the RTX 3080 I already own.
The stack (Elixir/Phoenix + Bumblebee):

  - Phoenix app on Fly.io

  - Bumblebee ML node on my home server (RTX 3080)

  - Tailscale + libcluster to connect them

From the code's perspective, they're one Erlang cluster. Where I can call the ML service like a local function. Tailscale tunnels the traffic, libcluster handles discovery.
Capacity: ~1M comparisons/hour. I currently need a fraction of that.
Scaling: If I need more, I spin up cloud GPU nodes, connect them to my Tailscale network, and libcluster auto-discovers them. Zero code changes.
Happy to answer questions about any of this!

value: Show HN: Buzz Bear – Monitor Reddit with Semantic Search ($0/mo cloud GPU costs)

author: yosalama


value: vaultsandbox

value:
I've spent the last few months working on something I wish I'd had years ago.
I kept running into the same issue: CI green, production mail broken. TLS handshake failures, DKIM alignment mismatches, SPF soft-fails ... the stuff that only surfaces when real mail servers are involved.
Most test tools (Mailpit, MailHog) are catch-alls. They confirm "an email was sent" but don't validate the protocol. They also aren't designed for network-exposed environments: no auth, unprotected Web UI, easy to enumerate messages.
VaultSandbox is my attempt at fixing that.
It's a self-hosted SMTP gateway (AGPLv3) that validates SPF, DKIM, DMARC, and rDNS on every incoming message. You keep your production email provider (Postmark, SendGrid, SES) in tests and you just change the recipient domain. No mocking, no config changes.
There are client SDKs (Node, Python, Go, Java, .NET), plus a Web UI and a CLI for manual testing.
Some technical details:
Deterministic Tests
Instead of polling or sleep loops, the SDKs use Server-Sent Events (SSE) so test assertions trigger the moment the mail hits the gateway.
Minimal infrastructure footprint
Built with NestJS and Angular, with no external database dependency to keep the container footprint small and easier to reason about.
Post-Quantum Encryption
I use ML-KEM-768 for the encryption layer. Incoming mail is encrypted immediately using a client-generated public key and the plaintext is discarded. The server only ever stores encrypted message data and cannot decrypt it. I chose PQ because I wanted to build something I wouldn't have to revisit in five years. If it handles large PQ keys reliably, everything else is easy.
Quick start:
https://vaultsandbox.dev/getting-started/quickstart/
Site:
https://vaultsandbox.com
I'd love feedback, especially on whether AGPLv3 would be a blocker for something you'd self-host in dev.

value: Show HN: VaultSandbox – Test your real MailGun/SES/etc. integration

author: vaultsandbox


value:
I've never posted on ShowHN before, but I wanted to share my Xmas 2025 project; to try a new approach to controlling our kids screen time.
This also involved massively over-engineering a solution in order to play with a shiny new gadget (and avoid the in laws at Christmas, obviously)
I've shared some learnings on AI coding with embedded devices, and how I approached the product design/hardware selection side of things.
The Web App is at https://screenie.org - and I'm Open Sourcing the device and web app code later today (links to follow on that site)

value: Show HN: I built an Open Source screen timer for the m5stickc (Arduino)


value: ulrichbate

value:
I've been working on Octopii for around a year now, a "batteries-included" library that aims to make building distributed systems in Rust as easy as writing a standard struct
Octopii acts like a "Distributed Systems Kernel." It handles the physics of the cluster (storage, networking, leader election) so you can focus entirely on your application logic.
It's effectively the infrastructure behind something like Cloudflare Durable Objects, but packaged as a crate you can run on your own hardware.

value: Show HN: Octopii – Turn any Rust struct into a replicated,fault-tolerant cluster

author: ulrichbate


value: standew

value: Show HN: A photo restoration tool that recovers facial details

author: standew


value: stevensu

value:
I built VoltCode to solve AI coding bottlenecks by running multiple AI agents simultaneously (tested on M1 Pro). Generate components with Claude while Gemini writes tests—all in one IDE.
Problem: Current AI coding is sequential. You wait for Claude to finish one component before starting the next. With complex apps, you're constantly blocked—generate navbar → wait → generate auth → wait → write tests → wait. Each task takes 10-30s, adding up to minutes of idle time.
How it works: VoltCode's parallel task engine runs up to multiple AI agents simultaneously. Chat with Claude Code to generate a dashboard while Gemini writes API routes and another Claude instance creates tests. All tasks execute in parallel with intelligent queue management.
Key insight: Modern apps need multiple components. Instead of sequential AI calls, batch them. The bottleneck isn't AI speed—it's waiting for one task to finish before starting the next.
Built with Tauri + React. Supports Claude Code, Gemini, Codex with MCP protocol. Live preview updates as each parallel task completes. Task panel shows all running jobs with progress.
The magic moment: Watch your app build itself as multiple AIs work simultaneously.

value: Show HN: VoltCode Run multiple Claude/Gemini tasks in parallel

author: stevensu


value: Show HN: Continuous learning from streaming events (Kafka and online ML)


value:
Hi HN,
I built cmd-chat, a peer-to-peer terminal chat application written in Python.
It focuses on privacy and simplicity:
- End-to-end encrypted messaging (SRP authentication + symmetric encryption)
- No servers, no databases, no logs
- Nothing written to disk — everything runs in RAM
- Pure CLI/terminal-based UX
The goal was to explore how far you can push secure communication with minimal infrastructure and zero persistence.
I’d really appreciate feedback on the security model, protocol design, and any ideas for improvement.
Thanks!

value: Show HN: End-to-end encrypted terminal chat with no servers or disk writes


value: Show HN: Solving the 5000W Compute Wall in Physics AI via Algebraic Continuity


value: Show HN: PlayTheAI – Test AI models in strategy games (Open Beta)


value:
I’ve spent the last year developing a decomposition kernel that addresses the "Linear Bottleneck" in standard compression (Zstd, LZMA, Brotli).
The Problem: Traditional algorithms operate on 1D streams. They are blind to the spatial, temporal, or hierarchical architecture of modern data (3D models, nested JSON, multi-modal blobs). When you force these structures into a 1D window, you leave significant entropy on the table.
The Solution: PXG v3.0 maps binary data to a 13505x13505 grayscale grid. By treating data as a coordinate system rather than a line, our engine utilizes adaptive tiling to isolate redundant blocks across the entire file, not just a sliding window.
Key Benchmarks:
Efficiency: Consistent 60-88% reduction on JSON, PDF, and FBX/3D vertex data.
Searchability: This is an in-place succinct structure. The data is the index. You can query strings, hex patterns, or metadata directly from the compressed binary.
Latency: Seek-latency is clocked at ~0.04ms. Search speed for a complex pose library (225 chunks) is ~6.00ms.
Verification: 100% Byte-Perfect Lossless reconstruction.
The Ecosystem: PXG isn't just a utility; it's designed as the foundation for the AXIS ecosystem—enabling zero-load-time gaming and high-density "Heavy Data" pipelines.
The web demo is live at the URL above. No signups, no trackers. Upload a file (Max 50MB for the demo), download the .pxg, and use the Debug Index to search the compressed results in real-time.
I’ll be here to answer technical questions regarding the tiling logic..

value: Show HN: PXG v3.0 – Searchable Compression via 2D Spatial Decomposition


value: nberkman

value:
I built a tool that stores your full Claude Code history to let you easily find and resume sessions. It has TUI, CLI and MCP interfaces. It's a single Go binary, and the session history is synced to SQLite each time you use it.
Default mode is the TUI with a session browser and full-text search. Once a session is selected you can browse and search within it, resume it or export to markdown.
The MCP server provides tools to let Claude search back through the session for pre-compact context or pull from prior sessions. I use this constantly.
I've seen elaborate continuity systems to give Claude Code access to history but this simple approach has been very effective.
Installation:
macOS: brew install neilberkman/tap/ccrider
Linux/other: git clone https://github.com/neilberkman/ccrider && cd ccrider && go build
MCP server: claude mcp add --scope user ccrider $(which ccrider) serve-mcp
Source: https://github.com/neilberkman/ccrider

value: Show HN: ccrider - Search and Resume Your Claude Code Sessions – TUI / MCP / CLI

author: nberkman


value: bkraszewski

value:
Hello HN,
I’m the solo developer behind ScrollMind. I built this because I was frustrated with the two extremes of learning AI:
Academic Textbooks: 50 pages of Greek notation before you write a single line of code.
Hype Twitter/YouTube: "Build an LLM in 5 minutes" tutorials that skip all the engineering fundamentals.
I wanted something in the middle: Engineering intuition.
What is it?
ScrollMind is an interactive guide to Neural Networks that works like a social media feed. Instead of 2-hour lectures, the content is broken down into bite-sized "posts"—diagrams, interactive quizzes, and short explainers.
The goal is to turn "doom-scrolling" muscle memory into learning time. You can finish a concept (like Embeddings or Backpropagation) in the 5 minutes you have between meetings.
What’s under the hood?
The Content: It covers the full "Intro to AI" stack: Vectors, Layers, Non-Linearity, Loss Functions, and Optimization.
The Approach: Visuals first, notation second. We visualize high-dimensional concepts so you understand what the math is doing before you memorize the formula.
The Stack: React/Vite frontend with Firebase for the backend. Content is structured as a DAG (Directed Acyclic Graph) of micro-concepts rather than linear chapters.
The "Business Model"
The entire "Intro to AI" course (12 concepts, 100+ posts) is free. I plan to release advanced, paid courses later (e.g., "Building LLMs from Scratch"), but the foundational knowledge should be accessible to everyone.
I’d love your feedback on:
Does the "feed" format actually help you retain info, or is it too fragmented?
Are the visual explanations for concepts like "Vectors" and "Embeddings" intuitive enough?
Check it out here: [Link to your deployed app]
Thanks!

value: Show HN: ScrollMind – A visual engineering guide to AI that fits in your feed

author: bkraszewski


value: sbondaryev

value:
Hi HN,
I built this interactive guide to help build intuition for time complexity.
There is already a lot of writing on this topic here (e.g. [1], [2]), so I tried to keep the explanation minimal and focus on examples you can interact with.
The visualizer runs your JavaScript code, tracks `op()` markers as `n` increases, and plots the growth curve in real-time.
I also tried to visualize the Master Theorem by mapping recursion trees to the work done at each level.
I'd love to hear your feedback on the visualizations or if you find the Master Theorem section intuitive.
[1] https://news.ycombinator.com/item?id=5655075
[2] https://news.ycombinator.com/item?id=45002182

value: Show HN: Big O Notation – An Interactive Guide

author: sbondaryev


value: smacke

value:
Hi HN, sharing my holiday season passion project, pipescript, which lets you write code like this in Jupyter Python notebooks:
42 |> $+1 # 43
The $ is a placeholder for the value in the previous pipeline step, like (.) in magrittr.
There's a ton more you can do thanks to macro expansion capabilities added by pipescript. Here's 5 factorial:
range(1, 6) |> reduce[$$] # 120
Placeholders can also be given informative names unlike in magrittr:
range(1, 6) |> reduce[$accum$current] # 120
The lack of names placeholders in magrittr had been my biggest complaint. Anyway I had a lot of fun scratching this itch and am really proud of the result, hope you like it too. :)

value: Show HN: Magrittr-like pipe syntax for IPython

author: smacke


value: kiraken

value:
I built a small guided tour library for React because I couldn’t find a free one that works cleanly with React 19+.
It’s lightweight, uses modern React APIs, and is free. Let me know what you think: https://github.com/Aladinbensassi/react-guided-tour

value: Show HN: React Guided Tour Library

author: kiraken

title: Show HN: React Guided Tour Library


value: todaycompanies

value: Show HN: RepoCard – A launch kit for GitHub repos (OG images, code snaps, posts)

author: todaycompanies


value: itsmeadarsh

value:
I built a React virtualization library that offloads scroll calculations to Rust compiled to WebAssembly.
Why I built this:
I was working on a trading dashboard that needed to display 500k+ rows of live tick data. react-window worked fine at 10k rows, but at scale, every scroll event caused visible jank. Profiling showed the bottleneck was JavaScript - calculating visible ranges and item offsets was blocking the main thread for 8-12ms on each scroll.
I wondered: what if the math happened in WASM instead?
What it does:
Warper is a React hook (useVirtualizer) that renders only visible items. The difference from existing libraries:
Scroll position to visible range calculations happen in Rust/WASM
Item offsets stored in a Fenwick tree for O(log n) updates when heights change
Binary search for scroll-to-index is O(log n) instead of O(n)
No JS object allocations during scroll = no GC pauses
Technical details:
The WASM module maintains a Fenwick tree (binary indexed tree) of item heights. When you scroll:
JS passes scroll position to WASM
WASM binary searches the tree to find the start index
WASM returns [startIndex, endIndex, offsets[]]
React renders only those items
For variable heights, updating a single item's height is O(log n) instead of recalculating all subsequent offsets.
Benchmarks (Chrome, M1 Mac):
10k items: react-window 60 FPS, Warper 120 FPS
100k items: react-window ~40 FPS, Warper 120 FPS
1M items: react-window ~12 FPS, Warper 118 FPS
At 10M items, react-window crashes. Warper holds at ~115 FPS.
Try it:
Live demos (no signup): https://warper.tech
Stress test with 1M rows: https://warper.tech/one-million-rows
Variable height chat: https://warper.tech/chat
GitHub: https://github.com/warper-org/warper
npm: npm install @itsmeadarsh/warper (~45KB gzipped with WASM)
Limitations:
Requires top-level await or a bundler plugin for WASM
Only React 18+ (uses useSyncExternalStore under the hood)
Horizontal virtualization not yet implemented
Happy to answer questions about the Fenwick tree implementation or WASM/JS interop challenges.

value: Show HN: Warper – React virtualization with Rust/WASM for 10M+ items

author: itsmeadarsh


value: deveworld

value:
Hi HN,
This is my first project/paper (independent work; I’m a high school student in Korea).
PonderTTT explores when to run Test-Time Training (TTT) updates instead of updating on every segment.
The gate is training-free: it uses the TTT layer's self-supervised reconstruction loss to decide UPDATE vs SKIP.
A single threshold is calibrated on unlabeled data and adapted online via EMA to maintain a target update rate.
In GPT-2 code language modeling experiments (124M–1.5B), this reached 82–89% Oracle Recovery and improved over Random Skip baselines on some OOD languages (up to 16% lower loss).
Note: v1 experiments are JAX/Flax on GPUs. I'm working on a v2 scale-up to Gemma 3 (TPU).
I'd really appreciate feedback on:
1) whether reconstruction loss is a sensible gating signal in practice,
2) evaluation/baselines you think are important for this setting.

value: Show HN: PonderTTT – Training-free adaptive compute for LLMs via TTT gating

author: deveworld


value: aragoss

value: Show HN: Chaos Proxy – Cloud-native alternative to Charles Proxy for teams

author: aragoss


value: jancurn

value: Show HN: mcpc – Universal command-line client for Model Context Protocol (MCP)

author: jancurn


value: HFGDownloader

value: a Go tool to download large HuggingFace models and datasets quickly. It uses parallel connections, supports resume, and has both a CLI and a sleek Web UI. One-liner install

value: Show HN: Fast HuggingFace model downloader with Web UI and parallel downloads

author: HFGDownloader


value: ntkris

value:
Hi HN,
I built Simboba because we needed something for our own product, and I wanted to explore how dev tools change with AI coding assistants.
The hardest part of evals is creating good annotated test cases. So I focused on getting users there with the power of AI coding assistants.
How it works:
- AI drafts datasets from your codebase
- Web UI to review and refine cases
- Everything tracked in git
- Multi-turn conversation support
- LLM-as-judge + deterministic checks (e.g. was tool xyz called)
- Evals run as simple Python scripts
The AI coding assistant angle: I wanted users running customised evals in 5 minutes, not just a generic example. Started with a CLI command that generates a prompt for Claude Code / Cursor. That felt like too much friction. Then tried a separate markdown file with instructions, but AI tools didn't find this easily.
What worked: clear instructions in the README plus structured schemas (Pydantic). The AI reads the README, understands your codebase, the structure required for the package and drafts a real dataset for your product. Then writes the eval script.
I'd love to know what you think, and happy to answer questions!

value: Show HN: Simboba – Evals in under 5 mins

author: ntkris


value: erikpau

value:
I built a CLI tool for capturing website screenshots directly from your terminal. It displays images inline using Sixel, iTerm2, or Kitty protocols, so you can preview sites without leaving your workflow.
Built in Rust, it's open source, you can find the code here: https://github.com/allscreenshots/allscreenshots-cli

value: Show HN: Capture website screenshots from your terminal. No browser needed

author: erikpau


value: caiobzen

value:
Hi HN
I’m an Engineering Manager, and over the years I struggled with one recurring problem:
important management signals (1:1 notes, concerns, feedback, missed check-ins, context, achievements) were always scattered across tools or stuck in my head.
Ledger is a tool I started building to solve that for myself:
• One private space for EMs (not HR, not employees)
• Capture 1:1 notes, concerns, and follow-ups
• Simple tracking of people journey, not tickets
• Optional AI summaries to support reviews and coaching (very conservative by design)
The goal isn’t to replace judgment or conversations, but just to reduce memory bias and make better decisions with less mental load.
It’s early, opinionated, and shaped by real EM work rather than frameworks.
I’d love feedback, especially from people managing engineers or managers of managers.
Link: https://l3dger.com
Happy to answer questions or discuss what shouldn’t exist in tools like this.
— Carlos

value: Show HN: Ledger – A private workspace for Engineering Managers

author: caiobzen


value: benmarten

value: Show HN: Dokku-multideploy – Deploy and migrate multiple apps between servers

author: benmarten


value: yimsk

value:
Claws is a terminal UI for AWS resources (Go + Bubble Tea).
Key idea: query multiple profiles × regions at once and show results in one view to reduce context switching.
Features: Navigate 163 resource types with vim-style keys and command mode / Optional read-only mode + confirmation for destructive actions / Built-in CloudWatch Logs viewer (tail)
How to try: brew install --cask clawscli/tap/claws, then run claws and press P / R.
UX feedback welcome—especially any moments where you felt lost, surprised, or slowed down.

value: Show HN: Claws – Terminal UI for AWS resources (k9s-style)

author: yimsk


value: smurfysmurf

value:
I created a data pipeline that aggregates data from
Pleiades
Stanfords ORBIS
Harvards DARMC
AWMC
ToposText
WikiData
and then normalizes it all into a single schema and builds a SQLite database.
I did this in support of a free app I developed that gives a Google/Apple maps like experience for ancient Rome.
I had a difficult time finding good, joined data sources and created my own. I thought I might opensource it with the hope that
1) Others may find some value in this (especially academics)
2) Others can contribute and grow the breadth and depth of the data
Open to all feedback or thoughts and also any points to relevant datasets or similar projects that might exist
Github: https://github.com/thomaspalaio/roma-data-pipeline
(P.s. first time doing a side project / open source)

value: Show HN: Roma Data Pipeline – Open-Source Ancient Rome Data

author: smurfysmurf


value: stanko

value:
Hey, I've shared this game while it was still a work in progress in one of the Tell HN threads. I was pleasantly surprised that a lot of people tried it, and I got some positive feedback and constructive criticism.
Anyway, I found a gamedev library I really like - Kaplay [1]. What I like about it is that easy things are easy. Meaning I could have fun building the game without learning (or fighting) a new tool. I always wanted to make games, but this is the first one I actually did.
And I have to tell you - game development sparks joy! It combines so many things (game design, programming, art, sounds, UI...), and it is incredibly fun.
The game is a combination of action and turn-based gameplay. Probably a too ambitious goal, but I think I managed to make a fun little game. If you are not sure what I'm talking about, try playing the tutorial, it should help. There is also a global leaderboard, which is dominated by my friend, and I would appreciate if someone can dethrone him :)
It is completely free. I'm thinking of open sourcing it, but the code isn't up to my regular standards, as I was learning on the go. Also, I was more excited about adding stuff than going back and refactoring. So I'm still deciding on that one.
Before you ask, no, I haven't vibe-coded it. For me personally, that would mean delegating the fun stuff to something else. I’ve been working on it for about a month, in the evenings after my kid is asleep.
All feedback is appreciated!
[1] https://kaplayjs.com/
P.S. I also plan a blog post or two about it. I already started an interactive demo on how missiles are coded.

value: Show HN: Shoot-em-up Deck Building game

author: stanko

title: Show HN: Shoot-em-up Deck Building game


value: mtyz

value:
Hi HN,
I built FlipHN, a Hacker News reader with a swipe-based interface:
– Swipe right to save stories
– Swipe left to skip
– Built-in translation for non-native English readers
The goal was to make HN browsing faster and more accessible on mobile.
Would love feedback, especially from heavy HN readers.

value: Show HN: FlipHN – A Tinder-like way to browse Hacker News

author: mtyz


value: micksmix

value:
I built Kingfisher, an extremely fast Apache 2.0 OSS secret scanner (Rust) that goes beyond simply finding secrets.
- Live validation: checks whether a candidate secret actually works, so you can ignore dead strings.
- "What can this key do?" / Access Mapping (optional): authenticates and enumerates the credential’s effective access (AWS, GCP, Azure, GitHub, GitLab).
- Local triage UI: opens a local-only report so you can review findings + blast radius without sending code anywhere.
Try it out:

  brew install kingfisher
  #
  kingfisher scan /path/to/code --view-report
  #
  kingfisher scan --git-url https://github.com/org/repo.git --view-report
  #
  kingfisher scan . --access-map --view-report

I'd love feedback on:
- false positives/negatives on your repos
- which access-map / blast radius target you want next
- what the UI should surface first during incident triage

value: Show HN: Kingfisher, a fast OSS secret scanner with validation and blast radius

author: micksmix


value: naxmax

value:
I've been using Claude Code for more than 100 projects over the past year (since Feb 24, 2025 to be exact :)) and kept running into the same problem - the AI generates tons of code but then I'm stuck trying to review and understand it all. Created different workflows, approve line by line (too cumbersome), create manual reviews (also cumbersome) etc.
Then I realized the bottleneck isnt code generation anymore, its code comprehension. Like, AI can spit out infinite code but we still gotta review it, maintain it, debug it (sometimes at 2am when something breaks lol).
So I built this thing called Claude Bootstrap. Its basically a collection of "skills" (markdown files) that Claude reads before writing any code. Think of it like giving Claude a coding standards doc but one it actually follows.
The main stuff it enforces:
- TDD is mandatory - tests have to fail first before you write implementation. sounds annoying but it actually catches so many bugs
- hard limits on complexity - 20 lines per function, 200 per file. forces you to keep things simple
- theres a pre-push hook that runs code review and blocks if it finds critical issues
- it tracks when your changes are getting too big for a reviewable PR
heres how to use it:
git clone https://github.com/alinaqi/claude-bootstrap.git ~/.claude-bootstrap
cd ~/.claude-bootstrap && ./install.sh
# then in any project
claude
> /initialize-project
it sets up skills files, pre-push hooks, session management for context across convos, todo tracking etc.
got like 39+ skills now covering react, node, python, supabase, shopify, even reddit ads api and ms teams bots
the key insight for me was that ppl struggle with claude code not becuase the tool is bad, but because theres no guardrails. the delta is in the instructions you give it.
honest limitations tho:
this isnt magic. sometimes i still have to remind claude to follow TDD - itll try to jump straight to implementation and i gotta be like "nope, write the failing test first". the skills help but you gotta believe in them and keep enforcing them over and over.
the biggest mindset shift for me was bug fixing. when i find a bug now, i dont ask the AI to just fix it. i ask it "why did our tests miss this?" first. find the gap in test coverage, write a test that catches the bug, THEN fix it. otherwise you're just playing whack-a-mole.
also the 20 line limit - claude will sometimes split things weirdly just to hit the limit. you gotta use judgement. the limit is there to make you think, not to follow blindly.
and context management is still annoying. long sessions = claude forgets stuff. thats why theres session management skills but its not perfect. i still lose context sometimes and have to re-explain things.
hygiene is a big one too. i constantly enforce organization - active todos go in active.md, completed ones move to completed.md, all specs live in _project_specs/. claude will randomly dump files wherever if you dont watch it. i review file placements regularly and clean up anything thats in the wrong spot. sounds tedious but a messy repo = messy AI output. garbage in garbage out.
basically: these skills are guardrails not autopilot. you still gotta drive. and keep the car clean lol
curious what guardrails others have found useful? or if anyones tried something similar with cursor or other ai coding tools

value: Show HN: Claude Bootstrap – Opinionated Guardrails for Claude Code

author: naxmax


value: pmaze

value:
LLMs are often used to reduce the amount of reading we do. I’m hopeful they can be used to augment our reading habits instead.
I gave Claude Code a set of CLI tools to explore a library of 100 non-fiction books (sampled from HN’s favourites) and surface sequences of excerpts that link ideas.
I was first intrigued when it linked Steve Jobs’ self-deception to an excerpt about Theranos, and it ended up finding many more compelling trails.
I hope someone else finds them interesting as well.
Implementation notes: https://pieterma.es/syntopic-reading-claude/

value: Show HN: Syntopic reading with Claude Code – connections across 100 books

author: pmaze


value: anishkv

value:
Hi HN,
I built ReelSafe because I kept losing videos I knew I had saved.
I’d save an Instagram reel or a YouTube Short thinking “I’ll find this later,” but later meant endlessly scrolling through bookmarks with no way to search by what was inside the video.
So I built a small app that:
Lets you save reels, shorts, and videos from multiple platforms
Uses AI to understand what’s in the video (topics, actions, context)
Allows searching your saved videos using natural language
(e.g. “that breathing exercise video” or “keto recipe reel”)
The focus is on retrieval, not recommendations.
This is an early version and I’m especially interested in feedback around:
Whether AI-based search feels useful or overkill
What signals would make search results feel more trustworthy
Privacy expectations around analyzing saved content
Link: https://reelsafe.anishkv.in
Happy to answer any questions and share technical details if useful.
— Anish

value: Show HN: ReelSafe – Save and AI search your fav videos from YouTube, Insta or FB

author: anishkv


value: PeterAnderson

value:
Hey HN!
Happy New Year! I built Twitter Viewer because Twitter now requires login to view public content, which creates unnecessary barriers for researchers, journalists, and casual users.
What it does:
View any public Twitter profile & tweets (no account needed)
Search tweets by keywords
Download Twitter videos in MP4 format
100% anonymous (no tracking, no data collection)
Tech Stack:
Next.js 14 (App Router) for SSR and fast loading
Tailwind CSS for styling
Hosted on Vercel with Edge runtime
Twitter API integration (via proxy)
Why I built this:
Since Twitter changed its policy in 2023, you can't even view a single tweet without creating an account. This is frustrating for people who just want to quickly check a profile or share a link.
The tool has been in private beta for a month with positive feedback. I'm launching publicly today and would love your thoughts!
Live: https://twitterwebviewer.com
Happy to answer any questions about the implementation or features!

value: Show HN: Twitter Viewer – View Profiles,Search Tweets,Download Videos (No Login)

author: PeterAnderson


value: yashau

value:
I built this because I needed a simple way to send snippets to colleagues or copy/paste text from my phone to a random computer without logging into anything. I used a few other services for a while, but the downtime and general bloat finally got to me. I decided to build my own over the New Year break.
It is live here: https://yp.pe
Full disclosure: I vibe coded the vast majority of this using Claude Code, but I kept a pretty tight leash on the logic. The full commit history is public if you want to see the fumbles and the process. I will be the first to admit that some of my initial architecture decisions were not the best, and I completely own up to that, but I am happy with where the end result landed.
The Features:
- Fast and Lightweight: No ads and no tracking. CORS policy blocks Cloudflare analytics.
- Real-time Collab: Uses Yjs/CRDTs. It is limited to 10 concurrent editors by default on a first come first served basis, but it allows unlimited viewers.
- "Smart" Slugs: Slugs are kept as short as possible. I specifically removed ambiguous characters like capital I and lowercase l so it is easy to type the URL manually into another computer address bar.
- Note Controls: You can set notes to expire after a certain time or after a specific number of views. By default, any note not accessed in 90 days is automatically cleaned up.
- Privacy: No logins. E2E encryption for password protected notes. Passwords and hashes never leave your browser, only encrypted blobs do. There is a Playwright test in the repo that verifies this.
- The Rest: Custom slugs, syntax highlighting via highlight.js, rate limiting, PWA installable.
The Caveats:
I wanted to avoid the complexity of ownership, so the rules are simple: anyone can edit or delete any note. It is designed for quick, ephemeral use rather than long-term storage. If someone takes your slug, they can delete it and you can take it back. It is a bit of a free-for-all, but it keeps the codebase clean.
Technical Stack:
- Frontend: Svelte 5 with runes
- Backend: Hono
- Infrastructure: Runs on Cloudflare Workers, using Durable Objects for the real-time sync and D1 for the database.
It has not been tested at scale, but since it is on Workers, I hope it holds up. Now that the holidays are over and I am heading back to work, I will not have a ton of time to maintain this, so PRs are very welcome if you find bugs.
I am hosting a public instance for now at yp.pe. If the costs get crazy I might not be able to keep it public, but I tried to make it as easy as possible to self-host with deployment scripts and documentation in the repo.

value: Show HN: A lightweight, E2E encrypted pastebin built with Svelte 5 and Hono

author: yashau


value: peshwarla

value: Show HN: Mlship – Turn any ML model into a REST API with one command

author: peshwarla


value:
I’ve always struggled with the Capture phase. Most apps feel too heavy in the moment. Even coming up with a title can be enough to break the flow.
My app Ilseon (Android) addresses that specific problem. It’s not a full GTD system or project manager. It’s a targeted task manager designed to reduce mental noise and help users focus on one thing at a time.
Ilseon has GTD elements in its workflow though:
* Fast capture
Tasks and ideas can be captured with almost no structure. No required titles, tags, or projects at the moment of capture.
* Voice capture for hands-busy moments
When typing isn’t practical (walking, driving), I record a short voice memo. Optionally, if you add a Gemini API key, Ilseon can extract tasks from the transcript, but this is strictly optional and happens after capture, not during.
* An idea inbox
There’s a separate scratchpad for thoughts that aren’t quite tasks yet. During a review, these can be promoted into tasks or notes, or discarded.
* Reflection after completion
Completion isn’t the end. A small reflection step encourages reviewing what was actually done.
* Local-first storage
Audio is saved as standard .m4a files in a local folder (Recordings/ilseon/).
I’m looking for feedback from people who care about a clean capture process. Do you experience friction during capture with your current tools, especially when you’re away from your desk?
GitHub: https://github.com/cladam/ilseon
Play Store: https://play.google.com/store/apps/details?id=com.ilseon

value: Show HN: Ilseon, as a GTD "Capture" App

title: Show HN: Ilseon, as a GTD "Capture" App


value: jfranchino

value:
This is a short technical article documenting a personal project.
The goal was to hide a radar-based presence detection system inside an ordinary phone charger.
The focus is not on firmware features, but on design decisions:
- physical constraints
- radar orientation
- electrical isolation
- simplicity over configurability
It’s not a tutorial and not a product announcement.
Just a record of engineering decisions made under real-world constraints.
Feedback is welcome.

value: Show HN: A stealth ESP32 radar hidden in a phone charger

author: jfranchino


value:
I made this because I had trouble "thinking aloud" during technical interviews, even when I knew the optimal solution.
I'm using it right now to work on practicing vocalizing my ideation, which is a huge component of technical interviews that leetcode doesn't cover.
It integrates seamlessly into leetcode.com and sits on your screen as a little "rubber duck."
LeetDuck is automatically configured to proactively ask you a random behavioral question at the start, respond to runs and submits, and ask you about the time and space complexity when you successfully complete the problem.
Let me know what you guys think! Is this actually something other people would use too?

value: Show HN: LeetDuck – AI voice-to-voice mock interviewer for LeetCode.com


value: tonyww

value:
Hi HN, I’m the solo founder behind SentienceAPI. I’ve spent the last December building a browser automation runtime designed specifically for LLM agents.
The Problem: Building reliable web agents is painful. You essentially have two bad choices:
Raw DOM: Dumping document.body.innerHTML is cheap/fast but overwhelms the context window (100k+ tokens) and lacks spatial context (agents try to click hidden or off-screen elements).
Vision Models (GPT-4o): Sending screenshots is robust but slow (3-10s latency) and expensive (~$0.01/step). Worse, they often hallucinate coordinates, missing buttons by 10 pixels.
The Solution: Semantic Geometry Sentience is a "Visual Cortex" for agents. It sits between the browser and your LLM, turning noisy websites into clean, ranked, coordinate-aware JSON.
How it works (The Stack):
Client (WASM): A Chrome Extension injects a Rust/WASM module that prunes 95% of the DOM (scripts, tracking pixels, invisible wrappers) directly in the browser process. It handles Shadow DOM, nested iframes ("Frame Stitching"), and computed styles (visibility/z-index) in <50ms.
Gateway (Rust/Axum): The pruned tree is sent to a Rust gateway that applies heuristic importance scoring with simple visual cues (e.g. is_primary)
Brain (ONNX): A server-side ML layer (running ms-marco-MiniLM via ort) semantically re-ranks the elements based on the user’s goal (e.g., "Search for shoes").
Result: Your agent gets a list of the Top 50 most relevant interactable elements with exact (x,y) coordinates with importance value and visual cues, helping LLM agent make decision.
Performance:
Cost: ~$0.001 per step (vs. $0.01+ for Vision)
Latency: ~400ms (vs. 5s+ for Vision)
Payload: ~1400 tokens (vs. 100k for Raw HTML)
Developer Experience (The "Cool" Stuff): I hated debugging text logs, so I built Sentience Studio, a "Time-Travel
Debugger." It records every step (DOM snapshot + Screenshot) into a .jsonl trace. You can scrub through the timeline like a video editor to see exactly what the agent saw vs. what it hallucinated.
Links:
Docs & SDK: https://www.sentienceapi.com/docs
GitHub (SDK):
SDK Python: https://github.com/SentienceAPI/sentience-python
SDK TypeScript: https://github.com/SentienceAPI/sentience-ts
Studio Demo: https://www.sentienceapi.com/docs/studio
Build Web Agent: https://www.sentienceapi.com/docs/sdk/agent-quick-start
Screenshots with importance labels (gold stars):
https://sentience-screenshots.sfo3.cdn.digitaloceanspaces.co... 2026-01-06 at 7.19.41 AM.png
https://sentience-screenshots.sfo3.cdn.digitaloceanspaces.co... 2026-01-06 at 7.19.41 AM.png
I’m handling the backend in Rust and the SDKs in Python/TypeScript. The project is now in beta launch, I would love feedbacks on the architecture or the ranking logic!

value: Show HN: Sentience – Semantic Visual Grounding for AI Agents (WASM and ONNX)

author: tonyww


value: nynrathod

value:
Built Doo because I was tired of writing 200 lines of auth boilerplate for every API.
Example (complete API):
import std::Http::Server;
import std::Database;
struct User {

     id: Int @primary @auto,
     email: Str @email @unique,
     password: Str @hash,

}
fn main() {

     let db = Database::postgres()?;
     let app = Server::new(":3000");

     app.auth("/signup", "/login", User, db);
     app.crud("/todos", Todo, db);  // Todo = any struct you define

     app.start();
 }

Result:
- POST /signup with email validation + password hashing (automatic from @email, @hash)
- POST /login with JWT
- Full CRUD endpoints for GET, POST, GET/:id, PUT/:id, DELETE/:id
- Compiles to native binary
Status: Alpha v0.3.0. Auth, CRUD, validation, and Postgres working. Actively fixing bugs.
https://github.com/nynrathod/doolang
What would you need to see before using this in production?

value: Show HN: Doo – Generate auth and CRUD APIs from struct definitions

author: nynrathod


value:
Easily compare two list figure out diffs, common and unique items in the lists.
A simple list diff.
Check out - https://comparetwolists.dev/

value: Show HN: Online tool to compare two lists


value: MattELab

value:
Hello hackers! I'm MattELab and I've built [SentientMerchant.com](http://sentientmerchant.com/) - Stock Market & Crypto News Sentiment
As someone who owns multiple stocks, and perhaps you may hold or be interested in at least 1 stock and/or crypto, it was pretty overwhelming for me to keep up with the bombardment of news released 24/7 related to stocks and crypto that I hold as life gets pretty busy sometimes (e.g., academics, work). Hence, so often, I became unfazed and immune to reading stock/crypto news, which negatively impacted how I made investment decisions as they were often done uninformed...
I built [sentientmerchant.com](http://sentientmerchant.com) with the goal of freeing up time and making more informed investment decisions. Hence, instead of spending long hours burying myself in countless news articles related to stocks and crypto that I hold, or being unfazed as result of feeling overwhelmed from constant information flow, building sentientmerchant allowed me to get the gist and sentiment of my favorite stock and crypto from with just a single number (on a scale of 0 to 100) in a matter of seconds, which would tell me whether the overall sentiment of my stock/crypto is positive, neutral, or negative.
Additionally as someone who may react more strongly to negative news related to my favorite stock/crypto, bias would be introduced. Hence, SentientMerchant helps me make objective financial decisions, through labelling individual sentiment of each piece of news before calculating the overall/average sentiment (again from a scale of 0 to 100) of my favorite stock and/or crypto.
As of now, I have yet to monetise this website, so all features are currently free-to-use! Hope you enjoy!

value: Show HN: Get sentiment/gist of stock/crypto news in seconds with only a number!

author: MattELab


value: mstykt

value:
I built a desktop mock server that lets you update endpoints while it's running. No restart required.
The problem: Every time I changed a mock endpoint in other tools, I had to restart the server. WebSocket connections dropped, test flows broke.
The solution: Catch-all handlers that read config on every request. Change anything – routes, responses, delays – and it takes effect immediately. WebSocket/SSE connections stay alive.
Features that might interest you:
• State machine for multi-step API flows (visual editor)
• Chaos engineering: corrupt responses, inject latency, simulate rate limits
• WebSocket mocking with 3 modes (conversational, streaming, triggered)
• SSE streaming (perfect for mocking ChatGPT-style responses)
• API recording: proxy to real API, auto-capture as mock endpoints
• Response templating: {{request.path.id}}, {{request.body.user.name}}
Privacy: Runs 100% local. No cloud, no telemetry, no account.
Free for local development. macOS/Windows/Linux.
https://mocklantis.com

value: Show HN: Mocklantis – Mock server with live endpoint updates (no restart needed)

author: mstykt


value: Show HN: Training a Hamiltonian Neural Netwrork from Scratch in PyTorch


value: taariqlewis

value:
We added the official Hacker News API to SerenAI's x402 Gateway.
AI agents can now query HN stories, comments, and users through the same MCP interface they use for Seren's paid publishers like Firecrawl and Perplexity. We're aiming to deliver greater composability: an agent can pull HN discussions (free), scrape competitor sites with Firecrawl, and get AI analysis from Perplexity, all in one protocol.
We built a competitive intelligence example that tracks Show HN launches and competitor mentions across HN.
GitHub: https://github.com/serenorg/x402-mcp-server
Install: npx @serendb/x402-mcp-server

value: Show HN: Hacker News API on SerenAI X402 Gateway

author: taariqlewis


value: rosanza

value: Show HN: Rendery3D – Turn ordinary photos into studio-quality 3D assets

author: rosanza


value: fairyFayra

value:
Hi HN,
I built "Square Face Generator," a simple web tool to create retro pixel-art avatars. It's completely free and open-source.
I wanted a quick way to generate consistent pixel avatars for my projects, so I made this using [这里填你的技术栈，比如 Next.js and Canvas API].
Key features:
Unlimited customization options.
Instant download.
No registration required.
I'd love to hear your feedback or suggestions for new features!

value: Show HN: A retro square face avatar generator (Next.js and Canvas)

author: fairyFayra


value: mlatman

value:
Hey HN,
I wanted to see what happens if you put a large group in control of a site that’s completely built and updated by an AI agent. See the site here: https://youarethepm.com.
I first tried this with a small group of co-workers and it worked surprisingly well, so the obvious next step was: give it to a bigger group of strangers and see what we learn.
This site is fully autonomous. An AI agent reads this thread, decides what to do, writes code, and ships updates on a virtual computer. I might step in if it gets totally stuck, but the goal is for the site to evolve primarily based on this discussion.
How it works:
- Leave a comment with a feature request, bug report, design tweak, or question
- Every ~5 minutes, the agent checks this thread, reads new comments, and decides what to work on
- It writes code, tests it locally, and deploys to Vercel via Git
- Upvotes affect priority — highly upvoted comments rise on its roadmap
The site started as a blank canvas this morning. Everything you see was built by the agent based on earlier comments.
All of the work is done by a https://Tasklet.ai agent (disclosure: I work there). If you’re curious about the technical details, I wrote up how it works here: https://michaellatman.com/articles/you-are-the-pm

value: Show HN: You are now the product manager of this site

author: mlatman


value: Chuyue

value: Show HN: Unblock Apps by Studying

author: Chuyue

title: Show HN: Unblock Apps by Studying


value: tlar

value:
Hi HN,
Package repositories don't need to be complicated. They're just static files: metadata indexes and the packages themselves. Yet somehow hosting your own feels like you need dedicated infrastructure and deep knowledge of obscure tooling.
repogen is an SSG for package repos. Point it at your .deb/.rpm/.apk files, it generates the static structure, you upload to S3 or any web host. Done. $0.02/month to host packages for your whole team.
It supports Debian, RPM, Alpine, Pacman, and Homebrew. Has incremental mode for updating repos without redownloading everything. Handles signing. Very alpha, but it works. Would love to get feedback!

value: Show HN: Repogen – a static site generator for package repositories

author: tlar


value: artpar

value:
Made this to use my laptop terminal session on mobile without data going through a server.
tt start -p mypassword → get a URL (qrcode) → open in browser → enter password → connected.
Direct webrtc datachannel between your machine and browser.
Signaling server is a cloudflare worker, exchanges ~2KB of sdp/ice metadata then gets out of the way. Password never transmitted - argon2id derives 256-bit key locally on both ends. All terminal i/o gets nacl secretbox encryption before hitting the datachannel. double encrypted with dtls underneath but I wanted the relay to see nothing useful even during signaling.
go + pion/webrtc, about 14k loc. browser is xterm.js + webcrypto for argon2id. stun default, turn for symmetric nat.
my use case: checking on claude code runs from my phone when im not at my desk. hotel wifi, spotty mobile data. spent time on turn fallback, keepalive with reconnection, buffered writes during disconnects. pwa so it works from home screen and survives app switching. holds up ok on 3g.
Trade-offs: ice gathering takes 2-5s on connect. browser cant initiate, need cli on host. codes expire 24h.
Single binary, no deps. daemon mode for multiple sessions. tests with race detector, chaos tests for disconnects, network condition simulation. crypto and webrtc at ~72% coverage.
https://github.com/artpar/terminal-tunnel
ps: default relay runs on my cloudflare free tier so no guarantees. you can self-host the worker or run tt relay locally.

value: Show HN: Tt – P2P terminal sharing over WebRTC

author: artpar


value:
Hello HN,
I built a tool to extract high-quality frames from videos entirely in the browser.
Link: https://video-to-image.com
The Problem I frequently need to grab specific high-res frames from video footage for thumbnails or documentation. Opening heavy desktop editors (Premiere/Resolve) is overkill for this single task, and existing web tools usually require uploading the file to a server (privacy risk + bandwidth constraints) or result in compressed, low-quality output.
How It Works The application runs 100% client-side with no server-side processing for the video files.
Local Loading: It uses URL.createObjectURL to load the local file into an HTML5 video element. The binary data never leaves your device.
Frame Capture: To extract a frame, the app seeks the video element to a specific timestamp and draws the content to an off-screen <canvas>. This allows us to export the image data as a Blob (PNG/JPG/WebP) while preserving the original video resolution (up to 4K).
AI Quality Scoring: To solve the problem of selecting the best frame among similar ones, I implemented a client-side analysis engine. It evaluates pixel data from the canvas context for sharpness (focus), contrast, and exposure. It assigns a quality score (0-100) and flags blurry frames, which is particularly useful for filtering out motion blur in batch exports.
Technical Challenges
Seeking Precision: One of the biggest hurdles was video.currentTime seeking. Browsers often snap to the nearest keyframe rather than the precise timestamp requested, especially with inter-frame compression like H.264. I had to implement logic to verify the seek position.
Memory Management: Batch exporting hundreds of 4K frames for a ZIP download quickly hits browser memory limits. I implemented a queue system to process, compress, and release objects from memory in chunks to prevent crashes on lower-RAM devices.
Limitations
Codec Support: Since it relies on the browser's native decoding capabilities, file support is limited to what your browser can play (e.g., H.265/HEVC support is inconsistent across Chrome/Firefox/Safari).
Performance: Decoding high-bitrate 4K/60fps footage entirely in the browser can be CPU-intensive.
I’m happy to answer any questions about the implementation or the client-side stack. Feedback on the quality scoring algorithm is especially welcome.
Thanks!

value: Show HN: Video to Image – Client-side frame extraction with AI quality scoring


value:
LLM chat breaks when you're learning. Side questions either clutter the main chat, or you copy/paste into a new chat and lose the context.
Tangents makes the workflow explicit. You can branch off any message to chase a rabbit hole, then merge the findings back without polluting the main thread.
Key Features:

  - Branching: Select text in any message to fork a new chat.

  - The Collector: Highlight snippets across different branches to build a "shopping cart" of context.

  - Compose: Send a prompt using only what is in your Collector (explicit context control).

  - Console: Inspect exactly what context is being sent to the LLM before you hit enter.

How it's different:
It is not a node-graph canvas. It keeps the linear chat UI but allows inline branching. It is not an agent framework; it is a tool for humans who want manual control over the LLM's context window.
-----
View it here: https://tangents.chat/hn
Note: Currently supports OpenAI (BYOK supported).

value: Show HN: Tangents – Non-linear LLM chat with hands-on context control


value: atharvashah

value:
Most tools let you add tasks forever.
This one doesn’t.
One main goal.
Eight subgoals.
Eight actions each.
Runs entirely in the browser. No accounts. Exportable.
This is a client-only app. No backend. No auth.
The grid is intentionally finite. You get 64 action slots. That constraint is the point. Built it because infinite lists made prioritization worse.
Import/Export works seamlessly.
Looking for feedback from people who feel stuck planning big goals.
Happy to answer technical or design questions.

value: Show HN: 9×9 goal grid for multitaskers (No back end, No login, No Cost)

author: atharvashah