value: iwantmyhatback

value:
For my ML projects, I wanted a way to run jobs with cloud compute that was as simple as running commands locally. I also wanted it to be language agnostic (I work with Python and Julia), and easy to string together jobs, run in different environments, into ad hoc pipelines. Finally, I wanted it to be cloud provider independent.
So I created o-o, a CLI for easily running jobs on GCP and Scaleway (more cloud providers to come) and would appreciate any and all feedback. Please check it out:
homepage: https://o-o.tools/
source | issues | mailing-list: https://sr.ht/~ootools/oocli/

value: Show HN: A simple CLI for running ML jobs (or any jobs) with cloud compute

author: iwantmyhatback


value: diginova

value: Show HN: Space Pong

author: diginova

title: Show HN: Space Pong


value: We built a product that can take in text to describe your circuit and generate the electronics for you in minutes. Reach out to hi@silixon.io so I can send you our product to try out.

value: Show HN: Natural language in. Working electronics out. In minutes


value: Show HN: Vibe Pulse – One place to approve all Claude Code operations


value:
Hey all,
This is a project I’ve been working on over the last year.
In addition to combining data from multiple federal sources into a single UI, I built a 2,500+ rule regex-based parser / pseudo state machine that classifies every legislative action into discrete states and stages. This makes it possible to generate a day-by-day timeline of what happened to every bill over the last 50 years, and a graph showing how many (and which) bills occupy each major legislative state at any point in time. In total, 1,555,069 actions are parsed into 1,157 unique enums across 41 stages.
I also fully re-parsed the official bill text XML into a modern format and recreated the large bill-text XLS styling system in CSS, which dramatically improves load times and (to my knowledge) is the first near-complete recreation of that XLS styling in CSS.
Hope you find it interesting :)

value: Show HN: Interactive Timeline of US Legislation (1975–Present)


value: janbalangue

value:
I’ve been working on a small, design-first async bulkhead for Java.
It focuses strictly on admission control:
– bounds in-flight async operations
– fails fast under saturation
– never queues or waits
– defines permit lifetime explicitly (admitted → terminal)
v0.3.1 is a small patch release that fixes cancellation classification in observability (wrapped CancellationException is now reported as CANCELLED), without changing runtime behavior.
I’m interested in feedback from people who’ve dealt with overload, fan-out amplification, or unclear async semantics in Java systems.

value: Show HN: An async bulkhead for Java with explicit overload semantics

author: janbalangue


value: dakom

value: Show HN: AwsmRenderer, a browser-native WebGPU renderer in Rust

author: dakom


value:
Hi HN,
We recently built a QuickBooks integration for admin.flexprice.io, our usage-based billing system.
The goal was to build a reliable bridge between modern billing models (usage, metered charges, commitments) and traditional accounting workflows.
Key design choices:
- One-way invoice sync (billing → accounting)
- Automatic customer and service-item creation
- Entity mapping to prevent duplicates
- Inbound payment sync via QuickBooks webhooks
- Clear separation of responsibilities between systems
Sharing in case this is useful to others dealing with similar billing → accounting gaps here!
Happy to answer questions if any, we have the docs here: http://docs.flexprice.io/integrations/quickbooks
If you would like to jump in-depth, we also have a open-source community and would love to see you there: http://bit.ly/4huvkDm

value: Show HN: Usage-aware QuickBooks sync for billing systems


value: grebnov

value:
I wrote a single-header CUDA radix sort library that's 1-6% faster than CUB for 32-bit keys and up to 38% faster for small types.
Why bother? CUB's radix sort is already memory-bound, which is theoretically optimal. But CUB's codebase prioritizes backward compatibility and generality across GPU generations, leaving room for targeted optimizations on modern hardware.
Benchmarks (RTX 5090, 67M elements):
int32_t keys: 1.53ms vs 1.62ms (+6%)
int8_t keys: 0.19ms vs 0.25ms (+32%)
int32_t pairs: 3.07ms vs 3.10ms (+1%)
What's different:
Implements OneSweep with decoupled lookback
PDL (Programmatic Dependent Launch) overlaps histogram with first sort pass on Hopper+
Fine-grained PTX cache hints to avoid polluting L2
CUDA Graph caching drops launch overhead from ~100μs to ~5μs
Auto-tuned tile sizes for 48 type combinations
The other goal is education. CUB is harder to read. I have tried to make every optimization decision explicit in the comments — not just what the code does, but why the GPU hardware forces that choice.
GitHub: https://github.com/IlyaGrebnov/libcusort
Happy to answer questions about GPU radix sort internals or the specific optimizations.

value: Show HN: Libcusort – A radix sort for modern Nvidia GPUs

author: grebnov


value: rodricios

value:
wxpath is a declarative web crawler where web crawling and scraping are expressed directly in XPath.
Instead of writing imperative crawl loops, you describe what to follow and what to extract in a single expression:

    import wxpath

    # Crawl, extract fields, build a Wikipedia knowledge graph
    path_expr = """
    url('https://en.wikipedia.org/wiki/Expression_language')
         ///url(//main//a/@href[starts-with(., '/wiki/') and not(contains(., ':'))])
             /map{
                'title': (//span[contains(@class, "mw-page-title-main")]/text())[1] ! string(.),
                'url': string(base-uri(.)),
                'short_description': //div[contains(@class, 'shortdescription')]/text() ! string(.),
                'forward_links': //div[@id="mw-content-text"]//a/@href ! string(.)
             }
    """

    for item in wxpath.wxpath_async_blocking_iter(path_expr, max_depth=1):
        print(item)

The key addition is a `url(...)` operator that fetches and returns HTML for further XPath processing, and `///url(...)` for deep (or paginated) traversal. Everything else is standard XPath 3.1 (maps/arrays/functions).
Features:
- Async/concurrent crawling with streaming results
- Scrapy-inspired auto-throttle and polite crawling
- Hook system for custom processing
- CLI for quick experiments
Another example, paginating through HN comments (via "follow=" argument) pages and extracting data:

    url('https://news.ycombinator.com',
        follow=//a[text()='comments']/@href | //a[@class='morelink']/@href)
        //tr[@class='athing']
          /map {
            'text': .//div[@class='comment']//text(),
            'user': .//a[@class='hnuser']/@href,
            'parent_post': .//span[@class='onstory']/a/@href
          }

Limitations: HTTP-only (no JS rendering yet), no crawl persistence.
Both are on the roadmap if there's interest.
GitHub: https://github.com/rodricios/wxpath
PyPI: pip install wxpath
I'd love feedback on the expression syntax and any use cases this might unlock.
Thanks!

value: Show HN: wxpath – Declarative web crawling in XPath

author: rodricios


value: sniner

value:
Hey HN! We built a tool that uses eBPF to discover AI services and their data flows in Kubernetes clusters.
Modern AI apps often follow this pattern:
1. Service receives request
2. Queries database (PostgreSQL/Redis/MongoDB)
3. Sends data to LLM API (OpenAI/Anthropic/Bedrock)
4. Consumes or returns the AI generated response
Security teams often don't know:
- Which services are making AI calls
- What databases they're accessing first
- Whether PII is being sent to third-party APIs
- What libraries and packages are being used for AI
Our eBPF based tool attaches to network and fs syscalls to observe:
- Outbound connections to AI API endpoints (pattern matching on domains/IPs)
- Database protocol detection (PostgreSQL, MySQL, MongoDB wire protocols)
- Service-to-service communication within the cluster
- Libraries invoked by processes (PyTorch, HF, OpenCV etc)
Architecture:
- eBPF with C in kernel space
- Go userspace agent processes events
- Results sent to in-cluster exporter
- Next.js for visualization
GitHub: https://github.com/aurva-io/AIOstack
Demo: https://aurva.ai
Questions for you guys:
1. What classifications/buckets would you like to see for apps?
2. Other protocols/services we should detect?
3. Performance overhead-what's acceptable in prod?

value: Show HN: AIOStack – Using eBPF to Secure AI Services in Kubernetes

author: sniner


value: bluehuman

value: Show HN: Lazypg – A simple terminal UI for PostgreSQL

author: bluehuman


value: wowzzz

value: Show HN: Cybercore CSS – Cyberpunk Design System

author: wowzzz


value:
I struggle with (self diagnosed ADHD) so I built a tool to easily capture my every thought, stick everything in a big pile that later I can search, sort, and do something with.
Related and really interesting: https://news.ycombinator.com/item?id=46610156

value: Show HN: A tool to capture my every ADHD thought


value: sargizsakoo

value:
Hi HN,
I built ClaimVault after seeing how overwhelming insurance claims become when people don’t have photos, receipts, or proof ready.
The idea is simple: help people organize home inventory, photos, videos, and documents in one place before something like a fire, flood, or theft happens.
Would love feedback on the approach, UX, or whether this solves a real problem for you.

value: Show HN: ClaimVault – Proof for Insurance Claims

author: sargizsakoo


value: lowdanie

value: Show HN: Differentiable Quantum Chemistry

author: lowdanie


value: antomal

value:
I built GRSH because I wanted a modern, memory-safe shell that feels native to FreeBSD but works seamlessly on macOS.
While there are many shells out there, GRSH is my take on a minimal, fast, and secure command interpreter written entirely in Rust. It's designed for users who want the safety guarantees of Rust without the overhead of more bloated alternatives.
I'm currently working on the official FreeBSD port. I’d love to get feedback on the shell's behavior and performance from the community.
Github: https://github.com/antoniomalara301289/grsh

value: Show HN: Grsh – A high-performance shell for FreeBSD written in Rust

author: antomal


value: ggange

value:
Hi all, I have just published MCP Review - an open-source platform where developers can rate and review MCP Servers.
The goal is to solve a problem I kept running into: there are thousands of MCP (Model Context Protocol) servers out there, but no easy way to know which ones are actually good, reliable, or worth your time. Many MCP repositories exist but the evaluation of the servers - when present - is managed by the administrator of the repo; reviews and tales of experience by real users are then scattered on Reddit or Discord, making the experience of building AI workflows long and complicated.
In MCP Review, anyone can review and rate servers, helping others in the choice of the best tool for their needs. Reviews and rates are tied to a GitHub account, so we prevent abuse and visitors can verify the competence of the reviewer.   At the moment, I built the infrastructure's main feature and I am encouraging developers to upload their work and join the community. It takes less than 2 mins if a public Github repo is available and the Server card is highly customisable, from description to tool list to custom icon.
The app is built with
 - Next.js 16 (App Router) + TypeScript
 - PostgreSQL + Prisma
 - NextAuth.js (GitHub)
 - Tailwind CSS + Radix UI
And it is fully open-source, any contribution is welcome (https://github.com/ggange/mcp-review).
You can browse servers without signing in. Authentication (GitHub) is only needed to rate or upload servers.
I am continuously working and I'd love feedback on the rating/review system, search and filtering UX, what features would make this more useful and any bugs or issues you encounter.
Thanks for checking it out!

value: Show HN: MCP Review – An Open-Source Platform to Rate and Review MCP Servers

author: ggange


value:
For the past year I've been working to rethink how AI manages timing in conversation at Tavus. I've spent a lot of time listening to conversations. Today we're announcing the release of Sparrow-1, the most advanced conversational flow model in the world.
Some technical details:
- Predicts conversational floor ownership, not speech endpoints
- Audio-native streaming model, no ASR dependency
- Human-timed responses without silence-based delays
- Zero interruptions at sub-100ms median latency
- In benchmarks Sparrow-1 beats all existing models at real world turn-taking baselines
I wrote more about the work here: https://www.tavus.io/post/sparrow-1-human-level-conversation...

value: Show HN: Sparrow-1 – Audio-native model for human-level turn-taking without ASR


value: maaydin

value:
Hi HN,
I built DanceJump as an experiment in making rhythm games more accessible. It overlays arrows on top of any YouTube video and lets you play directly in the browser using a keyboard, controller, or USB dance pad.
It’s not meant to replace DDR or StepMania style simulators, but rather to make it possible to jump into songs that don’t normally have charts especially for quick or casual/family play.
It currently ships as a Chrome extension because it needs tight integration with the YouTube player and low-latency input handling. Everything runs fully client-side, no accounts, no tracking.
This started as a way to generate playable charts for songs that don’t normally exist in rhythm game libraries. I’d really value feedback on timing accuracy, input latency, and whether this feels usable compared to traditional setups.

value: Show HN: DanceJump For YouTube – turning videos into browser rhythm game

author: maaydin


value:
If you record videos regularly and end up with a messy clips folder, I built a macOS app to help.
AlgoMommy organizes raw video files into an existing folder hierarchy based on short spoken instructions you say inside the recording (e.g. “Hey Cleo, this is wedding B-roll - tag it green” or “Hey Cleo, this is a New York sunrise”). After recording, drop the clips into AlgoMommy; it listens for the instructions you said during recording and copies the files to the appropriate sub-folder.
Download (DMG):
- https://download.algomommy.com/app/macos/public/AlgoMommy-1....
- 492 MB - most of this is WhisperKit, signed & notarized
- sha256: de354d073467aece719433f170f1886c5ab781835e4caccc4054827ee3320ee5
Demo video (48s):
- Youtube: https://www.youtube.com/watch?v=Ucj-D9yOKBc
- Raw MP4: https://download.algomommy.com/public/AlgoMommy.mp4
Try it now:
1) Install the DMG and log in with this shared demo account:

  user: hn@algomommy.com
  pass: hnpass2026

2) Choose a target root folder (you currently need to pre-create your folder hierarchy).
3) Drag & drop a few videos and click "Organize videos"
Auth is required because the service uses paid LLM calls.
What leaves your machine / privacy:
- No raw video or audio is uploaded.
- Audio is extracted + transcribed locally.
- The only data sent is: (1) ~30s text transcription snippets for segments that appear to address “Cleo”, and (2) the list of relative destination folder paths under the root you selected (so the model can choose a folder).
- Those snippets are used to decide destination folder + tags/metadata.
Why “Cleo” (and why natural language):
- WhisperKit is accurate but slow, Apple's SpeechAnalyzer is fast but less accurate. AlgoMommy uses SpeechAnalyzer to quickly find "Cleo"-addressed segments, then re-transcribes just those ~30s chunks with WhisperKit for accuracy.
Safety:
- AlgoMommy only "copies" videos, it never "moves" / "overwrites" videos.
Inspiration:
- Initially this was a Python script for my partner, to solve this very issue. I subsequently decided to "productize" the solution as a macOS app.
I’m looking for feedback on:
1) Does this solve a significant problem for you?
2) Is the workflow clear and robust in real-world usage?
3) Today you must pre-create the folder hierarchy: is that acceptable, or should the app be able to create target folders in some cases? If folder creation is valuable, what rules would make it safe/predictable?
4) Any voice commands you’d want beyond “organize/tag this clip” (e.g. “start a new video file here”)?
Happy to answer questions and go deep on implementation details if anyone’s interested.

