Show stories

OP here.

I built this because I recently caught myself almost pasting a block of logs containing AWS keys into Claude.

The Problem: I need the reasoning capabilities of cloud models (GPT/Claude/Gemini), but I can't trust myself not to accidentally leak PII or secrets.

The Solution: A Chrome extension that acts as a local middleware. It intercepts the prompt and runs a local BERT model (via a Python FastAPI backend) to scrub names, emails, and keys before the request leaves the browser.

A few notes up front (to set expectations clearly):

Everything runs 100% locally. Regex detection happens in the extension itself. Advanced detection (NER) uses a small transformer model running on localhost via FastAPI.

No data is ever sent to a server. You can verify this in the code + DevTools network panel.

This is an early prototype. There will be rough edges. I’m looking for feedback on UX, detection quality, and whether the local-agent approach makes sense.

Tech Stack: Manifest V3 Chrome Extension Python FastAPI (Localhost) HuggingFace dslim/bert-base-NER Roadmap / Request for Feedback: Right now, the Python backend adds some friction. I received feedback on Reddit yesterday suggesting I port the inference to transformer.js to run entirely in-browser via WASM.

I decided to ship v1 with the Python backend for stability, but I'm actively looking into the ONNX/WASM route for v2 to remove the local server dependency. If anyone has experience running NER models via transformer.js in a Service Worker, I’d love to hear about the performance vs native Python.

Repo is MIT licensed.

Very open to ideas suggestions or alternative approaches.

Hi HN,

I built WhatHappened (whathappened.tech) because I have a love/hate relationship with this site. I love the content, but the "wall of text" UI gives me FOMO. I was spending too much time clicking into vague titles ("Project X") or wading through flame wars just to find technical insights.

I built this tool to act as a filter. It generates a card for the top daily posts with a few specific features to cut the noise:

1. AI Summaries: It generates a technical TL;DR (3 bullet points) and an ELI5 version for every post.

2. The Heat Meter: I analyze the comment section to visualize the distribution: Constructive vs. Technical vs. Flame War. If a thread is 90% Flame War, I know to skip it (or grab popcorn).

3. Contrarian Detection: To break the echo chamber, the AI specifically hunts for the most upvoted disagreement or critique in the comments and pins it to the card.

4. Mobile-First PWA: I mostly read HN on my phone, so I designed this as a PWA. It supports swipe gestures and installs to the home screen without an app store.

Stack: Next.js, Gemini, Supabase.

It currently supports English and Chinese. Any feedback will be appreciated! My original X post: https://x.com/marsw42/status/1997087957556318663, please share if you like it or find it helpful! :D

Thanks!

i always loved looking up the On-Line Encyclopedia of Integer Sequences (OEIS) when researching a sequence of numbers.

so I decided to make a TUI and CLI for it so that I can browse sequences in the terminal.

it supports almost all the features on the site (including the OEIS Webcam) and supports graphs, a preview pane, exporting and bookmarks.

more features here: https://github.com/hako/oeis-tui?tab=readme-ov-file#features

repo: https://github.com/hako/oeis-tui

gitHub releases: https://github.com/hako/oeis-tui/releases

cargo: cargo install oeis-tui

Hi HN!

This keyboard is like a corne (v4) [0] with the physical layout of a fifi [1].

The PCB can be ordered from JLCPCB with PCB assembly of the components: no need to solder anything yourself! (unless you want encoders) See the ordering guide in the repository for more information [2].

Main Characteristics:

- 36/40 keys

- Encoder support

- Embedded RP2040 controller

- USB-C to connect the halves

- PCB assembly: no soldering required (unless you use encoders)

