Web markup.
Native pixels.

Rendrix compiles a strict subset of HTML and CSS into one native desktop executable. The Rendrix engine draws the window, and no browser or Node runtime ships with the app.

bun install -g @bytethedeveloper/rendrix
rendrix init my-app
cd my-app && rendrix dev

Experimental, in early beta. The Windows host has been run by hand; hosts for other platforms are built in CI.

Rendrix counter
RENDRIX NATIVE RENDERING

Rendrix

HTML + CSS + TypeScript. No browser engine.

CLICK COUNTER 0 Click below to update native UI state.

Backend actions run in embedded QuickJS, not Bun at runtime.

A simulation of examples/counter. These buttons run in the browser, not in the Rendrix runtime.

What ships with your app.

A typical Electron app carries a browser and a Node.js runtime. A Rendrix app carries the Rendrix host and your compiled bundle, and nothing else.

Typical Electron app
Your HTML, CSS and JavaScript
Node.js
Chromium
Rendrix app
Your app, as a .rdx bundle
Rendrix engine and QuickJS

These are layers, not file sizes. No size, memory or startup measurements have been made yet.

Source on the left. Native window on the right.

These are the real files from examples/counter/src. Switch tabs to read each one, then use the window to see what they describe.

<!doctype html>
<html>
  <body>
    <main class="shell">
      <section class="card">
        <div class="badge">RENDRIX NATIVE RENDERING</div>
        <h1>Rendrix</h1>
        <p class="subtitle">HTML + CSS + TypeScript. No browser engine.</p>
        <div class="counter-panel">
          <span class="eyebrow">CLICK COUNTER</span>
          <span class="count" data-bind="count">0</span>
          <span class="hint">Click below to update native UI state.</span>
        </div>
        <div class="buttons">
          <button id="decrement" class="secondary" data-onclick="decrement">− Decrease</button>
          <button id="increment" class="primary" data-onclick="increment">+ Increase</button>
          <button id="reset" class="ghost" data-onclick="reset">Reset</button>
        </div>
        <p class="footer">Backend actions run in embedded QuickJS, not Bun at runtime.</p>
      </section>
    </main>
  </body>
</html>
Rendrix counter, 900 × 600
RENDRIX NATIVE RENDERING

Rendrix

HTML + CSS + TypeScript. No browser engine.

CLICK COUNTER 0 Click below to update native UI state.

Backend actions run in embedded QuickJS, not Bun at runtime.

An interactive simulation of the counter. The real window is drawn by the Rendrix host from the compiled .rdx bundle.

Three parts, one job each.

Markup is compiled ahead of time, logic runs in a small sandbox, and the pixels come from the Rendrix engine. Nothing in the shipped app asks for a browser or a JavaScript runtime.

Markup and styles

A strict subset of HTML and CSS is parsed at build time into an element tree with explicit keys. Selectors, specificity and inheritance are resolved before anything reaches the window, so the layout you write is the layout that ships.

TypeScript backend

One backend.ts exports state and actions. It is transpiled to JavaScript and run in embedded QuickJS on the UI thread. Actions are synchronous and see only get, set and update.

One executable

Packaging copies a prebuilt Rendrix host and appends the app bundle to it. The result is a single .exe that runs without Bun, Node or Rust on the machine.

From source files to one native executable.

Each stage writes a file you can inspect. The bundle is plain JSON, so you can open it and see exactly what the host will render.

Your project

  • src/index.html
  • src/styles.css
  • src/backend.ts
  • rendrix.config.json

rendrix compile

Parses the HTML subset, resolves CSS, transpiles the backend and writes a .rdx document.

{
  "format": "rendrix-1",
  "name": "rendrix-counter",
  "width": 900,
  "height": 600,
  "root": { "tag": "body", … },
  "backend_js": "…"
}

rendrix build

Copies the prebuilt host and appends the bundle. The host reads it back at startup.

Host executable, the bundle JSON, an 8-byte little-endian length, then the RENDRI01 marker.

Writes dist/rendrix-counter.exe

A small, native backend.

