Theme

Go-native UX framework

lurpicUI

A Go framework for realtime UI, mixed media, and data visualization — a retained facet tree, deterministic projection, and an automation seam with typed observations and GUI-backed actions.
Read the principles View on GitHub

lurpicUI is a Go-native interactive UX framework — the facet projection reference implementation. It is built for realtime UI, mixed media, and data visualization applications: a retained facet tree and projection system, a cross-platform rendering pipeline, asset bundling and streaming, and Android application build tooling.

The architecture holds to a small set of load-bearing principles: facets own translation, not truth; stores are the single source of truth; the runtime thread owns all mutable engine state; and concurrency accelerates projection without leaking into the programming model. Background workers compute against immutable snapshots and commit through version-checked results — the engine feels single-threaded to authors, and that is the point.

Applications talk to the outside world through LDP — the Lurpic Drive Protocol: typed observations and GUI-backed actions over an authenticated Unix-domain socket, with explicit grants, session fencing, and virtual time. There is no direct store mutation anywhere in the protocol — actuation is GUI-backed input.* and cmd.execute only, and human input always wins.

# Install

Build from source — Go 1.27.2+, CMake, and (for Android targets) the Android SDK/NDK/JDK with a Rust toolchain and cargo-ndk. Platforms today: Linux desktop and Android.

Clone and run the quick demo

git clone https://github.com/lexbity/lurpicui && cd lurpicui
go test ./...
go run ./demos/quick_square_app

# Try it

  1. Verify the toolchain

    go test ./... proves the tree builds on your machine; for Android targets, run lurpic doctor android to check the SDK/NDK/JDK and cargo-ndk wiring.

  2. Run the demo app

    go run ./demos/quick_square_app opens the smallest facet+store app in the tree — a square you can interact with, driven through projection like every other lurpicUI application.

  3. Author your own app

    A lurpicUI project is a lurpic.toml at the root, a Go entry point under cmd/<app-name>/, and your assets. Start from the demo and read the facet runtime principles .

# What it offers

Facet projection

Facets are stateful projection boundaries: they observe stores, own interaction state, and derive local spatial form — never domain data.

One runtime thread

The runtime thread exclusively owns the facet tree, stores, signals, and projection results; workers compute on immutable snapshots and commit through the job system.

Deterministic frames

Snapshot→work→commit with store version checks: a job computed against stale state never lands.

LDP automation seam

Typed observations and GUI-backed actions over an authenticated Unix socket — grants, session resume with fencing, request replays, and bounded ledgers.

Virtual time

Drivers can lease the engine clock and advance frame by frame — deterministic UI tests without sleeps.

Android tooling

Debug APKs can compile the drive seam; release builds refuse it. adb forward for remote automation, socket never leaves the device.

# Read the docs

Core

Facet Runtime Principles

The why behind every decision — the principles that constrain the architecture, stated so you could reconstruct it.

lurpicUI on GitHub

lurpicUI is Apache-2.0 licensed and under active development. The demo apps under demos/ are the fastest tour; the principles document is the contract the engine is held to.
Open the repository