2026年3月29日 的 Show HN

BreezePDF lets you edit, sign, merge, compress, redact, OCR, fill forms, extract tables, and use 30+ more PDF tools — all in the browser, no sign-up. Files never leave your computer.

I built it because when people search Google for common PDF tasks, many of the tools they find upload documents to a server. I wanted an option that keeps files local instead.

I posted an earlier version on HN last spring: https://news.ycombinator.com/item?id=43880962

At the time it only supported a small set of features. Over the last 10 months I rebuilt large parts of it and expanded it to nearly 40 tools, including several ideas that came from comments in that earlier thread.

There is also now a desktop app for macOS, Windows, and Linux, plus a CLI/SDK for developers.

A developer's machine accumulates tools fast. A Rust CLI you compiled last year, a Python formatter installed via `uv`, a language server pulled from npm, a terminal emulator from a curl script, a Go binary built from source. Each came from a different package manager, each with its own install incantation you half-remember.

I wanted a way to declare what I need without adopting a complex system like Nix or Ansible just for a single laptop. The result was a plain old Makefile.

I wrote a short post on using Make (along with a tiny bash script and fzf) to create a searchable, single-command registry for all your local dev tools. It’s not a new framework or a heavy tool—just a simple way to organize the package managers we already use.

If you're tired of losing track of your local environment, you might find it useful.

Crazierl is an experimental/hobby operating system based around BEAM.

I've linked the browser based demo; I don’t recommend using a phone; it does work, slowly, on the phones I tested, but it’s very awkward to use. You can share a link with a hashtag with your friends and click the consent checkbox, and it (should) link up into dist and I’ve also included a chat application you can start with chat:start(). (quit chat with /quit, or use the shell menu with ctrl-g to switch between shells etc).

The browser demo relies on the v86 javascript x86 virtual machine. You can also run Crazierl on a real x86 system, but I’ve had mixed luck on modern systems, it uses some esoteric legacy VGA features and support for that isn’t getting better.

Crazierl is fairly limited: 32-bit x86, BIOS boot, only two NIC drivers virtio-net and realtek 8168. But it's got enough to become part of an Erlang dist cluster. It also supports SMP, but it’s crashy with high core counts in qemu; there’s almost certainly several concurrency bugs in the kernel. There's also a lot of excess tcp debug spew (sorry).

Source code is available (Apache) https://github.com/russor/crazierl/

It’s a curated list of directories and launch platforms where you can submit your product and actually get traffic, backlinks, and early users

I included useful data for each one so you don’t have to guess where it’s worth posting

Features; 100+ directories and platforms to promote your SaaS; SEO data like domain rating and traffic; Info on whether links are dofollow or nofollow; Organized and easy to go through; Saves hours of searching and manual research; Great for getting early users and backlinks;

If you’re launching or growing a SaaS and don’t know where to promote it, this should help

Scheduling meetings across multiple time zones has always been painful for me, especially across daylight saving time transitions. So I built a visual timeline that makes it easy to find overlapping availability.

Add your locations, drag to select a time range, and share a link. Recipients see the proposed times in their local time zone automatically.

A few things that might be interesting:

* Location search over GeoNames with fuzzy matching using weighted edit distance, so typos and partial names still resolve correctly.

* Shareable links encode the selected time range and locations in a base62 payload to keep URLs short and stateless — no database lookup needed.

* Handles the annoying edge cases: DST transitions use the IANA timezone database, and 15/30-minute UTC offsets (Nepal, India, Newfoundland) work correctly.

* Google Calendar and Outlook integration, but all calendar data is fetched and processed entirely in the browser. Events are never fetched or stored on the server.

Would love feedback on what's useful, not useful, or could be improved!

36 cities so far. Every visit lights up your dot.

I have spent a long time working in an XP/TDD style, so when AI coding tools became useful enough for real work, I adopted them quickly. The first bottleneck I hit was not code generation, it was verification: AI could write code and tests quickly, but I was still the person reviewing implementations, clicking through flows, checking logs, inspecting database state, and deciding whether the result was actually correct.

