GPU-drawn interface toolkit

Kinogaki UI

A from-scratch, retained-mode UI toolkit in pure C++ on top of Kinogaki Platform: an immediate-mode 2-D drawer over the render hardware interface, a themeable widget framework with docking, and an event-driven loop that repaints only what changed.

A GPU-drawn interface toolkit

Kinogaki UI is a from-scratch, retained-mode user-interface toolkit for building native applications. It draws the Kinogaki Editor and the example apps, and it is what you reach for when you want a native interface with the same control as the document model underneath it, building on Kinogaki Platform alone.

It is pure C++ on top of Kinogaki Platform, in two layers: a 2-D drawing layer that talks to the GPU, and a widget framework that lays out and routes events. A stack for building software needs an interface layer as controllable as everything else in it: Kinogaki UI links one library, runs as native code, and keeps the whole widget tree under your control.

What's in it

Drawing & text: an immediate-mode 2-D canvas over the platform's render hardware interface, with fonts from a pluggable, size-cached interface.
The app: an event-driven loop that repaints only dirty regions, with a job system and notifier queue; and a synthesized event-value model that turns raw input into Click / Drag / DoubleClick intent.
Widgets: the control set, item views (lists, trees, tables), and an editable text editor.
Composition: layout containers, a docking shell, and data-driven themes.

The shape of it

#include "kinogaki/ui/Build.h"
using namespace kinogaki::ui;

auto panel = column(
    title("Inspector"),
    field("Amount", slider(0.4f, [&](float v){ amount = v; })),
    field("Name",   textField("ball")),
    button("Apply", [&]{ apply(); }));

A panel is one expression: containers take their children directly, leaves configure up front, and the factories handle ownership and conversion for you. That parsimony is a deliberate house style: the toolkit is a joy to assemble and hard to misuse.

Why build it

Kinogaki UI is modelled on the parts of mature desktop UI architecture that matter for responsiveness: per-region offscreen buffers so panning one panel repaints only that panel, event compression, and navigation that never re-evaluates the document. It carries this in pure C++ on Kinogaki Platform, and it is fast: the interface layer you want under a tool that has to stay fluid while a document (and an agent) change underneath it.

Start with the Quickstart to put a window on screen, then read the app loop for how it stays idle-cheap.

Quickstart ›