Roadmap

The road to beta.

An Electron-class developer experience that ships tiny apps on WebKit instead of a bundled browser - with native modules that never need a compiler. Below: what's shipped, the exact stops between here and beta, and what "beta" has to prove before we'll say the word. No vapor; if it isn't built, it says so.

v0.1.0-alpha.6 macOS · Linux · Windows MIT

Where we are today

29
Electron-shaped modules
~70-80%
weighted API parity
~1,600
tests passing · 3-OS CI matrix
0
compiled native code

Published on npm; the site you're reading is the docs. The framework runs on macOS, Linux and Windows (x64), the pinned-engine store and CLI are in place, and self-contained relocatable WebKits - including a from-source WinCairo build - load from the store in CI. The per-method truth lives on the parity page.

Release plan

From here to a beta you can check.

  1. alpha.5
    Shipped

    The framework, the CLI, and the engine store

    the release that put bunmaska on npm - three platforms, honest gaps.

    • An Electron-shaped API on Bun + system WebKit - 29 modules, ~70-80% weighted parity, pure bun:ffi, zero compiled native code, zero runtime deps.
    • macOS and Linux in full; Windows (x64) in beta on a from-source WinCairo backend, green on CI next to the other two.
    • The CLI loop - init / dev / build - producing real .app, .deb and .exe distributables, plus a pure-Bun auto-updater.
    • The pinned-WebKit engine store: side-by-side, content-addressed, signature-verified installs. Relocatable engines proven on Linux and Windows CI.
    • Frameless windows, bundled preloads, dev live-reload, and an event-driven macOS run loop (~10× less idle CPU).
  2. alpha.6
    Shipped

    Foundation - the unglamorous release. Deliberately.

    where we are today - on npm as `latest`.

    • Landed from the internal code review: the crash-class FFI lifetime fixes, and a security fix that closes an engine-downgrade path - a genuinely-signed older or other engine can no longer install under a different pinned id, because the store now binds the dir to the id inside the signed engine.json.
    • The engine repository is live at engines.bunmaska.org: pack a built engine dir to .tar.zst, content-hash it, Ed25519-sign the bytes, publish to R2; bunmaska engine install resolves the id against the feed, verifies the signature against the baked release key and re-checks the hash before extracting. The first hosted engine is the WinCairo WebKit Windows apps require - installed from the real CDN, end-to-end.
    • The start of the Electron contract-fidelity pass: app.isReady() is a method, toPNG/toJPEG return Buffer, Tray takes a NativeImage, loadFile handles hash/query and encodes paths properly. The rest of the list rides in alpha.7.
    • A first test-budget gate in CI: a minimum pass count and a skip ceiling per OS, so a silently-degraded suite fails the build instead of shrinking quietly.
    • The website is held to the framework’s own strict TypeScript + lint bar, gated in CI.
  3. alpha.7
    In progress

    Hosted engines - the distribution unlock

    any app, any platform, a tested WebKit one fetch away.

    • The feed shipped early, in alpha.6: engines.bunmaska.org serves the signed WinCairo engine from Cloudflare R2, and the release public key is baked in as the trust anchor. What remains is the rest of the catalogue - the stable-train WinCairo build (hosted engines track WPE stable releases, where security advisories land), the hosted Linux engine, and publishing wired into CI instead of run by hand.
    • The render pass for the relocatable Linux engine: it loads from the store today; next it draws.
    • Cross-distro Linux engines (an old-glibc base, one build across distros).
    • Engine delivery for end users: embedded in the bundle or fetched on first run. Never something a user types.
    • The foundation leftovers carry here, not dropped: the coverage ratchet, the remaining contract-fidelity fixes, shared e2e harness helpers, and the Windows WebKit stack tested on every push.

    Exit test a fresh machine goes install > init > build > running app on a pinned engine, on all three OSes

  4. alpha.8
    Planned

    API depth - the last stretch real apps hit

    closing the gap list the parity page already admits to.

    • session.cookies on all three platforms - the auth-app blocker.
    • A real autoUpdater.quitAndInstall (atomic swap + relaunch) and cryptographically signed updates, not just integrity hashes.
    • Linux capturePage, powerMonitor idle/battery, page-title-updated, per-instance webContents.ipc.
    • The self-pipe wakeup primitive that structurally prevents the one hang class we’ve ever shipped.
    • A worked serial-port native module - the buildless-FFI flagship demo, as a real package.

    Exit test no "easy" cells left on the parity page; every N/A documented with its reason

  5. v0.2.0-beta.1
    The bar

    What beta means here - checkable, not vibes

    every box below is verifiable. No box, no beta.

    • The API surface is frozen for the beta line; semver discipline begins.
    • install > init > dev > build > launch runs end-to-end in CI on macOS, Linux and Windows - not just unit-green.
    • Hosted engines are live and the auto-updater has shipped a real update to a real app.
    • At least five real open-source Electron apps run via dependency swap, and one app we use daily has run for two weeks without a crash.
    • Docs are complete: every implemented method documented, the parity matrix exact, the migration guide tested against a real app.
    • Coverage at threshold, zero silent skips, and published (measured, methodology-included) size and memory numbers.
  6. v1 line
    After beta

    After beta

    real, but not next. Listed so you know we know.

    • Windows ARM64 (waiting on upstream WinCairo) and a Windows isolated content world.
    • The macOS pinned-engine spike - system WKWebView stays the default either way.
    • Delta updates, crash reporting, a SECURITY.md + disclosure process.
    • The event-driven run loop on Linux and Windows, then upstreaming a Bun event-loop API so the pump disappears entirely.

The one everyone asks about

Windows, the honest version.

Windows is in beta - a from-scratch Win32 backend with WinCairo WebKit, green on CI. Here's the honest state, gaps and all.

Not WebView2

The easy Windows path is WebView2 - Microsoft Edge, i.e. Chromium. We didn't take it. Windows renders on WinCairo WebKit, the real WebKit port, loaded from the same engine store as every other platform.

A real Win32 backend

Built from scratch on bun:ffi - window + message pump, the WinCairo WebKit view and IPC bridge, and the full secondary-module set (clipboard incl. images, dialogs, tray, safeStorage via DPAPI, screen, shell, shortcuts, power, theme). It runs on a windows-latest CI runner.

x64 today, ARM64 next. Never 32-bit.

x64 is in beta now; ARM64 waits on upstream WinCairo. Windows is moving to ARM - so ARM64 is a when, not an if. x86 isn't on the list at all.

Still the expensive platform

Windows has no system WebKit, so we ship and maintain the WinCairo engine ourselves - CVE treadmill and all. That's why hosting the WinCairo builds is on the alpha.7 stop: a Windows app has to be able to fetch its engine.

Honest status: the backend is built and runs on a Windows CI runner, but a Windows app still needs a WinCairo engine in the store - and we don't host those builds yet. Windows is real in the code; shipping it end-to-end waits on the hosted engine, the same step Linux is waiting on.

Want to watch it happen?

It's all in the open. Star it, read the docs, or come argue about the parity matrix.

Read the docs > GitHub
Morty Proxy This is a proxified and sanitized view of the page, visit original site.