value: Jamium

value:
I built Perspectives because I got tired of ChatGPT agreeing with everything I said.
Ask any LLM to "consider multiple perspectives" and you get hedged consensus. The model acknowledges trade-offs exist, then settles on a moderate position that offends nobody. Useful for summaries. Useless for decision making.
Perspectives forces disagreement. 8 personas with fundamentally incompatible frameworks debate your question through a structured protocol, then vote using Single Transferable Vote to surface where they actually land. The output is a PDF report synthesising all of it.
How it works
Blind Proposals: Each persona generates a position without seeing the others. This prevents the "anchoring problem" where early responses shape later ones, bypassing the default sycophancy of LLMs.
Interrogation of Blind Proposals: Proposals face structured challenges from 3 opposing personas. A "high-empathy" persona (e.g., The Idealist) will be challenged by a "low-empathy" cluster (e.g., The Pragmatist). This reveals exactly where arguments buckle under pressure.
Discussion & Voting: Personas can debate (optional) before ranking preferences via STV. This highlights first-choice winners and preference flows rather than simple majority rule.
Analysis/Prediction Report: The final PDF structures recommendations first, followed by supporting analysis (factual background, risk assessment, evidence quality).
Two Operational Modes
Analysis Mode ("What should we do?"): Evaluates options and surfaces trade-offs. Output is qualitative judgment.
Prediction Mode ("What will happen?"): Generates probability estimates with resolution criteria.
Feedback Loops
Most AI agent projects have no way to measure whether their outputs are actually good. Users provide subjective feedback, which is noisy and unreliable. The system optimises for seeming useful rather than being useful.
Prediction Mode creates an objective feedback loop. When a prediction resolves, I can measure accuracy.
I'm integrating Polymarket as the verification source. Run a question through Perspectives, record the predictions, compare against actual outcomes when they resolve. Over time, this builds calibration data showing which methodologies perform best for different question types.
Persona Sets
Different decisions need different analytical lenses. Four built-in sets:
Philosophical (Default): Best for ethical dilemmas and strategic decisions.
Business-Focused: Best for commercial decisions.
Product-Focused: Best for product development.
Forecaster: Optimised for Prediction Mode.
Technical Details
LLM Support: Supports any OpenAI/Anthropic compatible API (Claude, OpenRouter, Ollama, Grok, etc.).
Web Search: Optional integration for grounding debates in recent events.
Output: Single PDF report per query.
What I'm Looking For
I've been building this solo and could use external feedback on a few things:
1. Does the blind proposal mechanism actually produce better disagreement?
2. Is the interrogation protocol overkill or useful? The structured challenge/response/verdict cycle generates rich data, but adds latency (dependant on concurrency settings).
3. What decisions would you run through this?
4. Do you use ChatGPT or similar systems to make decisions?
5. Do you find "chain of thought" output useful for tracking reasoning?
Links
Perspectives: https://getperspectives.app
Dev blog: https://blog.jmatthews.uk
Example Analysis Report (Is it viable to run a nation where all laws expire after 10 years and must be re-passed?): https://drive.google.com/file/d/1hsJOWsQDAtVOqOKF6_a_Q1jYOlB...
Example Prediction Report (Will Kraken IPO by 31st March 2026?): https://drive.google.com/file/d/1m3RedFtv8lKgFqf1_rvzl8W6cTs...
Happy to answer any questions in this thread.

value: Show HN: Perspectives – I wanted AI to challenge my thinking, not validate it

author: Jamium


value: abrowniejr

value: Show HN: Usagebar – Track Claude Code Usage from Your Menu Bar

author: abrowniejr


value: skeam

