by Davlatov | 2025-11-20 11:04:39+00:00
RORE: The Post-Web Interface Engine

Executive Summary For over a decade, the software industry has been held hostage by the "Web-First" dogma. We build mobile apps using browser engines (WebViews). We deploy megabytes of JavaScript just to render a simple button. We struggle with the fragility of CSS and the overhead of the DOM.

RORE is the declaration of independence from the Web Stack.

Rore is a high-performance, GPU-accelerated UI framework built entirely in Rust. It abandons HTML, CSS, and JavaScript in favor of a unified, type-safe, and purely native architecture that targets every platform from a single codebase.

The Mission: One Language (Rust). One Architecture. True Native Performance.

Key Value Propositions:

No WebView: We do not wrap a browser. We render pixels directly via the GPU.

No Garbage Collection: No Java, No Dart, No JS. Just deterministic memory management.

Zero-Config Build: rore build android — instant cross-compilation without "Dependency Hell."

Universal Reach: iOS, Android, Windows, macOS, Linux, and Web (WASM) — all running at 120 FPS. Engineering Philosophy 2.1. "Complexity Encapsulated"

The internal engine of Rore is incredibly complex—managing GPU pipelines, memory safety, and font shaping. However, the developer API is designed for radical simplicity.

The Principle: "A nuclear reactor on the inside, a TV remote on the outside." 2.2. The Paradigm Shift

We are replacing legacy standards with modern, high-performance alternatives: Component The Legacy Web Stack The Rore Solution Benefit Structure HTML (String-based) Rust DSL (Macros) Type-safe, compile-time checks Styling CSS (Global, Cascading) Rust Style Structs Scoped, Atomic, Zero runtime parsing Logic JavaScript / TS Rust Native Logic Multi-threaded, Memory-safe Rendering DOM / Virtual DOM WGPU (Direct) 10x less memory, 120+ FPS Layout Browser Engine Taffy (Flex/Grid) Headless, Deterministic, Fast

The Developer Experience (DX) 3.1. The Declarative DSL

We know that writing UI in raw Rust can be verbose. To solve this, Rore utilizes Procedural Macros to create a clean, beautiful Domain Specific Language (DSL) directly within Rust code.

It feels like Python or SwiftUI, but compiles to bare-metal machine code.

No closing tags. No semicolons where unnecessary. Just pure logic and structure.

3.2. The "Zero-Config" CLI

The biggest pain in cross-platform development is the environment setup (Gradle, Xcode, Pods, SDKs).

The Rore CLI solves this via a hermetic build system. Bash

1. Install cargo install rore-cli

2. Build & Deploy to connected Android device rore run android --release

The CLI handles SDK management, cross-compilation targets, asset bundling, and signing automatically.

Technical Architecture 4.1. Kernel & Rendering (WGPU)

Rore speaks the native graphics language of the OS via WGPU:

Metal (macOS/iOS)

Vulkan / OpenGL (Android/Linux)

DirectX 12 (Windows)

WebGPU (Web) Unlike React Native, which relies on a "Bridge" to ask the OS to draw a button, Rore draws the button itself. This guarantees Pixel-Perfect Consistency across all devices.

4.2. Reactivity: Fine-Grained Signals

We have abandoned the Virtual DOM (React model). It is too heavy. Rore uses Signals.

When a variable changes, Rore does not re-render the component tree. It surgically updates only the text node or property bound to that signal.

Result: O(1) update complexity.

Battery Life: Significantly extended due to reduced CPU cycles. 4.3. Unified Backend (R2R Architecture)

If you use Rust on the backend, Rore offers a "No-API" experience. Frontend and Backend share a single types crate. Rust

No JSON serialization overhead.

No REST/GraphQL endpoints to maintain.