The PCB was made by a Fiverr contractor (I don't know how to do it myself, their profile here [3]) and the case by me.

If there is anything missing in the README or the docs, feel free to let me know.

[0] https://github.com/foostan/crkbd

[1] https://github.com/raychengy/fifi_split_keeb

[2] https://github.com/v3lmx/cornifi/blob/main/docs/pcb_ordering...

[3] https://www.fiverr.com/circuitwork32

Hi HN!

I'm building a JavaScript debugger called Wirebrowser. It combines network inspection, request rewriting, heap snapshots, and live object search.

The main experimental feature is BDHS (Breakpoint-Driven Heap Search): it hooks into the JavaScript debugger and automatically captures a heap snapshot at every pause and performs a targeted search for the value or structure of interest. This reveals the moment a value appears in memory and the user-land function responsible for creating it.

Another interesting feature is the Live Object Search: it inspects runtime objects (not just snapshots), supports regex and object similarity, and lets you patch objects directly at runtime.

Whitepaper: https://fcavallarin.github.io/wirebrowser/BDHS-Origin-Trace

Feedback very welcome, especially on whether BDHS would help your debugging workflow.

Built this over the last few days, based on a Rust codebase that parses the latest ALPR reports from OpenStreetMaps, calculates navigation statistics from every tagged residential building to nearby amenities, and tests each route for intersection with those ALPR cameras (Flock being the most widespread).

These have gotten more controversial in recent months, due to their indiscriminate large scale data collection, with 404 Media publishing many original pieces (https://www.404media.co/tag/flock/) about their adoption and (ab)use across the country. I wanted to use open source datasets to track the rapid expansion, especially per-county, as this data can be crucial for 'deflock' movements to petition counties and city governments to ban and remove them.

In some counties, the tracking becomes so widespread that most people can't go anywhere without being photographed. This includes possibly sensitive areas, like places of worship and medical facilities.

The argument for their legality rests upon the notion that these cameras are equivalent to 'mere observation', but the enormous scope and data sharing agreements in place to share and access millions of records without warrants blurs the lines of the fourth amendment.

Hi HN, I’ve released a new version of chess-tui, a Rust terminal UI for playing live games against Lichess opponents.

The update includes a cleaner TUI, better performance, improved keybindings, and smoother real-time integration with the Lichess API. It’s designed as a simple, fast way to play chess without leaving the terminal.

Repo:https://github.com/thomas-mauran/chess-tui

Feedback and bug reports are welcome. Happy to answer questions!

steem.dev is a developer platform focused on building decentralized applications on the Steem blockchain. It provides tools, documentation, and resources to help developers create and deploy Steem-based applications.

BrickQRCode is a platform that allows users to create and manage QR codes for their Lego bricks, enabling easy identification, organization, and sharing of custom Lego creations.

Mobile keyboards today are almost entirely based on the 26-key, 3-row QWERTY layout. Here’s a new 2-row, 16-key alternative designed specifically for smartphones.

I built Pfff!!! as a side project to vent daily frustrations in a fun, positive way. My partner and sister complain a lot about little things (traffic, work, life annoyances), and I love step-counter apps that make walking addictive with streaks and XP. So I combined the two:an app where you rant freely, earn XP, level up, and get instant AI replies in different tones (empathetic, cynical, sarcastic, humorous).Free:3 rants per day Premium: unlimited + more tones

It was also a great learning exercise: AI integration, text/audio processing, payments (Stripe), DB, etc.Try it out and let me know what you think – brutal feedback welcome!https://pfff.me(Already shared on Indie Hackers: https://www.indiehackers.com/post/launching-pfff-gamified-ve... )

Mapibara is a platform that helps individuals and organizations create and manage their online presence, including building websites, managing social media profiles, and analyzing digital marketing performance.

The article discusses the future of news consumption in 2035, predicting a shift towards more personalized, interactive, and immersive news experiences driven by advancements in technology and user preferences.

PaCoRe is an open-source library that provides various components for building conversational AI systems, including language models, dialogue managers, and response generation models. The library is designed to be modular and extensible, allowing developers to easily integrate and customize its components to suit their specific needs.

I built AlgoDrill because I kept grinding LeetCode, thinking I knew the pattern, and then completely blanking when I had to implement it from scratch a few weeks later.

AlgoDrill turns NeetCode 150 and more into pattern-based drills: you rebuild the solution line by line with active recall, get first principles editorials that explain why each step exists, and everything is tagged by patterns like sliding window, two pointers, and DP so you can hammer the ones you keep forgetting. The goal is simple: turn familiar patterns into code you can write quickly and confidently in a real interview.

https://algodrill.io

Would love feedback on whether this drill-style approach feels like a real upgrade over just solving problems once, and what’s most confusing or missing when you first land on the site.

I built Reddit Toolbox after hitting Reddit's new API restrictions. Getting API approval now takes weeks (if it happens at all), which makes most Reddit tools unusable.

Reddit Toolbox is a Windows desktop app that works without needing API approval:

- Search and analyze subreddits - Extract posts and user data in bulk - AI-powered community insights - Export to CSV - All processing happens locally

Built mainly for marketers and researchers who need Reddit data but don't want to deal with the API approval process.

Free tier: 90 searches/day Paid: $4.99/month or $49/year

The desktop approach lets us bypass API limitations while keeping everything private (data stays on your computer).

Would love feedback from anyone who's dealt with Reddit's API changes.

Hey HN! Like most here regular meetings have always been a big part of my work.

Over the years I've learned the value of active note taking in these meetings. Meaning: not minutes, not transcriptions or AI summaries, but me using my brain to actively pull out the key points in short form bullet-like notes, as the meeting is going on, as I'm talking and listening (and probably typing with one hand). This could be agenda points to cover, any interesting sidebars raised, insights gotten to in a discussion, actions agreed to (and a way to track whether they got done next time!).

It's both useful just to track what's going on in all these different meetings week to week (at one point I was doing about a dozen 1-1s per week, and it just becomes impossible to hold it in RAM) but also really valuable over time when you can look back and see the full history of a particular meeting, what was discussed when, how themes and structure are changing, is the meetings effective, etc.

Anyway, I've tried a bunch of different tools for taking these notes over the years. All the obvious ones you've probably used too. And I've always just been not quite satisfied with the experience. They work, obviously (it's just text based notes at the end of the day) but nothing is first-class for this usecase.

So, I decided to build the tool I've always felt I want to use, specifically for regular 1-1s and other types of regular meetings. I've been using it myself and with friends for a while already now, and I think it's got to that point where I actually prefer to reach for it over other general purpose note taking tools now, and I want to share it more widely.

There's a free tier so you can use it right away, in fact without even signing up.

If you've also been wanting a better system to manage your notes for regular meetings, give it a go and let me know what you think!

fanfa.dev is a website that provides free and open-source tools and resources for web development, including a code editor, task runner, and package manager. The site aims to simplify the development workflow and empower developers with a user-friendly platform.

https://github.com/mcp-shark/mcp-shark Site: https://mcpshark.sh/

I built MCPShark, a traffic inspector for the Model Context Protocol (MCP).

It sits between your editor/LLM client and MCP servers so you can: • See all MCP traffic (requests, responses, tools, resources) in one place • Debug sessions when tools don’t behave as expected • Optionally run “Smart Scan” checks to flag risky tools / configs

For years I’ve wanted to start a podcast to interview curious and passionate makers in the depths of their creative pursuits.

I would love any feedback, a rating, and if you know anyone would would make a great guest, please let me know!

I'm a dev who got tired of wasting entire evenings planning trips. After the 10th time finding myself with 50 tabs open at 2 AM reading contradictory blog posts, I built Voyaige.

What it does: Enter a city + your travel style (budget backpacker, luxury, foodie, etc.) → get a personalized PDF guide in ~15 minutes. Not generic "Top 10" lists—actual itineraries with opening hours, transport tips, and recommendations that match YOUR preferences.

Why Perplexity over GPT/Claude: Perplexity's Deep Research API was the game-changer. It actually cites real sources and pulls fresh data. GPT-4 kept giving me outdated restaurant recommendations from 2021. Perplexity searches, synthesizes, and cites—perfect for travel where accuracy matters.

  Tech stack:
  - Laravel backend with queue workers for long-running generation
  - Perplexity Deep Research API for research + synthesis
  - Custom PDF generation (tried DOMPDF, settled on Browsershot + headless Chrome)
  - Polar for payments (Stripe rejected me 3 times as "travel content")

  Hardest technical challenges:
  1. API response quality: Prompt engineering to get consistent structure across different cities/personas
  2. PDF layout: Making 25-page guides that actually look good and are readable on mobile
  3. Queue management: Handling generation failures gracefully + retry logic
  4. Payment processors: Finding one that accepts "AI-generated content" businesses

  Questions for HN:
  1. Would you pay $13 to skip 3-5 hours of research?
  2. What would justify higher pricing? 
  3. How do you feel about AI-generated travel advice vs. human travel bloggers?

  Link: https://voyaige.io

  Happy to discuss or answer any questions!

FATE is an open-source federated learning framework that enables secure and privacy-preserving collaboration among multiple parties. It provides a comprehensive set of tools for building, training, and deploying federated learning models across different platforms and cloud environments.

Hi HN, tl;dr we built a bug finder that's working really well, especially for app backends. Try it out and send us your thoughts!

Long story below.

--------------------------

We originally set out to work on technical debt. We had all seen codebases with a lot of debt, so we had personal grudges about the problem, and AI seemed to be making it a lot worse.

Tech debt also seemed like a great problem for AI because: 1) a small portion of the work is thinky and strategic, and then the bulk of the execution is pretty mechanical, and 2) when you're solving technical debt, you're usually trying to preserve existing behavior, just change the implementation. That means you can treat it as a closed-loop problem if you figure out good ways to detect unintended behavior changes due to a code change. And we know how to do that – that's what tests are for!