value: Show HN: AlgoMommy – Organize video clips by talking while recording (macOS)


value: abdibrokhim

value: last poster went pretty viral

value: Show HN: AI Vibe Coding Hackathon

author: abdibrokhim

story_text: last poster went pretty viral

title: Show HN: AI Vibe Coding Hackathon


value: matheusml

value:
I wanted to find an iPad game where my 5yo could learn math, which sounded simple.
Turns out most kids' educational apps are... shady. Notifications, streak mechanics, ads for games definitely not meant for children, coin systems and flashy rewards designed to maximize engagement rather than learning.
So I decided to vibe code something for her.
The result is Lumi. It's a simple math app with:
- No ads, no accounts, no tracking
- No notifications
- No coins, streaks, or variable reward nonsense
- Daily limits (because kids should go play outside)
- Works offline, stores everything locally
- Supports English, Portuguese, German, French (more to come)
My daughter has been using it for a while now and actually enjoys it. The problems adapt to her level, and when she hits the daily limit, it just tells her to go do something else.
It's completely free and open source. I built it for her, but figured other parents might find it useful too.
https://playlumi.app/
https://github.com/matheusml/lumi
Happy to answer questions about the tech stack (SvelteKit, TypeScript), decisions, or anything else

value: Show HN: A kids' math app without dark patterns

author: matheusml


value: MrTravisB

value:
Hi HN,
My team and I are building Tabstack to handle the "web layer" for AI agents. Launch Post: https://tabstack.ai/blog/intro-browsing-infrastructure-ai-ag...
Maintaining a complex infrastructure stack for web browsing is one of the biggest bottlenecks in building reliable agents. You start with a simple fetch, but quickly end up managing a complex stack of proxies, handling client-side hydration, and debugging brittle selectors. and writing custom parsing logic for every site.
Tabstack is an API that abstracts that infrastructure. You send a URL and an intent; we handle the rendering and return clean, structured data for the LLM.
How it works under the hood:
- Escalation Logic: We don't spin up a full browser instance for every request (which is slow and expensive). We attempt lightweight fetches first, escalating to full browser automation only when the site requires JS execution/hydration.
- Token Optimization: Raw HTML is noisy and burns context window tokens. We process the DOM to strip non-content elements and return a markdown-friendly structure that is optimized for LLM consumption.
- Infrastructure Stability: Scaling headless browsers is notoriously hard (zombie processes, memory leaks, crashing instances). We manage the fleet lifecycle and orchestration so you can run thousands of concurrent requests without maintaining the underlying grid.
On Ethics: Since we are backed by Mozilla, we are strict about how this interacts with the open web.
- We respect robots.txt rules.
- We identify our User Agent.
- We do not use requests/content to train models.
- Data is ephemeral and discarded after the task.
The linked post goes into more detail on the infrastructure and why we think browsing needs to be a distinct layer in the AI stack.
This is obviously a very new space and we're all learning together. There are plenty of known unknowns (and likely even more unknown unknowns) when it comes to agentic browsing, so we’d genuinely appreciate your feedback, questions, and tips.
Happy to answer questions about the stack, our architecture, or the challenges of building browser infrastructure.

value: Show HN: Tabstack – Browser infrastructure for AI agents (by Mozilla)

author: MrTravisB


value: thymathgeek

value:
Hi HN,
Would appreciate any feedback on my working prototype!
Cloud Code allows you to programmatically invoke a command-line coding agent. The agent runs in a cloud sandbox, so there's no need to install anything locally. Cloud Code makes it easy to incorporate coding agents in Zapier/n8n automations or build them into your app.
How it works
1. Sign in with Github
2. Enter your Gemini API key (ChatGPT and Claude support coming soon)
3. Send a request to the API endpoint shown with the name of your Github repo and instructions for the agent. It will make the changes you request and publish a PR. You can also specify a callback URL. The agent will send a response to that URL when it completes its task.
Example use cases
- Whenever a new error or alert occurs in your app, automatically trigger an agent to investigate and fix it.
- Whenever a new engineering task is created for your team, trigger an agent to estimate the task's difficulty and sketch out an implementation.
- Non-technical colleagues, such as customer service reps, can refer technical questions to the agent (without needing to ask a developer).

value: Show HN: Cloud Code – Launch coding agents via API

author: thymathgeek


value: andrexibiza

value: Show HN: Connect Claude AI to iMessage/WhatsApp via Poke MCP

author: andrexibiza


value:
Hey HN,
I’ve been building a few color and image-related tools with a focus on ease of use, solid UI/UX, and correctness as a hobby project.
What makes these different from other online tools? Very often I needed free, simple, yet powerful utilities for these little tasks and couldn’t find anything that fit, so I ended up building them myself (100% client-side, no sign-ups required!)
Color Palette Generator: Uses the OKLCH color space (instead of RGB) to generate perceptually the most distinct colors for a given scheme. It also includes sequential palettes and palette generation from an image for convenience.
Smart Color Replacer: Uses HSV-based fuzzy matching, supports multiple input-output color pairs (something I couldn’t find elsewhere), and preserves original highlights and shadows by replacing only hue. It also includes a “magnetic lasso”-style tool that snaps selection vertices to detected object boundaries (not perfect yet - I’m working on additional selection modes) to limit replacements to specific areas.
Color Mixer:A pretty simple mathematical Color averager, but allows you to input colors in multiple spaces (just write anything in the textbox, or 'bulk' copy and paste!), and adjust input and output colors quickly by clicking on the swatch.
Image Blender: Fast, simple, no frills client-side image blending. Change opacity if you need.
I’d love to hear your kind suggestions or feedback!

value: Show HN: 'Irrational' Tools – Perception-first color/image utilities


value: masterpos

value:
Hi everyone,
Repomance is an app for discovering curated and trending repositories. Swipe to star them directly using your GitHub account.
It is currently available on iOS, iPadOS, and macOS. I plan to develop an Android version once the app reaches 100 users.
Repomance is open source: https://github.com/mpospirit-apps/Repomance-iOS
All feedback is welcome, hope you enjoy using it.

value: Show HN: Repomance: I made a Tinder like app that you can discover & star repos

author: masterpos


value: pdrojack

value:
TL;DR: Mobile notifications for AI workflow approvals. Built it because running 5+ AI agents at once is chaos.
The problem:
This paragraph is the longest thing I've written by hand in weeks. Everything else? AI-generated across 5 browser tabs (GPT, Gemini, Claude) and multiple terminals running Claude Code.
They're FAST. They're GOOD. But here's what nobody tells you: you become the bottleneck.
I'd start 3 agents on different tasks, context switch between them, and lose track of which ones needed my input vs which ones were safe to auto-execute. Critical decisions got buried in terminal output.
What I tried:
Telegram bots (hacky, unreliable)
Slack integrations (too much noise)
Checking terminals every 5 minutes (defeats the purpose of automation)
None of it worked.
What I built:
viahuman – a notification server that lets AI agents ping me when they need human approval.
How it works:
Integrated a local MCP server with my LLMs
Told them: "Run autonomously, but notify me for important decisions"
They send mobile push notifications when done or stuck
I approve/provide context from my phone
They adapt and continue

value: Show HN: ViaHuman, app for LLMs to send me notifications

author: pdrojack


value: pavelmolodecfd

