Vortex

Vortex is a C++ GUI framework for building one application that runs natively on desktop, web, and Android. A portable C++ core owns the widget tree and resolves styling from Layers .lyr files; thin per-platform reconcilers mirror the result into real native widgets. One codebase, one set of styles, every platform.

Vortex is being reviewed and re-documented by hand after Layers 3.0, and APIs may change.

✨ This project is developed with AI-assistance. Please refer to our AI policy.

Vortex Showcase

How it works

A Vortex app is three small pieces:

Styles: the interface is declared in Layers. Styles are structure: a style names the app's widgets, inherits each one's primitive from the framework library, and links colors to the active theme.

App << Vortex/App:
    Main Window << Vortex/Main Window:
        App Pane/Content:
            Greeting << Vortex/Text:
                Text: "Hello, Vortex"

An entry: build_app() applies the root style and wires interaction. The framework's shared shell (frameless window, titlebar tabs, settings menu, theme dialogs) is one call:

void Vortex::build_app(VApp& app) {
    app.set_root_style("App");
    wire_main_window_shell(app);
}

A platform shell: a few lines per platform hand the app's identity and asset directories to the framework runner.

That's the whole app. The core builds a render tree from the styles, and each platform's reconciler renders it natively: Qt widgets on desktop, DOM elements on web, Android Views on mobile. Events flow back through the same core, so behavior is written once. Switching the theme re-points the shared theme node and re-skins the entire app with zero platform-specific code.

Platforms

Target	Technology	Output
Desktop	Qt 6, in-process reconciler	native executable
Web	Emscripten/WebAssembly → DOM	`vortex.js` + `vortex.wasm`
Android	NDK/JNI → classic Views	Gradle library module + your app module
Static web	build-time HTML/CSS emitter	crawlable static pages from the same styles

Features

Native everywhere: real Qt widgets, real DOM, real Android Views; no embedded browser, no canvas lookalike.
Fourteen widget primitives: Box, Text, Button, Icon, Editor, Image, Video, Markdown, QR, Scanner, Check Box, Combo Box, Link, Host.
Styles are structure: interfaces are declared in Layers .lyr files, not C++; a widget's type comes from the primitive its style inherits.
Runtime theming: dark/light plus accent themes, user theme directories, instant whole-app re-skin.
Data-driven layout: a flex-like vocabulary (Layout.Direction, Layout.Grow, Size.Max Width, …) interpreted by every reconciler.
Responsive and mobile-aware: width breakpoints with state variants (@Narrow, @Mobile), plus automatic mobile scale-up of icons, text, and metrics.
A ready-made shell: frameless main window, titlebar tabs, settings menu, and theme dialogs that any app inherits and extends.
Portable platform seams: HTTP, file pick/upload, timers, persistence, in-app purchases, injected by each platform shell and consumed portably by app code.

Repository layout

core/       Portable C++17 core: widget tree, style resolution, render tree + diffs.
            Vendors nlohmann/json (theme documents, the update check, the patch stream).
styles/     Library widget styles (.lyr): the framework's building blocks.
themes/     Bundled themes (JSON): dark/light + accents.
icons/      Shell SVG icons.
platforms/  Reconcilers: desktop/ (Qt6), web/ (WASM→DOM), android/ (Views), static-web/ (emitter).
examples/   The demo app: a minimal peer consumer of the framework.
tests/      Headless test targets.
ext/        The Layers engine (submodule) + vendored QR encoder.

Building

Requires CMake 3.22+, a C++17 compiler, and Qt6 for the desktop target.

git clone --recursive https://codeberg.org/HuntrSoftware/vortex.git
cd vortex
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/platforms/desktop/vortex-desktop

./build-all.sh builds every platform in one shot. See the build guide for the web (Emscripten) and Android (Gradle/NDK) steps.

Documentation

Full documentation lives at huntrsoftware.com/vortex:

Build guide: building the framework and demo on every platform
App development guide: creating your own Vortex app
Styling guide: styles, inheritance, states, and themes
Widgets guide: the primitives and runtime data binding
Layout guide: layout vocabulary, overlays, and responsive behavior
Custom Themes guide: writing a theme and loading it into any Vortex app

Real-world use

Vortex powers node.you (the same C++ app tree shipping on desktop, web, and Android) and the Docuriser documentation tool that builds huntrsoftware.com itself.

License

Vortex is open-source under the MIT license.