Electrobun 1.0 launches for building fast, cross-platform desktop apps with TypeScript

Electrobun ships stable version 1.0

Developer and Blackboard founder Jarred Sumner has released Electrobun 1.0, a new framework designed to build small, fast desktop applications using TypeScript and the Bun runtime. The release marks the end of a two-year development cycle focused on eliminating the performance overhead and developer friction associated with Electron.

The framework allows developers to write desktop apps that run on macOS, Windows, and Ubuntu. It targets the "Goldilocks" zone of desktop development, offering the ease of web technologies without the heavy memory footprint of Chromium-based shells. By leveraging Bun’s foreign function interface (FFI), Electrobun maintains high execution speeds while keeping the binary sizes significantly smaller than traditional alternatives.

The project began when the creator hit technical roadblocks while building co(lab), a hybrid browser and code editor. The original version relied on Electron, but the complexity of code signing, notarization, and distribution became a primary motivator for a custom solution. Electrobun now serves as the foundation for the fully rewritten co(lab) application.

Moving past the Electron tax

Electron has dominated desktop development for a decade, but it carries a heavy "Electron tax" in the form of high RAM usage and massive installers. Developers often find themselves fighting the framework to handle basic tasks like auto-updates and window management. Electrobun addresses these pain points by automating the most tedious parts of the shipping process.

The framework generates installers, auto-update artifacts, and differential patches automatically. This allows developers to use any static host, such as Amazon S3, Cloudflare R2, or GitHub Releases, to distribute their software. The goal is to make shipping a desktop app as seamless as deploying a website to the web.

While Tauri offers a similar alternative using Rust, many web developers find the learning curve for Rust too steep. Electrobun stays within the TypeScript ecosystem, making it accessible to a wider range of software engineers. It provides a familiar environment while utilizing low-level languages like Zig and C++ under the hood to ensure performance.

Technical foundation and Zig integration

The development of Electrobun required a deep dive into low-level systems programming. The creator spent 24 months learning and implementing code in Zig, C, C++, and Objective-C. This multi-language approach allows the framework to interact directly with native operating system APIs across different platforms.

One of the most significant technical achievements in the framework is zig-bsdiff. This is a custom port of the C-based bsdiff tool, which the developer optimized using SIMD (Single Instruction, Multiple Data) instructions and zstd compression. These optimizations result in extremely small differential updates, saving bandwidth for both developers and end-users.

The architecture of the framework changed as Bun matured. Originally, Electrobun relied on a complex Zig FFI layer, but it now leans directly on Bun’s stable FFI. This shift allowed for an "inverted" architecture where Bun uses shared memory to manage workers, keeping the application efficient even when running multiple processes simultaneously.

Building a better webview

A recurring issue in desktop frameworks is the implementation of Out-of-Process Iframes, or OOPIF. Electron’s implementation of the webview tag has been deprecated by the Chromium team for years, leading to persistent bugs and rendering issues. Electrobun introduces a custom electrobun-webview component to solve these legacy problems.

This new webview acts as a "super iframe" that provides true process isolation without the common pitfalls of existing solutions. It handles DOM positioning and layering correctly, ensuring that UI elements do not flicker or disappear during window resizing. This implementation works natively across all supported platforms without requiring custom patches to the underlying browser engines.

The framework provides a comprehensive suite of native features that go beyond simple window rendering. Developers have access to a robust set of tools for building professional-grade software:

• Cross-platform window controls and native menus.
• Global keyboard shortcuts and accelerators.
• System clipboard access and native dialog boxes.
• Webview partitions and isolated session storage.
• Find-in-page functionality and custom bundling tools.

The path to version 1.0

The transition to v1.0 signals that the framework is stable enough for production-grade, long-lived products. The creator emphasized that the goal was to build a tool that prevents "platform churn," where developers are forced to rewrite their apps every few years due to framework shifts. By focusing on stability, Electrobun aims to be a permanent fixture in the developer's toolkit.

The community surrounding the project has grown steadily during the beta period. Users on the project's Discord server have been instrumental in filing issues and testing early builds on various Linux distributions and Windows versions. This feedback loop helped refine the framework's tooling and documentation before the official launch.

Electrobun is the first major release from Blackboard, a new "startup lab" focused on building better developer tools. With the framework now stable, the focus shifts to expanding the ecosystem and supporting more complex use cases. The project remains open for developers who want to escape the overhead of Node.js and Chromium while keeping the flexibility of TypeScript.

The framework is available now for developers looking to build their next desktop project. It represents a significant shift toward Bun-native development, proving that the modern web stack can produce high-performance desktop software. As more developers move away from Electron, Electrobun stands as a viable, TypeScript-first alternative for the next generation of apps.