value:
Hi HN! We built Nuria because we felt that traditional calorie tracking is often too tedious and focused on the wrong things.
Nuria is designed to be a friendly partner on your journey to a body you create yourself. You can track your food in the way that feels most natural to you—using photos, text, or voice. Beyond just tracking, Nuria helps you build sustainable eating habits with personalized meal plans and recipe creation.
We'd love to hear your feedback!

value: Show HN: Nuria – Build better eating habits with photo, text, or voice tracking

author: pavelmolodecfd


value: mjomaa

value:
Hey HN,
I've been building SaaS apps for 12 years and got tired of rebuilding the same things every time. Not only for products, but also internal tools in our organization.
Things like admin panels, billing/credits, multi-organization support and even marketing pages are still surprisingly annoying and time-consuming to get right. Having these solved upfront makes a huge difference and you can use your Claude tokens for features right away.
What's in it:
- Authentication (Better Auth) - email/password, social, MFA, account linking, profile management, session management
- Multi-tenancy - organizations, invitations, roles, ownership transfer
- Billing – subscriptions, per-seat pricing, lifetime purchases,  trials, huge amount of webhooks supported
- Credits – usage-based billing for AI features
- Admin panel – user management, impersonation, ban user, manual email verification, billing sync
- AI chatbot – Vercel AI SDK with streaming and tool calling
- Marketing pages – landing, pricing, blog, docs (fumadocs), changelog, careers, about, legal pages
- Emails - all the email templates ranging from "forgot password" to "your trial has ended", etc.
Tech stack:
- Next.js 16 and React 19
- tRPC for end-to-end type safety
- Better Auth for authentication
- Prisma or Drizzle ORM (two separate versions)
- Tailwind CSS + shadcn/ui
- TypeScript with strict mode
Two ORM?
It's two versions, not at the same time. Prisma and Drizzle. Both versions have feature parity - pick what fits your workflow.
Pricing:
One-time purchase with lifetime team access. Use it for unlimited projects including client work.
Happy to answer any questions about the architecture, design decisions or specific features.
- Website: https://www.achromatic.dev
- Demo: https://demo.achromatic.dev
I’m planning to add TanStack-based variants and more opinionated, use-case specific starter kit included in the same license, such as:
- CRM starter kit
- Workflow builder starter kit
- Support/helpdesk starter kit
- etc.
Happy to hear feedback or answer questions.

value: Show HN: Achromatic – AI Ready Next.js 16 Starter Kit

author: mjomaa


value: modinfo

value: Show HN: AI file watcher that provides intelligent suggestions using local LLM

author: modinfo


value: Show HN: I built a collaborative browser-based beat maker (no login required)


value: odedfalik

value:
I built an unofficial CLI and MCP server for Lambda cloud GPU instances.
The main idea: your AI agents can now spin up and manage Lambda GPUs for you.
The MCP server exposes tools to find, launch, and terminate instances. Add it to Claude Code, Cursor, or any agent with one command and you can say things like "launch an H100, ssh in, and run big_job.py"

  Other features:
  - Notifications via Slack, Discord, or Telegram when instances are SSH-ready
  - 1Password support for API keys
  - Also includes a standalone CLI with the same functionality

Written in Rust. MIT licensed.
Note: This is an unofficial community project, not affiliated with Lambda.

value: Show HN: A fast CLI and MCP server for managing Lambda cloud GPU instances

author: odedfalik


value:
I’ve mostly stopped using Apple TV as every app wants another subscription these days - I mostly just connect my laptop via HDMI.
That works fine until you need to pause or click something. Surely there must be a way to use the Apple TV remote for this I thought. I was surprised that there was not (at least not in a simple, open way), so I started poking at how the Siri Remote communicates with macOS and spent a weekend mapping its inputs to cursor movement, scrolling, and media controls. The result is a small menu bar app called Remotastic.
It's simple, written in Swift, built mostly for my own comfort but I figured let's open source it as I'm sure somebody else will be looking for the same thing!
https://github.com/lauschue/Remotastic

value: Show HN: Controlling macOS with an Apple TV Remote


value: urjit

value:
Hi everyone,
I've spent the last year using tools like NotebookLM and ChatGPT for stuff ranging from studying, research, and writing. Its been okay, but I've found that this standard chat interface has been a bottleneck for sustained work. The answers are useful, but all of the information remain limited in linear, ephemeral threads than would also span across multiple conversations.
ThinkEx is an open-source alternative that augments the normal the chat interface with a spatial, grid-like canvas. It works like a physical desk: instead of your context scrolling away or getting lost across different windows, you spread out PDFs, videos, and notes side-by-side to interact them easily.
Its fully open source as well :)

value: Show HN: Rethinking the user interface of AI, open source<3

author: urjit


value: luthiraabeykoon

value:
I’ve been iterating on vid2ascii over the past couple of months and wanted to share a progress update.
vid2ascii is a browser app that converts video into high-resolution ASCII art in real time. The main goal was to push quality and performance further than the typical canvas or WebGL approaches by moving the heavy work onto the GPU using WebGPU compute.
Recent improvements since the initial version:
Switched from CPU-only rendering to GPU-backed WebGPU compute for per-frame processing
Much higher effective resolution and frame rate, even on large videos
Full RGB color ASCII output instead of grayscale only
Better luminance mapping and character selection for sharper detail
Real-time controls for contrast, brightness, and character sets
Video export support (.webm), not just live playback
The original prototype started as a quick experiment, but most of the work since then has been about making it actually usable and performant for longer videos and higher resolutions.

value: Show HN: Real-time video to high-resolution ASCII using WebGPU (major updates)

author: luthiraabeykoon


value: SeanDorje

value:
hi my name is sean dorje (yc x25).
i built harmony because our team's been running on discord for years and we've been dying for something like this so we can finally track our meeting notes/action items.
if your team runs on discord, please feel free to try it out!
it's free to use forever :)

value: Show HN: Harmony – AI notetaker for Discord

author: SeanDorje


value: Show HN: Extract Structured Data from Any Web Page


value: Nortca

value:
Prediction markets are having a moment, but searching them is painful:
- Markets are spread across 9+ platforms
- Each platform has different UX and search capabilities
- No way to compare similar markets across platforms
- Finding new markets on topics you care about requires manual checking
I built UPMI to solve this. One search queries all platforms, AI scores relevance, and you get a unified table of results sorted by match quality.
The architecture is fairly straightforward:
- Firecrawl maps platform URLs in parallel
- Gemini Flash fetches + analyzes actual market pages
- Streaming SSE for progressive UI updates
- Chat interface for deeper analysis on selected markets
What I learned:
- URL context in Gemini is powerful but rate-limited (throttling required)
- Structured outputs need careful schema design or you get hallucinations
- Real-time streaming UX is hard but worth it for perceived speed
Tech: Next.js 16, React 19, Gemini API, Firecrawl, Neon Postgres
Try it: [URL]
Looking for feedback on relevance scoring and whether this is useful to actual traders vs. just a fun project.

value: Show HN: I made a search engine for prediction markets

author: Nortca


value: dkrychowski

value: Show HN: FormTS – Define forms with TypeScript instead of drag-and-drop

author: dkrychowski


value: igomeza

value: Show HN: Experimentplatform, A/B testing images with LLMs

author: igomeza


value: MrGrife

value:
Hi HN, I built a Chrome extension that helps during live interviews.
Flow is simple: press Record, capture the interviewer’s question, it gets transcribed, and you get a structured answer in real time.
I recently added a screenshot feature because many interview prompts are visual (coding tasks, system design prompts, error output on screen). You can take a screenshot and the AI generates a response based on what’s displayed.

value: Show HN: VoiceMeetAI – a Chrome extension for real-time interview Q&A

author: MrGrife


value: codingstark

value: Show HN: Mailbak – Email backup tool with a cyberpunk TUI built in Bun

author: codingstark


value: peterspath

value: Show HN: Top Four – a directory of /top4 pages

author: peterspath


value: SpicyG

value: I wrote this to describe an execution model where recovery is enforced locally instead of inferred from history. Rather than retries replay or coordination each unit admits or rejects state and input pairs and resets immediately when constraints are violated. Recovery cost is constant failures do not correlate and tail latency never forms because there is no recovery negotiation. This is not about availability theater or smarter retries but about refusing to remain broken.

value: Show HN: Context-Free Recovery via Constant-Time Enforcement

author: SpicyG


value: aanogueira

value:
Hi HN,
I built Code Search because I got tired of the gap between "finding code" and "fixing code" at scale.
The workflow I wanted: search for a deprecated pattern across all my repos, preview the replacements, then have the tool create branches and open merge requests automatically. Existing tools either couldn't do this or required enterprise infrastructure I didn't have.
What it does:
- Sub-second regex search using Zoekt (trigram indexing)
- Bulk find-and-replace across repositories
- Automatic branch creation and MR/PR opening
- Web UI, CLI, and REST API
- Connects to GitHub, GitLab, Bitbucket, Gitea
Tech: Go backend, Next.js frontend, runs on Docker Compose.
I've been using it to manage ~1,000 repos. The bulk replace feature alone has saved me hours of tedious work.
Feedback welcome, especially on the architecture decisions documented.

value: Show HN: A self-hosted code search with bulk replace and auto PRs

author: aanogueira


value:
Hi, I built a small experiment around discussions and opinions.
Instead of a global feed, everything is organized into topic-based channels, so conversations stay contextual and don’t disappear over time.
There’s no content yet — I’m sharing this at an early stage and looking for participants.
The idea is to make disagreement readable, letting different viewpoints live side by side without optimizing for engagement or timelines.
Thanks to anyone who takes a look or shares their thoughts.

value: Show HN: A discussion-first community for opinions