value:
I built a tool to test forms / landing pages versions in funnels.
It works through redirects. You get one permanent link that randomly shows version A or B (or more) to visitors. Tracks clicks and form submissions. No code installation needed.
Works with any platform that has shareable URLs like Linktree, Carrd, Notion pages, Tally forms, typeform, ...
Main use case I'm seeing:
testing ad with forms funnels (ads → form page → submit) to save ad spend, increase submits.
testing ad with landing page funnels (ads → landing page → product link clicked → shop) to save ad spend, increase clicks, increase revenue.
Can be used to test copy, design and layout, form provider A vs form provider B, ...
Uses minimal cookies for session consistency (eg: always shows A once you've seen A).
A little something I've not found on other tools so added in it: it provides swtchd hosted thank you page so people can use redirect on submit on form-builder to track and optimize provider-hosted forms in minutes.
Would love feedback on whether this solves a real problem or if I'm missing the point, and also if redirects seems fine to use for tracking purpose.

value: Show HN: Swtchd.io no code tool to A/B test forms / landing pages

author: skeam


value: yunusabd

value:
Hello HN, here's my app that I built around language learning with YouTube. I'm posting to connect with language learners and people building in this space.
I know some people use YouTube for language learning, but I think it's still a bit under the radar for many. I mean, where else can you find millions of hours of video content with decent quality (mostly) and in virtually every language in existence, about basically any topic there is?
The app has two main goals:
1. Allow interacting with the transcript to copy and translate, which you can't do with the YouTube app.
2. Facilitate interaction with the video content through exercises, to improve understanding and retention.
I'm using it currently to polish up my Mandarin, which I learned to a decent level some 10 years ago. For this kind of casual use case I find it quite good, if I do say so myself.
There's currently around 1k users across Android and iOS. Korean seems to be popular as a target language, as well as Turkish, which interestingly is being learned in Somalia of all places. But according to my stats, it turns out that the most popular language pair is English->English. So right now I'm working on improving the experience for this kind of "monolingual" learning.
The app can be used for free, with an optional ad to unlock exercises per video.
iOS:
https://apps.apple.com/us/app/lingolingo-language-challenge/...
Android:
https://play.google.com/store/apps/details?id=com.lingolingo...

value: Show HN: YouTube App Centered Around Language Learning

author: yunusabd


value: krnelstudio

value: Show HN: Applyra, Improve your app rankings – simply

author: krnelstudio


value: levberg

value:
Threat Road is a free vulnerability database that publishes fresh CVE data every single day.
- No middleman.
- No delays.
- No paywalls.
Why I built it:
- NVD's interface feels like Windows XP and updates are slow
- CVE Details is just repackaged NVD data with the same delays
- Premium databases cost five figures and are overkill for most teams
What makes it different:
- Daily updates
- Clean, modern interface
- Filter by vendor, category, CVSS score
- Actually fast and usable
- Zero cost
If you want daily CVE tracking, that's where you'll find it.

value: Show HN: It's a free vulnerability database that publishes fresh CVE data daily

author: levberg


value: reposquirrel

value:
Hi HN
We’ve just released a new version of RepoSquirrel, focused on deeper insights into both development activity and operational incidents.
This release adds:
New visualizations showing workload distribution per subsystem over time
Faster and more accurate code analysis by replacing cloc with Tokei
A new PagerDuty integration that connects incidents directly to Git users and repositories
With the PagerDuty integration you can visualize things like:
Open incidents and open/resolve trends
Incident frequency by severity
Incidents per hour (time-of-day patterns)
Severity over time and averages
Who is resolving and assigning incidents
Per-responder views of what they’re handling and when
Arbitrary incident searches (e.g. customer-specific incidents) with visualizations
Documentation (with screenshots) for the PagerDuty integration is here:
https://github.com/reposquirrel/reposquirrel/blob/main/docs/...
One thing I’d love help with: since I only have limited demo data that I can publish publicly, I’m very interested in screenshots from real-world systems (anonymized, of course). If you’re using PagerDuty and RepoSquirrel and are willing to share how it looks in practice, that would be hugely appreciated.
Happy to answer questions or dive deeper into how any of this works.

value: Show HN: RepoSquirrel – New release with deep PagerDuty and Git visualizations

author: reposquirrel


value: erlfire

value: Show HN: Erlauncher - A lightweight app launcher written in Zig for X11

author: erlfire


value: cybercageio-dev

value:
Hey HN,
We just shipped PII detection for CyberCage.
The idea: builders move fast, copy-paste doesn't think. Sometimes sensitive stuff ends up in AI tools — SSNs, API keys, customer data. Not intentional, just momentum.
So we built something that catches it before it leaves the machine.
What it does:
- Detects SSNs, credit cards, phone numbers
- Catches API keys (AWS, GitHub, OpenAI...)
- Custom patterns you define
- Works on images too — all processed locally
ML powered detection runs on-device. Nothing gets sent anywhere for scanning.
You choose what happens: log, block, or auto-redact.
Works with Claude Web, ChatGPT, GitHub Copilot, x.AI.
See it in action: https://www.youtube.com/watch?v=FiibtTUSqU8
Would love your feedback.
— Sia

value: Show HN: CyberCage – On-device PII detection for AI tools (text and images)

author: cybercageio-dev


value:
I built a Python-based video upscaler that prioritizes privacy and local execution.
Most AI video tools today are cloud-based, which isn't ideal for private media or long-form archival projects. This tool brings a professional upscaling pipeline directly to your machine.
Why I built this:
I wanted a simple "one-command" way to take old SD footage (like home movies or archival clips) and upscale them to 1080p and 4K without complex configurations or data leavings my hardware.
Key Features:
- Hybrid Support: Auto-detects NVIDIA CUDA or Apple Silicon (MPS).
- Smart Fallback: If no GPU is found, it automatically switches to OpenCV FSRCNN so it still works (though slower) on any CPU.
- The Pipeline: It doesn't just "stretch" video. It uses Real-ESRGAN for AI enhancement up to 1080p, then applies high-quality Lanczos interpolation for 4K delivery.
- Format Handling: Handles 4:3 to 16:9 aspect ratio correction with smart padding and preserves/remuxes the original audio track.
GitHub: https://github.com/pratik227/upscale_video_4k
Sample Output - https://github.com/pratik227/upscale_video_4k/blob/main/outp...

value: Show HN: Local-First AI Video Upscaler with CPU Fallback


value: MrPan

value:
I am developing an architecture called Sparse Gated Resonance (SGR). It is a sequence modeling approach designed to avoid the quadratic scaling of traditional Self-Attention. I have been benchmarking a 722k-parameter SGR against a 921k-parameter Transformer on Victor Hugo’s "Notre-Dame de Paris" (English).
The SGR replaces the attention mechanism with a "Causal Pulse." It uses gated 1D convolutions to generate a navigation vector that resonates against a brain-map of character embeddings. This allows the model to maintain a "Living Cell" state that updates with linear complexity.
Full source and implementation: https://github.com/MrPan2048/GeometricTransformer/
Benchmarking Data (Notre-Dame de Paris):
STEP 3900 ARCH | LOSS | PPL | ENT | TIME
SGR | 1.4481 | 4.26 | 1.5476 | 19.0ms
STD | 2.0275 | 7.59 | 2.1476 | 40.3ms
Semantic Comparison (Generation from "Quasimodo"):
SGR: "Quasimodo. Then minds that the accasteady which which the"
STD: "Quasimododo ng, o uer tre the todo hemo’He wand at tine."
Technical Observations:
Computational Efficiency: SGR maintains a significant latency advantage, consistently running at ~19ms compared to the Transformer's ~40ms. This confirms the efficiency of the linear pulse over quadratic attention.
Convergence Quality: By Step 3700, SGR reached a Perplexity (PPL) of 4.46, whereas the Transformer lagged at 8.36. SGR successfully produces recognizable English phrases and punctuation, while the Transformer still exhibits "stuttering" artifacts (e.g., "Quasimodododod").
Entropy Stability: SGR has stabilized at an entropy of ~1.54, which represents the optimal "Mastery Zone" for English text. The Transformer’s higher entropy (~2.14) correlates with its lack of structural coherence.
I am seeking an endorsement to publish a formal paper on this architecture to arXiv (CS.ML). I believe these results demonstrate that "Living Cell" resonance models can outperform Attention in parameter-constrained and latency-sensitive environments. If you are a researcher willing to endorse or review the mathematical formalization, please contact me via GitHub.

value: Show HN: SGR – A Linear-Complexity "Living Cell" Outperforming Transformers

author: MrPan


value: kwnaidoo

value: Free Chrome extension! This tool makes learning with YouTube easier: simply right-click at any point in a YouTube video to leave a note. You can later return to the video and jump straight to the exact timestamp where the note was created, and keep a summary of all notes created across multiple YouTube videos.

value: Show HN: YouTube Notetaker. Right-click to add timestamped notes on videos

author: kwnaidoo


value: garkotipankaj

value: Show HN: Infera – agentic CLI for inferring and provisioning cloud infra

author: garkotipankaj


value: tgalal

value:
Exemplary tool created using my tool for turning prompts into "native-looking" executables:

  $ READFORME.md --help
  Usage: READFORME.md [OPTIONS] --repo <repo> --info <info>

  Prompt inputs:
        --branch <branch>  Branch name, defaults to "main"
        --repo <repo>      The github repository name
        --info <info>      Which info is needed [possible values: summary, installation, example, quickstart]

It's one of the more useful ones: extracts information from the README.md file from a github repo, e.g., usage:

  $ READFORME.md --repo tgalal/promptcmd --info summary
  A tool to define and run programmable prompts as native CLI commands: create .prompt templates, enable them
  with promptctl, and execute with argument parsing, stdin/stdout, multi-provider model support, caching, and
  load balancing.

value: Show HN: READFORME.md

author: tgalal

title: Show HN: READFORME.md


value: ayarotsky

value: Show HN: Diesel-guard v0.5.0 – Lint Diesel/SQLx Postgres migrations (24 checks)

author: ayarotsky


value: tesladrivewatch

value:
Hi HN,
I’ve built TeslaTV (https://teslatv.net), a web-based entertainment platform designed specifically for Tesla’s in-car browser.
The goal is to make media consumption inside the car simpler and more enjoyable, especially while parked or charging.
Features:
- Optimized UI for Tesla’s browser
- Easy access to YouTube and other video platforms
- Live TV / IPTV support
- No app installation required (browser-only)
This is an independent, third-party project (not affiliated with Tesla).
I’m actively improving the UX based on user feedback.
I’d really appreciate any feedback, ideas, or criticism from the community.
Thanks!

value: Show HN: TeslaTV – Watch YouTube, Live TV and Streaming in Tesla's Browser

author: tesladrivewatch


value: Saltyfishh

value:
Hello HN,
I’m one of the creators of ServBay.
I built this because I got tired of the cognitive load required just to start coding. On my Mac, it was a fragile mix of Homebrew services and asdf conflicts. On Windows, managing PATH variables and fighting with Docker Desktop's resource usage was equally frustrating.
I missed the simplicity of the MAMP/XAMPP era, but I needed to support modern stacks (Go, Rust, Node, etc.).
What it is:
ServBay is a native local development environment for both macOS and Windows. It is not a wrapper around Docker or VMs. It bundles everything you need into a single, isolated ecosystem so it doesn't mess with your system libraries.
Key Features:
- Multi-Version Stacks: Run Python, PHP,Node.js, Go and Rust and more simultaneously. No path conflicts.
- Concurrent Databases: Run PostgreSQL 14 and 16 at the same time on different ports. Also supports MySQL, MariaDB, Redis, and MongoDB.
- Automatic SSL: Generates valid certificates for local domains automatically. No more mkcert manual steps.
- Built-in Tunneling: Expose localhost to the internet for webhook testing/demos.
Why not just use Docker (or WSL)?
We use Docker for production. But for local dev, the file system sync latency and resource overhead can be overkill for day-to-day coding. ServBay is designed for when you just want to write code immediately without waiting for containers or virtual machines to spin up.
I’d love to hear your feedback on your current local workflow. I'll be here to answer any questions!
Link: https://www.servbay.com

value: Show HN: ServBay – Native local dev environment (modern XAMPP)

author: Saltyfishh


value: uppnrise

value:
A friend of mine was struggling with manually extracting data from PDFs, so I built a REST API to automate it.
Main features:
- Text extraction (full document or specific pages)
- Table extraction → JSON with headers/rows
- Invoice parsing → vendor, amounts, line items, tax (auto language detection)
- Resume parsing → contact info, skills, work experience, education
- Metadata, links, embedded images extraction
API endpoint: https://pdfpull-895295000838.europe-west1.run.app/docs
Playground: https://bnacar.dev/pdfpull-landing/playground.html
Tech: FastAPI, PyMuPDF, pdfplumber. Rule-based extraction (no LLM API calls).
The invoice/resume parsers detect language automatically (EN/DE/TR) and extract fields without per-template configuration.
Demo key for testing: sk_demo_123456789
Example request:

    curl -X POST "https://pdfpull-895295000838.europe-west1.run.app/api/v1/parse/invoice" \
      -H "X-API-Key: sk_demo_123456789" \
      -F "file=@invoice.pdf"

Returns structured JSON:

    {
      "vendor_name": "ACME Corp",
      "invoice_number": "INV-2024-001",
      "total_amount": 1250.00,
      "currency": "USD",
      "line_items": [...],
      "confidence": 0.92
    }

Free to try (100 requests with demo key). Looking for feedback on the API design and what document types to add next.

value: Show HN: Pdfpull – PDF extraction API with structured invoice and resume parsing

author: uppnrise


value:
Hey HN, I've built auto-focus a small macOS application that runs in the background, detects automatically when you are in the flow and disables notifications for you. No fancy AI, no cloud, just a simple setup of your work apps/sites and Auto-Focus will protect your flow.
It would make my day if you give it a try.

value: Show HN: Auto-Focus – Automatically block Notifications when in the flow


value: rageonruby

value: Show HN: Rage – A fiber-based Ruby framework

author: rageonruby


value: AutYellow

value:
Hey HN,
I built QuietPage because I loved 750words.com but it felt dated and had zero privacy guarantees. And honestly, I wanted to build something.
It's a journaling app with:
- Daily writing with auto-save (like 750words)
- End-to-end encryption (Fernet: AES-128-CBC + HMAC-SHA256)
- Streak tracking to build the habit
- Mood tracking and basic analytics
- Tag system
Each user gets a unique encryption key, entries are encrypted before they hit the database. Even I can't read them.
Tech stack is Django REST + React + PostgreSQL + Redis. Running on Railway but you can also self-host it with Docker.
It's free to use right now. To be honest, I'm not sure about monetization yet, just want to see if people actually find it useful first :)
Would love your feedback!

value: Show HN: QuietPage – Privacy focused journaling with E2E encryption

author: AutYellow


value: hjegeorge

value:
`nothingtoseehere` (PyPI) generates human-like mouse movement + typing for browser/UI automation, especially web agents (Fitts’ Law, asymmetric velocity profiles, tremor, layout-aware typos, etc.). Built for consent-backed workflows where perfectly linear automation looks uncanny and gets misclassified as non-human.
Repo has a Wikipedia demo + a writeup with research/citations.
Also interested in the ethics/norms here: what does “good citizen” agent behaviour on the web look like before this turns into an arms race? If you work on bot mitigation / anti-fraud (Cloudflare or otherwise), I’d love your perspective.

value: Show HN: Allowing web agents to click and type like humans (Python library)

author: hjegeorge


value: hardiksondagar

value:
Hey HN — I built Take a Break, a Chrome extension that starts a timer on streaming sites and gently reminds you when it’s time to sleep. It shows a countdown with snooze, and a midnight reminder without auto‑close. You can customize timers and sites.
Would love feedback on UX and if the reminders feel too aggressive or too soft.
Demo / listing: https://chromewebstore.google.com/detail/ehhhemnkemficpheoid...
Repo: https://github.com/hardiksondagar/take-a-break

value: Show HN: Take a Break – a gentle extension to stop autoplay late at night

author: hardiksondagar


value: nihakue

value:
I don't feel like my brain is wired to make friends on the internet anymore. Everything seems to either happen in totally isolated private groups or on such a massive stage that it's hard to be myself. On top of that, everyone is yelling at the top of their lungs to be heard over the din, or catering what they say to appease algorithms. There isn't much room for nuance. Then when we aren't on this big stage we're in these carefully curated protective bubbles that shield us from any kind of discord.
I wanted to create a place where people can talk and hang out and build communities at a more human scale. A site where people are smooshed together more or less randomly and sheltered for long enough that they can hopefully find some common ground.
I'm building Isles ( https://isles.app/ ), which is just this really simple/dumb forum that has two things that set it apart:
1. When you sign up, you're put on an island randomly. You can only see posts from others on that island. Island populations are capped
2. Very occasionally, two islands will 'link up' basically at random. For a short time, both islands can interact with each other. When the islands separate, you can choose to stay on the other island. If you do, you can't go back unless those two islands link again.
That's it. My hope for Isles is that it gives people a break from big homogenous social spaces. It's really early days and still more of a sketch than an actual product, but I wanted to share it to see if the idea resonated with others. I'm looking for any feedback at all.

value: Show HN: I'm building an experimental forum to help people connect

author: nihakue


value: Show HN: Automatic Chrome tab grouping that runs on-device


value: Show HN: Aviation Compliance Checker – Automated FAA Compliance for GitHub


value: smallluo

value:
I built this after realizing that most reading tools
optimize for extracting information, not for reading itself.
This app is designed for staying with a book:
- minimal, distraction-free UI
- offline-first, local data
- no forced notes, no summaries, no gamification
You open a book, read a chapter, and think.
Nothing interrupts you unless you ask.
It’s not about reading faster.
It’s about reading more attentively.
I’m sharing this to get feedback from people
who care about books and deep reading.

value: Show HN: A quiet, offline-first reading app for reading books

author: smallluo


value: flammafex

value:
I built Freebird as a resistance to the surveillance state that has been established in the United States. Every useful system requires identity by default. Want rate limiting? Track users. Want access control? Create accounts. Want to prevent spam? Surveil everyone.
Freebird uses VOPRF (Verifiable Oblivious Pseudorandom Function) to separate "can you do this?" from "who are you?" Users get unforgeable tokens that prove authorization while revealing nothing about identity. The issuer can't link issuance to usage. The verifier can't identify the token holder. Correlation is mathematically impossible.
Real-world use cases:
- Marginalized community identity verification without keeping a list of said marginalized people.
- Municipal feedback systems (residents report issues without fear of retaliation)
- Anonymous voting (one person, one vote, enforced cryptographically)
- Library computer time limits (without logging what people read)
- STI clinic eligibility (without creating subpoenable records)
It's built in Rust, implements the IETF VOPRF draft, and is fully self-hostable. Try it:
git clone https://github.com/flammafex/freebird
cd freebird
docker compose up
Apache 2.0.
I'd love feedback on the implementation and where else this could be useful.

value: Show HN: Freebird – Authorization without identity using VOPRF cryptography

author: flammafex


value: kirilldn

value:
Hi HN,
I’m Kirill, a developer, and I’ve been building Festiveo, an app for music festival lovers. It helps you discover festivals worldwide, track lineups, get updates, and plan your festival calendar.
Some things you can do with Festiveo:
Browse festivals by country, genre, or date.
See full lineups and artist info.
Save festivals to your personal list.
Get early alerts about lineup rumors and updates.
I built this app because I love going to festivals and wanted an easier way to keep everything organized in one place.
I’d love to hear your feedback on the app, what features you’d like, and what could make it more useful for festival-goers.
You can check it out here: [link to your app/website]
Thanks for taking a look!
— Kirill

value: Show HN: Festiveo – Find and Track Music Festivals Around the World

author: kirilldn


value:
Hi HN,
I got tired of having to register and having friends having to register accounts just for accepting a party or dinner invitation (also plenty of friends have left social media) so I coded a minimal, no-login event tool: https://yupno.com
Dev-friendly stuff: Full REST API, async webhooks for RSVPs with Slack/Discord-adapted payloads. Auto-generates Ical, JSCalendar and JSON-LD. No auth, uses admin/user tokens in url. Should be possible connect to other stuff in fun ways.
Free to use, no ads, no tracking. I just wanted a simple tool that respects my time and privacy. Might figure out some way to monetize it if it gets traction, perhaps Stripe integration for tickets to events or something.
Docs/API details: https://yupno.io/docs.html

value: Show HN: Yupno – No-login RSVP tool with REST API and webhooks


value: rmqyeby

value: Show HN: ClipDock – a visual clipboard workspace for screenshots on Windows

author: rmqyeby


value: enginyoyen

value: Show HN: An account protection API beyond disposable email blocks

author: enginyoyen


value: aradzhabov

value: An open-source solution designed for individuals with extreme physical limitations, including total paralysis. When traditional assistive tech fails, this works by interpreting a single micro-movement—like slightly opening the mouth—into full PC control. Features a core system that receives micro-signals from any sensor to navigate a customizable hierarchical menu. The system enables voice commands for non-verbal users and bypasses OS language barriers. Ready to restore digital independence.

value: Show HN: AbleMouse Beyond Switch – PC control for users with total paralysis

author: aradzhabov


value: mmsols

value:
Hey HN,
I built Captain's Deck because I missed Norton Commander-style file management on macOS.
Key features:
- Dual-pane interface
- Vim-style navigation (hjkl, gg, G, /)
- Built-in terminal with path sync
- Git integration (status badges, stage/unstage)
- Remote connections (SFTP, FTP, S3, WebDAV, cloud drives)
- Archive browsing (ZIP, RAR, 7z as folders)
- Retro themes (Norton Commander blue + CRT effects)
It's a native Swift/AppKit app. One-time $19.99 purchase, 14-day trial.
I'd love feedback on what would make this useful for your workflow.
https://captains-deck.com

value: Show HN: Captain's Deck – A dual-pane file manager for macOS

author: mmsols


value: lilouartz

value:
Hey HN! This has been my project for a few years now. I recently brought it back to life after taking a pause to focus on my studies.
My goal with this project is to separate fluff from science when shopping for supplements. I am doing this in 3 steps:
1.) I index every supplement on the market (extract each ingredient, normalize by quantity)
2.) I index every research paper on supplementation (rank
every claim by effect type and effect size)
3.) I link data between supplements and research papers
Earlier last year, I took pause on a project because I've ran into a few issues:
Legal: Shady companies are sending C&Ds letters demanding their products are taken down from the website. It is not something I had the mental capacity to respond to while also going through my studies. Not coincidentally, these are usually brands with big marketing budgets and poor ingredients to price ratio.
Technical: I started this project when the first LLMs came out. I've built extensive internal evals to understand how LLMs are performing. The hallucinations at the time were simply too frequent to passthrough this data to visitors. However, I recently re-ran my evals with Opus 4.5 and was very impressed. I am running out of scenarios that I can think/find where LLMs are bad at interpreting data.
Business: I still haven't figured out how to monetize it or even who the target customer is.
Despite these challenges, I decided to restart my journey.
My mission is to bring transparency (science and price) to the supplement market. My goal is NOT to increase the use of supplements, but rather to help consumers make informed decisions. Often times, supplementation is not necessary or there are natural ways to supplement (that's my focus this quarter – better education about natural supplementation).
Some things that are helping my cause – Bryan Johnson's journey has drawn a lot more attention to healthy supplementation (blueprint). Thanks to Bryan's efforts, I had so many people in recent months reach out to ask about the state of the project – interest I've not had before.
I am excited to restart this journey and to share it with HN. Your comments on how to approach this would be massively appreciated.
Some key areas of the website:
* Example of navigating supplements by ingredient https://pillser.com/search?q=%22Vitamin+D%22&s=jho4espsuc
* Example of research paper analyzed using AI https://pillser.com/research-papers/effect-of-lactobacillus-...
* Example of looking for very specific strains or ingredients https://pillser.com/probiotics/bifidobacterium-bifidum
* Example of navigating research by health-outcomes https://pillser.com/health-outcomes/improved-intestinal-barr...
* Example of product listing https://pillser.com/supplements/pb-8-probiotic-663

value: Show HN: I've been using AI to analyze every supplement on the market

author: lilouartz


value: dgerlanc

value:
Hi HN,
I built MMI (Mother May I?) with Claude Code to solve an annoying friction point: manually approving every single Bash command.
The Problem
Claude Code asks for permission before running any shell command. This is sensible from a security standpoint, but it means you're constantly hitting "approve" for commands like git status, pytest, or ls -la. It breaks flow and adds friction to every development session.
The Solution
MMI is a CLI hook that auto-approves known-safe commands while maintaining a fail-secure default. Unrecognized commands still require manual approval.
How it works:
1. Deny list checked first – Dangerous patterns (sudo, rm -rf /, chmod 777) are always rejected
2. Safe commands allowlisted – Read-only commands, test runners, linters, and build tools you configure
3. Proper shell parsing – Uses an AST-based parser (mvdan.cc/sh) to correctly handle pipes, chains, and quoted strings
4. Audit trail – Every decision logged to JSON-lines for debugging and compliance
Key design decisions:
- Fail-secure: Unknown commands require manual approval
- Command chains validated: "safe && dangerous" is rejected (ALL segments must be safe)
- Wrapper-aware: Strips timeout, env, .venv/bin/ before validation
- Heredoc-smart: Backticks inside quoted heredocs treated as literal text
Example config (TOML):
```
  [safe]
  simple = ["ls", "pwd", "cat", "head", "tail"]
  subcommands.git = ["status", "log", "diff", "add", "commit", "push"]
  subcommands.cargo = ["build", "test", "check", "clippy"]<p><pre><code>  [deny]
  simple = ["sudo", "su", "doas"]
  regex = ["rm\\s+(-[^\\s]*)?.*\\s+/($|\\s)"]</code></pre>
```
A note on security
Claude Code recently added built-in sandbox mode that restricts file system writes and network access. This is a great step toward secure defaults. However, MMI still provides value even with sandboxing:
- Audit trail – Every command decision logged for review and compliance
- Explicit allowlists – Know exactly what's approved rather than relying on implicit sandbox rules
- Deny patterns – Block specific dangerous patterns before they hit the sandbox
- Reduced interruptions – Sandbox mode can still prompt; MMI auto-approves known-safe commands
No allowlist can anticipate every attack vector. MMI is a convenience layer that reduces friction for common safe commands while maintaining defense-in-depth – it works alongside sandboxing, not as a replacement.
Why not just approve everything?
That defeats the purpose of Claude Code's permission system. MMI lets you define exactly which commands you trust, keeps a complete audit trail, and defaults to asking when uncertain.
The repo includes example configs for Python, Node, Rust, and a strict read-only mode.
GitHub: https://github.com/dgerlanc/mmi
Blog post with more details: https://dangerlanc.com/writing/mmi/

value: Show HN: Mother May I? – Auto-approve safe Bash commands in Claude Code

author: dgerlanc


value: juliavvrn

value:
Hi HN. I built an API to solve personality drift in long LLM contexts.
Unlike RAG (which handles facts), AIIM enforces behavioral state using 12 parametric locks (Logic, Empathy, etc.) and tracks emotional decay. It forces the model to stay "in character" even when the context window fills up.
Free API for devs: https://ai-im.tech

value: Show HN: AIIM – Parametric Identity Engine for Consistent NPCs

author: juliavvrn


value: lastodyssey

value:
Hi hn,
I made a small relaxing game for additive color mixing at https://playdropstack.com/hueflow/
Thanks

value: Show HN: Hueflow – Additive Color Mixing

author: lastodyssey


value: sheikyon

value: Show HN: LLM-X – Know How Much Memory Your LLM Needs

author: sheikyon


value: morozred

value:
Hi HN — I built a small CLI called SkillLens to help answer: “What agent skills do I have installed, and are any of them sketchy?”
A lot of agent ecosystems (Claude/Codex/OpenCode, etc.) store skills as folders with a SKILL.md. These files can contain surprisingly powerful instructions (and sometimes unsafe patterns), but they’re easy to forget once installed. We're also tend to run them with --dangerously-skip-permissions and let them install whatever they want, but I got a bit anxious about it so decided to build a tool to have some peace of mind.
I decided to not go with AST static check but instead use whatever CLI you have locally to validate it.
SkillLens does two things:
1. Discovery: it scans common local skill locations (configurable) and lists what it finds.
2. Optional audit: if you have an auditor CLI installed (claude or codex), it sends each SKILL.md (currently truncated to ~12k chars) to the auditor and asks for structured JSON output:
- verdict: safe | suspicious | unsafe
- risk: 0–10
- summary + issues with evidence
It also caches audit results locally so reruns won't check skills again unless those were updated, you installed anything new or you explicitly asked it to do so with --force flag.
Install/run:
npx skilllens scan
# or
pnpm dlx skilllens scan
Notes / caveats:
- v0.1; I’m still iterating on the prompt/schema and the “what counts as suspicious” heuristics.
- Today it sends the skill text to whatever your auditor CLI uses (so treat it like sharing the skill contents with that provider). “Redacted evidence extraction” is planned, but not implemented yet.
- If the auditor CLI isn’t installed, it still produces a scan report and marks audits as skipped.

value: Show HN: SkillLens – scan and audit locally installed agent skills

author: morozred


value: Damianroot

value: Cursor changed how I write code, and wanted the same for writing. Bluefeather lives in your doc, suggests edits inline for you to accept/reject instead of copy-pasting to ChatGPT. For papers, contracts etc.  Still early in building so alpha testers are welcome.

value: Show HN: Curor/Lovable for Writing

author: Damianroot

title: Show HN: Curor/Lovable for Writing


value: cybrefly

value: Show HN: Codify – From Casual Browser Actions to Reusable Automation Tools

author: cybrefly


value: dassh

value:
I built this for myself while debugging multimodal AI APIs.
The problem: I kept running into JSON responses stuffed with Base64-encoded images. Every time, I had to copy the string, find an online decoder, paste, preview. Repeat for each image. It got old fast.
So I made ViewJSON. Paste your JSON, and it automatically detects and renders Base64 media inline: images, audio, video, even PDFs. No more copy-paste decode loops.
Other things it does:
- Format/minify JSON
- Paste an image, get Base64 string (reverse direction)
- Build API requests, copy as cURL
- Variable substitution for testing
- Share JSON via URL
No login, completely free. Would love feedback on edge cases I might have missed!

value: Show HN: I built a JSON viewer that decodes Base64 media inline

author: dassh


value: Show HN: Doclific – ERD's, Architecture Diagrams, and Snippets, All in Your Repo


value: yaoluxing

value: Built a modern web app to help people in Pakistan calculate the import taxes for mobile devices. The PTA (Pakistan Telecommunication Authority) requires taxes ranging from 18% to 47% depending on your identity type.

value: Show HN: PTA Tax Calculator – Calculate Pakistan mobile import taxes instantly

author: yaoluxing


value: lukapg

value:
Hi HN,
I’m building Formtone, a form backend that analyzes form responses and surfaces the signal that usually gets buried.
Once forms start getting real volume (support, feedback, reviews), reading every submission doesn’t scale. Important issues get missed, and everything starts to feel equally urgent. Users may point to the same problem or request the same feature in many different ways. Manual triage often misses this.
Formtone processes incoming text and:
- detects sentiment
- scores priority
- categorizes responses into user defined categories
- summarizes responses
- drafts suggested replies
- suggests actionable insights based on recurring patterns
It also tracks sentiment change week over week for each form you create and find most common issues.
It works with any form via a simple API or webhook, and can push insights to tools like Slack or Discord.
I’m especially interested in feedback on:
- whether this solves a real problem for you
- what signals you’d want surfaced first
- how you handle form feedback today
Happy to answer questions. Thanks for taking a look.

value: Show HN: Formtone – intent detection for forms (API-first)

author: lukapg


value:
Hi HN,
I built BrightGrade, a collection of grade calculators to help students:
• Final Grade Calculator – What score do you need on your final?
• Weighted Grade Calculator – Category weights (homework 20%, exams 50%, etc.)
• Semester Grade Calculator – Track your progress throughout the semester
• GPA Calculator – Convert letter grades to GPA
• College Grade Calculator – Weighted by credit hours
• Assignment Grade Calculator – Calculate assignment grades and scores
Available in English, Spanish, and French. No sign-ups, totally free.
brightgrade.app
Feedback appreciated!

value: Show HN: BrightGrade-Grade Calculators (Final, GPA, Weighted, Semester)


value: jennalk

value:
I saw a Terrence Tao quote recently, that AI is great at converting billions of pieces of data into one good answer, but humans are great at taking 10 observations and making an inspired guess. That ability to make inspired guesses is something we should retain.
I built this because I caught myself using ChatGPT for things I used to think through myself, like emails, texts, basic problems. I was skipping the thinking part to get to the answer faster.
My own thinking has started feeling duller. struggling with hard ideas and coming up with something original is something I've been outsourcing as of late. So I built this for myself and anyone else who wants that back.
The premise is simple: One creative, weird, provocative prompt a day, to be answered by yourself. just a daily rep to try and think for yourself again.

value: Show HN: A tool to practice lateral thinking organically

author: jennalk


value:
I Built an Infinite Canvas for AI Image and Video creation Because I Was Tired of switch between different website and interrupts my creative process。
Here's the core idea: what if you could dump all your creative thoughts, reference images, and video outputs onto one surface—like organizing ideas on a whiteboard? Then connect the dots between them, literally.
Because that's actually how your brain works when you're planning a creation.
No more tab-switching that kills your momentum. No more "wait, where did I save that file?" moments that yank you out of the zone.
Everything's right there, organized the way your mind naturally works—spatially, not linearly.
you can keep creating on the same canvas while the ai is generating.
there is more feature on https://storyvid.ai/, i hope anyone face the same issue would like it.

value: Show HN: StoryVid – create image and video on an infinity canvas


value: gxjoe

value: Show HN: Hands-on guide to immersive 3D maps on the web

author: gxjoe


value:
https://github.com/quilrai/LLMWatcher/releases/latest/downlo... - Signed and Notarized app
I use coding agents (claude code, codex, cursor etc) a lot and wanted a lightweight app which
1 - have searchable logs of all conversations
2 - rate limit or get notified if using too much context length (-especially useful for reminding myself to use a new session)
3 - block api keys etc from going to LLM providers
4 - get overview of tokens, tools used, and other interesting information
So, I made LLMWatcher
Using base url feature supported by most of the coding agents, LLMWatcher sits in the middle of coding sessions and can do all the above + some extra goodies
Also has a LLM Gateway feature, which can be used to get monitored/ proxied URLs with controls for any LLMs
Would love some feedback on this and to know if anyone finds it useful
Note: Always wanted to make desktop apps, and Tauri made it very easy to do so. Attempted with python first but got dragged into signing and packaging hell

value: Show HN: I made a Mac app for rate limiting and monitoring LLM requests


value: stewartjarod

value:
Hey HN, I'm Jarod. Spent 2 years at SendGrid watching developers struggle with email infrastructure. Built Wraps to fix the SES setup problem.
One command or package (CDK & Pulumi) deploys production email infra to your AWS account:
`npx @wraps.dev/cli email init`
~30 seconds to configure SES, DKIM/SPF, event tracking, and sandbox exit. You own everything—we just provide the tooling.
Key decisions:
- BYOC: Deploys to your AWS, you pay AWS directly for sending
- Zero credentials stored: OIDC federation only
- Open source CLI/SDK: MIT licensed, free forever
- No lock-in: Send emails and SMS from YOUR AWS account.
Dashboard with templates/analytics/broadcasts/automations is $10-149/month, tiered around the number of custom events you send. CLI and SDK are free.
Tradeoffs: You need an AWS account. If you want zero AWS involvement, the managed services are solid.
Happy to discuss architecture decisions or answer questions.

value: Show HN: Wraps – AWS SES made usable (templates, broadcasts, + automations)

author: stewartjarod


value:
I built OopsAgain to solve a specific problem: iOS makes it easy to forget birthdays, even when they’re in Contacts.
The app lets you view existing birthdays or add missing ones to contacts, set per-person reminder schedules (including multiple reminders), and surface upcoming birthdays via a home screen widget.
OopsAgain stores contact name, picture, and birthday locally only, purely to enable displaying the upcoming birthday on the widget. Nothing is uploaded or synced to any server.
This is an early version and I’m mainly looking for real-world feedback on whether the reminders, widget, and overall flow are actually useful.
You can try it via TestFlight here:
https://testflight.apple.com/join/VnugUCbA
I’m around in the comments for questions and feedback.

value: Show HN: OopsAgain – a small iOS app to stop forgetting birthdays


value: smravec

value: Show HN: Opinionated, zero-config blocker for Reels and Shorts

author: smravec


value: ryanshrott

value: Show HN: Local voice-to-text app that types keystrokes (works in RDP/Citrix)

author: ryanshrott


value: mooball

value:
I got tired of waiting on ChatGPT to finish "cooking", so I made an extension that plays a sound when it's done generating.
Originally I just shared with friends/family but I'm starting to get random reviews like: "love the tool, hate the sound."
https://github.com/rumblelab/chatdinger
https://go.chatdinger.com/hn
I'm curious, what sound do you think the AI should make when it's done cooking? And why the heck hasn't openAI made this native yet?

value: Show HN: A Chrome extension that dings when ChatGPT is done "thinking"

author: mooball


value: wabiosdev

value:
Hi HN — I built Accent AI, an iOS/Android pronunciation + public speaking coach.
What it does:
- Listen to short prompts and give feedback on pronunciation, stress/intonation, pacing, and breathing.
- A “meeting mode” style practice for clearer speech under pressure (stage anxiety / speaking confidence).
Why I built it:
I work with many non-native English speakers who can write English well but aren’t understood quickly in calls/interviews. I wanted fast, targeted drills that focus on clarity (not just vocabulary).
How it works (happy to go deep in comments):
- [Briefly describe your pipeline/model choices, scoring method, and what’s computed on-device vs server]
- Privacy: [What audio is stored? for how long? opt-out?]
- Platforms: iOS + Android.
Pricing:
For the next 20 hours I’m running a one-time promo: lifetime is free on iOS and $0.50 on Android. After that it returns to normal pricing
(Using Gemini btw)
I’d love blunt feedback on accuracy and what would make this genuinely useful in real meetings/interviews.

value: Show HN: Accent AI – real-time speech clarity drills (pronunciation,stress etc.)

author: wabiosdev


value: matthewduff

value:
Hi HN, we’re the creators of Borr AI. We’ve open-sourced a pipeline designed to turn physical retail environments into structured, auditable data.
In digital products, we have high-fidelity analytics for every user interaction. In physical retail, that data is usually locked inside proprietary black boxes or grainy CCTV. Borr is a self-hosted platform that fuses stereo vision and weight telemetry to create a "computational truth" for physical spaces.
The Use Cases:
Forensic Theft Detection
Instead of just recording video, Borr generates a hashed "evidence packet." It correlates 3D proximity events with weight sensor deltas to provide a mathematical certainty estimate of an interaction, making it auditable for security and court admissibility.
We provide the primitives to track customer journeys in 3D without cloud facial recognition. You can analyze shelf "dwell times," product interaction rates, and heatmaps with millimeter precision using our DLT (Direct Linear Transform) solvers.
Checkout-Free Retail: The system could be expanded to track "identity custody" across camera blind spots using a BIP solver. This allows developers to build "Just Walk Out" experiences where transactions are validated by the fusion of vision and weight data.
Technical Stack:
Dual-camera triangulation using YOLOv8-pose. Probabilistic correlation of weight sensors (0.7 weight) and vision events (0.3 weight). Locally-Aware Transformers (LATransformer) to maintain persistent user IDs without biometrics.
https://github.com/phamtrung0633/retail-ai

value: Show HN: Borr AI – An open-source telemetry for retail

author: matthewduff


value: underwoodxie

value:
While testing Nano Banana Pro, I tried a different habit: instead of explaining “change this area,” I simply marked the exact spots on the image. The results felt instantly more controllable, so I turned that workflow into a canvas-based editor that sends the image + marks to the model in one step.
3 bullets
Canvas-first editing: doodle/annotate directly on the image (circle/paint/point) to show where to change
One-click “image + marks → AI” loop, designed to reduce ambiguity and cut down retries
A few tuned presets that most people tend to like (e.g., 1-click contact sheet, 2D → 3D conversion)
Video example：https://x.com/underwoodxie96/status/2014271173132173642
Try it here：https://promptsref.com/tool/AI-Image-Editor

value: Show HN: Mark edits on images, then send them to AI

author: underwoodxie


value:
After running a web design company for 14 years and selling it, I was looking for a new way to build WordPress sites with AI that didn’t involve page builders, adding designers, bloated themes, or starting from a blank canvas every time.
A few challenges I faced in building, maintaining, and updating nearly 1,500 websites on Wordpress were:
1) Plugin bloat - The more plugins required, the slower Wordpress became.
2) Website Builders - Updating website builders without breaking client websites was a near impossible task.
3) Staff grew as we added customers - We were forced to add staff with specific skillsets to help build new sites AND also maintain website for customers.
So I tried building Wordpress sites the following ways:
* Traditional WordPress themes that never look like the demo without hours of tweaking.
* Wordpress builders that lock you into proprietary plugins that added bloat or broke sites when you try to update. This is what we did prior. Not much has changed.
* No-code & AI builders that could only export static HTML or web apps, not SEO friendly websites. This produced beautiful sites but they couldn't be indexed by Google and Bing as Single-Page Applications.
None of these fit my desired workflow so I built PressMeGPT.com:
PressMeGPT is an AI powered theme generator uses AI to design homepages and then turn it into a WordPress theme, not just HTML or a mockup. You describe the site in plain English, refine it with prompts, choose fonts, stock photos, and icons, and then export to either a Classic WordPress Theme, or modern Gutenberg Block Theme that works with Full Site Editor.
My goal was to cover the 80% of work that normally happens when designing a website, then customize it in Wordpress by reusing styles, layouts, and components across the rest of the site instead of rebuilding everything manually.
This started as a solution to my own workflow problem - a friend recommended I make it public so here it is.

