Put your idea on an e-ink screen.

Create a Rust app, run it in our simulator, try it on a supported reader, and publish it to Cobalt Store.

You can start without a device. Hardware testing comes after the interaction works in the simulator.

Start in the simulator

cargo install --path crates/kobo-cli
kobo new my-app
cd my-app
kobo dev

From idea to Store

1. Create

Start from the app template and build one useful screen.

2. Run

Use the Cobalt simulator for quick interaction and failure-state checks.

3. Test

Confirm the final interface and device behavior on supported hardware.

4. Publish

Submit the app for review and independent Store delivery.

An app is one Rust file.

Implement KoboApp, draw the current screen, and handle named actions.

This counter has one value and one button. Run it with kobo dev, then add only the services the app needs.

Continue with the SDK reference

use kobo_sdk::{
    action_id, ActionId, Context,
    KoboApp, ScreenBuilder,
};

#[derive(Default)]
struct Counter { taps: u32 }

impl KoboApp for Counter {
    fn on_start(&mut self, ctx: &mut Context) {
        self.show(ctx);
    }

    fn on_action(
        &mut self,
        ctx: &mut Context,
        action: ActionId,
    ) {
        if action == action_id("tap") {
            self.taps += 1;
        }
        self.show(ctx);
    }
}

impl Counter {
    fn show(&self, ctx: &mut Context) {
        ctx.set_screen(
            ScreenBuilder::new("counter")
                .top_bar("Counter")
                .heading(format!("{} taps", self.taps))
                .primary_button("tap", "Tap")
                .build(),
        );
    }
}

fn main() {
    let _ = kobo_sdk::run(
        "counter",
        Counter::default(),
    );
}

Documentation

SDK reference

Application lifecycle, interface components, services, capabilities, commands, and limits.

Publish an app

Repository layout, review requirements, screenshots, tests, and Store submission.

Test on a reader

Supported devices, connection steps, diagnostics, and hardware evidence.

Store format

Signed packages, the public catalog, updates, rollback behavior, and release flow.