Xenolith is a cross-platform C/C++ SDK — a Vulkan engine, a self-contained system runtime, and a full set of application libraries. Build for Linux, Windows, Android and macOS from a single codebase — without the Windows SDK, without the NDK, without the macOS SDK.
Nothing to pre-install — the toolchain ships everything, even GNU Make itself.
No platform SDKs to install or license. One toolchain builds them all — the legal and technical gatekeepers are simply out of your way.
As far as physically possible, every platform exposes the same interface — no forests of #ifdef, no per-OS rewrites.
Every build is a cross-compile. Change platform with a single flag; your code and Makefile stay exactly the same.
Windows without UCRT or the Windows SDK, Android without the NDK, macOS without the macOS SDK — the toolchain carries its own libc, linker and headers.
Cross-compile by default. Targeting another platform is one flag: STAPPLER_TARGET=<triple>. Same source, same Makefile.
Nothing to pre-install. The toolchain ships its own GNU Make, Clang, lld, lldb and shader compiler — pinned to exact versions for reproducible builds.
Modules resolve themselves. List what you use; dependencies are pulled in transitively, with a clear error if something is missing.
Shaders compiled in the build. GLSL is compiled to SPIR-V and embedded as a header — no extra step.
IDE-ready out of the box. Every build emits compile_commands.json; VS Code configs for clangd, builds and LLDB ship with each project.
An umbrella runtime that gives every platform one POSIX surface, then replaces the parts that matter.
The same POSIX surface on glibc, musl, Bionic and macOS — and a fully custom libc on Windows. time_t / off_t are 64-bit on every platform; missing OS calls return ENOSYS instead of vanishing from the API.
A full pthread on every platform: priority-inheritance mutexes (futex on Linux, WaitOnAddress on Windows, os_sync on macOS), robust mutexes, a writer-fair rwlock and an adaptive spinlock.
C++ destructors between longjmp and setjmp actually run — thread teardown and cancellation are clean, not the undefined behavior you get in plain C.
Its own partial C++ STL for full ABI control — exception-free, with Status/Result<T> errors and intrusive ref-counting that captures allocation backtraces in debug builds to hunt leaks.
One call → three kernels. The same SPRT lock maps to each platform's native primitive — with priority inheritance — so your code stays identical across Linux, Windows and macOS.
The same runtime that gives you libc and threads also gives you the event loop, the windows and the displays — all the platform-specific machinery behind one interface, with no platform SDK in sight.
A single dispatch API (Looper / Queue) over epoll + io_uring (Linux), IOCP (Windows), kqueue / CFRunLoop (macOS) and ALooper (Android): timers, socket and file readiness, async file I/O, a worker thread pool, process spawning with streamed stdout/stderr, and cross-thread wakeups.
Real backends for Wayland, X11/XCB, Win32, Cocoa and Android — Linux even picks Wayland or X11 at runtime (with XWayland fallback) and integrates GNOME/KDE portals over DBus. Each hands the engine a ready Vulkan surface. No Windows SDK, no NDK.
Multi-monitor enumeration with a spanning desktop, per-display scale and fractional DPI scaling on Wayland, exclusive fullscreen, refresh-rate / present-mode control, physical size and EDID — HDR-aware on supported outputs.
Mouse (scroll & stylus), an XKB-mapped keyboard with modifiers, and touch; typed IME text input (email / number / phone / password / multiline); a clipboard with MIME-type negotiation; server- or client-side window decorations.
Describe a frame as a graph of passes and resources; the engine inserts the barriers and layout transitions. Graphics and compute live in the same graph.
On-demand rendering. A new frame is prepared only when the scene actually changes — real battery savings while your app sits idle.
A custom GPU allocator. Page-based sub-allocation with budgeting and a dedicated-allocation fallback, tuned for the async frame model.
Descriptor layouts from your shaders. Descriptor sets and push constants are extracted from SPIR-V via reflection — no drift-prone boilerplate.
Vulkan on macOS, handled. MoltenVK with the correct portability subset, discovered straight from your .app.
A genuine CSS-flexbox toolkit — direction, wrap, justify, align, grow/shrink/basis, gaps and order.
Material icons as vector data, crisp at any pixel density, with animatable morphing.
Move, scale, fade, tint; sequence, spawn, repeat; Sine / Quad / Cubic / Expo / Elastic / Back / Bounce easings plus Bézier — and physics-based inertia for natural scrolling.
Tap, long-press, swipe, pinch, scroll and hover recognizers; a priority/capture dispatcher with focus groups and IME text input.
Its own scene and director per window, with display density propagated through gestures and rendering, and monitor/mode selection.
Pixel-perfect text. A GPU glyph atlas with async rasterization, variable fonts (weight / width / optical-size axes), dictionary hyphenation, justification, and crisp rendering at any display density.
Images, raster and vector. Read PNG / JPEG / WebP / GIF / TIFF and write PNG / JPEG / WebP with 16 high-quality resampling filters; vector paths tessellated on the GPU, sharp at any DPI.
Declarative schemes, rich field types (objects, sets, files, images with thumbnails, full-text, virtual & computed fields), per-operation role-based access control, keyset pagination and upsert — one API across both engines.
A single Value container serializes to JSON, CBOR or a URL-safe format — with transparent LZ4 compression and automatic format detection.
OpenSSL, GnuTLS and mbedTLS backends; RSA, ECDSA and EdDSA; GOST 3410/3411/3412 on the OpenSSL & GnuTLS backends; JWT with algorithm-confusion protection and constant-time verification.
Snowball stemming, PostgreSQL-compatible query vectors, a smart tokenizer (email / URL / path-aware), headline highlighting and fuzzy matching — with an in-memory index for offline use.
A document engine with a real CSS box model — block flow, floats, full tables, pagination — plus EPUB 2/3 with table of contents and embedded fonts, emitted as positioned objects rendered directly on the GPU.
A Pug template engine with conditionals, loops, includes and mixins, escaped/unescaped output, and hot-reload on file change.
Every container, string and value can use arena pools — allocate thousands of objects, free them all in one call, no per-object destruction — or plain malloc. The choice is a single template parameter, so you get server-grade allocation behavior without rewriting anything.
A desktop installer (Windows, macOS, Linux) sets up the engine, host toolchain and targets, with GPG-verified downloads and a clear progress UI.
Scaffold a graphical project, then build, run, clean and rebuild from the GUI — pick your target, run the result, and read build errors with plain-language hints. A headless CLI covers CI.
Toolchains are downloaded once and shared across engine versions, so updates don't duplicate gigabytes. English and Russian interface.
Pinned & reproducible — every build uses the same vetted versions
We'd rather tell you what's real than oversell. These are designed and partly built — exciting, but not finished.
A thin-client / GPU-server architecture: secure QUIC transport, scene-graph serialization, thin GPU handles. The streaming per-frame protocol is still ahead.
A working WAMR host runtime with a rich data/filesystem API for sandboxed guest code. Graphics aren't exposed to the guest yet.
GPU particle systems and iOS support are in active development — iOS currently builds a toolchain sysroot only.
One small app fetches the engine, host toolchain and target sysroots from the release server (GPG-verified, resumable), then scaffolds, builds and runs your first Vulkan project. Headless on servers and CI.
The installer builds are currently unsigned — first launch needs a Gatekeeper / SmartScreen confirmation. (The GPG verification above is of the downloaded SDK artifacts, which is real.)
For C and C++ developers shipping one codebase to Linux, Windows, Android and macOS without wrestling platform SDKs — apps, tools, games, readers, or graphics- and compute-heavy software on a modern Vulkan foundation.