That pushed me to move validation further left. Before implementation, AI had to produce test plans. After implementation, it had to execute those plans too: drive the browser, inspect logs, check DB state, create tickets for failures, fix them, and retest until the output converged. Auth9 (https://github.com/c9r-io/auth9) became the proving ground for that method. Once it was clearly working, I started building Agent Orchestrator so the process would not depend on me manually supervising every step.

By mid-February, I was already using early Orchestrator-style automation inside Auth9. In mid-March, I used it during the highest-risk refactor so far: replacing the headless Keycloak setup with a native `auth9-oidc` engine. The core replacement landed over 3 days, and the same method and tooling helped converge the follow-up technical debt and complete the community OIDC Certification tests by the end of the month. That was the point where I became confident this was useful not only for greenfield work, but for governing high-risk change in a real system.

At the time, "orchestration" was the word I cared most about, which is why the project got its name. Later, OpenAI's Harness Engineering framing gave me a better name for the broader shape of the work. The project today is a local-first Rust control plane for long-running agent workflows: YAML resources, SQLite-backed task state, machine-readable CLI output, structured logs, and guardrails around shell-based agents.

- GitHub: https://github.com/c9r-io/orchestrator - Docs: https://docs.c9r.io - Auth9: https://github.com/c9r-io/auth9 - Install: `brew install c9r-io/tap/orchestrator` or `cargo install orchestrator-cli orchestratord` - License: MIT

I built this using Compose Multiplatform, with a C++ backend for the fluid simulation and rendering. Any feedback is welcome!

I built OS3-RNode as a tiny RNode-compatible LoRa modem firmware for CH32V003 + E22-900M22S.

It is based on a small deterministic event-driven core, with no scheduler, no threads, and bounded interrupt work. The goal was to make a minimal and auditable transport for Reticulum/NomadNet on very constrained hardware.

The article has the architecture notes and a firmware link. Feedback on the event model, failure handling, and interoperability tradeoffs would be useful.

tabical: swipeable 2-4 stop city itineraries for NYC, DC, and Atlanta. You swipe right or left and a personalization vector updates on each swipe to curate your deck.

The backend pipeline is where most of the interesting work lives: currently trending signals are harvested each day, and from those signals we fetch the candidates to build itineraries.

Built this because deciding what to do in a city like NYC is a genuinely annoying problem that no existing app solves end-to-end. Happy to talk more.

Before reading text please try the app https://www.whattobuy.app (to get great UX feedback)

Shopping research is one of the most challenging tasks and people spend 30-60 min before buying an item. We developed a platform called “WhatToBuy” to save people time. In some cases shoppers are not super aware of what to really order for a trip or occasion. Our app helps them to get a range of products needed for each use-cases hence saving time and money.

App workflow: Describe your situation in plain English. In Fast mode, you get three ready-to-shop carts: Budget, Balanced, and Premium with real products, real prices, and direct buy links. In Deep mode, AI assistant has a conversation with you first and builds a single cart tailored specifically to your answers.

How it works: * You type something like "camping weekend with two young kids" or "setting up a home office on a tight budget" * AI assistant (powered by Claude) parses the scenario and generates a list of specific product search queries. For example, in the above query for camping, product search will be "tent 4-person easy setup" instead of simply "tent". * Those queries hit Shopping API and return real-time results. * A scoring layer ranks by price, rating, and review count to pick one winner per product category per tier.

Two modes: * Deep (default): AI assistant asks a few follow up questions before building a single personalized cart. We default to this because more context means dramatically better picks. Sign in is required for this mode, but you can always drop back to Fast mode with one click. * Fast: Instant three-tier carts, no sign in needed, works right away.

Please take a look: https://www.whattobuy.app No account needed to try the fast mode. Would love feedback on where the recommendations miss or where the UX feels off.

I'm building a Telegram bot to practice Dutch. GPT-4o-mini kept picking vocabulary words I already knew, so I built a classical NLP pipeline to do it instead.

It takes a short text + learner level (A0–B1) and returns the best words to study, using Stanza for parsing and corpus frequency ranks (SUBTLEX-NL, srLex, SUBTLEX-US) for scoring. Wins at A1/A2, loses at A0 where the LLM picks more obvious words.

I also tried adding multi-word phrases (ADJ+NOUN, VERB+NOUN, phrasal verbs) backed by NPMI-scored collocation whitelists. Couldn't beat GPT there because it just "knows" which phrases matter.

For the phrase work I had to extract collocations from 100M+ OpenSubtitles lines. Published them as a free dataset: https://huggingface.co/datasets/vladvlasov256/opensubs-collo... There are 43K bigrams across English, Dutch, and Serbian.

Source https://github.com/vladvlasov256/vocab-nlp

I built an opensource skill that runs N implementations in parallel, has each one reviewed blind by a separate agent, then a judge picks the winner or synthesizes the best parts of each.

Each slot can use a different skill (CE:work in one vs superpowers:test-driven-development) and harness (CC vs. Codex). Or put different emphasis on each slot (functional vs. robustness). Also works for non-coding tasks (writing) and you can create custom slot-machines.

The main insight is simple enough: AI agents are probabilistic. The same spec produces different code every time; different designs, different bugs, different quality.So running parallel implementations can increase quality if we can judge effectively.

There is a real tradeoff here of increased time and tokens for quality but for production code this is often worth it; particularly on long running overnight loops on subscription plans. Also a simple way to learn which skills and harnesses actually work best for your codebase.

Appreciate any feedback / PRs. This is early!

Disclaimer: English is not my first language. I used an LLM to help me write post clearly.

Hello everyone,

I just wanted to share my project and wanted some feedback on it

Goal: Most image models today are bulky and overkill for basic tasks. This project explores how small we can make image classification models while still keeping them functional by stripping them down to the bare minimum.

Current Progress & Results:

Cat vs Dog Classification: First completed task using a 25,000-image dataset with filter bank preprocessing and compact CNNs.

Achieved up to 86.87% test accuracy with models under 12.5k parameters.

Several models under 5k parameters reached over 83% accuracy, showcasing strong efficiency-performance trade-offs.

CIFAR-10 Classification: Second completed task using the CIFAR-10 dataset. This approach just relies on compact CNN architectures without the filter bank preprocessing.

A 22.11k parameter model achieved 87.38% accuracy.

A 31.15k parameter model achieved 88.43% accuracy.

All code and experiments are available in my GitHub repository: https://github.com/SaptakBhoumik/TinyVision

I would love for you to check out the project and let me know your feedback!

Also, do leave a star if you find it interesting

Hi HN!

I've been very unimpressed with how LLMs think when it comes to anything creative. It's no surprise - they've been lobotomized by RLHF to be helpful, predictable and consistent - all of these things are counterproductive in a more creative setting.

So I've built a little something to help LLMs be less creatively bland and dumb. It's called ThinkFu (because I believe creative thinking, when practiced well, is a martial art).

Anyway, you can watch a 3-min video demo here: https://www.youtube.com/watch?v=x-LQvX105SI

Or you can just add it to your claude code like this:

/plugin marketplace add move38studios/thinkfu

/plugin install thinkfu@move38studios-thinkfu

You can also explore what's happening in the code here: https://github.com/move38studios/thinkfu

The TL;DR is:

1. I've collected 200+ "thinking moves" from things like oblique strategies, triz, systems thinking, design thinking etc. and adapted them for LLMs

2. I've added a little randomness with variables, so that the total number of moves that you can get is somewhere around 500 billion. Because in creative thinking randomness is a feature not a bug.

3. There is a vector search and a tiny LLM router (behind an MCP) that tries to get you the right "thinking move" for whatever your problem may be.

Everything runs on cloudflare (still love you guys, despite all the recent issues).

Oh, also on first use you can opt in or out of sending the anonymized ratings back to my endpoint. The idea is that the LLM (or user) can rate whether a certain move was productive or not in a certain context.

If I collect enough ratings, I'll finetune a custom LLM for the router and I think routing will get better as a result.

Hope y'all find it interesting!

I'd be happy to answer questions and get bug reports and PR requests and what not. It's a tiny experiment - but if it works it could be fun to scale with the community.

I built a watchface inspired by Pink Floyd's "Dark Side of the Moon". A prism that refracts light into a rainbow to show the time. The minute hand is a light ray, the rainbow points at the hour.

It's written in Zig, which lets me target the browser (WASM), a Raspberry Pi Zero 2 W driving a 13.3" e-ink display as a wall clock, a Pico 2 for bare-metal battery operation, and eventually the Pebble Round 2 smartwatch.

I built it with Claude Code (Opus) as an experiment in AI-assisted coding while keeping real ownership of the code. Claude does the fast iteration, I make the architecture decisions and refactor by hand. Every line in lib/ is reviewed and curated. Hybrid workflow, not autopilot.

The rendering went through a few iterations. Started with physical dispersion using Cauchy's equation, but tuning the coefficients for all 720 time combinations was a nightmare and some just looked bad. Then I tried bouncing light inside the prism, which was better but had ugly corner cases. In the end I dropped the physics and went with a simple traced path that always looks good. 360 commits of learning what to throw away.