Show HN за 28 марта 2026 г.

QuickBEAM is a JavaScript runtime embedded inside the Erlang/OTP VM.

If you’re building a full-stack app, JavaScript tends to leak in anyway — frontend, SSR, or third-party code.

QuickBEAM runs that JavaScript inside OTP supervision trees.

Each runtime is a process with a `Beam` global that can: - call Elixir code - send/receive messages - spawn and monitor processes - inspect runtime/system state

It also provides browser-style APIs backed by OTP/native primitives (fetch, WebSocket, Worker, BroadcastChannel, localStorage, native DOM, etc.).

This makes it usable for: - SSR - sandboxed user code - per-connection state - backend JS with direct OTP interop

Notable bits:

- JS runtimes are supervised and restartable - sandboxing with memory/reduction limits and API control - native DOM that Erlang can read directly (no string rendering step) - no JSON boundary between JS and Erlang - built-in TypeScript, npm support, and native addons

QuickBEAM is part of Elixir Volt — a full-stack frontend toolchain built on Erlang/OTP with no Node.js.

Still early, feedback welcome.

Edit, sign, merge, compress, redact, OCR, fill forms, extract tables, and 30+ more tools — all in the browser, no sign-up. Files never leave your computer. Now with a desktop app (macOS/Windows/Linux) and a CLI/SDK for developers.

I've been building Pneuma, a desktop computing environment where software doesn't need to exist before you need it. There are no pre-installed applications. You boot to a blank screen with a prompt. You describe what you want: a CPU monitor, a game, a notes app, a data visualizer and a working program materializes in seconds. Once generated, agents persist. You can reuse them, they can communicate with each other through IPC, and you can share them through a community agent store. The idea isn't that everything is disposable. It's that creation is instant and the barrier to having exactly the tool you need is just describing it.

Under the hood: your input goes to an LLM, which generates a self-contained Rust module. That gets compiled to WebAssembly in under a second, then JIT-compiled and executed in a sandboxed Wasmtime instance. Everything is GPU-rendered via wgpu (Vulkan/Metal/DX12). If compilation fails, the error is automatically fed back for correction. ~90% first-attempt success rate.

The architecture is a microkernel: agents run in isolated WASM sandboxes with a typed ABI for drawing, input, storage, and networking. An agent crash can't bring down the system. Agents can run side by side, persist to a local store, and be shared or downloaded from the community store.

Currently it runs as a desktop app on Linux, macOS, and Windows. The longer-term goal is to run on bare metal and support existing ARM64 binaries alongside generated agents. A full computing environment where AI-generated software and traditional applications coexist.

Built entirely in Rust.

I built this because I think the traditional software model of find an app, install it, learn it, configure it; is unnecessary friction. If a computer can generate exactly the tool you need in the moment you need it, and then keep it around when it's useful, why maintain a library of pre-built software at all?

Free tier available (no credit card). There's a video on the landing page showing it in action.

Interested in feedback on the concept, the UX, and whether this is something you'd actually use.

Hey HN,

Automated research is the next big step in AI, with companies like OpenAI aiming to debut a fully automated researcher by 2028 (https://www.technologyreview.com/2026/03/20/1134438/openai-i...). However, there is a very real possibility that much of this corporate research will remain closed to the general public.

To counter this, we spent the last month building Enlidea---a machine-to-machine ecosystem for open research.

It's a decentralized research hub where autonomous agents propose hypotheses, stake bounties, execute code, and perform automated peer reviews on each other's work to build consensus.

The MVP is almost done, but before launching, we wanted to filter the waitlist for developers who actually know how to orchestrate agents.

Because of this, there is no real UI on the landing page. It's an API handshake. Point your LLM agent at the site and see if it can figure out the payload to whitelist your email.

I built a Windows 95–style weather app for iPhone.

I've been building AI products for a while. For this one I made a deliberate choice: none of the 16 tools use AI.

  Meeting cost calculators, freelance rate calculators, PRD generators,
  runway calculators, sprint retro boards — these problems don't need
  a language model. They need a well-designed form and correct arithmetic.

  Built on Nuxt 4 + Vue 3, fully static, runs in your browser. No account
  required to use anything. Optional Firebase auth only kicks in if you
  want to save output.

  Irony worth naming: Claude Code was my pair programmer throughout.
  The choice wasn't anti-AI — it was about using the right tool for
  the right problem.

  Happy to talk stack, the non-AI tradeoffs, or anything else.

Its not super fancy, but I have found it useful from small emails to larger design docs so thought I would share.

Garry Tan's gstack proved you can give Claude Code a full engineering team via the SKILL.md standard. I asked: what about the PM layer?

One command (/pm-run) runs the full planning cycle inside your terminal — audit → objectives → strategy → roadmap → PRD. Each skill writes a markdown artifact, the next one reads it. Context compounds across the whole pipeline.

The part I find most useful: it builds persistent memory of your product in ~/.nanopm/memory/. Re-run /pm-audit six months later and it knows what you tried before. No other PM tool does this because no other PM tool lives in your editor.

/pm-breakdown creates tickets directly in Linear or GitHub Issues from the PRD.

https://github.com/nmrtn/nanopm

Early days, would love to know: does running PM work inside your editor feel right, or does it belong in a separate tool?

! wanted to bring back some of that old weather channel vibe and the WeatherStar 4000+ emulator was a great way to get it, but it wasn't really easy to just pull it up on my Shield TV in the morning. So I put together this Android app and figured others might be into it too.

The app is a WebView wrapper around the WeatherStar 4000+ web emulator by netbymatt. It bundles everything locally and injects some JavaScript on top for kiosk features like location detection, settings, and music.

Location chains through GPS first, then falls back to IP geolocation if that's not available. Settings are accessed with a long press and get saved between sessions.

The music comes from the Weatherscan Complete Collection on Archive.org.

NUPA: private post-scarcity OS using BLM land leases + contract law. 100M Monte Carlo runs show 99.999999% survival, 6,480x more resilient than US GDP under systemic noise. Fixed Cost Arbitrage beats AI job loss—humans cheaper than robots. No taxes, no strikes. Python scripts on repo in /simulations folder.

Repo:

https://github.com/bedardbrandon928/National-Unity-and-Prosp...

Short explainer video:

https://youtu.be/RE560yVFb0I?si=UlVPkmCkrsg24Dzj

Its a site that lets you practice real code snippets and shows you your wpm. Free to play no sign in required.

Hey HN, we built Octopus an open-source, self-hostable AI code reviewer for GitHub and Bitbucket. It uses RAG with vector search (Qdrant) to understand your full codebase, not just the diff, and posts inline findings on PRs with severity ratings. Works with Claude and OpenAI, and you can bring your own API keys. Video: https://www.youtube.com/watch?v=HP1kaKTOdXw | GitHub: https://github.com/octopusreview

Hello HN, I made this website where you are given a unique survival scenario made by AI and you have to describe what you would do. The AI then decides if you would live or not. If you progress every round gets exponentially harder. Round 1 is a house fire, by round 6 you're fighting a kraken. I tried to make it as funny as possible.

Built using Cloudflare and GPT-4.1 Nano API.

Wordgen is a fast and easy to use wordlist generator that can make robust wordlists very fastly. Make millions of lines of wordlist in just a minute. Use your custom wordlist with tools like hydra and simulate cracking any password. Made using Go and Shell it has the speed of Go and ease of Python.

Download WordGen from here -->

https://github.com/CzaxStudio/wordgen

#Fast #Secure #StaySafe