The design trades browser breadth for a smaller, inspectable system. These are the properties the current prototype is built around.

  1. Parse

    Strict HTML subset to an element tree with explicit keys and attributes. Unsupported tags fail the build.

  2. Style

    CSS parsed with PostCSS. Descendant matching, class and id selectors, inheritance and specificity are resolved.

  3. Transpile

    The single backend file is compiled with the TypeScript compiler to CommonJS (ES2020).

  4. Render

    The Rendrix host opens a GPU-accelerated window and draws the tree. Media queries are evaluated at compile time.

  5. Run

    Clicks invoke actions in QuickJS. The view takes a state snapshot and redraws. QuickJS has an approximate heap cap, not a CPU-time limit.

One rendering engine

Rendrix is the only engine, in early beta. The deprecated legacy host stays available until the Rendrix M1 gate.

No Node or Bun at runtime

Bun or Node is needed for development. The distributed app does not need either one installed.

Fast iteration

Changing HTML, CSS or TypeScript recompiles the bundle and reuses the existing host. Rust is not rebuilt.

Plain-text bundle

The .rdx document is JSON. Its format and contents can be read and checked directly.

Compile-time components

<template data-component> is expanded at compile time. Recursive uses and duplicate IDs are rejected.

Explicit data binding

data-bind and {{stateKey}} read backend state. data-onclick dispatches named actions.

Build the counter from a checkout.

Requires Bun or Node 20+ for the developer CLI. Compiling the bundle does not need Rust. Building the native host does.

Check and compile the example

bun install
bun run test
bun run rendrix:compile

Writes examples/counter/dist/rendrix-counter.rdx.

Get a native host, once per machine

Point RENDRIX_HOST at a host you trust, or compile one with the Rust toolchain. On Windows that also needs the MSVC build tools.

bun run rendrix:host

Package the executable

bun run rendrix

Writes examples/counter/dist/rendrix-counter.exe.

Or install the CLI from npm

bun install -g @bytethedeveloper/rendrix
rendrix --version

-g installs rendrix globally. Without it, Bun adds the package to the current project's node_modules. npm works too: npm install -g @bytethedeveloper/rendrix. View the package on npm.

Or start a new project with the CLI

rendrix init my-app
cd my-app
rendrix dev

rendrix dev rebuilds and restarts the host on save. It is a fast reload, not state-preserving hot module replacement. rendrix build writes the single executable, and rendrix build --target linux-x64 or rendrix all packages the other platforms. rendrix run also opens an Electron project directory, converting it first.

The reference, rendered here.

The architecture, supported syntax, build steps and safety model, read directly on this page.

Loading…

Status: an experimental prototype, stated plainly.

Rendrix is not a production-ready GUI SDK. The Rendrix engine is the sole renderer and is in early beta: feature coverage is limited and a long way from stable. The list below reflects what the deprecated legacy host (available until the Rendrix M1 gate) documents today.

Works today

  • Strict HTML subset with class, id, data-bind and data-onclick
  • Forms, text inputs, textareas and keyboard editing
  • Images, repeated data lists and optional virtual scrolling
  • Media queries that update when the window is resized
  • CSS with element, class, id and compound selectors, specificity and inheritance
  • Flex and grid layout, including mixed px/fr tracks
  • Synchronous backend actions with get, set and update
  • Confirmation prompts, clipboard, file access and allowlisted network requests
  • Compile-time <template> components
  • Single-executable packaging with the appended bundle, plus an optional NSIS installer on Windows
  • Cross-target builds for Windows, macOS and Linux on x64 and arm64, using verified prebuilt hosts
  • Electron project conversion into a Rendrix project, with a report that lists what needs review

Not yet

  • Rendrix feature coverage: state-driven re-render, hover/active/focus, scrolling, images, text editing, accessibility and animations are on the M1–M3 ladder
  • General-purpose native dialogs beyond confirmation and file picker prompts
  • Unequal sizing for pure fr grid tracks and explicit grid placement
  • Sandbox isolation for untrusted backend code; execution time and heap limits are not a sandbox
  • Built-in signing or encryption: signing runs a command you configure, and packages are neither encrypted nor tamper-proof
  • Complete Electron compatibility: the importer lists each partial or unsupported API

Only run backend code and Electron projects you trust: execution limits are not a sandbox, and importing an Electron project runs its build script. The container format is a prototype. The Windows host has been run by hand. Hosts for other platforms are built in CI and have not been run here.

Start with the counter.

Clone the repository, compile the example and open the window it produces. Everything in the demo above is the same source.