So we started with writing tests. Tests create the guardrails that make future code changes safer. Our thinking was: if we can test well enough, we can automate a lot of other tech debt work at very high quality.

We built an agent that could write thousands of new tests for a typical codebase, most "merge-quality". Some early users merged hundreds of PRs generated this way, but intuitively the tool always felt "good but not great". We used it sporadically ourselves, and it usually felt like a chore.

Around this point we realized: while we had set out to write good tests, we had built a system that, with a few tweaks, might be very good at finding bugs. When we tested it out on some friends' codebases, we discovered that almost every repo has tons of bugs lurking in it that we were able to flag. Serious bugs, interesting enough that people dropped what they were doing to fix them. Sitting right there in peoples codebases, already merged, running in prod.

We also found a lot of vulns, even in mature codebases, and sometimes even right after someone had gotten a pentest.

Under the hood: - We check out a codebase and figure out how to build it for local dev and exercise it with tests. - We take snapshots of the built local dev state. (We use Runloop for this and are big fans.) - We spin up hundreds of copies of the local dev environment to exercise the codebase in thousands of ways and flag behaviors that seem wrong. - We pick the most salient, scary examples and deliver them as linear tickets, github issues, or emails.

In practice, it's working pretty well. We've been able to find bugs in everything from compilers to trading platforms (even in rust code), but the sweet spot is app backends.