value: Show HN: Pressmegpt.com Generate Classic and Gutenberg WordPress Themes with AI


value: jsontsx

value: the best model kept switching and I wanted to experiment with the models as soon as possible.

value: Show HN: I built an iOS app with all 5 major AI models for $13/mo

author: jsontsx


value: epsteingpt

value:
Built an auditable AI (Bible) translation pipeline: Hebrew/Greek source packets -> verse JSON with notes rolling up to chapters, books, and testaments. Final texts compiled with metrics (TTR, n-grams).
This is the first full-text example as far as I know (Gen Z bible doesn't count).
There are hallucinations and issues, but the overall quality surprised me.
LLMs have a lot of promise translating and rendering 'accessible' more ancient texts.
The technology has a lot of benefit for the faithful, that I think is only beginning to be explored.

value: Show HN: Bible translated using LLMs from source Greek and Hebrew

author: epsteingpt


value:
I built an AI that detects chart patterns to fight my own confirmation bias I kept losing money on trades because I'd "see" patterns that weren't there. Classic confirmation bias — when you're already in a position, your brain lies to you.
So I built a tool: upload any chart screenshot, get pattern detection in seconds.
Why Gemini over GPT-4V?
Tested both. Gemini 1.5 Flash is: - Faster (~2s vs ~5s) - Cheaper (~$0.0001 per analysis) - More consistent structured outputs for this specific task GPT-4V sometimes gave me essays. Gemini stayed focused.
Stack: Next.js 14, Supabase (auth + postgres), Stripe, Vercel
The hard parts weren't the AI:  - Auth edge cases (email confirmation flows, session refresh) - Credit system (what happens when API fails mid-request? refund?) - Making it not look like a hackathon project (I'm a backend guy, CSS is pain)
Is it always right? No. TA itself is debatable. But it's a second opinion that doesn't care what positions I'm holding. That's the value.
https://trinith-ai.vercel.app
Would love feedback from:
- Traders who can tell me if the output format is useful
- Anyone who's built with vision APIs (optimization tips?)
- Skeptics who think this is dumb (genuinely want to hear why)

