Kryon

Features

One source, every platform

The runtime owns the whole UI lifecycle: build the widget tree, reconcile state, layout nodes, route input, render, and draw overlays. You describe intent; Kryon handles ordering, focus, inspection, and overlay behavior.

#import "kryon.h"

Counter :: (state: *CounterState) {
    col {
        Text("Count: " + to_string(state->n))
        Button("Increment") {
            state->n += 1
        }
    }
}

k2ir counter.kry
k2c  counter.kir
k2js counter.kry
k2b  counter.kir

# edit app.kry, save, watch it reload
$ kryon preview my-app

// click a node in preview → jump to source
AppHome: app.kry:7
  Text("Sample App")    app.kry:9
  BottomNav(...)        app.kry:10

Why Kryon

Native first, alive by default

Everything visible is a node. Source stays primary. KIR keeps the compiler debuggable, C keeps native integration direct, and KRB opens a portable renderer path.

Compiler Pipeline

One frontend, native and portable backends

Kryon lowers .kry into debuggable KIR, then emits readable C for native applications or compact KRB cartridges for portable renderers.

#import "kryon.h"

Greeting :: (name: string) {
    row {
        Icon(ICON_ROCKET)
        Text("Hello, " + name)
    }
}

Greeting.kir
  source spans
  widget tree
  event logic
  imports

Greeting.c    # native backend
Greeting.krb  # portable cartridge

Showcase

Real apps built with Kryon

The showcase tracks shipped Kryon applications and ranks public submissions by stars from public source platforms. Add a project through the public metadata repo.

Platforms

One source, the targets apps ship to

The same interface source builds for the environments real apps ship to — no platform-specific forks of your UI code.

Android

Mobile runtime and KRB host capabilities.

iOS

Mobile renderer through the portable runtime contract.

ESP32

Small KRB renderers with constrained capability sets.

Microcontrollers

Embedded targets for draw primitives, input, timers, and storage.

Linux

Native C builds and KRB renderers.

Windows

Native C builds and KRB renderers.

macOS

Native C builds and KRB renderers.

FreeBSD

Native desktop, servers, and embedded targets.

Plan 9

Portable runtime target with a small native host layer.

Browser

Browser renderer, WASM logic, and KRB preview.

Get started

Build the runtime and tools

Kryon is free and open source. Clone, build, and install in a few commands.

Build the runtime:

git clone https://github.com/kryonlabs/kryon.git
cd kryon
make
make install

The clean compiler tool direction:

k2ir app.kry
k2c  app.kry    # or app.kir
k2js app.kry
k2b  app.kry    # or app.kir

A simple .kry shape:

#import "kryon.h"

AppHome :: (app: AppState*) #ui {
    Screen root: {
        y: int = ScaleUIPx(24)

        Text("Sample App", ScaleUIPx(20), y, ScaleUIPx(24))
        BottomNav(app->bottom_nav)
    }
}

Documentation

• API reference — runtime, node, and widget surface
• Kry language reference — source syntax, KIR lowering, compile-time checks, and backend contracts
• Widget and language matrices — frontend, compiler, and widget coverage
• Renderer matrices — surface backends, KRB hosts, and native Linux backend direction
• Benchmarks — generated text-input and lowering performance summaries
• Source repository — code, issues, and releases
• Discord — chat, help, and showcase
• Telegram — news and announcements

FAQ

Questions