2025年9月30日 の Show HN

Hey, I'm Josh, cofounder of Imbue. We built Sculptor because we wanted a great UI for parallel coding agents.

We love Claude Code, but wanted to solve some of the problems that come from running multiple agents in parallel (ex: merge conflicts with multiple agents, reinstalling dependencies with git worktrees, Claude Code could deleting your home directory, etc).

Sculptor is a desktop app that lets you safely run Claude Code agents by putting them in separate docker containers. This lets you use Claude without having to compromise on security or deal with annoying tool permission prompts. Then you can just tell Claude to keep running the code until it actually works.

To help you easily work with containerized agents, we created “Pairing Mode”: bidirectionally sync the agent’s code into your IDE and test/edit together in real time. You can also simply pull and push manually if you want.

We have some more cool features planned on our roadmap that are enabled by this approach, like the ability to “fork” conversations (and the entire state of the container), or roll back to a previous state.

It’s still very early, but we would love your feedback.

Sculptor itself is free to use, so please try it out and let us know what you think!

Hey everyone,

Cobalt is a program for painting textural and expressive pixel-art on Windows, Linux, Nintendo DS, and in-browser. The same 46KB core executable runs on all platforms, with a thin emulator layer sitting on top to handle differences in inputs and filesystem access (which makes it easy to port between systems). It's built on Bedrock[0], an 8-bit virtual computer system I posted about here in July.

I created Cobalt because I wanted to draw messy, gritty pixel art without smooth gradients, and the smaller colour palette helped with making bolder colour choices. Images can be moved back and forth between platforms, so you can copy works-in-progress to the DS to keep working away on the bus or train. It's like a 2004-era vision of the future.

There's a live demo on the linked page that runs in the browser, and there are downloadable demos for every platform here[1]. Let me know if you try it out or have any questions!

[0] https://benbridle.com/bedrock

[1] https://derelict-engineering.itch.io/cobalt

I've been frustrated with dependency hell and clutter on my VPS from dev, so I built Devbox: a lightweight, open-source CLI tool that spins up isolated development environments using Docker. Each project runs in its own container, but your code stays in simple flat folders on the host machine—no messing with volumes or sync issues. Environments are disposable, so you can nuke and recreate them without losing your work. Key features: - Instant setup: `devbox init my-project` and you're in a fresh env with `devbox shell`.

- Configurable via JSON: Define packages, services, and more in a `devbox.json` file. Share it in your repo for reproducible setups—teammates just run `devbox up`.

- Docker-in-Docker by default: Build and run containers inside your env without extra config.

- Host-friendly: Edit code directly on your machine; the container handles the runtime.

- Templates for quick starts: Built-ins for Python, Node.js, Go, web dev, etc.

- Advanced options: Port mapping, env vars, resource limits, and even mounting your dotfiles.

It's FOSS (MIT license), Linux-focused (Debian/Ubuntu, or WSL2 on Windows), and super easy to install: `curl -fsSL https://devbox.ar0.eu/install.sh | bash`.

Check out the launch page and docs at https://devbox.ar0.eu, or the repo at https://github.com/itzCozi/devbox. I'd love some feedback, stars, or contributions to help grow this into a solid community tool!

Hey all,

Just wanted to show off this app I built, its a LAN based WebRTC baby monitor that connects any apple devices together over WIFI so you can turn an old iPad or iPhone into a baby monitor!

I got a bit sick of all the sketchy products that require you to buy another device and may or may not connect to Chinese servers and store all your information somewhere.

So I figured what if there were no servers and we could just use our existing devices!

I would love any feedback! You will need two apple devices to test it, but simulators do work.

Last week Cloudflare released Cap'n Web [1], a schema-free capability-based RPC protocol. I built capn-rs this week - a Rust implementation with full wire protocol compatibility. Links:

GitHub: https://github.com/currentspace/capn-rs Crates: https://crates.io/crates/capnweb-server API docs: https://docs.rs/capnweb-server

What's working:

Wire compatibility verified via integration tests against TypeScript reference Multi-transport: HTTP batch, WebSocket, WebTransport (HTTP/3) Complete IL (intermediate language) expression evaluator Promise pipelining with dependency resolution Comprehensive test coverage