value: Show HN: Open-source-ish chart pattern detection using Gemini Vision API


value: vibefarm

value:
Creator here.
I built VibeFarm because prompt work kept collapsing into scattered notes, version chaos, and lost “recipes” across Midjourney, Sora, DALL·E, ChatGPT, etc. I wanted something closer to an IDE: structured, reusable, and model-agnostic, not a chat wrapper.
VibeFarm is a non-generative prompt composition workspace. Prompts are built from semantic slots (subject/context/style/etc.), optional layers, and saved snapshots (“VibeCards”) that export clean prompts to any model or to a portable .vibe JSON format.
Design choices:
- No generation inside the app, it’s intentionally just composition (no model lock-in, no API costs).
- Static curated vocabulary: 20,000+ palettes, ~1M fragments, instant drag-drop, no runtime calls.
- Reuse-first: variables for series swaps, video-mode timeline overrides, and versioned snapshots.
Try it instantly (guest mode): https://app.vibefarm.ai
Homepage: https://vibefarm.ai
Optional demo video: https://youtu.be/IgEly7VpwwI
Happy to answer questions or hear feedback, especially from people doing structured or repeatable prompt work.

value: Show HN: VibeFarm – A non-generative IDE for composing AI prompts

author: vibefarm


value: cenrunzhe