value:
Hi HN,
I’m Alex. I previously worked as an engineer at Google, and I’m building Nauma (https://nauma.ai).
The idea came from trying to plan my own finances and watching friends in tech do the same. Once you have equity compensation, uneven income, high taxes, and early-retirement decisions, spreadsheets become fragile and hard to use very quickly. It's hard to reason about taxes, timing, and uncertainty at the same time.
The alternative most high-net-worth families use is advisor software behind an AUM model. In practice, that means paying ~1% of assets every year, with costs rising as portfolios grow. More importantly, that model tends to bias advice toward keeping assets managed, even when people want to use their money (buy a house, start a company, diversify a concentrated position, donate, or retire earlier). Nauma stands for "No AUM".
Nauma is an attempt to build the tool I wish existed: transparent, scenario-driven financial planning that lets people reason about tradeoffs themselves. Instead of focusing on investments, Nauma focuses on life decisions and shows their long-term tax and cash-flow impact.
What it does
Models long-term projections with multiple scenarios (retire early vs. later, move states, rent vs. buy). Handles U.S. tax complexity (progressive brackets, capital gains, RMDs, Roth conversions). Models taxation across account types (brokerage, 401(k), IRA, Roth, 529, HSA). Helps users reason about long-term goals and tradeoffs, including the risk of over- or under-saving. Connects brokerage accounts to track net worth and investments automatically. Designed for people with equity compensation, uneven income & expenses, or non-linear careers
The goal is to make advisor-grade modeling accessible without requiring blind trust in a black box or paying ongoing fees tied to asset size.
The app is live at https://nauma.ai.
You'll need to sign up, but then you can try the demo mode. You can explore scenarios, connect your brokerage accounts for free, and I’m especially interested in feedback on modeling assumptions, edge cases, and where this approach breaks down.
Happy to answer questions or discuss how others here think about long-term planning.

value: Show HN: Nauma – financial planning for people in tech


value: Show HN: Muti Metroo, my multi-hop VPN-like mesh tunnel with no root privileges


value: jshchnz

value:
I found myself frequently wanting to schedule tasks in Claude Code (both one-time and recurring) so I built a CC plugin to help with that.
To install:
/plugin marketplace add jshchnz/claude-code-scheduler
/plugin install scheduler@claude-code-scheduler
Then just tell Claude what you want (some examples):
Every Wednesday at 3am find dead code: unused functions, unreachable branches, commented-out code, and unused imports. List by file with line numbers.
Schedule a code review every weekday at 9am. Review commits from the last 24 hours, check for bugs, security issues, error handling gaps, and code that needs comments. Summarize with file:line references.

value: Show HN: Claude Code Scheduler

author: jshchnz

title: Show HN: Claude Code Scheduler


value: Sean-Der

value: Show HN: quick-sync. TikTok-esque video switch using WebRTC

author: Sean-Der


value: RileyHilliard

value:
Hey HN,
I had Mac Minis sitting in the corner doing nothing and a laptop battery that tanks whenever I run tests when working from a coffee shop & on battery power. So I built a CLI that syncs code over SSH and runs commands remotely on my (usually) idle hardware. That's basically it.
```
    brew install rileyhilliard/tap/rr
    rr run "make test"
```
Where this got surprisingly useful: heavy TDD with Claude Code. When you're running swarm agents or sub-agents, they all want to run tests constantly to verify their work. Great in theory, but suddenly you've got 3-4 parallel processes all hammering your test suite at once on your laptop. Tests fail because they're stomping on each other, ports are already in use, your laptop is melting, etc.
rr handles the coordination automagically. It tries your LAN IP first, falls back to Tailscale when you're remote, and waits if someone else (which is probably you in another terminal) is already using the machine. Throw multiple hosts at it and it'll load balance across whatever's available.
```
    hosts:
      mini-1:
        ssh:
          - 192.168.1.50
          - mini1-tailscale
      mini-2:
        ssh:
          - 192.168.1.51
          - mini2-tailscale
```
The parallel execution part is where it gets quite nice. My test suite takes ~60s on one machine. Partitioned across three, it finishes in ~20s. Same tests, 3x faster. Agents checking work via TDD stay productive instead of sitting around waiting.
This isn't really a CI/CD thing (that's async, runs when you push). rr is for your active dev loop when you want results NOW so you can keep iterating.
Any hardware that holds an SSH connection works. Old laptops, cloud boxes, whatever. Minimal setup on the remote side.
https://github.com/rileyhilliard/rr

value: Show HN: Distribute AI agent test runs across your spare machines via `rr`

author: RileyHilliard


value: yavuzyildirim

value:
I built this Chrome extension to solve my daily RAM problem. Chrome was constantly eating 8-10GB of memory with all my open tabs.
Smart Tab Suspender automatically suspends tabs you haven't used in a while, freeing up memory without closing them. Click back on a suspended tab and it instantly reloads.
Key features:
- Auto-suspend after configurable idle time
- Whitelist for important tabs
- Manual suspend/unsuspend options
- No data collection or tracking
On my machine with 50+ tabs, it reduced Chrome's memory usage by ~60%.
The extension is free and open to feedback. Let me know if you have suggestions or find any issues!

value: Show HN: Smart Tab Suspender – Reduce Chrome memory usage by autosuspending tabs

author: yavuzyildirim


value: jwardbond

value:
Hello!
Forecats is a custom integration for Home Assistant that uses Nano Banana and some pictures of your cats to serve daily pictures of your kitties enjoying whatever weather is in store for the day.
Because I am using it to serve images to a Spectra 6 e-ink screen, it also includes some optional post-processing (dithering and LUT correction) to optimize the final image. I've written more about this in a blog post[1].
No dogs allowed, unless anyone can think of a suitable dog-related weather pun.
[1] Technical details:  https://secondthoughts.my/posts/projects/forecats/

value: Show HN: Forecats – Weather-themed images of your cats in Home Assistant

author: jwardbond


value: jongwony

value:
AI coding assistants often assume intent and execute. Sometimes that’s fast; often it means more time undoing than doing.
Epistemic Protocols is a plugin for Claude Code that inserts decision checkpoints—before irreversible actions, when multiple approaches exist, or when intent might be misread.
Three protocols:
- /lens(/prothesis) — before analysis, lets you choose the perspective (performance, ops complexity, data model fit, etc.)
- /gap(/syneidesis) — at decision points, surfaces potential gaps as questions
- /clarify(/hermeneia) — when your request might be ambiguous, helps refine intent
Unknown unknowns:
Even well-scoped requests hide blind spots—the unknown unknowns. Epistemic Protocols help surface them early:
/lens broadens the frame so you don’t miss critical perspectives;
/gap turns “things we didn’t think to ask” into concrete questions;
/clarify reduces ambiguity that masks hidden assumptions.
In short, they convert unknown unknowns into known considerations when change is still cheap.
Principle: the AI illuminates options; you choose. Recognition over recall—selecting from clear choices beats guessing.
GitHub: https://github.com/jongwony/epistemic-protocols
Example:
```
> /lens "Should I use Redis or PostgreSQL for this cache?"
```
Claude shows lenses (Performance, Ops complexity, Data model fit…). You pick what matters, then it analyzes through those lenses.

value: Show HN: Epistemic Protocols – Decision Checkpoints for Claude Code

author: jongwony


value:
Hello HN,
I’m David. I built Matriq because I was frustrated with the "Post-Production Scrub."
I had hours of B-roll and long-form content, but finding a specific 5-second clip (e.g., "a red car passing by" or "a specific quote about React state") meant manually watching the footage at 2x speed.
What I built:
Matriq indexes video content visually and aurally. It uses multimodal embeddings to understand scene context, action, and dialogue.
The Use Case:
While it works for general editing, I’ve found the best use case is Content Repurposing. Creators with 100+ hours of archives can now instantly find "viral hooks" or specific topics to turn into Shorts/Reels without re-watching old footage.
It’s in beta. I’d love you to try breaking it or give feedback on the retrieval accuracy.
Link: https://matriq.video

value: Show HN: I built a semantic search engine for video ("Ctrl+F" for mp4s)


value:
Hey HN,
I'm building KernDB - managed PostgreSQL hosted exclusively
in Germany.
If you're running a B2B SaaS in Europe,
your customers increasingly ask about data residency. With
US providers, you're one acquisition away from your data
falling under US jurisdiction (see: Neon → Databricks).
KernDB is:
- Branches for PostgreSQL DBs
- German servers (Hetzner)
- No US Cloud Act exposure
- Postgres provisioned in 60 seconds
- Zero-downtime scaling
- Automated Backups
I'm building for teams who need to tell their customers "your data never leaves
the EU" and actually mean it.
Looking for early users who deal with GDPR conscious
customers. What else would you need from a EU-native
managed PostgreSQL provider?
https://kerndb.com

value: Show HN: KernDB – Managed Postgres Under EU Jurisdiction (Germany)


value: RobinBrooksAgt

value: I've been looking for a way to stay on top of the technical evolution of distributed databases without drowning in marketing fluff. So I built CockroachDB Daily. It's a minimalist newsletter that does one thing: analyzes the day's core commits, architectural shifts (SQL/KV/Storage), and community discussions. High signal. Low noise.

value: Show HN: CockroachDB Daily

author: RobinBrooksAgt

title: Show HN: CockroachDB Daily


value: kevinbaur

value:
AI has made it easy to create convincing landing pages, testimonials, and claims about traction.
Trusers is a small effort to highlight verified paying customers for startups.
It verifies customer numbers and growth using the Stripe API, not self-reported data.
You can see:
- total paying customers
- month-over-month customer growth
- average revenue per user (lifetime average)
- customer growth over time
Feedback is very welcome.

value: Show HN: Cutting through AI noise with verified startup traction

author: kevinbaur


value: botwork

value: Show HN: I built a local RAG pipeline to index 28 years of my personal data [video]

author: botwork


value: kamxgal

value:
Hi HN,
Last year I started pushing the limits of my JavaScript text editor engine – wondering where the performance ceiling really is. Turns out it can go head-to-head with Monaco (VS Code) and CodeMirror in many scenarios.
To show what it can do, I built FlixLines: a web-based log viewer that opens huge files directly in the browser – often faster than klogg (which is a native desktop app).
Real numbers from my 2021 laptop:
- 10 GB log opens in ~10 seconds
- 20 GB in ~17 seconds
- Memory usage under 100 MB
- Smooth 165 FPS scrolling on my 4K screen, regex search, bookmarks, highlight rules
Everything happens 100% locally – no uploads, no installation, no server-side processing.
Try the free demo (2 GB limit per file, limited bookmarks & highlight rules):
https://flixlines.com/demo-app
Here is a short video showing opening a 10 GB file in ~10 seconds:
https://www.youtube.com/watch?v=_ZWFltvotKI
More details, benchmarks and features:
https://flixlines.com
Pro version (unlimited everything) coming very soon – attractive early-bird pricing planned.
Curious to hear your thoughts: what are your biggest pains when dealing with large log files?
Thanks!
Kamil

value: Show HN: FlixLines – opens 10 GB logs in ~10 seconds in browser (demo)

author: kamxgal


value: koconder

value: I built a walk-through example of a complex multimodal LLM agent used in a self-driving car example that can self optimize.

value: Show HN: Self Optimizing Self Driving Car Agent

author: koconder


value: I'm too lazy to keep copying from resume to GPT, job description to GPT, then copy back to the Doc then edit etc. Why not have an AI-powered tool that does it all for me with just a few clicks and easy adjustment?

value: Show HN: AnotherResumeBuilder – Yeah just another one, check it out


value:
Beni AI is a real-time AI companion for face-to-face conversations.
It’s built to feel emotionally natural, consistent, and personal, with long-term memory that evolves through interaction.
Try Beni AI here: >> https://thebeni.ai/

value: Show HN: Beni AI – Real-time face-to-face AI companion


value: felipe-pathwave

value:
I needed a tool to track all the LLM and REST calls between microservices in my system.
Since most current options seemed a bit overkill for what I needed - and I wanted to have fun - I decided to vibecode this.
Here are the docs with screenshots, explanations and guide (INTEGRATION_GUIDE.md) for your LLM to do the implementation for you: https://github.com/felipe-tonon/path_tracker/tree/main/docs
I'm hosting it at https://tracker.pathwave.io and you can use it for free as long as there's no abuse and you don't burn all my Google Cloud credits.
You just need to create an account, generate an API Key and voilà.
As always, feedback and contributions to the repo are more than welcome
Thanks

value: Show HN: Free observability tool to track your REST and LLM calls

author: felipe-pathwave