Our approach trades compute for quality. Our codebase scans take hours, far beyond what would be practical for a code review bot. But the result is that we can make more judicious use of engineers’ attention, and we think that’s going to be the most important variable.

Longer term, we think compute is cheap, engineer attention is expensive. Wielded properly, the newest models can execute complicated changes, even in large codebases. That means the limiting reagent in building software is human attention. It still takes time and focus for an engineer to ingest information, e.g. existing code, organizational context, and product requirements. These are all necessary before an engineer can articulate what they want in precise terms and do a competent job reviewing the resulting diff.

For now we're finding bugs, but the techniques we're developing extend to a lot of other background, semi-proactive work to improve codebases.

Try it out and tell us what you think. Free first scan, no credit card required: https://detail.dev/

We're also scanning on OSS repos, if you have any requests. The system is pretty high signal-to-noise, but we don't want to risk annoying maintainers by automatically opening issues, so if you request a scan for an OSS repo the results will go to you personally. https://detail.dev/oss

The article announces the launch of Contraption's new print edition, which aims to provide a high-quality, physical magazine experience for readers interested in design, technology, and culture. It highlights the magazine's focus on in-depth reporting, thoughtful analysis, and striking visuals.

Hello Everyone! We built SQLFlow as a lightweight stream processing engine.

We leverage DuckDB as the stream processing engine, which gives SQLFlow the ability to process 10's of thousands of messages a second using ~250MiB of memory!

DuckDB also supports a rich ecosystem of sinks and connectors!

https://sql-flow.com/docs/category/tutorials/

https://github.com/turbolytics/sql-flow

We were tired of running JVM's for simple stream processing, and also of bespoke one off stream processors

I would love your feedback, criticisms and/or experiences!

Thank you

Mizu is an open-source, cloud-native infrastructure monitoring solution that provides real-time visibility and insights into distributed systems. It offers a flexible, modular design and supports a wide range of data sources, making it suitable for monitoring complex, modern cloud environments.

The article details the development of an Excel agent using Anthropic's Claude AI. The agent is designed to assist with Excel-related tasks, leveraging natural language processing to understand and execute commands.