value:
Hi HN,
I’m the maker of ChartGen AI. Last year, we launched a text-based AI agent called Ada.im. After analyzing thousands of user interactions, we stumbled upon a pattern we hadn't expected: users were constantly trying to paste data rows and ask for visual representations, but the text-based model couldn't handle it well.
We realized that for marketers, seeing the trend is more valuable than reading about it.
We pivoted that insight into a standalone tool:
Drag & Drop: Upload raw CSVs (FB Ads, GA4, TikTok, etc.).
Processing: We map the disparate column names into a unified schema.
Viz: It generates interactive charts to show ad spend ROI and conversion trends.
It's an attempt to make data storytelling accessible without needing a data analyst or SQL knowledge.
Would love to get your thoughts on the UX.
chartgen.ai

value: Show HN: It took us 4 months to realize that users wanted charts, not text

author: cenrunzhe


value: miketu

value: Helping freelancers close deals

value: Show HN: ManagerList Is Now Live

author: miketu

story_text: Helping freelancers close deals

title: Show HN: ManagerList Is Now Live


value: felarof

value:
Hey HN! We're Nithin and Nikhil, twin brothers building BrowserOS (YC S24). We're an open-source, privacy-first alternative to the AI browsers from big labs.
The big differentiator: on BrowserOS you can use local LLMs or BYOK and run the agent entirely on the client side, so your company/sensitive data stays on your machine!
Today we're launching filesystem access... just like Claude Cowork, our browser agent can read files, write files, run shell commands! But honestly, we didn't plan for this. It turns out the privacy decision we made 9 months ago accidentally positioned us for this moment.
The architectural bet we made 9 months ago: Unlike other AI browsers (ChatGPT Atlas, Perplexity Comet) where the agent loop runs server-side, we decided early on to run our agent entirely on your machine (client side).
But building everything on the client side wasn't smooth. We initially built our agent loop inside a Chrome extension. But we kept hitting walls -- service worker being single thread JS; not having access to NodeJS libraries. So we made the hard decision 2 months ago to throw away everything and start from scratch.
In the new architecture, our agent loop sits in a standalone binary that we ship alongside our Chromium. And we use gemini-cli for the agent loop with some tweaks! We wrote a neat adapter to translate between Gemini format and Vercel AI SDK format. You can look at our entire codebase here: https://git.new/browseros-agent
How we give browser access to filesystem: When Claude Cowork launched, we realized something: because Atlas and Comet run their agent loop server-side, there's no good way for their agent to access your files without uploading them to the server first. But our agent was already local. Adding filesystem access meant just... opening the door (with your permissions ofc). Our agent can now read and write files just like Claude Code.
What you can actually do today:
a) Organize files in my desktop folder https://youtu.be/NOZ7xjto6Uc
b) Open top 5 HN links, extract the details and write summary into a HTML file https://youtu.be/uXvqs_TCmMQ
--- Where we are now
If you haven't tried us since the last Show HN (https://news.ycombinator.com/item?id=44523409), give us another shot. The new architecture unlocked a ton of new features, and we've grown to 8.5K GitHub stars and 100K+ downloads:
c) You can now build more reliable workflows using n8n-like graph https://youtu.be/H_bFfWIevSY
d) You can also use BrowserOS as an MCP server in Cursor or Claude Code https://youtu.be/5nevh00lckM
We are very bullish on browser being the right platform for a Claude Cowork like agent. Browser is the most commonly used app by knowledge workers (emails, docs, spreadsheets, research, etc). And even Anthropic recognizes this -- for Claude Cowork, they have janky integration with browser via a chrome extension. But owning the entire stack allows us to build differentiated features that wouldn't be possible otherwise. Ex:  Browser ACLs.
Agents can do dumb or destructive things, so we're adding browser-level guardrails (think IAM for agents): "role(agent): can never click buy" or "role(agent): read-only access on my bank's homepage."
Curious to hear your take on this and the overall thesis.
We’ll be in the comments. Thanks for reading!
GitHub: https://github.com/browseros-ai/BrowserOS
Download: https://browseros.com (available for Mac, Windows, Linux!)

value: Show HN: BrowserOS – "Claude Cowork" in the browser

author: felarof


