"Electron gives apps mass. Strake gives them velocity."
Notice: Strake is an independent native application runtime originally derived from Blitz by DioxusLabs. It builds upon modular HTML/CSS foundations (Stylo, Taffy, Parley, Vello) to deliver a true lightweight Electron replacement capable of running standard web applications natively across macOS, Windows, Linux, iOS, and Android, backed by an on-demand, zero-copy offscreen Chromium fallback. See NOTICE for full attribution.
"In the compatibility layer, all hacks are permissible. On the modern path, zero waste is tolerated."
Strake is governed by two inviolable laws:
-
The Inviolable Law of Compatibility (Day 1 Drop-in Replacement):
- Any application written for Electron or standard web environments must run in Strake on Day 1 without breaking changes or painful architectural rewrites.
- In the compatibility layer, all pragmatic shims, polyfills, monkey-patches, and offscreen Chromium fallbacks are completely acceptable. No edge-case feature, legacy API, or obscure web specification will be turned away if an existing real-world app depends on it. Compatibility is our adoption vector.
-
The Inviolable Law of Ultra-Optimization (The End-State Moat):
- In our target steady state, no heavy rendering engines, multi-process bloat, or redundant virtual machines may permanently consume disk space, CPU, GPU, or RAM.
- Ultra-optimization is our technical reason for being: sub-30MB baseline RAM, sub-100ms cold startup, 120fps GPU compute rendering, 0% CPU at idle, and sub-20MB distributable binaries.
-
The Bifurcated Architecture: The Modern "Hyper-Path":
- The Legacy / Fallback Path: For unpolyfilled APIs or complex legacy browser subsystems (WebRTC, Widevine, intricate iframes), Strake dynamically routes rendering to a disposable, heavily throttled offscreen Chromium worker that hibernates or terminates the moment it is hidden.
- The Modern Hyper-Path: When an application authors clean, modern, evergreen web code (standard Flexbox/Grid layouts, modern ES modules, native Web APIs), the engine bypasses all shims, virtualization, and Chromium overhead entirely—executing directly on bare-metal Rust and GPU compute shaders with minimal resource consumption.
- The Developer Incentive: Developers are never blocked by missing features, but are naturally rewarded with featherweight, battery-friendly native performance simply by writing modern standard code.
Traditional desktop web wrappers (Electron, CEF) embed an entire Google Chromium browser and Node.js instance for every single application, consuming hundreds of megabytes of RAM, bloating binary sizes past 150MB, draining laptop battery life, and introducing seconds of cold-boot latency.
Strake re-architects client application infrastructure from first principles:
- Instant Cold Starts: Sub-100ms cold application launch.
- Featherweight Memory: Sub-30MB baseline RSS memory footprint (compared to Electron's 200MB–500MB+).
- Power Efficiency: 120fps GPU compute-shader vector rendering (via Vello / WGPU) with 0 FPS idle sleep when static.
- Compact Binaries: Under 20MB stripped distributable binaries with sub-500KB delta updates.
- Desktop: macOS (Metal), Windows (DirectX 12 / 11), Linux (Vulkan / Wayland / X11).
- Mobile: iOS (UIKit) and Android (SurfaceView) using the identical unified Rust core.
- Run standard web code (HTML, CSS, JavaScript/TypeScript) without a bloated multi-process V8 engine.
- Native microtask/macrotask HTML5 event loop wired directly to
strake-dom's generational SlotMap. - Dynamic QuickJS-ng runtime with future Static Hermes AOT compilation for typed bundles.
While Strake renders modern HTML and CSS with extreme speed and fidelity, arbitrary web applications occasionally rely on long-tail browser subsystems (WebRTC, Widevine DRM media, intricate iframes, or unhandled browser extensions).
Rather than failing or waiting years for full spec reimplementation:
- Native-First Core: 95%+ of UI layout, styling, text shaping, image rendering, and DOM events execute directly in native Rust.
- Zero-Cost Idle Fallback: The headless Chromium worker is never launched at startup (0 MB RAM, 0% CPU at rest).
- On-Demand JIT Spawning: Spawns an isolated headless Chromium worker only when an unsupported element is mounted.
- Zero-Copy GPU Texture Sharing: Offscreen frames stream directly into Strake's WGPU pipeline via OS-level shared GPU textures (
IOSurfaceon macOS,DXGIshared handles on Windows,dma-bufon Linux) with zero CPU memory copying. - Aggressive Auto-Eviction: Worker hibernates after 15 seconds of inactivity and terminates after 30 seconds of zero active fallback nodes, restoring memory back to the sub-30MB baseline.
┌────────────────────────────────────────────────────────────────────────┐
│ User Web App (TS, HTML, CSS) │
└───────────────────────────────────┬────────────────────────────────────┘
│
┌────────────────────────────┴────────────────────────────┐
▼ ▼
┌───────────────────────────────┐ ┌───────────────────────────────┐
│ JavaScript / TS Layer │ │ UI & Styling Layer │
│ • QuickJS-ng / Static Hermes │ │ • Stylo (Servo CSS Engine) │
│ • Generational SlotMap FFI │ │ • html5ever (HTML5 Parsing) │
└──────────────┬────────────────┘ └──────────────┬────────────────┘
│ │
│ Direct FFI / Microtask Event Loop │
▼ ▼
┌────────────────────────────────────────────────────────────────────────┐
│ Strake Core (Rust) │
│ │
│ • Layout: Taffy (Flexbox, CSS Grid, Block layout) │
│ • Typography & Shaping: Parley + HarfBuzz │
│ • Accessibility: AccessKit (Universal OS accessibility bridge) │
│ • Synthetic DOM & Event Dispatch │
└───────────────────┬────────────────────────────────┬───────────────────┘
│ │
[Native Surface] │ [On-Demand Fallback Surface]
▼ ▼
┌──────────────────────────────────────┐ ┌──────────────────────────────┐
│ Vello GPU Renderer │ │ Headless Chromium Worker │
│ Compute-shader 2D rendering │ │ (Offscreen CEF/Blink for │
│ via WGPU (Metal, DX12, Vulkan) │ │ WebRTC, complex DRM) │
└───────────────────┬──────────────────┘ └──────────────┬───────────────┘
│ │
│ Zero-copy GPU Texture Bridge │
└─────────────────┬──────────────────┘
▼
┌────────────────────────────────────────────────────────────────────────┐
│ Winit Native Window & Events │
│ (macOS, iOS, Windows, Android, Linux) │
└────────────────────────────────────────────────────────────────────────┘
strake-dom— Core synthetic DOM incorporating style resolution, Taffy layout, text shaping, and event dispatch.strake-paint— Translates DOM render nodes into GPU compute draws via anyrender / Vello.strake-shell— Connects the engine to host OS windowing, system tray, menus, dialogs, and AccessKit screen readers.strake-html— HTML5 parsing via html5ever.strake-net— Asynchronous resource fetching, corporate proxy discovery, and system root CA resolution.strake-cdp— Embedded Chrome DevTools Protocol server for live inspection and Vite HMR live reloading.
Ensure you have a modern Rust toolchain installed (1.80+):
# Clone the repository
git clone https://github.com/gregoreesmaa/strake.git
cd strake
# Launch the native Strake browser
cargo run -rp browser
# View a Markdown document via native engine
cargo run -rp rdme ./README.mdStrake is an open-source project originally derived from Blitz by DioxusLabs.
This project is dual-licensed under:
- Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
- MIT License (http://opensource.org/licenses/MIT)
The stylo_taffy crate is additionally licensed under the Mozilla Public License 2.0 (MPL-2.0) for interoperability with the Servo project.
See NOTICE for complete upstream copyright and patent notices, and TRADEMARKS.md for brand guidelines.