Electrobun

Electrobun 2.0 is here — read the launch post

Electrobun

Build ultra fast, tiny, cross-platform desktop apps. A hello world ships at about a megabyte — not a hundred of them.

TypeScript · Zig · Rust · Go · Odin — system webview, Chromium, or WGPU

Read the docs GitHub

Install Hutch — macOS / Linux

$ `curl -fsSL https://hutch.blackboard.sh/hutch/install.sh | sh` Copy

Windows PowerShell

\> `& ([scriptblock]::Create((irm https://hutch.blackboard.sh/hutch/install.ps1)))` Copy

Then create an app

$ `hutch electrobun init` Copy

Your language. Same framework.

TypeScript Zig Rust Go Odin

import { BrowserWindow } from "electrobun/main";
new BrowserWindow({
  title: "Hello Electrobun",
  url: "views://mainview/index.html",
  frame: { width: 800, height: 600 },
});

const electrobun = @import("electrobun");
fn createUi(core: *electrobun.Core, paths: *const electrobun.BundlePaths) void {
    core.configureWebviewRuntimeFromExecutableDir(paths, 0) catch return;
    const window_id = core.createWindow(.{
        .title = "Hello Electrobun",
        .frame = .{ .x = 160, .y = 100, .width = 800, .height = 600 },
    }) catch return;
    _ = core.createWebview(.{
        .window_id = window_id,
        .renderer = .native,
        .url = "views://mainview/index.html",
        .frame = .{ .x = 0, .y = 0, .width = 800, .height = 600 },
    }) catch {};
}

fn create_ui(core: &Core, bundle_paths: &electrobun::BundlePaths) {
    core.configure_webview_runtime_from_executable_dir(bundle_paths, 0).unwrap();
    let window_options =
        WindowOptions::new("Hello Electrobun", Rect::new(140.0, 100.0, 900.0, 640.0));
    let window_id = core.create_window(window_options).unwrap();
    let webview_options = WebviewOptions::new(
        window_id,
        "views://mainview/index.html",
        Rect::new(0.0, 0.0, 900.0, 640.0),
    );
    core.create_webview(webview_options).unwrap();
}

func createUI(core *electrobun.Core, bundlePaths electrobun.BundlePaths) {
    core.ConfigureWebviewRuntimeFromExecutableDir(bundlePaths, 0)
    windowOptions := electrobun.NewWindowOptions(
        "Hello Electrobun",
        electrobun.NewRect(140, 100, 800, 600),
    )
    windowID, _ := core.CreateWindow(windowOptions)
    webviewOptions := electrobun.NewWebviewOptions(
        windowID,
        "views://mainview/index.html",
        electrobun.NewRect(0, 0, 800, 600),
    )
    core.CreateWebview(webviewOptions)
}

create_ui :: proc() {
    electrobun.configureWebviewRuntimeFromExecutableDir(g_core, g_bundle_paths, 0)
    window_options := electrobun.defaultWindowOptions("Hello Electrobun")
    window_options.frame = {x = 160, y = 100, width = 800, height = 600}
    window_id, _ := electrobun.createWindow(g_core, window_options)
    webview_options := electrobun.defaultWebviewOptions(window_id)
    webview_options.url = "views://mainview/index.html"
    webview_options.frame = {x = 0, y = 0, width = 800, height = 600}
    electrobun.createWebview(g_core, webview_options)
}

Abbreviated for clarity — full walkthroughs for every language in the docs.

Megabytes, not hundreds

Electrobun — native main process

1.28 MiB

Electrobun — Cottontail

\~15 MiB

Typical Electron app

\~85 MiB

Compressed hello-world download, macOS ARM64, system webview renderer.

What's new in 2.0

WarrenNew

A SolidJS-inspired fine-grained reactivity framework built for Electrobun. Run it in your Cottontail or Bun process to write directly to native GPU surfaces — in standalone windows or composited into your webviews — or run it inside the webview itself to drive fine-grained reactivity in your web UI.

HutchNew

One CLI for everything: packages, scripts, bundling, pinned toolchains, and releases. Replaces npm, Bun, and the old Electrobun CLI.

CottontailNew

Our own TypeScript runtime, built with Zig on JavaScriptCore. Node.js and Bun-compatible where it counts, and smaller than either.

Six main processes

TypeScript by default. Zig, Rust, Go, or Odin when you want compiled performance — same core, same build tool, same packaging.

Interactive init

`hutch electrobun init` opens a keyboard-navigable template picker — 30 starters, from framework shells to GPU simulations.

Already in the box

Differential updates

Batteries-included zig-bsdiff powers updates as small as 4 KB. Just bring your own S3, R2, or static file host — no update server, with a full-download fallback.

Zstd self-extracting bundles

Releases ship as compact Zstandard self-extracting bundles that verify, extract, and launch on first run.

Code signing built in

Signing and notarization run as part of the release build — DMG on macOS, setup executable on Windows, self-extracting installer on Linux.

three.js & Babylon adapters

Control native GPU windows and surfaces composited onto your webviews from Cottontail or Bun, using the 3D libraries you already know.

Optional CEF bundling

System webviews keep apps tiny by default. Bundle a pinned Chromium when you want the same engine everywhere.

Canary + production channels

Two independent release channels out of the box — ship prerelease builds to testers alongside the production app.

30 templates to start from

Web framework starters

Your stack, wired into a desktop shell with hot-rebuilding dev mode.

• react-tailwind-vite
• solid
• svelte
• vue
• angular
• vanilla-vite
• tailwind-vanilla

App skeletons

Real application patterns: tabs, windows, storage, trays, media.

• multitab-browser
• multi-window
• notes-app
• sqlite-crud
• photo-booth
• tray-app
• hello-world
• bunny

GPU & native

Native main processes driving WGPU — simulations, particles, and 3D.

• zig-wgpu
• rust-flock-wgpu
• go-maze-wgpu
• odin-particles-wgpu
• odin-fluid-wgpu
• odin-jelly-bunny-wgpu
• odin-alchemy-wgpu
• odin-tree-wgpu
• wgpu
• wgpu-threejs
• wgpu-babylon
• wgpu-mlp

Warren UI (experimental)

Reactive GPU-rendered UI — no webview in the loop.

• ui-wgpu
• ui-color-picker
• ui-launcher

We don't just ship Electrobun — we live in it. Dash, our desktop product, is built end-to-end on Electrobun 2.0: Hutch builds it, Cottontail runs it, Warren renders parts of it, and its updates ship as binary diffs.

Start building

$ `curl -fsSL https://hutch.blackboard.sh/hutch/install.sh | sh` Copy

$ `hutch electrobun init` Copy

Quick Start GitHub Discord