value:
Writeup (includes good/bad sample generations): https://www.linum.ai/field-notes/launch-linum-v2
We're Sahil and Manu, two brothers who spent the last 2 years training text-to-video models from scratch. Today we're releasing them under Apache 2.0.
These are 2B param models capable of generating 2-5 seconds of footage at either 360p or 720p. In terms of model size, the closest comparison is Alibaba's Wan 2.1 1.3B. From our testing, we get significantly better motion capture and aesthetics.
We're not claiming to have reached the frontier. For us, this is a stepping stone towards SOTA - proof we can train these models end-to-end ourselves.
Why train a model from scratch?
We shipped our first model in January 2024 (pre-Sora) as a 180p, 1-second GIF bot, bootstrapped off Stable Diffusion XL. Image VAEs don't understand temporal coherence, and without the original training data, you can't smoothly transition between image and video distributions. At some point you're better off starting over.
For v2, we use T5 for text encoding, Wan 2.1 VAE for compression, and a DiT-variant backbone trained with flow matching. We built our own temporal VAE but Wan's was smaller with equivalent performance, so we used it to save on embedding costs. (We'll open-source our VAE shortly.)
The bulk of development time went into building curation pipelines that actually work (e.g., hand-labeling aesthetic properties and fine-tuning VLMs to filter at scale).
What works: Cartoon/animated styles, food and nature scenes, simple character motion. What doesn't: Complex physics, fast motion (e.g., gymnastics, dancing), consistent text.
Why build this when Veo/Sora exist? Products are extensions of the underlying model's capabilities. If users want a feature the model doesn't support (character consistency, camera controls, editing, style mapping, etc.), you're stuck. To build the product we want, we need to update the model itself. That means owning the development process. It's a bet that will take time (and a lot of GPU compute) to pay off, but we think it's the right one.
What’s next?
- Post-training for physics/deformations
- Distillation for speed
- Audio capabilities
- Model scaling
We kept a “lab notebook” of all our experiments in Notion. Happy to answer questions about building a model from 0 → 1.  Comments and feedback welcome!

value: Show HN: Text-to-video model from scratch (2 brothers, 2 years, 2B params)


value: kadirbelkuyu

value:
Creator here. If you manage multiple K8s clusters, you know the pain:
  kubectl config use-context staging-eu-west-1-prod-eks
  kubectl config set-context --current --namespace=monitoring
I built kubecfg to fix this:
  kubecfg add cluster.yaml          → import a kubeconfig file
  kubecfg add cluster.yaml --name prod  → import with custom context name
  kubecfg use                       → pick context interactively
  kubecfg ns                        → switch namespace
  kubecfg merge                     → combine kubeconfig files
Written in Go. Happy to answer questions!

value: Show HN: Kubecfg – A CLI to manage Kubernetes contexts and namespaces

author: kadirbelkuyu


value: BobbyLLM

value:
As a handsome local AI enjoyer™ you’ve probably noticed one of the big flaws with LLMs:
It lies. Confidently. ALL THE TIME.
I’m autistic and extremely allergic to vibes-based tooling, so … I built a thing. Maybe it’s useful to you too.
The thing: llama-conductor
llama-conductor is a router that sits between your frontend (eg: OWUI) & backend (llama.cpp + llama-swap). Local-first but it should talk to anything OpenAI-compatible if you point it there (note: experimental so YMMV).
LC is a glass-box that makes the stack behave like a deterministic system, instead of a drunk telling a story about the fish that got away.
TL;DR: “In God we trust. All others must bring data.”
Three examples:
1. KB mechanics (markdown, JSON, checksums)
You keep “knowledge” as dumb folders on disk. Drop docs (.txt, .md, .pdf`) in them. Then:
>>attach <kb> - attaches a KB folder
>>summ new - generates SUMM_.md files with SHA-256 provenance baked in + moves the original to a sub-folder
Now, when you ask something like:
> “yo, what did the Commodore C64 retail for in 1982?”
..it answers from the attached KBs only.
If the fact isn’t there, it tells you - explicitly - instead of winging it. Eg:
"The provided facts state the Commodore 64 launched at $595 and was reduced to $250, but do not specify a 1982 retail price. The Amiga’s pricing and timeline are also not detailed in the given facts.
Missing information includes the exact 1982 retail price for Commodore’s product line and which specific model(s) were sold then."
[Confidence: medium | Source: Mixed]
No vibes. Just: here’s what’s in your docs, here’s what’s missing, don't GIGO yourself into stupid.
Then, if you're happy with the summary, you can:
>>move to vault
2. Mentats: proof-or-refusal mode (Vault-only)
Mentats is the “deep think” pipeline against your curated sources.
* no chat history
* no filesystem KBs
* no Vodka
* Vault-only grounding (Qdrant)
It runs a triple-pass (thinker → critic → thinker). It’s slow on purpose. You can audit it. And if the Vault has nothing relevant? It refuses and tells you to go pound sand:
FINAL_ANSWER:
The provided facts do not contain information about the Acorn computer or its 1995 sale price.
Sources: Vault
FACTS_USED: NONE
[ZARDOZ HATH SPOKEN]
Also yes, it writes a mentats_debug.log. Go look at it any time you want.
The flow is basically:
Attach KBs → SUMM → Move to Vault → Mentats.
No mystery meat. No “trust me bro, embeddings.”
3. Vodka: deterministic memory on a potato budget
Potato PCs have two classic problems: goldfish memory + context bloat that murders your VRAM.
Vodka fixes both without extra model compute.
* !! stores facts verbatim (JSON on disk)
* ?? recalls them verbatim (TTL + touch limits so memory doesn’t become landfill)
* CTC (Cut The Crap)* hard-caps context (last N messages + char cap) and creates a concatenated summary (not LLM) so you don’t get VRAM spikes after 400 messages
So instead of:
“Remember my server is 203.0.113.42” → “Got it!” → [100 msgs later] → “127.0.0.1”
you get:
!! my server is 203.0.113.42`
?? server ip → 203.0.113.42 (with TTL/touch metadata)
And because context stays bounded: stable KV cache, stable speed, your potato PC stops crying.
There’s more (a lot more) in the README, but I’ve already over-autism’ed this post.
TL;DR:
If you want your local LLM to shut up when it doesn’t know and show receipts when it does, come poke it:
Primary (Codeberg)
https://codeberg.org/BobbyLLM/llama-conductor
Mirror (GitHub):
https://github.com/BobbyLLM/llama-conductor
PS: Sorry about the AI slop image. I can't draw for shit.
PPS: A human with ASD wrote this using Notepad++. If it the formatting or language are weird, now you know why.

value: Show HN: I'm tired of my LLM bullshitting. So I fixed it

author: BobbyLLM


value: wrogistefan

value:
I’ve been building a fully offline, local‑first TOTP authenticator for desktop (Windows/macOS/Linux).
No cloud, no sync, no telemetry, no external dependencies. Everything stays on the machine.
Why I built it:
Most 2FA apps are mobile‑only, closed‑source, or rely on cloud sync. I wanted something transparent, auditable, and desktop‑native — especially for people who work on multiple machines or air‑gapped environments.
Key features:
Local‑only storage (AES‑GCM + Argon2)
Encrypted vault with no external services
Cross‑platform desktop app
Import/export with encrypted backups
Open‑source, MIT licensed
Designed to be simple, predictable, and auditable
What’s new:
The project was recently accepted into the Kilo OSS Sponsorship Program, which gives me access to better tooling for code reviews and security analysis. This should help accelerate development and improve code quality.
Links:
GitHub: https://github.com/wrogistefan/desktop-2fa
Website: https://desktop-2fa.org
I’d love feedback on:
security model
threat assumptions
UX for onboarding
code structure and maintainability
missing features that would make it more useful
Happy to answer any questions.

value: Show HN: Desktop‑2FA – offline open‑source TOTP authenticator for desktop

author: wrogistefan


value: adius

value: Show HN: Brickify – Webapp to convert 3D models into Lego brick assemblies

author: adius


value: cannoneyed

value:
Hey HN! I wanted to share something I built over the last few weeks: isometric.nyc is a massive isometric pixel art map of NYC, built with nano banana and coding agents.
I didn't write a single line of code.
Of course no-code doesn't mean no-engineering. This project took a lot more manual labor than I'd hoped!
I wrote a deep dive on the workflow and some thoughts about the future of AI coding and creativity:
http://cannoneyed.com/projects/isometric-nyc

value: Show HN: isometric.nyc – giant isometric pixel art map of NYC

author: cannoneyed


value: ritammehta

value:
Hi Hacker News!
I’m Ritam, working with the small but mighty team at Nori. We’ve been obsessed in recent months with how to take tools like Claude Code from “I’ll experiment around with this” to “This is the most useful and necessary thing I use every day”. When I first sat down with our team to check out what they’d built, I found my skepticism about agentic coding melting away—they’d built useful, high quality, handwritten skills, instructions that functioned as “skillsets” to tie skills together for consistent and replicable results, and tooling to manage loading the right context for the right task into the agent.
In recent weeks, the conversation around skills has reached a fever pitch, as have lists and sites full of skills scraped from all over the internet. Much like the actual gold rush, the current state of those collections requires a lot of time and sifting to find small, real chunks of 24k skills hidden amongst the muck (or to use a more relevant word, slop). So at Nori, we decided to build an npm-style registry full of our curated skills and the necessary skillsets to tie them together. We’re launching it today at noriskillsets.dev, and it comes with a handy CLI tool to manage skills and skillsets on your machine, swapping them in and out of your Claude config as needed.
If you're not sure what I mean by skillsets: this is the real secret sauce that makes us way more productive. These are custom, purpose-built instruction sets for Claude Code that reference our skills and lay out how to tie them together into an appropriate SDLC, from planning to PR. There are lot of little weird semantic tricks that make Claude more attentive to instructions that we've baked into these.
Why not host these on Github? We're betting on our thesis: that it makes sense to tie these together with an easy to use CLI built to install and swap configs in and out of Claude, that a website custom-built for this purpose will allow us to iterate our way to surfacing what matters most and what doesn't to our users (custom, useful metadata), and that having an app separate from the discussion and churn on Github will make this a useful tool and less of a noisy social space.
If you’ve been excited about the recent discussion about Claude Code but don’t know where to start with customization: this tool is for you. If you’ve tried it and have found yourself underwhelmed by inconsistency or an inability to deal with complexity: this tool is for you. And if you’ve got your setup all customized but are constantly wading through hundreds of scraped sloppy skills online, searching for helpful ones… this tool is for you. We’re excited to hear what you think. We'll be adding more skills and skillsets from across the web from other folks that we trust, so come back frequently, and we encourage folks to send us the tools they love!

value: Show HN: A registry for curated, high quality Claude skills and skillsets

author: ritammehta


value: bhushanwtf

value:
Three.js recently introduced TSL (Three.js Shading Language), a way to write shaders in pure JavaScript/TypeScript that compiles to both GLSL and WGSL.
I built this editor to provide a visual interface for the tsl ecosystem. It allows developers to prototype shaders for WebGPU/WebGL and see the results in real-time. This is a beta release and I'm looking for feedback.

value: Show HN: A Node Based Editor for Three.js Shading Language (TSL)

author: bhushanwtf


value: trympet

value:
The goal of Swish is to provide a zero-click way to view your portfolio.
I made Swish after finding it too annoying and tedious to check my portfolio in my broker or Google Finance. This app removes the conscious decision to "poll" your portfolio by _always_ showing it on your desktop. While this might not be everyone's cup of tea, I hope that you find it interesting nevertheless.
After graduating high school (in 2020) and first getting started with stocks, I was surprised there were no simple "widget" apps for stock tickers. Somehow, what used to exist in the Windows Vista era ceased to exist. So, I made this app purely to satisfy my own needs, but then I quickly started getting email suggestions from customers to add new features. Even though my initial goal was to create something similar to the widgets in Windows Vista, it has now evolved into a much more refined experience.
I render the widgets using native Direct2D/Direct3D11/DComp APIs. There are still optimizations to be made in the rendering pipeline (hardware accelerated tessellation, using DirectComposition swap chain, etc.). I strive for high performance as I know many folks use my app on their laptop, where battery life is important. There are also a ton of features I'd like to add, but haven't had the time.
Let me know what you think!

value: Show HN: Swish Finance – a zero-click way to watch your portfolio

author: trympet


value: akarshc

value: Show HN: a small API layer for real-time AI streaming, retries, and debugging

author: akarshc


value: vhantz

value:
A handful of C++ libraries already exist for interprocess communication with i3wm. However, integrating them with Qt tends to require quite a lot of boilerplate. For my own projects, none of them could be integrated in a way that feels clean enough to my taste, so I decided to build my own library to do just that.
The result is qi3pc. A simple C++ library that provides idiomatic Qt bindings for i3wm's IPC interface.
Getting information from i3 is as simple as sending a message and waiting for a reply or subscribing to events and waiting for them to be triggered. This is done with the signal/slot mechanisms offered by Qt and normal C++ functions.

value: Show HN: Qt bindings for i3wm's IPC interface

author: vhantz


value: helsinki

value:
I built Token Count, a daily-ish AI comedy podcast where three recurring characters argue about other podcasts and internet culture. Latest ep (#10) is “Pretzels, Pigeons, and the Tall Whites” (47m): it starts with modern-male nonsense and pivots into Laos travel/medical chaos, Kill Tony clip discourse, pigeon-fighting masculinity, and “Tall Whites” UFO lore.
The interesting part (for HN) is the architecture: it’s not a single prompt that “writes a podcast.” It’s a multi-stage, retrieval-grounded pipeline:
- Ingest: RSS → download audio → chunked STT → segment + score
- Storage: embeddings in Qdrant + entities/relationships in a Postgres graph (Apache AGE)
- Compose: generate a beat outline (target seconds + button/turn lines)
- Per-beat GraphRAG bundles: pull transcript segments + add do-not-say, temporal context, character memory, and running gags
- Write: a “writers’ room” sequence (pitch → draft → table read → punch-up → editor)
- Verify: grounding/redundancy/pacing/risk checks before render
- Render: multi-voice TTS + audio assembly into a publishable episode
I’d love feedback on:
1) Is it enjoyable to listen to?
2) Is it funny?
3) What you might prefer to hear?
Apple Podcasts (if Spotify is not your thing): https://podcasts.apple.com/us/podcast/token-count/id18664643...