value:
Beni AI is a real-time AI companion for natural 1:1 conversations.
Unlike typical text-based character chat, Beni focuses on face-to-face interaction, consistent personality, and long-term memory that adapts to you over time.
We’re building Beni for users who want an AI that feels like a real presence rather than a scripted chatbot.
Try it here: >> https://thebeni.ai/

value: Show HN: Beni AI – video call with your AI companion


value: gaigalas

value:
Made this for myself.
I'm always picking up the guitar or bass during the day and playing something, and I dislike metronomes, preferring real drum beats as a backdrop.
Now I can just load it up on the phone or notebook and play along.
The beats are also easily shareable. All you have to do is copy the URL. For example:
https://alganet.github.io/quick-beats/#120|4/4|black-pearl|1...
Any feedback is appreciated!

value: Show HN: Quick Beats – minimalistic webapp (mobile and desktop) drum machine

author: gaigalas


value: kccanarch

value:
I got tired of reading PDF reports for Carbon Offsets that claimed to be "Protected Forests" but looked suspicious on Google Maps.
So I built Silent Earth—a standalone forensic engine (Python/React) to audit them mathematically.
The Stack:
* Ingestion: Scrapes Verra/Gold Standard registries for project coordinates.
* Telemetry: Queries the Sentinel-2 Satellite Constellation (via Microsoft Planetary Computer).
* Analysis: Calculates NDVI (Biomass Density) and performs spectral analysis on the claimed area.
* AXIOM Kernel: Cross-references industrial "shutdown" claims against Tropospheric NO2 levels (Sentinel-5P).
The Result: I routinely find "Verified" assets with an NDVI < 0.2 (Bare Soil).
The tool is currently local-only for privacy, but I'm planning to move the data stream to Snowflake.
Happy to answer questions about the geospatial stack (Rasterio/Shapely) or the satellite APIs.

value: Show HN: I built a satellite forensic engine to detect fraud in Carbon Markets

author: kccanarch


value: rgbjoy

value:
Welp... I finally shipped. This is my first real project. I wanted a checklist app the way I wanted it so I built chklst.
What’s different? Simple, drag & drop reordering, keyboard shortcuts, color labels. There’s a live demo on the landing page so you can try it without signing up.
Free accounts can create 1 list. Premium is $5/month for up to 25 lists + shareable lists. What do you think?
I built it with Next.js 16 + Turso/libSQL + Drizzle + Better Auth + Stripe.
https://www.chklst.xyz/
Would love feedback on onboarding, UX, and pricing.
Thanks everyone!

value: Show HN: Chklst – A Minimalist Checklist

author: rgbjoy


value: gzalo

value:
I designed and built a physical replica of a 1970s-style front panel microcomputer with 25+ toggle switches, 16 LEDs, and an LCD display. The brain is a Raspberry Pi Pico running an Intel 8080 CPU emulator.
The main twist: I decided to see how far I could get using Claude Code for the firmware. That and the web emulator were written almost entirely using Claude Code (Opus 4.5). I've kept the full prompt history here: https://github.com/gzalo/microcomputer/blob/main/ai_prompts....
It was able to create the emulator in just a few prompts! It really surprised me that it was able to make a WebAssembly version from the same code (compiled with emscripten) and get the physical layout of the panel from a given photo. It also created some simple working examples using 8086 instructions!
Repository: https://github.com/gzalo/microcomputer

value: Show HN: IMSAI/Altair inspired microcomputer with web emulator

author: gzalo


value: Show HN: Commosta – marketplace to share computing resources


value: hankwilliamsjr

value:
Hi everyone!
I recently built an end-to-end RAG app, and I needed to do some serious data extraction off the web. I realized that many web scraping tools index too heavily on the markdown style - so you end up with tons of noise in vector DBs and you can't track content diffs.
I built meter to fix that - extracts only the data you want, and notifies you either through webhook or a pull endpoint of any changes to that data over time.

value: Show HN: Detect changes and keep data in sync with meter's web scraper

author: hankwilliamsjr


value:
Hi HN,
I’m a solo developer and built PicPhoto while working on small e-commerce projects.
The tool focuses on product photography using reusable prompt templates, such as background replacement, cleaner lighting, and consistent styles. The goal is to help users get usable product images without learning prompt engineering.
Users can try it for free, and there’s an invite system where both sides get credits. The project currently has a few dozen users, mostly small sellers and creators.
I’d really appreciate feedback, especially on whether the prompt-template approach makes sense and what features would be most useful.

value: Show HN: A simple tool for product photos


value: alphatesterguy

value:
Hey HN,
I built tickk because I have ADHD and every productivity app felt like work. I'd have an idea, open an app, then spend 5 minutes deciding if it's a "task" or a "note" or which project it belongs to. By then, the thought was gone.
What it does:
- Talk into your phone/laptop → it transcribes and auto-categorizes into tasks, notes, or events
- Uses local NLP (compromise.js) - no data leaves your device
- Works offline, no account needed, completely free
The key insight: Capture first, organize later. Your brain shouldn't have to categorize while it's still thinking.
Tech stack:
- Next.js + TypeScript
- Web Speech API for voice recognition
- compromise.js for NLP classification (runs in browser)
- IndexedDB for storage (nothing hits a server)
- PWA installable, works offline
Why no AI?
I experimented with OpenAI/Claude APIs but found:
Latency killed the flow (you want instant feedback when brain-dumping)
Privacy concerns - productivity data is deeply personal
Local NLP handles "buy milk" vs "remember to call mom" just fine
Open source: https://github.com/digitalwareshub/tickk
Would love feedback, especially from other ADHD/neurodivergent folks. What's missing? What would make this actually useful for you?

value: Show HN: Tickk – Voice productivity app- local NLP, no cloud, no AI, no signup

author: alphatesterguy


value: aashikbaruwal

value:
Hi HN,
I’m the creator of Satya, an open-source AI learning companion designed for classrooms in Nepal who lack powerful computers.
The Problem:
Most EdTech assumes high-speed internet. In rural Nepal, 60% of students rely on 10-year-old hardware (think 3rd-gen Intel i3s with 4GB RAM) and have zero or spotty connectivity. They are completely locked out of the AI education revolution.
The Solution:
Satya runs entirely offline on this legacy hardware. It combines a local SLM (Small Language Model) with RAG to answer questions based on the official designated curriculum.
The Stack:
Model: Microsoft Phi-1.5 (Quantized to Q4_K_M). I found this to be the sweet spot for running CPU-only inference ~10-12s on an i3.
RAG: Local ChromaDB stores embeddings of Grade wise textbooks and teacher notes.
Diagrams: I couldn't afford Stable Diffusion, so I built a custom logic-based engine (Regex + Templates) to generate ASCII diagrams for concepts like "Photosynthesis" or "Database Schema" in <5ms.
Why not just use a bigger model?
This project operates under a strict "4GB RAM / No GPU" constraint. I've prioritized accessibility over having the "SOTA" benchmark scores. If it doesn't run on a dusty school laptop, it doesn't help our students.
The project is fully open source. I'd love feedback on further optimizing RAG for low-resource environments or specific SLM recommendations!
Repo: https://github.com/aa-sikkkk/satya/

value: Show HN: Satya – Offline-first AI tutor for rural schools (Phi-1.5 and RAG)

author: aashikbaruwal


value: Show HN: Dreamlux – Free AI video generator with no watermarks │


value: yazinsai

value:
I built this because I kept having the same frustrating experience: I'd be away from my laptop—on the couch, in a coffee shop, waiting somewhere - and I'd think of something I wanted to try with Claude Code. But CC is a CLI tool that runs on your machine, so I was stuck.
The obvious solution would be some kind of mobile app, but I didn't want to build a chat wrapper. I wanted the real Claude Code experience - the actual terminal, with all my files, my environment variables, my git repos. Just... on my phone.
So I built a WebSocket bridge. The server spawns a PTY session running Claude Code, and the frontend is just xterm.js in a mobile-responsive wrapper. Your phone connects over the tunnel, and you get a real terminal.
The interesting bits:
- Zero-config remote access: I'm using Cloudflare Tunnel (the free tier) so there's no port forwarding or firewall nonsense. Run bun start and you get a QR code with a public URL.
- Session persistence: This was important. I didn't want to lose my conversation if I locked my phone or switched apps. Sessions stay alive on the server, and you can reconnect hours later.
- Dev server preview: When you're building UI and Claude spins up a dev server, you can preview it right in the app. The server detects listening ports and proxies them through.
- Push notifications: The service worker watches for Claude's "waiting for input" markers and pings you. So you can let Claude work in the background and get notified when it needs you.
The whole thing is ~2000 lines. Backend is Express + node-pty + ws. Frontend is vanilla JS because I didn't want to ship a framework for what's essentially a terminal wrapper.
GitHub: https://github.com/yazinsai/claude-code-remote
Would love feedback, especially from anyone who's dealt with mobile terminal UX. The virtual keyboard situation is... a work in progress.

value: Show HN: Claude Code Remote – Access Claude Code from Your Phone

author: yazinsai


value: Android app that finally lets you control flashlight brightness, add strobing with multiple frequencies. It's beautiful, seamless and open source!

value: Show HN: Flashlight: Android app that lets you control torch brightness


value: Show HN: Open Contribution Graph: A GitHub heatmap for anything you can POST


value:
I built this to solve my own problem — sourdough takes ~20 hours from start to finish, and I was tired of setting a dozen alarms and constantly checking "what's next?"
Flour Hour lets you pick a recipe, set your start time (or work backwards from when you want to eat), and it calculates every step with exact timestamps.
Includes 22 recipes: classic sourdough, same-day sourdough, focaccia, bagels, croissants, brioche, discard pancakes, and more. Each with ingredients.
Tech: React + Vite, deployed on GitHub Pages.
The interesting part — I built it entirely by talking to Claude Code. Described what I wanted like a client, and it wrote all the code. Took about 3 hours of conversation (not counting rate limits).
GitHub: https://github.com/YaninaTrekhleb/flour-hour
Happy to answer questions about the build process or the app itself.

value: Show HN: Flour Hour – I built a bread baking app with Claude Code in 3 hours


value: AbdoulayeSeydi

value:
Deploying ML models on-device is still a huge pain. Most teams default to cloud inference because:
Testing a model on different devices is manual and error-prone
Device constraints aren’t obvious from model exports
Rewriting deployment code for multiple platforms wastes days or weeks
I built Refactor AI, an infrastructure tool that:
Analyzes a trained ML model and flags ops that won’t run on the target device
Refactors the model where possible
Generates deployment-ready code for CoreML, ONNX Runtime, ONNX.js, and TFLite
This reduces deployment time from days to minutes, and lets teams run inference natively on-device, saving on cloud GPU costs.
Open to feedback, testing on real models, or ideas for improvement.

value: Show HN: Tool that automates ML model deployment on mobile/edge devices

author: AbdoulayeSeydi


value: chopratejas

value: Show HN: Headroom – Reversible context compression for LLMs(~60% cost reduction)

author: chopratejas


value: febtiger

