Strata

Declarative Minecraft UI with reusable components, caller-owned state, and headless rendering.

Create custom screens and HUDs from Fabric Mods or Paper, Folia, and Velocity plugins. For server-driven UIs, the server or proxy owns the definitions, state, and event handlers, while the required Strata Fabric client Mod renders the interface and delivers player input. Vanilla clients cannot display these UIs.

Modrinth · Hangar · CurseForge

This page documents the development sources; for an installed version, use the documentation at its matching release tag.

Example · Still frames

Minecraft screens often mix layout, input, state, resources, and version-specific calls in one class. Strata separates those responsibilities so an interface can be composed, reused, and tested through a common API.

• Keep one interface as a screen or HUD, switch its presentation, and control game input through its session.
• Arrange interfaces with rows, columns, wrapping groups, grids, and overlays.
• Compose controls, text editors, scrolling views, images, and Minecraft resource-backed content.
• Add sizing, backgrounds, pointer and keyboard actions, focus, and layout parent data through modifiers.
• Reuse application components or implement custom primitives through the public Element and Node SPI.
• Render portable drawing and semantics in JVM tests, with separate loaded-client verification for native behavior.

The component overview shows the available components with images and compiled examples. Complete screens demonstrate how they fit together. Try the interactive web demos for a counter, progress controls, and a keyed list running in your browser.

A confirmation screen combines text, buttons, and layout components into a reusable UI definition.

Compare components and browse their examples.

Players need the Strata Fabric runtime and Fabric Language Kotlin for both client-defined and server-driven UIs. Client Mod UI source needs only strata-api on its compile classpath. Install exactly one version-matched runtime as a separate client Fabric Mod together with Fabric Language Kotlin; do not bundle multiple versioned Strata runtimes.

dependencies {
    compileOnly("dev.s7a.strata:strata-api:0.2.2")
    modRuntimeOnly("dev.s7a.strata:strata-runtime-minecraft-fabric-<minecraft-version>:0.2.2")
    modRuntimeOnly("net.fabricmc:fabric-language-kotlin:<compatible-version>")
}

The version-matched runtimes are also available from Modrinth. Declare it as a required dependency in the consuming Mod so UiDefinition.open() always has a presenter in production:

{
  "depends": {
    "strata": ">=0.2.2"
  }
}

Install the appropriate Strata plugin JAR with the plugin classifier in the server or proxy's plugins directory. Keep the client and server/proxy on the same Strata release. The matching Fabric client Mod is required for every player using the UI.

Add these repositories to either plugin's build.gradle.kts:

repositories {
    mavenCentral()
    maven("https://repo.papermc.io/repository/maven-public/")
}

Paper / Folia dependencies:

dependencies {
    compileOnly("dev.s7a.strata:strata-paper-api:0.2.2")
    compileOnly("io.papermc.paper:paper-api:<paper-api-version>")
}

Velocity dependencies:

dependencies {
    compileOnly("dev.s7a.strata:strata-velocity-api:0.2.2")
    compileOnly("com.velocitypowered:velocity-api:<velocity-api-version>")
}

Replace the platform API version placeholders with versions compatible with your target server or proxy. See the compiled Paper example build and Velocity example build for complete consumer projects. Do not bundle Strata into your plugin. Paper consumers declare depend: [Strata] in plugin.yml; Folia consumers also declare folia-supported: true. Velocity consumers declare a required dependency on plugin ID strata. A Velocity-owned UI needs the client Mod and proxy plugin; install Strata on a Paper backend only when that backend also owns UIs.

The Paper / Folia guide and Velocity guide include compiled examples and the state, threading, and lifecycle contracts.

The compatibility reference lists supported targets, artifact names, and Java requirements.

Create a new UiDefinition for each opening and call open() on the installed runtime's owner thread. Compose actions with modifiers, as in this API-only example:

import dev.s7a.strata.component.Button
import dev.s7a.strata.component.Column
import dev.s7a.strata.component.Text
import dev.s7a.strata.layout.HorizontalAlignment
import dev.s7a.strata.modifier.Modifier
import dev.s7a.strata.modifier.menuBackground
import dev.s7a.strata.modifier.onActivate
import dev.s7a.strata.modifier.padding
import dev.s7a.strata.modifier.size
import dev.s7a.strata.ui.UiDefinition

/**
 * Opens a confirmation screen on the installed runtime's owner thread.
 */
internal fun openConfirmationScreen(onConfirm: () -> Unit) {
    UiDefinition("Confirm action") {
        Column(
            modifier =
                Modifier.Empty
                    .size(320, 180)
                    .menuBackground()
                    .padding(12),
            spacing = 8,
            horizontalAlignment = HorizontalAlignment.Center,
        ) {
            Text("Continue with this action?")
            Button(
                "Yes",
                modifier = Modifier.Empty.onActivate { onConfirm() },
            )
        }
    }.open()
}

Screens and state explains definition ownership, state, input, and resource use.

The experimental browser runtime renders supported Strata components into native browser DOM. See the web build guide for the shared example, supported features, and build instructions.

Versioned Fabric Mods package their common runtime libraries. Integration modules contain verification and examples and are not published. See architecture for dependency boundaries.

The Paper and Folia and Velocity guides cover server-owned screens, HUDs, and their client requirements.

The optional performance testkit collects JVM/JMH timing, allocation and GC evidence, runtime work counts, and native presentation counters. It checks workload and loaded-binary identities and produces validated summaries and Before/After comparisons. Supply your real fixtures, actions, readiness conditions, and expected work; use Quick or selected investigations during iteration and standard conditions for acceptance.

Add dev.s7a.strata:strata-performance-testkit to JVM test dependencies, or dev.s7a.strata:strata-performance-testkit-multiplatform for shared fixtures, and keep its release version aligned with Strata. JVM collection, validation, aggregation, and comparison run in Java. See the testkit guide for setup, collection, and evidence contracts.

The optional plugin checks component boundaries, modifier use, retained state, and UI roots. Apply Detekt with the compatible version from Strata's version catalog, enable Maven Central, and add:

dependencies {
    detektPlugins("dev.s7a.strata:strata-detekt-rules:0.2.2")
}

Enable the strata rules in the project's Detekt configuration and run ./gradlew detektMain with strata-api on the application's analysis classpath. These rules need type analysis; an untyped detekt run does not verify them. The authoring checks guide provides the configuration, check-task wiring, and each rule's incorrect and corrected examples.

See the changelog for release summaries, detailed changes, and upgrade notes.

Start with the documentation index, then use layout, modifiers, and text and editing to build an interface. The Dokka API reference contains signatures and KDoc; the Element SPI explains custom primitives. Contributing covers development.

The public Strata skill provides checked authoring guidance for AI tools. Preview it with gh skill preview sya-ri/strata skills/strata or install it with npx skills add sya-ri/strata --skill strata.

Strata is pronounced “STRAY-tuh” (/ˈstreɪtə/), the plural of stratum, meaning a layer. It is available under the MIT License.