value: Show HN: Token Count – multi-agent AI comedy podcast with Temporal and GraphRAG

author: helsinki


value: SerafimKorablev

value:
Just to clarify the background a bit. This project wasn’t planned as a big standalone release at first. On January 16, Ollama added support for an Anthropic-compatible API, and I was curious how far this could be pushed in practice. I decided to try plugging local Ollama models directly into a Claude Code-style workflow and see if it would actually work end to end.
Here is the release note from Ollama that made this possible: https://ollama.com/blog/claude
Technically, what I do is pretty straightforward:
- Detect which local models are available in Ollama.
- When internet access is unavailable, the client automatically switches to Ollama-backed local models instead of remote ones.
- From the user’s perspective, it is the same Claude Code flow, just backed by local inference.
In practice, the best-performing model so far has been qwen3-coder:30b. I also tested glm-4.7-flash, which was released very recently, but it struggles with reliably following tool-calling instructions, so it is not usable for this workflow yet.

value: Show HN: First Claude Code client for Ollama local models

author: SerafimKorablev


value: ajujaans

value: Show HN: AI Code Guard – Detect security flaws in Copilot/ChatGPT generated code

author: ajujaans


value:
git-credential-manager is great. Until you try to use it inside a linux docker container. You then run into the un-fun issue of how to set up secure credential storage in linux.
It would be easier if you could manage your credential in git-credential-manager on your macOS/Windows host but then have those credentials automatically used by git inside your dev container.
That's what this utility does. git-credential-forwarder sets up a proxy server on your host that uses the git credential interface to pass credentials back and forth between host and container. Nothing ever gets stored in your container, git (in the container) just requests credentials via the proxy (on the host) when it needs them.
This is the same trick VS Code uses to achieve this outcome. Only this is open source and doesn't require you to be using VS Code.

value: Show HN: Use Git credentials stored on your host inside a dev container


value: mberg

value:
As I've increasingly pursued orchestrated agentic coding - I needed a safe way to run Claude Code in YOLO mode on my mac.
I looked at a lot of options including Docker but then came across Lima (Linux for Mac) and this great guide by Chris Hager on how create a dev sandbox for your mac using Lima.  This creates an Ubuntu VM, mapped to your dev directory with RW access, port and SSH forwarding, Mise support for language installs and automatic code agent installs.
https://www.metachris.dev/2025/11/sandbox-your-ai-dev-tools-...
I followed his guide. Got it working on my own then thought I'd try packaging it up in a claude skill to share.  And holy yep works great!
To setup just go to /plugin -> marketplace in Claude Code and add
recodelabs/lima-devbox
Then install the skill and ask Claude to create you a VM.  Claude will ask you some questions and then proceed to build you your VM.
Side note - this really hits home for me that Agent Skills is really all you need.  Instead of writing a guide or wrapping this up in a app/TUI just bake any knowledge or process you want to automate and share into a skill.  Definitely feels like the future.
Would love your feedback and PRs if you have ideas on how to improve.
https://github.com/recodelabs/lima-devbox
Thanks! Matt

value: Show HN: Lima-devbox – Claude skill for creating a VM dev sandbox on your Mac

author: mberg