value:
I built this calculator after getting startup vs Big Tech offers and struggling to compare (or even fully understand them). In moments of panic I'll forget basic statistics and go straight to searching Blind or Reddit instead. I think the calculator keeps some expectations grounded, but also helps map out optimistic cases.
- Enter startup details (stage, valuation, equity, salary)
- Select your Big Tech level (L3–L7) and current company
- Compare expected value over X years with p10 / p50 / p90 outcomes, some fun insights.
All assumptions and sources are documented.
I’d appreciate feedback on the model—especially the exit multiple assumptions at later stages. Let me know if there are glaring errors in the financial modeling.

value: Show HN: Calculator to compare Startup offers vs. Big Tech comp

author: febtiger


value: peiiii

value: Show HN: Skild – The NPM for AI agent skills

author: peiiii


value: oldcai

value: Based on https://semanticsearch.ai/

value: Show HN: Free, maintenance‑free semantic search and related posts for Hexo

author: oldcai

story_text: Based on https://semanticsearch.ai/


value: fwttnnn

value:
Hi everyone, this project was originally submitted 2 months ago
for my final exam (data viz) which sadly didn't get accepted.
Demo (Videos):

    - Normal Params <https://github.com/user-attachments/assets/ce8bf347-5b34-450e-91d1-20bdfd67be65>
    - depth=5 Params <https://drive.google.com/file/d/1Nz8OMbOTjByBwt0xHEDrO-f94i4h4hY6/view>

I also had conducted an online experiment to see if the user has
interacted to parts of the graph (e.g., each album, the axis).
There is 'hidden' features:

    - Time Range: controls how recent the data is, which you can toy with via params: (http://127.0.0.1:3000/?range=medium) where range can be either "short" | "medium" | "long", defaults to "short".
    - Depth: controls how many song(s) is retrieved, which you can toy with via params: (http://127.0.0.1:3000/?depth=5) where depth is a positive number (>= 1).

Please note that you can only run the app locally, since there's
limitations for the Spotify Web API. Everything you need to configure
is documented on the `README` file, thank you :)

value: Show HN: Sptfw – (unofficial) Spotify wrapped, how mediocre is your taste?

author: fwttnnn


value: mathewmon

value:
Hi HN,
I’m a solo founder and content creator. I built ViralIQ after repeatedly posting videos and not really understanding why some performed well and others didn’t.
Most feedback I got was vague (“looks good”), and analytics only helped after publishing, when it was too late to change anything. I wanted clearer signals earlier.
ViralIQ lets creators upload a video and get structured feedback before publishing, covering things like pacing, clarity, engagement, and parts that may lose attention.
There’s a free plan so it’s easy to try. It’s still early, and I’m mainly interested in whether this problem resonates and what people would expect from a tool like this.
Happy to answer questions or hear critiques.

value: Show HN: ViralIQ – Get structured feedback on videos before publishing

author: mathewmon


value: bobsterlobster

value:
Mounty is a GTK4 app for managing SMB network shares on Linux.
Add shares, test connections, mount/unmount, and enable automount (writes to fstab for you).<p>Built with Python + GTK4/libadwaita. Available on AUR for Arch users.
If there are any bugs, sue me. (Please don't actually do that, it's MIT licensed)

value: Show HN: Mounty – Because I was too lazy to edit fstab

author: bobsterlobster


value: keepamovin

value:
https://mailpilot.chat
What is this? A local TUI (like Claude, Codex, Gemini, OpenCode or Copilot) that wraps your agent and sends each turn to an email in a nice format.
What does it enable? It lets you email your agents. And them email you. So They Keep Working on the tasks you want, and You go and do What You Want. No need to stay at your desk. Be free.
I built this for me, but thought others would find it useful, so I turned it into a product. I want get outside, and away from my desk, but still have the agents work.
The accidental killer feature: You can CC your team. If you forward the thread to a coworker, their reply goes straight to the agent context too. It turns a local session into an async multiplayer thread.
Works out of the box with Claude, Codex, Gemini, Copilot, and OpenCode. Happy to answer questions!
https://mailpilot.chat

value: Show HN: MailPilot – Freedom to go anywhere while your agents work

author: keepamovin


value:
Hello HN,
I’m David. I built Matriq because I was frustrated with the "Post-Production Scrub."
I had hours of B-roll and long-form content, but finding a specific 5-second clip (e.g., "a red car passing by" or "a specific quote about React state") meant manually watching the footage at 2x speed.
What I built: Matriq indexes video content visually and aurally. It uses multimodal embeddings to understand scene context, action, and dialogue.
The Use Case:
While it works for general editing, I’ve found the best use case is Content Repurposing. Creators with 100+ hours of archives can now instantly find "viral hooks" or specific topics to turn into Shorts/Reels without re-watching old footage.
It’s in beta. I’d love you to try breaking it or give feedback on the retrieval accuracy.
Link: https://matriq.video

value: Show HN: Matriq – Search inside video files using natural language


value: kccanarch

value:
I got tired of reading PDF reports for Carbon Offsets that claimed to be "Protected Forests" but looked suspicious on Google Maps.
So I built Silent Earth—a standalone forensic engine (Python/React) to audit them mathematically.
The Stack:
* Ingestion: Scrapes Verra/Gold Standard registries for project coordinates.
* Telemetry: Queries the Sentinel-2 Satellite Constellation (via Microsoft Planetary Computer).
* Analysis: Calculates NDVI (Biomass Density) and performs spectral analysis on the claimed area.
* AXIOM Kernel: Cross-references industrial "shutdown" claims against Tropospheric NO2 levels (Sentinel-5P).
The Result: I routinely find "Verified" assets with an NDVI < 0.2 (Bare Soil).
The tool is currently local-only for privacy, but I'm moving the data stream to Snowflake.
Happy to answer questions about the geospatial stack (Rasterio/Shapely) or the satellite APIs.

value: Show HN: I built a satellite forensic engine to detect fraud in Carbon Markets


value: superhuang

value: Show HN: I Indexed 4000 Agent Skills for Claude and OpenAI

author: superhuang


value: Strift

value:
I play MTG (Magic: The Gathering) and find the quality of AI tools in the space quite low.
The reliability isn’t there, and the overpromises (e.g., automated deck building) vs. the reality (pulling 100 cards from EDHrec) lead to a negative reception. This contributes to the community feeling that AI just outputs slop because “it doesn’t get” Magic.
I’m trying to improve the status quo by using RAG, and I found it brings better results than most “smart search” tools.
Feedback welcome :)

value: Show HN: Semantic search for MTG

author: Strift

title: Show HN: Semantic search for MTG


value: karmaniverous

value: Show HN: Win-link-router – route tel: links to WhatsApp (Windows)

author: karmaniverous


value:
Hi everyone!
This post will probably resonate with those who have dogs/ likes dogs/ moving or planning to move to Dubai in the near future with their pups.
For most of us with dogs, they are our priority.  and while there's an assumption that Dubai might not be the right place for dogs, thats not entirely true. Yes, it can get tricky to find what you're looking for, which is why I built DubaiWoofs. It's essentially a place to show you at a glance what you'll need to make their lives easier in Dubai- from parks to vets to petstores and areas to live.
I'm still building it out and more than happy to hearing anything you'd like to see added! you can either leave a comment here or use the chat option on the site.
So far I've got a blog with 2 articles, more planned to go up.

value: Show HN: I built DubaiWoofs for those moving to Dubai with Dogs


value: ovonvo