The interesting design challenge was mapping Cap'n Web's record-replay .map() semantics to Rust's type system while maintaining ergonomic APIs. Cap'n Web records operations on placeholder values to build execution plans - in Rust this became a clean builder pattern with type-level guarantees. Built this as an experiment with Claude Code for porting complex protocols. The AI handled mechanical translation well, but architectural decisions (especially around async/await patterns and lifetime management) required human judgment. This is early days - I'd especially appreciate feedback on API ergonomics and any edge cases I might have missed. Also happy to discuss the protocol design or the AI-assisted development experience.

[1] https://news.ycombinator.com/item?id=45332883

hey everyone,

I've been working on JPDB is a GDB like debugger for waveforms. if you give JPDB a waveform* and some other information, then you can step through the program that was executed when that waveform was created.

i say GDB-like because JPDB has it's own GDB client (its called shucks), that implements the client side logic of the GDB protocol faithfully, but doesnt have all of the GDB niceties (like python integration, etc). this allows the project to be specialized on debugging waveforms specifically, when compared to another approach like connecting to a gdb client

JPDB integrates with the waveform viewer surfer (https://surfer-project.org/), so you can look at other signals there. this is still ongoing because the underlying protocol (WCP) is a little Fresh

if you're developing your own CPU, give it a shot. Superscalar designs arent supported yet but it would be pretty straightforward, just give me your waves ( i am touching my fingers together villainously as i type this) and i will make it happen

also if you want to use system with a "normal" gdb client, the dang library presents a gdbstub server, so you can run that and connect to it.

here's a demo but it should work on your local machine if you follow the readme:

https://www.youtube.com/watch?v=EOo1aG_wcJg

I created a wiki which is intended to be a culinary encyclopedia. The idea came to me when I wanted to know about the culinary properties of rosemary–how it should be used, what culinary heritage it originates from, etc. The Wikipedia page for rosemary is too generic and not tailored towards culinary info. I was surprised that something like CulinaryWiki didn’t already exist.

There is basically nothing here yet (except the Rosemary page). I wanted to show HN to see if other cooking enthusiasts wanted to contribute some pages.

Hi HN,

I’m Arun, 17, from India. While my friends scroll Instagram and Snapchat, I’ve been obsessed with building something different. I don’t want a regular job — I want to push technology.

So I built WhiteLotus — a social app where every account is face-verified. No bots, no fake profiles, no spam. Just real people.

Core ideas:

AI-powered face verification (1 account per person)

1-on-1 private chats (only with friends)

Photo-based posting (keep it visual, keep it real)

“Kingdoms” (Fire, Water, Earth, Air tribes) for community vibes

Leveling system that shows how active and trustworthy you are

“TrustNotes” where friends can write notes about you

Right now, it has ~44 users. Growth is… hard. I’m shipping alone in Flutter + Django, fixing bugs, and trying to figure out how to get beyond 1 new user a day.

I know Instagram and Snapchat are addictive giants — but I believe there’s space for something real. A place where you don’t worry if the profile DMing you is fake.

I’d love feedback from this community:

Does this solve a real problem?

What would make you switch or at least try it?

How should I think about growth as a solo indie?

Even if nobody uses it, this journey has taught me more than any job ever could. But I’d love to hear your thoughts.

WhiteLotus on Play Store

https://play.google.com/store/apps/details?id=com.whitelotus...

Thanks for reading

Had a Lot of issues with existing APIs especially with Attachment support. Hence built own Whatsapp API.

Currently only Send Messages

Hi HN! I’ve been frustrated with traditional payments for a while. Paypal has frozen my funds on two occasions; and in one of them the funds were never recoverable. When I’m not using PayPal, international bank transfers take days and charge me insane amounts.

Also, every country usually has their own payment app parallel to the banking system: Portugal, where i currently live, has MB WAY, Brazil has PIX, Argentina has Mercadopago, the US has Cashapp. None of these work with each other.

Money still feels like pre-dotcom era tech when it should feel like a whatsapp message: send instant, anywhere, and for free.

Me and my team have been building Peanut to make money feel like Whatsapp. Peanut is a payments app, like Cashapp, but it works in any country. On top of that, you do more than only instant Peanut to Peanut payments; Peanut works with Banks, Peanut works with apps like MercadoPago and Pix, and if they have none of that, Peanut also works with crypto.

We wanted to build Peanut the right way, and that’s why:

- We’re not published on any app store. Peanut is a Progressive Web App (https://en.wikipedia.org/wiki/Progressive_web_app) (of which I sadly see way too few !!). This way we don’t have to bow to the Apple/Google tech cabal and can rely on open standards. - The core of peanut is decentralized & non-custodial. The only one that has control of the funds is the user; as it should be. Peanut is not like a traditional bank, where fraud, political instability, or a bank-run might pwn you. Your funds are always yours and no one else can touch them. - Your funds are secured by passkey. This is much harder to crack or extract than a password or pin, and you won’t get pwned if your seed phrase gets leaked. We think it’s a much better approach for consumers. - Trust is crucial; all the app code is open-source at https://github.com/peanutprotocol/peanut-ui/tree/peanut-wall... - The app is completely free; we only passthrough banking costs. The way we intend to make money is off of merchants in the future. We believe Visa and Mastercard take a way too big of a chunk of payments, and we can be competitive with them.

My personal favorite feature that we’ve built: generate a send link, drop it in a chat with the person you’re talking with, and let them receive it in whatever option they want (no questions asked!).

We’re still in Beta, so I hope you can forgive any tech hiccups. We’re also rolling out country support on a week-by-week basis; by the end of October we should have full EU, US & LATAM banking coverage. But I wanted to launch Show HN early, because I respect this community a lot and have always loved getting feedback from it (and often giving my own!).

Also, let me know your username and I’m happy to send you a few $ to play around with the app.

I made a little website you can only visit when your phone is in airplane mode. Enjoy that short moment of disconnection.

ProcASM is general purpose, visual programming language that I've developed. A few months ago I made a post about ProcASM v1.0 here <https://news.ycombinator.com/item?id=43892442> and got some feed about the UI.

So, I spent that last few months trying to improve the UI. Before, I used a GUI library, that I developed specifically for this app using SDL3, for ProcASM. I used Emscripten to port it to run in web browsers for those who wanted to try the app. Now, the front-end is written in HTML, CSS, and JavaScript to execute in a web browser. The back-end is a server that stores user's projects and handles user's requests. There is also a tutorial with text and video that will walk you through the usage of the app. My hopes are that the UI will be more approachable for those who want to try out the app.

The plan going forward is to develop new software using ProcASM and blog about the details and the advantages of using ProcASM.

i made this for my niece for her 3rd birthday. it was inspired by this reel: https://www.instagram.com/reel/DIE2O59Svcz/?igsh=MXNnbmJsZWR.... the main difference (i believe) is that this is entirely self-contained and does not require integrating with a smart home system. the bulb connects directly to a wifi network on the nanoc6, and the nanoc6 posts commands directly to the tasmota command endpoint on the smart bulb. this was a lot of fun to build :)

About the feature:

We built a tool for automatically assessing business health from complex management financial documents and bank statements.

In order to get this working reliably, we had to iterate extensively on the prompts for the structured output at the field level.

This led us to building a feature to allow users to improve them too, and with some context engineering, we have what we are calling “feedback loops”.

Here is a 2 min demo https://www.youtube.com/watch?v=ZDNlEZydoXU

How it works (video runs through these steps):

1. Create a target form for your extraction (AI helps create it)

2. Upload a document (choose from different models)

3. Review the quality of the extraction (and check the PDF citations)

4. If there are any mistakes, correct them and give feedback at the field level

5. Once you feel like you've seen enough errors and provided enough corrections, use the Feedback workflow to refine your field descriptions.

You can try the app here https://app.sea.dev/

(it works best when you do at least 2-3 reasonable extractions between prompt refinements)

The feedback feature is currently in beta. If you make some corrections and then go to https://app.sea.dev/feedback you'll see them ready for review and refinement.

I would love to get feedback on how we might improve this idea. The video was a toy example but it is live and working with a few early credit analysts customers and they seem to like it.

I built Piles, a simple browser extension that lets you save highlighted text instantly as notes.

No tags, no categories, no formatting — just highlight your text → save in piles → keep reading.

Setup takes less than a minute: enter your email, click the link, install the extension, done.

Would love to hear your feedback, ideas, or critique.

Hey HN,

As a freelancer, I found myself spending time every month manually opening PDF and Word invoices, copying the details into a spreadsheet, and tracking payments. It was tedious and error-prone.

I decided to build a simple desktop app to automate this. It's a GUI built with Python and Tkinter that points to a folder of invoices, parses the key details (invoice #, amount, date), and stores everything in a local SQLite database for tracking and analysis. It's been quite a time- and headache-saver for me.

A Note on Simplicity & Caveats

I'm sharing this in case it's useful to any other freelancers or businesses, but I want to be upfront about its limitations:

    The UI is very basic. It's built with vanilla Tkinter and is all about function over form. It's not the prettiest app, but it gets the job done.

    The core automation relies on a "patterns" feature that matches invoice prefixes to clients. This is super useful for my own workflow but might be a bit niche if your invoice naming is less consistent. You can still use manual entry if patterns don't work for you.

    The stats dashboard is Euro-centric right now and aggregates all currencies into a total shown in Euros (€). I plan to fix this later.

It's a simple personal project that solves a personal problem. The code is on GitHub, and I'd love to hear any feedback or suggestions you might have.

Hands‑only multi‑view hand pose pipeline with a browser demo in Rerun. Outputs: per‑view 2D keypoints + boxes, 3D keypoints, MANO joint angles & shape (all predictions, not GT). Four stages: camera estimation → shape calibration → 2D keypoints → pose optimization.

Known issues: not real‑time (~5 min for 30s/8 views on a 5090), too many cameras (target: 2 exo + 1 stereo ego), struggles with interacting hands.

Code: https://github.com/rerun-io/annotation-example/tree/dbt

Hi HN,

I built LegesGPT, an AI legal assistant that helps speed up legal research.

The problem: finding the right law or code often means digging through long government websites. It’s slow and frustrating, especially for lawyers and researchers.

Our solution: you ask a legal question, and LegesGPT answers with a clear explanation plus citations from official government sites (US, UK, UAE for now). It’s already being used daily by dozens of lawyers to save hours of research.

Under the hood, it uses advanced AI models reasoning + retrieval from government legal sources, so you always see where the answer came from.

I’d love feedback. Whether you’re a lawyer, developer, or just curious.

What features would make this more valuable to you?

https://legesgpt.com

I feel like LLMs can help me understand anything. However, jumping between ChatGPT, tabs, and docs gets in the way of building real understanding beyond isolated summaries and questions. This is my attempt at fixing that — for lifelong learners, researchers, professionals and students.

Would love your thoughts on the interface, and whether this would be useful in your own work or otherwise.

It fastest than traefik in 2-3 times, caddy in 10-15 times. Easy start and best effort with default cfg for.

I've been using online webhook tools for years, but always thought they felt slow and cluttered. Figured I could build something cleaner with modern tools.

Spent the past week building WebhookBox.

How it works:

Go to webhookbox.io, click the button, you get a URL like webhookbox.io/w/abc123. Send webhooks to it. They show up instantly. That's it.

No signup needed for testing (anonymous, 24hr retention). If you do sign up, you get persistent URLs, history, API access, etc.

What I built:

- Real-time request viewer (Supabase Realtime is honestly pretty slick for this - saved me from building custom WebSocket infra)

- See headers, body, query params - everything

- Custom responses if you need to return specific status codes or test error handling

- Export as cURL/Python/JS/whatever

Tech decisions:

Next.js + Supabase + Vercel edge functions. Used edge to get ~50-80ms global response times. Postgres JSONB for flexible payload storage. Rate limiting via Vercel KV to prevent abuse (100 req/hour per anonymous endpoint).

Free tier is 3 endpoints, 100 requests/month. Pro is $9/mo if you need more.

Thinking about adding webhook forwarding to localhost next - basically a WebSocket tunnel to forward webhooks directly to your dev server, skip ngrok entirely. Would that be useful or is the current approach good enough?

Hi HN! I'm a PM at Wikipedia and have been working on a way to make Wiki speedruns into a playable game for younger gens (hence Roblox). Since a Wiki speedrun is where you go from one article to another using links on the page, the thinking was, let's make a 3D navigable maze that responds to your choices.

We did it, and the feedback is pretty decent so far, but I feel like it needs something to make it more exciting. I'd love to hear your thoughts, especially if you're into games. How did we do?

Hi HN! I'm Jeff, Founder from ProductionApps. We're all using AI to code faster, but it's no secret that vibe-coded apps are a new kind of technical debt. The prototype that looks great on the surface but is a tangled mess of security flaws, unmaintainable spaghetti code and partially functioning backends.

ProductionApps.ai is a service built to solve this exact problem. We are a team of senior engineers and builders who implement a customized plan for your app - at a professional engineering-standard that can be integrated by your organization.

Please let me know if you have any questions or feedback. Thanks!