value:
Hey, I'm Gong Chao, currently working at Zai.
Last weekend after playing football and heading home, an idea suddenly popped into my head. I got the urge to build it and spent the whole weekend hacking it out — *AgentShield* .
Nowadays everyone's using Cowork, Claude Code, or various AI agents to manipulate files and write code. It's awesome, but sometimes AI goes "crazy" and messes up your files, making it impossible to revert to the original state (don't ask me how I know... ).
For code, you have Git, but that requires commits, and it's not friendly for large files.
AgentShield puts a shield around your workspace, monitoring file changes in real-time. When things get messed up, you can *rollback with one click*, giving you a *"regret pill"*.
Under the hood, it uses zero-copy technology and takes up no space. This tool is dedicated to all the brothers who've been screwed over by AI. Welcome to try it out!
https://github.com/tomsun28/agentshield
PS: I've only tested it on macOS

value: Show HN: AgentShield, The missing safety layer for Cowork and AI Agents


value: tgalal

value:
This is an example tool I created using my tool (promptcmd) for turning prompts into "native-looking" executables:

  Usage: bashme_a_script_that [OPTIONS] <query>...

  Prompt inputs:
        --stdin  accept stdin input
    <query>...   positional query. Can be spaced and with/without quotes

It makes use of caching responses: if I review the generated script and it looks good (or incomprehensible and I'm in YOLO mood), I run the command again and pipe directly into bash. It'll use the reviewed response instead of generating a new one.
Would love to get feedback or ideas for promptcmd:
Github: https://github.com/tgalal/promptcmd/
Documentation: https://docs.promptcmd.sh/
Examples: https://promptcmd.sh/lib/

value: Show HN: Bashme_a_script_that", generate and cache bash scripts via promptcmd

author: tgalal


value: saisrirampur

value:
Hello HN, this is Sai and Kaushik from ClickHouse. Today we are launching a Postgres managed service that is natively integrated with ClickHouse. It is built together with Ubicloud (YC W24).
TL;DR: NVMe-backed Postgres + built-in CDC into ClickHouse + pg_clickhouse so you can keep your app Postgres-first while running analytics in ClickHouse.
Try it (private preview): https://clickhouse.com/cloud/postgres
Blog w/ live demo: https://clickhouse.com/blog/postgres-managed-by-clickhouse
Problem
Across many fast-growing companies using Postgres, performance and scalability commonly emerge as challenges as they grow. This is for both transactional and analytical workloads. On the OLTP side, common issues include slower ingestion (especially updates, upserts), slower vacuums, long-running transactions incurring WAL spikes, among others. In most cases, these problems stem from limited disk IOPS and suboptimal disk latency. Without the need to provision or cap IOPS, Postgres could do far more than it does today.
On the analytics side, many limitations stem from the fact that Postgres was designed primarily for OLTP and lacks several features that analytical databases have developed over time, for example vectorized execution, support for a wide variety of ingest formats, etc. We’re increasingly seeing a common pattern where many companies like GitLab, Ramp, Cloudflare etc. complement Postgres with ClickHouse to offload analytics. This architecture enables teams to adopt two purpose-built open-source databases.
That said, if you’re running a  Postgres based application, adopting ClickHouse isn’t straightforward. You typically end up building a CDC pipeline, handling backfills, and dealing with schema changes and updating your application code to be aware of a second database for analytics.
Solution
On the OLTP side, we believe that NVMe-based Postgres is the right fit and can drastically improve performance. NVMe storage is physically colocated with compute, enabling significantly lower disk latency and higher IOPS than network-attached storage, which requires a network round trip for disk access. This benefits disk-throttled workloads and can significantly (up to 10x) speed up operations incl. updates, upserts, vacuums, checkpointing, etc. We are working on a detailed blog examining how WAL fsyncs, buffer reads, and checkpoints dominate on slow I/O and are significantly reduced on NVMe. Stay tuned!
On the OLAP side, the Postgres service includes native CDC to ClickHouse and unified query capabilities through pg_clickhouse. Today, CDC is powered by ClickPipes/PeerDB under the hood, which is based on logical replication. We are working to make this faster and easier by supporting logical replication v2 for streaming in-progress transactions, a new logical decoding plugin to address existing limitations of logical replication, working toward sub-second replication, and more.
Every Postgres comes packaged with the pg_clickhouse extension, which reduces the effort required to add ClickHouse-powered analytics to a Postgres application. It allows you to query ClickHouse directly from Postgres, enabling Postgres for both transactions and analytics. pg_clickhouse supports comprehensive query pushdown for analytics, and we plan to continuously expand this further (https://news.ycombinator.com/item?id=46249462).
Vision
To sum it up - Our vision is to provide a unified data stack that combines Postgres for transactions with ClickHouse for analytics, giving you best-in-class performance and scalability on an open-source foundation.
Get Started
We are actively working with users to onboard them to the Postgres service. Since this is a private preview, it is currently free of cost.If you’re interested, please sign up here. https://clickhouse.com/cloud/postgres
We’d love to hear your feedback on our thesis and anything else that comes to mind, it would be super helpful to us as we build this out!

value: Show HN: Managed Postgres with native ClickHouse integration

author: saisrirampur


value: nate-gehringer

value:
For several years, I’ve been tinkering on (yet another) personal finance app … largely to practice the craft, and as a way to try out things we didn’t get to use at $DAY_JOB. I was laid off from $DAY_JOB last year, so I decided to see if I could turn my side project into a real enterprise.
Low-cost infrastructure is a primary concern, and I hope to be able to offer the application as freeware indefinitely, with costs subsidized by a subset of paying subscribers. All of the app’s functionality is available in the free version, except …
1. Database back-up and restore via cloud storage services (currently S3, Google Drive, and Dropbox)
2. Syncing transactions from banking institutions (via Plaid)
You can read about the app’s selling points on the landing page, so I won’t repeat the rest here. Some of the finer, more interesting technical details …
- The main data store is IndexedDB. Originally, the plan was to use CouchDB, but when I learned about IndexedDB, it allowed me to imagine the local-first architecture that the app eventually implemented. For the needs of this application, I’ve found IndexedDB’s primitive nature very interesting, without being too limiting. My wishlist for it includes an asynchronous API, and encryption-at-rest would be nice, too.
- I rolled my own rendering system instead of using an off-the-shelf framework like React or Svelte. I obviously wouldn’t recommend this for the average project or person, but I was naively curious about the low-level concerns of such a library. My system uses a model—view model—view pattern to render Mustache templates to HTML, and simplifies binding event listeners to HTML elements. While I’m very happy with the developer experience it provides, any issues it causes impact end users — not an ideal trade-off. This is a definite area of focus for the future.
- Excellent accessibility is a goal. A lot of effort has gone into making the app as usable as possible, but the work here is not done. If you do front-end development and don’t have experience around accessibility, I’d recommend learning a bit about it as a great way to level-up your development skills. (In my experience, $INDUSTRY doesn’t place due weight on its importance.)
- Due to my dependency allergies, I also rolled my own Web Components to provide UI widgets that HTML doesn’t provide natively. <https://code.backwater.systems/#landscape> Despite the flak they receive, in my opinion, Web Components are awesome and should be more widely used.
Some questions for the community …
- Why do you think local-first software isn’t more popular?
- What’s the next feature you’d build?

value: Show HN: Backwater Finance – A free, local-first personal finance web app

author: nate-gehringer


value: Finbarr

value: Show HN: Startup Tarot Cards

author: Finbarr

title: Show HN: Startup Tarot Cards


value: maorbril

value: Show HN: Clauder – Make your Claude Code instances talk to each other

author: maorbril


value: eshaangulati

value:
I used to STRUGGLE with using GCP/azure/AWS because of the complex UI.
Ourguide is the first OS wide task guidance system that can show you where to click - step by step, for any task.
I built Ourguide because doing anything new on my computer involved a frustrating loop: watch a tutorial/ ask a chatbot, pause it, Alt-Tab to my software, hunt for the button, and switch back. The "Alt-Tab dance" was killing my flow.
Ourguide is early, but usable. Would love feedback on whether this is useful and if there was any task Ourguide was unable to help you with.
Here are a few examples of what you can ask:
- “How do I create a Public S3 bucket?”
- “How do I stop Spotify from opening on startup?”
- “How do I remove a class from my gradescope account?”
Thanks!

value: Show HN: Ourguide – OS wide task guidance system, it can show you where to click

author: eshaangulati


value: pablituuu

value:
Key Features:
- *AI-Powered*: Uses Gemini Pro for intelligent chat and content manipulation.
- *Tech Stack*: Built with Next.js 15, Fabric.js for canvas operations, and Tailwind CSS 4.
- *Responsive*: Engineered to handle complex timelines directly in the browser with high performance.
I'm particularly looking for feedback on performance and the AI interaction flow. Happy to answer any technical questions about the implementation!

value: Show HN: An AI-powered web video editor built with Next.js and Fabric.js

author: pablituuu


value: AmorBielyi

value: Show HN: Golang Support for Playdate Handheld

author: AmorBielyi


value: hankwilliamsjr

value:
Officially launching meter today - it tracks the changes on any website and sends you a webhook with the changes.
Supports proxies, antibot handling, and schedule management.
We’ve had a large amount of users migrate from traditional scrapers to only track the content changes.
We have a generous free tier - give it a try!

value: Show HN: Meter – data feed monitoring changes on any site

author: hankwilliamsjr


value: deofoo

value:
hihi,
LaReview is a dev-first code review workbench for complex changes.
You give it a PR (GitHub/GitLab) or a diff, and it builds a structured review plan grouped by flows (auth, API, billing) and ordered by risk. The goal is to make big reviews feel like a plan you can actually follow, not an endless scroll.
It runs locally and is designed to work with your existing AI coding agent (bring your own agent). No bot comment spam. You decide what feedback gets posted back to the PR.
Highlights:

  - AI review planning: flow-based tasks + risk ordering
  - Task-focused diffs: isolate only the hunks relevant to one concern
  - Custom rules: enforce standards like “DB queries must have timeouts”
  - Optional diagrams to understand flows before reading code (requires D2)
  - GitHub/GitLab sync to submit selected feedback + generate a summary
  - Export summary to Markdown

CLI:

  lareview
  lareview pr owner/repo#123
  git diff | lareview
  lareview --agent claude

Install:

  brew install --cask puemos/tap/lareview

Repo:

  https://github.com/puemos/lareview

I would love feedback on the workflow, what you would want it to catch, and what would make you trust it in real reviews.

value: Show HN: LaReview, local open-source CodeRabbit alternative

author: deofoo


value: MatHud pairs an interactive drawing canvas with an AI assistant to help visualize, analyze, and solve real-world geometry, algebra, and calculus problems in real-time.<p>MatHud lets you draw and manipulate geometric objects - points, segments, vectors, polygons, circles, ellipses, and angles - directly on an interactive canvas, while an AI assistant solves algebra, calculus, trigonometry, statistics, and linear algebra problems with LaTeX-formatted explanations. You can plot functions, compare intersections, shade bounded regions, translate and rotate objects, visualize probability distributions and bar charts, and fit regression models (linear, polynomial, exponential, logarithmic, power, logistic, sinusoidal) with R² statistics. The tool also supports graph theory structures like trees and DAGs, workspace management for saving and resuming projects, Vision mode for sharing your canvas with the assistant for feedback, and built-in client-side testing.

value: Show HN: MatHud – Open-source AI-assisted graphing calculator


value: Ayobamiu

value:
Hi HN,
I built a tiny Gmail extension that adds a quick safety check before emails are sent.
It catches common mistakes like:
- mentioning an attachment but forgetting to attach it
- sending emails late at night
- messages that sound more heated than intended
There’s no AI rewriting or analytics — it just pauses the send when something looks off and lets you decide.
This started as a personal itch after sending one too many “oops” emails.
Would love feedback from people who live in Gmail all day.
Link: https://chromewebstore.google.com/detail/jnlgfolocbbfhmgaljk...

value: Show HN: A Gmail extension that stops you from sending emails you'll regret

author: Ayobamiu


value: abdibrokhim

value: Show HN: Ilona Bernotaite Joins AI Vibe Coding Hackathon

author: abdibrokhim


value: ShreyaChaurasia

value:
Hi HN,
We’ve been working on credit-based billing systems, and one recurring issue we kept running into was how messy credit purchases become once real payments are involved.
Credits are easy when they’re manual or promotional. Things get complicated when customers need to:
- buy credits through a proper checkout,
- receive an invoice,
- complete payment asynchronously,
and only then have credits become usable.
Most teams end up stitching this together manually:
Invoices in one system, payment links in another, wallet balances updated via scripts or cron jobs, and reconciliation handled later.
We built a checkout flow where credit top-ups, invoices, payment links, and wallet state transitions are part of a single workflow:
- an invoice is generated,
- a payment link is created automatically,
- credits stay on hold until payment succeeds,
and are applied immediately once the payment clears.
Docs here if you want to see how the flow works end-to-end: https://docs.flexprice.io/docs/wallet/top-up-wallet
Would love feedback from folks who’ve built usage-based or credit-driven billing, or thoughts on edge cases we should be thinking about.
Happy to answer questions or feel free to join our community : http://bit.ly/4huvkDm

value: Show HN: Checkout Flow for credit-based billing

author: ShreyaChaurasia


value: ihmissuti

value: Show HN: AI Search Index – Track which AI bots crawl your website

author: ihmissuti


value: sebastianlay

value: A little browser extension I wrote for myself because sometimes I want to add little notes about other users. It's fun to see familiar faces pop up in random threads. I know it's not for everyone, and that's okay. For me it renewed a sense of community, which I found interesting, so I wanted to share it.<p>I consider the extension feature-complete, mostly because I don't want to deal with high maintenance when browser extension APIs invariably change.

value: Show HN: Orange Elephant – a browser extension to add annotations to HN users

author: sebastianlay


value:
I built a memory layer so multiple AI agents can share context, decisions, and files instead of forgetting and duplicating work.
Its not a chatbot. Its literally startup infrastructure.
Demo attached (waitlist is open)

value: Show HN: Infrastructure for multi-agent AI memory


value: Show HN: Mdview.io – renders 10MB Markdown files on the client


value: EdgarsHQ

value:
Hi HN, I built a directory of free (no signup/no cc) AI writing tools and wanted to share it with you. It’s basically a collection of preconfigured prompts to quickly improve text, change tone, reply to emails, rewrite, including some niche ones.
I used Astro with DaisyUI and Cloudflare Workers/CDN to make the site fast and SEO-friendly. Managed to get a 100% Lighthouse score, which is nice. Overall, it went pretty well, though I did run into a couple of bugs with Astro along the way — some of which have already been fixed. It uses Gemini 3 Flash under the hood right now. I've also spent some time protecting it from bots and scrapers with Turnstile, and I currently manage my costs by pre-funding credits to avoid any surprises on my bills with post-payment, in case bad actors try to exploit the service (and while not user-friendly, since it's a free public service, I might also add some fingerprinting if there's a need down the road).
My main motivation was to improve SEO presence and drive traffic/funnel into my main product (posted about it here: https://news.ycombinator.com/item?id=46183195). But at the same time, I wanted to create something useful, so I ended up spending more time on that than I initially planned. I’m curious to see how it all turns out, how much it will cost, and how soon I might run out of credits.
If you have a minute, let me know if/how it’s useful for you. Some prompts still need improvement, so feel free to share your results — I’m happy to explore and improve.
Link: https://textwisely.ai/directory

value: Show HN: I built a directory of free AI writing tools to support my main product

author: EdgarsHQ