value:
Hi HN,
aeph is a terminal-based markdown editor inspired by Ephe (https://ephe.app/).
I wanted the same ephemeral paper experience but in the terminal.
Features:
 - Quick TODO management (Ctrl+T to toggle, Ctrl+N to add)
 - Smooth markdown writing with auto-save
 - 9 pages with instant switching (Ctrl+O, then 1-9)
That's it. No config, no complexity.
Give it a spin if that sounds useful to you.

value: Show HN: Aeph – A minimal TUI Markdown editor with task management

author: ovonvo


value: Show HN: S3mini(0.9.1) Tiny ts S3 client, now supports blobs and streams


value: getmaapp

value:
Hello HN,
I'm excited to announce the release of @getmaapp/signal-wasm v0.1.0, a Rust crate compiled to WebAssembly that exposes the Signal Protocol (Double Ratchet, X3DH) to Browser JavaScript and TypeScript environments for E2EE messaging.
Repository: https://github.com/getmaapp/signal-wasm
NPM: https://www.npmjs.com/package/@getmaapp/signal-wasm
Motivation
The landscape of web applications is evolving rapidly, and secure communication is becoming more critical than ever.
- Rise of Chat Features: More web apps are integrating chat directly into their products.
- AI Chatbots: The proliferation of AI agents necessitates secure, private channels for sensitive data.
- Security Threats: With the increase in hackers, fraud, and data breaches, reliance on cleartext or weak encryption is no longer sufficient.
- Vendor Lock-in: Existing E2EE solutions function as "black boxes" or proprietary SaaS offerings, locking developers into specific ecosystems.
- Open Source Foundation: The Signal Protocol is the gold standard for E2EE, but using it in a pure browser environment has historically been challenging due to WASM constraints (system time, randomness, etc.).
- This project aims to provide a long-term open-source tool that makes the Signal Protocol accessible to any web developer, without the lock-in.
Implementation Details
This library wraps the upstream libsignal Rust crates and solves several WASM-specific challenges:
- Randomness: Replaces OsRng (which panics in WASM) with getrandom using the Web Crypto API.
- Time: Handles SystemTime panics by bridging to js_sys::Date.
- Async/Await: Exposes a clean async API for JavaScript, handling the synchronous Rust core.
Caveats & Disclaimers
- I am not a Cryptographer: I am primarily a TypeScript/React full-stack developer (Effect-TS) with a background in Product Management. While this library binds the official Signal Rust crates, the bindings themselves have not been audited.
- AI-Assisted Development: This project was built with significant assistance from AI coding agents (Google Antigravity, Claude Opus 4.5, Gemini 3).
- Attribution: Huge credit belongs to the Signal Foundation and their engineering team for creating the cryptographic primitives and the libsignal Rust implementation that makes this possible. We are standing on the shoulders of giants.
Call to Action
- This is v0.1.0. It works, it passes tests, and we have a working React demo in the repo. However, to make this the standard for web-based E2EE, we need community eyes on it.
- Collaboration and contributions are highly welcome. Whether it's code review, improving the WASM bridge, or building cool demos, I'd love to see what you build.
About Me
I'm a TypeScript/React developer and Product Manager.
LinkedIn: https://www.linkedin.com/in/thecannabisapp/
Github: https://github.com/thecannabisapp
Email: jia@getma.app
Thanks!

value: Show HN: Getmaapp/signal-WASM v0.1.0 – Signal Protocol for the Web

author: getmaapp


value: namedix

value:
I built a calorie tracker that removes the tedious parts of food logging.
Instead of searching databases, you just describe your meal: "scrambled eggs with toast and coffee" — AI calculates calories, carbs, protein, and fat. You can also snap a photo of food or a nutrition label.
Launched on Product Hunt yesterday and hit #5 with 200 upvotes — the feedback helped shape a lot of my thinking.
The accuracy scales with detail. "Had eggs" gives a ballpark. "2 eggs, 10g butter, 1 slice toast" gets precise. Grams = exact data.
I focused heavily on design — wanted something minimal that feels native to iOS. Most calorie apps look and feel like they haven't been updated since 2015.
Built with SwiftUI, syncs with Apple Health for personalized targets.
Would love feedback from the HN community on the approach. Happy to answer questions about the tech or design decisions.

value: Show HN: 0xCal – A calorie tracker where you just describe what you ate

author: namedix


value: fka

value: Show HN: Free and open sourced prompt skills game for kids

author: fka


value: snapmotion

value:
Hi HN,
I’ve been working on Combo, an open-source video SDK for the web. Most browser-based video editors rely on heavy server-side rendering or slow DOM-based previews. I wanted to see if we could get native-like performance directly in the browser.
Combo uses:
WebCodecs for hardware-accelerated encoding/decoding.
PixiJS (WebGL/WebGPU) for real-time multi-track composition and effects.
JSON-based schema for portable project states.
It supports everything you’d expect: video/audio layering, GLSL transitions, text/captioning, and fast exports.
Docs: https://docs.combo.sh
GitHub: https://github.com/designcombo/combo
I’d love to hear your thoughts on the architecture or any performance bottlenecks you’ve encountered with WebCodecs!

value: Show HN: Combo – A high-performance browser video editor SDK using WebCodecs

author: snapmotion


value: MakeMilk

value:
Hello everyone,<p>We all have technical itw during our journey.
I built SharpSkill in order to change this process' feeling.

value: Show HN: SharpSkill – Forget your thoughts about Tech Interviews

author: MakeMilk


value: emmaera

value: Zonfig lets you define a single Zod config schema and load overrides from env vars, JSON/YAML/.env, and secret stores. It validates on startup, provides great errors, and supports encrypted config values so secrets can be committed to source control.

value: Show HN: Zonfig – Zod-based config with validation and encrypted secrets

author: emmaera


value: ayi

value:
Like many developers, my resolution for 2026 was to finally start my own blog. I managed to avoid the trap of spending weeks building a custom static site generator, but I fell into a different rabbit hole: finding the perfect retro Windows color scheme for the UI.
While searching, I found a gist with old Windows colors' RGB vales and wanted to see how those classic colors would look on a modern framework. I tried creating an old-school LOB application UI to test them out. What I thought would be a few hours of tinkering ended up taking over the first two weeks of 2026.
WinDaisy is a collection of 33 themes for daisyUI that replicate these classic Windows color themes.
Some details:
- 33 Available Themes: Includes classic 9x looks like classic, teal, and plum (which comes with plus pack), as well as later styles like luna, zune, and aero.
- Technical Stack: The project uses Bun for package management and Tailwind CSS with the daisyUI plugin. No React, no SPA.
- Simple Implementation: Themes are applied by setting the data-theme attribute on the <html> tag or specific elements. You can click any theme on sidebar and it will be applied. A single HTML file with CSS.
- Customizable: You can add new themes by defining CSS variables in a theme.css file and rebuilding the project. "bun run build" that's it.
Repository: https://github.com/cnkt/WinDaisy
Live Demo: https://cnkt.github.io/WinDaisy/
Disclaimer: No ai used for this project. I wanted to mention that because it might affect how you perceive the work.

value: Show HN: WinDaisy – Try retro Windows colors on an old-school LOB app UI

author: ayi


value: ajujaans

value: Show HN: AI Code Guard – Detect security vulnerabilities in AI-generated code

author: ajujaans


value: mehditch

value:
Hi HN,
I'm sharing BAZINGA, a framework that applies professional software engineering practices to AI development.
The observation: AI coding tools generate code without the safeguards we require from human developers. No mandatory code review. No security scanning. No test coverage requirements.
BAZINGA addresses this by coordinating multiple AI agents that follow a professional workflow:
## The Workflow
1. PM analyzes requirements
2. Developer implements + writes tests
3. Security scan runs (mandatory)
4. Lint check runs (mandatory)
5. Tech Lead reviews code (independent reviewer)
6. Only approved code completes
## Key Principles
*Separation of concerns:* Writers don't review their own code. Developer agent writes, Tech Lead agent reviews. Same principle as human teams.
*Mandatory quality gates:* Security scanning, lint checking, and coverage analysis run on every change. Not optional.
*Structured problem-solving:* Complex issues get formal analysis:
- Root Cause Analysis (5 Whys)
- Architectural Decision Records
- Security Issue Triage
- Performance Investigation
*Audit trail:* Every decision logged with reasoning. Full traceability for compliance.
## What It Catches
- SQL injection, XSS, auth vulnerabilities (via bandit, npm audit, gosec, etc.)
- Code style violations (via ruff, eslint, golangci-lint, etc.)
- Missing test coverage (via pytest-cov, jest, etc.)
- Architectural concerns (via Tech Lead review)
## Quick Start
uvx --from git+https://github.com/mehdic/bazinga.git bazinga init my-project
MIT licensed. Works with Claude Code.
## Technical Approach
Built on research from Google's ADK and Anthropic's context engineering principles. Uses role-based separation with 6-layer drift prevention to ensure agents stay in their designated roles.
GitHub: https://github.com/mehdic/bazinga
Happy to discuss the engineering approach or answer questions about multi-agent coordination.
```

value: Show HN: Bazinga – Enforced engineering practices for AI coding

author: mehditch


value: kikkupico

value:
I'm calling this "Vibe Discovery" — distinct from vibe coding because I didn't know the requirements upfront. Started with "make something with the accelerometer" and discovered through 6 iterations that I wanted a WebGL marble game.
The interesting part was the dev setup: Claude Code running in Termux on a Redmi Note 9 (4GB RAM). The same-device feedback loop — code, test accelerometer, react, iterate — made rapid discovery possible in a way that laptop-to-phone deployment wouldn't.

value: Show HN: I built a game on my old phone without knowing what I was building

author: kikkupico


value: echoadam

value:
Hi HN,
I’ve always felt that traditional "Which character are you" quizzes were too static—relying on rigid branching logic and simple scoring that often yields predictable, low-accuracy results.
To solve this, I built CharacterTest.app. Instead of simple keyword matching, it uses an LLM-powered engine to perform semantic personality mapping. We decode user responses into the Big Five (OCEAN) and MBTI dimensions, then calculate proximity within a high-dimensional trait database covering 2,000+ characters across 100+ universes.
Technical Stack:
Framework: Next.js (App Router) with SSR for sub-second page loads and SEO.
AI Logic: Custom prompting architecture to prevent "personality bleed" and ensure multi-language consistency (supporting EN, JP, KR).
Privacy: No signup required for basic tests. I believe in "value first, data later."
I’m particularly curious about your thoughts on the mapping accuracy and the latency of the AI matching process. Would love to hear your feedback!

value: Show HN: CharacterTest.app–Scientific character matching using Big Five and LLMs

author: echoadam


value: mrcloudxiao

value:
We’re building Appcan, a security testing platform.
While running scans ourselves, we kept hitting the same problem: the reports were accurate, but hard to act on.
Most scan outputs are long lists of findings with severity labels, but very little context. You still have to decide what actually matters, what to fix first, and what can wait.
So we added an AI interpretation layer on top of existing scan results.
Instead of just showing raw findings, the AI reads the report as a whole and produces a short, structured summary explaining what the real risks are, why they matter, and where to focus first. It doesn’t re-scan anything or invent data; it only interprets what’s already there.
The goal isn’t to replace security engineers. It’s to reduce the cognitive load for teams who need to understand risk quickly and move forward.
We’re still early and learning. I’d love to hear from people who deal with security reports:
does this kind of AI-generated insight actually help, or does it create new problems?
Happy to answer questions and get feedback.

value: Show HN: Built an AI turns security scan results into human-readable insights

author: mrcloudxiao


value: ChopSticksPlz

value:
This is a simple Mind Mapping web based app built with open weight LLMs with focus on using locally deployed models like Devstral Small and Seed OSS.
Created this to get more familliar with AI assisted coding. 99% of code was written by LLM, however thinking, testing and debugging was still mostly done by me.
App is open source, code is on GitHub: https://github.com/cepa/mindmapp

value: Show HN: MindMapp – Mind mapping app built by AI in 12 hours

author: ChopSticksPlz


value: mmoustafa

value:
I've been on the road in some places with really sh*t cellular in the US and sometimes I really need to lookup something online but it will take an hour for Google to load. Well, Olly works even with zero bars as long as you have a (newish) iPhone and a view of the sky. Been a lifesaver for quick questions when I'm in the middle of nowhere.
Let me know what you think https://olly.bot/

value: Show HN: An AI assistant you can text via Apple satellite messaging

author: mmoustafa


value: foxiren

value: Merge Excel files online in seconds. Combine multiple Excel sheets into one workbook. Free, fast, secure and works directly in your browser — no upload required.

value: Show HN: Merge Excel Files

author: foxiren

title: Show HN: Merge Excel Files


value: JoaoW

value:
I'm a hobby gardener in the UK, and I got tired of garden planners telling me to plant tomatoes in March (when it's still freezing). Every app I found used generic USDA zones or assumed you lived in California.
So I built Leaftide - a garden planner that actually knows your local climate.
*What makes it different:*
- *Real frost dates* - Uses NOAA climate data for your exact location, not coarse hardiness zones
- *Growing Degree Days* - Calculates when plants will actually mature based on accumulated heat
- *Permanent plant tracking* - Track fruit trees, berry bushes, perennials across multiple years (this is what converts users to paid)
- *Visual plot designer* - SVG-based drag-and-drop for planning beds and spacing
*Tech stack:* Django + HTMX + vanilla JavaScript (for the plot designer) + PostgreSQL
Launched in October 2024. Currently 6 paid users (all from Reddit, not Product Hunt). £5/month or £45/year.
The surprising lesson: I thought climate-aware scheduling would be the killer feature, but permanent plant tracking is what people actually pay for. Turns out people want ongoing tracking tools, not one-time lookups.
*Try it:* https://leaftide.com
Happy to answer questions about the climate calculations, the HTMX/JS hybrid approach, or the journey from side project to (tiny) business.

value: Show HN: Leaftide – Garden planner with climate-aware scheduling (Django/Htmx)

author: JoaoW


value: stuartevansuk

value:
Hey HN,
I built Setflow https://www.setflow.app to solve my own problem, but I'm sure others have the same issue so sharing it here. I got back into DJing after 15+ years and realised I was spending more time organising playlists and trying to find tracks than actually mixing. What started as a small webapp to help myself turned into something usable for others.
What it does:
"Tell me the vibe. I'll build the set."

  Imports your Rekordbox library (XML export).
  Generates harmonically mixed playlists using Camelot wheel logic.
  BPM matching with smooth tempo transitions (±3% between tracks).
  Energy profiles: Journey, Peak Time, Warm Up, Chill, Cool Down for overall mood.
  Intelligent key progression with directional movement around the Camelot wheel.
  Exports back to M3U8 or Rekordbox XML format for a pre-built mix.

The problem it solves:
Firstly, for myself it was time. After amassing a large library over years I often ended up staring at what music to select, never mind understanding if it would sound great together. I just wanted to mix after being out of it for years.
This then evolved into building in harmonic mixing (playing tracks in compatible musical keys) making transitions sound smooth instead of clashing. I found that manually sorting hundreds of tracks by key and planning a set that flows well was tedious and time consuming. Rekordbox has a "Related Tracks" feature but it doesn't build you an actual runnable set with energy progression.
Setflow gives you a starting point playlist that works harmonically and follows an energy curve, so you spend your limited practice time actually mixing instead of dragging tracks around. Combined with playlist history and custom set generation you have flexibility to create, augment and move tracks around based on your output.
Tech stack:

  Next.js 16 (App Router)
  React 19, Tailwind CSS 4
  PostgreSQL 17 + Drizzle ORM
  BetterAuth (email/password with verification)
  Stripe for payments
  Resend for email
  Zustand with localStorage persistence
  Self-hosted on VPS

Core features:

  Smart Rekordbox importing with track de-duplication.
  Drag & drop reordering with visual feedback.
  Playlist Builder with smart harmonic suggestions.
  Transition notes explaining why each transition works.
  Set history and management.
  Mobile responsive.

Who it's for:
Look, pro DJs mostly already have this skill, but this is squarely aimed at:

  Bedroom DJs with large libraries and limited time
  Beginners who don't yet have an intuition for what tracks work together
  Anyone who wants a quick starting point for set prep. Old dads like me with limited time.

Pricing:
Free tier available to jump in with some limits. Hobby tier at £2.99/month. Pro at £4.99/month for larger libraries.
Would love feedback from any DJs or music nerds here. Happy to answer questions and can offer some free passes in exchange for genuine feedback.

value: Show HN: Setflow – Create harmonically mixed DJ sets from your Rekordbox library

author: stuartevansuk


value: yosid

value: Show HN: CallTuv - A browser dialer with 80+ hours of calls in its first month

author: yosid


value: elyalon

value:
Hello HN! I want to show off a tool I made for creating color scales by modifying curves of the OKLCH components (lightness, chroma, hue).
I also made an accompanying blog post about how I use it for web design: https://ely.al/posts/okscale-for-design

value: Show HN: Okscale – Create color scales using OKLCH curves

author: elyalon


value:
Hi HN,
I built a native macOS app for AI image generation, originally for my own creative work.
I enjoy working with models like Z-Image and FLUX, but many existing tools feel closer to research interfaces than creative tools. They expose a lot of power, but often interrupt creative flow.
This project is built around a creator-first workflow:
- Easy to get started, with no configuration beyond downloading or importing models
- Progressive controls: advanced options are available, but not required
- A built-in prompt library to save, reuse, and evolve prompts over time
- Lightweight prompt refinement that learns from your saved prompts
- Simple add-ons for upscaling and background removal
Under the hood:
- Runs Stable Diffusion, FLUX, and Z-Image fully locally
- Optimized for Apple Silicon using MLX and Metal
This is an opinionated attempt to make local image generation feel more like a creative tool and less like a technical setup.

value: Show HN: A creator-first native macOS app for local AI image generation


value: ansorre

value:
Hi HN,
working with AI today involves a lot of copy and paste. Single LLMs are rarely enough to solve real problems, so we constantly switch contexts, ask multiple LLMs, and let them correct each other.
To break free from all that, I built BlaBlaBlAI and released it as Apache 2.0 open source.
The idea is simple: no more 1-on-1 chats with LLMs, but chats with as many LLMs and as many humans in the same chat as needed. Think WhatsApp groups, but with LLMs too, and a reasonable set of tools to coordinate them (rules, muting, cost attribution).
I can imagine how many types of businesses could be built on top of a chat system like this. Obviously, having worked on this app for some time, I have a thousand ideas. But today I’m interested in emphasizing just three things:
1) Using many LLMs in the same chat instead of one has been, for my productivity, more disruptive than the invention of LLMs themselves. This is why I’m sharing this.
2) Ideas like this tend to evolve in one of two ways: either they fragment into many mediocre clones, or they converge into one or a few strong open-source implementations. I’m explicitly aiming for the second, which is why, for me, open source is a technical necessity, regardless of any potential business built on top.
3) I’m used to the concept “Make something people want”, so this message is meant to understand whether people actually want BlaBlaBlAI. I know how much I want this (very much), so this is really about understanding whether BlaBlaBlAI will evolve just for me or for many.
That’s it. I also made a video to show an example of use. The use case is absolutely genuine and real, it happened to me. Who hasn’t received less-than-ideal responses from LLMs? In fact, that’s precisely the point of BlaBlaBlAI: there’s no single perfect LLM, but many LLMs working together can make a real difference.
Final details and notes:
- Open-source code on GitHub (the app works)
- Multi-LLM chat
- Markdown support in messages
- Demo video showing real interactions between agents
Missing for now:
- Hosted version
- Easy setup (but an exhaustive README.md to run it exists)
- Onboarding
Links:
- GitHub repo: https://github.com/Transhumai/BlaBlaBlAI
- Demo video: https://youtu.be/cYnIs_9p99c
- Intro blog post: https://blablablai.com/blog/posts/welcome/
- Landing: https://blablablai.com/
I’ll be around all day to answer questions.
Thanks for reading.

value: Show HN: BlaBlaBlAI – An open-source chat where LLMs are aware of each other

author: ansorre


value: Show HN: A simple PS1 memory card editor


value: claudianadalin

value:
Built this because I kept seeing devs learn from todo app tutorials, then struggle when they hit real patterns like multi-tenancy or RBAC on the job.
The approach: you pick a standard domain (CRM, task manager) and make it weird. Your CRM becomes a cat fashion store. Your task manager becomes a heist planner. You learn the same enterprise patterns (multi-tenancy, permissions, theming, i18n) but end up with something that's not the 500th identical portfolio project.
The first challenge is free. Curious what HN thinks about this approach to teaching architecture patterns, and whether the "pick your weird domain" angle actually helps with motivation or just adds confusion.

value: Show HN: FrontendCheck – Learn enterprise patterns by building weird SaaS

author: claudianadalin


value: lagorita

value:
Hey HN! I built Tidey because my Desktop was always a mess.
The problem: Files pile up on Desktop and Downloads. Screenshots, PDFs, random downloads. You save them "temporarily" and forget about them for months.
The solution: Tidey sits in your menubar and watches those folders. When you're ready to clean up, it shows you each file one by one. You preview it, then click Delete (goes to Trash) or Keep (moves to ~/Documents/Kept/, organized by year/month).
That's it. No complex rules, no automation magic. Just a fast way to make decisions about files you've been ignoring.
Tech stack:
- Swift/SwiftUI (native macOS)
- Sparkle for auto-updates
- Landing page: Next.js on Cloudflare
I'm a solo dev, happy to answer any questions about the app or the build process.
Demo video: https://trytidey.com (scroll to "See It In Action")

value: Show HN: Tidey – A tiny Mac menubar app to triage Desktop and Downloads clutter

author: lagorita


value: lhassa

value:
  I built a CLI tool that generates Anthropic Agent Skills using AI. Describe what you want in plain English, and it creates a complete SKILL.md file with structured instructions, examples, and edge case handling.

  Example:

      pip install ai-skillforge[ai]
      export ANTHROPIC_API_KEY=your-key
      skillforge generate "Review Python code for security vulnerabilities"

  This creates a ready-to-upload skill with:
  - YAML frontmatter (name, description)
  - Step-by-step instructions for Claude
  - Multiple realistic examples
  - Edge case guidance

  You can also improve existing skills with AI, validate against Anthropic's requirements, and bundle into zip files for upload.

  Works with Anthropic, OpenAI, or Ollama as the generation backend.

  GitHub: https://github.com/lhassa8/skillforge
  PyPI: https://pypi.org/project/ai-skillforge/

  Built this because writing good skills from scratch is tedious, and I wanted something that could scaffold production-quality instructions quickly. Feedback welcome!

value: Show HN: AI-SkillForge – Generate Anthropic Agent Skills from Natural Language

author: lhassa


value: finsuba

value:
Hi HN,
I built Finsuba Premium to solve a problem I kept running into while trading:
Most sites highlight “top gaining stocks” over a fixed time window (e.g. 9:30–4:00), but that often hides the actual tradeability. A stock can finish the day up big while offering very different outcomes depending on when you entered and exited.
Finsuba Premium sends a daily and weekly email showing the top-performing U.S. stock trades, based on identifiable entry and exit points rather than broad time-based gains. It includes:
- exact entry time & price
- exact exit time & price
- trade duration and performance
It’s not a signal service or alert system. Everything is processed at the end of the trading day and ran through minute by minute. I built this for traders who want to improve by reviewing winning setups consistently, rather than reacting to alerts in real time.
Link: https://www.finsuba.com/premium/
Happy to answer questions about how the trades are selected, the data pipeline, or the product itself. Feedback very welcome.

value: Show HN: See the best daily US stock trades with entry and exit timing

author: finsuba


value: antjanus

value: Show HN: I, AI – A story about AI

author: antjanus

title: Show HN: I, AI – A story about AI


value: galgia

value:
Old school aesthetic and new learning concepts.
The whole mastery plan consists of 18k puzzles. Split by each tactical concept, each piece, each square.
Example:
Unique chess squares: 64
Topic: M1
Unique pieces: 6
Puzzles: approx. 6*64
The coverage of squares is 85%, as some moves are mathematically impossible, and for some exotic positions, I did not find any quality puzzles.
Have fun and master chess!

value: Show HN: Pawnch – Addicitve chess puzzles with explanations

author: galgia


value:
Hi HN,
I built *Webhook Debugger* because existing tools were either ephemeral (RequestBin) or required persistent tunnels (ngrok) that I couldn't leave running on a staging server.
*Repo*: https://github.com/ar27111994/webhook-debugger-logger
*The Stack*:
Node.js, Express, Apify SDK (for storage/dataset abstraction), Docker.
*Key Technical Decisions*:
1.  *Global SSE Heartbeat*: Instead of `setInterval` per connection (O(N) timers), we use a single global timer to flush heartbeats to all `res` objects.
2.  *SSRF Protection*: Custom validator (`src/utils/ssrf.js`) that resolves DNS and checks against a blocklist (including AWS Metadata IP `169.254.169.254`) before forwarding/replaying requests.
3.  *Resilience*: The Replay engine implements exponential backoff for `ECONNABORTED` errors, allowing it to handle "blips" when targeting local dev servers.
4.  *Hot-Reloading*: A background poller reads the input JSON every 5s and dynamically updates middleware, rate limits, auth keys, and webhook counts without restarting the process.
5.  *Platform Integration*: We encountered (and fixed in v2.8.7) a specific schema validation bug that only occurred in the platform UI, teaching us to lean on native storage exports rather than wrapping them in custom views.
It's open source (ISC). I'd love feedback on the *SSRF implementation* – ensuring users can replay to `localhost` (safe in dev) but not internal subnets (unsafe in prod) was a tricky balance.

value: Show HN: Webhook Debugger – OS Alternative to RequestBin with Replay,SSRF Checks


value: agentvivi

value: Show HN: Witness Archives – A daily history puzzle built with React Native Web

author: agentvivi