A code-first Kotlin Multiplatform engine for building interactive 2D and 3D applications.

Awake gives Kotlin applications a small, composable runtime for scenes, rendering, physics, and retained UI. Author your application in Kotlin, keep platform code at the edge, and share the same game or tool code across desktop, mobile, and the web.

Awake is early alpha software. APIs and published artifacts can change between releases.

• Kotlin Multiplatform — share application and scene code across supported targets.
• Code-first scenes — author entities, systems, assets, and lifecycle in Kotlin.
• Composable runtime — combine ECS, rendering, physics, input, and UI as needed.
• Multiple backends — Vulkan for native targets and WebGPU for the web.
• Native UI runtime — build retained UI with Awake's own UI and Shadcn component modules.

Awake Studio is the visual editor for Awake Engine. It edits 2D and 3D scenes, game UI, node-based logic and shader graphs without code, and publishes games that play in the browser. Open it in the browser, download it, or read the user guide.

Studio is a separate product built on Awake. This repository stays code-first and free under Apache-2.0: you never need Studio to use the engine, and the scene documents it saves are plain files the engine loads.

Clone the repository and run the engine showcase:

./gradlew :samples:engine-showcase:run

The repository also includes a UI component showcase. See the engine showcase README for the available demos and web commands.

Awake artifacts are published to Maven Central. Core modules share one version (latest 0.16.0); the Vulkan backend has its own release train (latest 0.1.33, built against Core 0.16.0). Add only the modules your application uses to gradle/libs.versions.toml:

[versions]
awake = "0.16.0"
awake-vulkan = "0.1.33"

[libraries]
awake-bootstrap = { group = "com.awakekt.awake.engine", name = "bootstrap", version.ref = "awake" }
awake-shaders = { group = "com.awakekt.awake.asset", name = "shaders", version.ref = "awake" }
awake-vulkan = { group = "com.awakekt.awake.backend", name = "vulkan", version.ref = "awake-vulkan" }

The WebGPU backend is not in Maven Central releases yet: it builds on a wgpu4k snapshot, so it is published only as a snapshot to https://central.sonatype.com/repository/maven-snapshots/, and its wgpu4k builds (io.ygdrasil) come from https://awakekt.github.io/awake/, which hosts the exact builds it was tested with. Pin it to your Core version with -SNAPSHOT appended. Every Core release after 0.8.5 publishes that build of WebGPU from the release commit, with every Core module held at the release. For 0.8.5 and earlier, <core>-SNAPSHOT is a plain main snapshot whose Core modules are at <core>-SNAPSHOT and are not held, so a web build that must stay on one Core needs a later release.

For a desktop JVM target, use the lifecycle and shared shader contract in commonMain, and the Vulkan host in desktopMain:

kotlin {
    jvm("desktop")

    sourceSets {
        commonMain.dependencies {
            implementation(libs.awake.bootstrap)
            implementation(libs.awake.shaders)
        }
        named("desktopMain").dependencies {
            implementation(libs.awake.vulkan)
        }
    }
}

Create an application with the bootstrap DSL:

import com.awakekt.awake.engine.bootstrap.dsl.app

val game = app {
    window {
        title = "My Awake App"
        size(1280, 720)
        backend.vulkan()
    }
}

The getting started guide shows the desktop host and render-plan setup. The engine showcase is the complete working example.

You do not need every module. Start with the smallest runtime for your target, then add scene, rendering, physics, asset, or UI modules as your application grows. The module guide contains the complete module map.

Awake is designed for Kotlin Multiplatform projects targeting:

• Desktop JVM
• Android
• iOS
• WebAssembly/browser

Desktop uses Vulkan (MoltenVK on macOS and iOS), Android uses Vulkan, and the browser uses WebGPU. Backend and platform availability is still expanding during the alpha releases. Use the examples and release notes as the compatibility reference for the version you are using.

Applications that store credentials or handle sensitive data can evaluate these optional tools:

Check KSafe's effective protection level and JVM fallback behavior: software key storage is not equivalent to an OS-backed vault. Applications requiring OS-backed protection should enforce that policy explicitly.

Sekret's logging protection covers generated toString() output; direct property logging and serialization still need application controls. Its string obfuscation is reversible, so keep server credentials on the server rather than embedding them in a distributed application.

Neither library is bundled with or integration-tested against Awake. Verify target-platform, Kotlin/compiler and release-packaging compatibility before adoption; both remain optional application dependencies.

• Online documentation and live samples
• Getting started
• Documentation index
• Module guide
• Release process
• Architecture decisions and references
• AwakeKt brand system
• llms.txt, a plain-text index of the docs for AI tools

Issues and pull requests are welcome on GitHub. Please read the contribution guide and release guidance before making a change. Security issues should follow the security policy.

Awake is available under the Apache License 2.0. Third-party components keep their own licenses, listed in NOTICE.md: the Roboto font, and the UI font atlases drawn from it, are under the SIL Open Font License 1.1. The AwakeKt and Awake names, and the Ember Signal mark, are governed separately by the trademark notice.