⏱️ Lectura: 11 min
A Kobo Clara BW can today install an arXiv reader, a full terminal, or a Hacker News client without ever leaving the device’s Wi-Fi, something Rakuten never enabled out of the box. That’s what Cobalt proposes: an open source platform that turns the e-reader into a device with its own App Store: a launcher, a catalog of signed applications, and a Rust SDK for writing new apps.
📑 En este artículo
The project, published by BandarLabs on GitHub, is installed only once via USB, and from then on everything (installing, updating, or deleting apps, and even updating the platform itself) happens over Wi-Fi. Restarting the reader always returns it to Kobo’s original reading firmware.
TL;DR
- Cobalt is an open source platform that adds a launcher, a signed App Store, and a runtime to Kobo e-readers.
- It only supports the Kobo Clara BW (model N365); other models are rejected during installation.
- The initial installation requires USB with rustup and the armv7-unknown-linux-musleabihf target; the rest arrives over Wi-Fi.
- The SDK is written in Rust: each app implements the KoboApp trait and declares screens with ScreenBuilder.
- Each app runs as an unprivileged process and accesses network, storage, audio, or the front light only with explicit permission.
- The launch catalog includes 16 apps, ranging from an arXiv reader and Sudoku to a Hacker News client and a native terminal.
- Restarting the device returns the Kobo to its original reading firmware without leaving any trace of Cobalt.
- The project is open on GitHub under BandarLabs and accepts third-party apps via pull request.
What Cobalt Is and What It Changes on the Kobo
Cobalt adds three pieces to the Kobo Clara BW: a launcher that opens installed apps and always leaves a path back to the original reader, a signed App Store that installs, updates, and deletes apps over Wi-Fi, and a Rust SDK for writing new apps as static ARM binaries.
The first installation requires connecting the device via USB cable to a computer with Rust and compiling the installer for the Kobo’s ARM target. After that first step, the cable is no longer needed: the app catalog is downloaded, updated, and fully reinstalled directly from the device.
Each app runs as an independent, unprivileged process. Before any binary is executed, the runtime verifies the catalog signature, the package signature, the installed manifest, and the executable itself.
Context and History
Commercial e-readers (Kobo, Kindle, Nook) run embedded Linux, but manufacturers block the installation of third-party software: you can only read books, not run your own programs. That closed-off approach drove the jailbreaking community for years to seek root access, usually fragile, that a simple firmware update could break overnight.
Cobalt takes a different approach: instead of forcing permanent root access, it installs a separate application layer that coexists with Kobo’s firmware. The project itself makes it clear: it is not affiliated with Rakuten Kobo, and restarting the device returns it to the original reader without leaving a trace.
This puts it in the same territory as previous projects like KOReader, the most widely used alternative reader for e-ink screens, or fully open hardware initiatives like Open Book on Crowd Supply. The key difference is that Cobalt does not replace the reading system: it complements it with an app ecosystem you can install without buying new hardware.
Technical Details and Performance
The technical core of Cobalt is the SDK: each app implements the KoboApp trait and declaratively describes its screens with ScreenBuilder. The runtime handles layout, e-ink refresh scheduling (partial or full), navigation with the Back button, and the app’s lifecycle.
Apps don’t open device resources directly: they request permission. Network, storage, audio, front light, and Wi-Fi are controlled by a capability system, and a denial comes back as a value the app can handle instead of a crash.
The launch catalog includes 16 apps: a launcher and an App Store as the foundation, plus Sudoku, Morse (sends a typed message by blinking the front light across the whole panel), Audiobook Studio (researches, writes, narrates, and plays an original audiobook), Gutenbird (reads any OPDS library: Project Gutenberg, Standard Ebooks, Open Library, or your own), a Hacker News client with full comment threads, a Feeds reader, Daily Brief (gathers the day’s news in the background while you use another app), an AI Command Center, Sidekick (approves or rejects code agent requests away from the keyboard), a native panel Terminal, a Components catalog from the interface toolkit itself, Settings, Todo, Tic-tac-toe, and Magnet (locates the Hall sensor behind the bezel and reports its changes).
Sudoku is, deliberately, the test case for the distribution system: it exists only in the Store and never shipped in the initial USB package, so installing it from the device proves that Wi-Fi delivery works end to end.
The arXiv app reads directly from the HTML that arXiv publishes for every paper since December 2023 (abstracts, sections, equations, and results tables) and paginates it for the reader’s panel.
💭 Key takeaway: The capability model (requesting permission instead of direct access) is what allows third-party apps to be installed without compromising the rest of the device: if an app misbehaves, it stays isolated in its own unprivileged process.
USB Once, Wi-Fi Forever
| Method | When It’s Used | Advantage | Limitation |
|---|---|---|---|
| Initial installation via USB | The first time Cobalt is installed on the Kobo | Done only once in the device’s lifetime | Requires a computer with Rust and the compiled ARM target |
| Updates over Wi-Fi | Installing new apps, updating them, or updating the platform | Never need to plug in the cable again | Depends on having Wi-Fi configured on the reader |
Installation and catalog transactions are failure-recoverable: if an update is interrupted midway, the reader stays with the version it had before, not with a half-installed state.
flowchart TD
A["App Store"] --> B["Signed catalog on GitHub"]
B --> C["Cobalt runtime"]
C --> D["Unprivileged process per app"]
D --> E["Permissions: network, storage, audio, front light"]
subgraph Kobo["Kobo Clara BW"]
C
D
endGetting Started with Cobalt
Only the Kobo Clara BW (model N365) is supported for now: the installer rejects any other model instead of trying to guess the hardware configuration. Before starting, fully charge the device and connect it via USB to your computer.
Installing the CLI (Linux and macOS)
git clone https://github.com/BandarLabs/Cobalt.git
cd Cobalt
rustup target add armv7-unknown-linux-musleabihf
cargo run -p kobo-cli -- setupIf you don’t have Rust installed yet, rustup can be added with the official script (curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh) on both Linux and macOS.
Installing the CLI (Windows)
winget install Rustlang.Rustup
git clone https://github.com/BandarLabs/Cobalt.git
cd Cobalt
rustup target add armv7-unknown-linux-musleabihf
cargo run -p kobo-cli -- setupAll three operating systems end up running the same cargo command: the only thing that changes is how rustup gets onto the machine. After setup, restart the Kobo and open Cobalt from the reader’s menu; from there, open the Store and everything else arrives over Wi-Fi.
Writing your own app follows an equally short flow:
kobo new my-app
cd my-app
kobo devkobo dev launches the SDK simulator with layout diagnostics, so you can iterate on the screen without flashing the device on every change. Here’s a minimal example of a Rust app, with a reading page counter:
use kobo_sdk::{ActionId, Context, KoboApp, ScreenBuilder};
#[derive(Default)]
struct ContadorLecturas {
paginas_leidas: u32,
}
impl KoboApp for ContadorLecturas {
fn on_start(&mut self, ctx: &mut Context) {
self.render(ctx);
}
fn on_action(&mut self, ctx: &mut Context, accion: ActionId) {
if accion == kobo_sdk::action_id("marcar_pagina") {
self.paginas_leidas += 1;
}
self.render(ctx);
}
}
impl ContadorLecturas {
fn render(&self, ctx: &mut Context) {
let pantalla = ScreenBuilder::new("contador")
.top_bar("Reading Counter")
.heading(format!("{} pages read today", self.paginas_leidas))
.button("marcar_pagina", "Mark page as read")
.build();
ctx.set_screen(pantalla);
}
}
fn main() {
let app = ContadorLecturas::default();
let _ = kobo_sdk::run("contador-lecturas", app);
}Each action (a tap on a button) arrives via on_action with an ActionId, and the app decides what to do and redraws the screen with ScreenBuilder. The rest (the partial refresh of the changed area, navigation with the Back button) is handled by the runtime.
⚠️ Heads up: Installing Cobalt isn’t a process you can reverse with a simple tap: follow the full walkthrough in docs/INSTALL.md in the repository, which includes recovery steps in case something fails midway through the initial installation.
Impact and Analysis
What’s interesting about Cobalt isn’t just that an e-reader can run Sudoku: it’s the distribution model. Apps are published independently of the platform. When a pull request for a new app gets merged, that app is compiled for ARM, signed, and added to the catalog without Cobalt needing a new version or the user having to reinstall anything.
That separation (platform on one side, app catalog on the other, each with its own update channel) is the same one used by the major mobile App Stores, applied to a device with a low-end ARM processor and an e-ink screen that refreshes in hundreds of milliseconds, not in fractions of a second like an LCD screen.
The current catalog mixes utilities (Todo, Terminal, Settings), entertainment (Sudoku, Tic-tac-toe), reading (Gutenbird, arXiv, Feeds), and tools tied to AI agents (Sidekick, AI Command Center, Daily Brief), which suggests the project is aimed at both traditional reading users and developers who want a low-power e-ink panel as a secondary peripheral.
What’s Next
For now Cobalt only supports one model (Kobo Clara BW / N365), so the obvious next step for the community is adding support for other Kobo models with compatible processors. The project is open on GitHub under BandarLabs and accepts third-party apps through regular pull requests, which opens the door for the catalog to grow faster than it would if it depended only on the original team.
The missing piece for knowing whether this scales is the one the project itself has the least control over: how quickly Kobo (or Rakuten) reacts if third-party app installation goes mainstream, given that Cobalt coexists with the official firmware instead of replacing it.
📖 Summary on Telegram: View summary
Try it yourself: if you have a Kobo Clara BW on hand, clone the Cobalt repository on GitHub and run cargo run -p kobo-cli -- setup to see the App Store working on your own reader today.
Frequently Asked Questions
Which Kobo models does Cobalt support?
For now, only the Kobo Clara BW (model N365). The installer rejects any other model instead of trying to adapt to it.
Do I need the USB cable every time I install an app?
No. USB is only used once, to install Cobalt. After that, installing, updating, or deleting apps (and updating the platform itself) happens over Wi-Fi directly from the device.
What happens if I restart the Kobo after installing Cobalt?
The device returns to Kobo’s original reading firmware. Cobalt coexists as a separate layer; it doesn’t replace the manufacturer’s system.
What language are apps written in?
In Rust, using the Cobalt SDK. Each app compiles into a static ARM binary that runs in its own unprivileged process.
Is Cobalt affiliated with Rakuten Kobo?
No. The project itself explicitly clarifies this: it’s an independent community development with no relation to the manufacturer.
Can I publish my own app on the Cobalt Store?
Yes. App contributions are regular pull requests to the repository; once merged, the app is compiled, signed, and appears in the catalog without the user having to reinstall anything.
References
- Cobalt’s official site: project overview, app screenshots, and installation guide.
- GitHub repository: source code for Cobalt’s SDK, runtime, and CLI.
- KOReader: the alternative e-ink reader mentioned as a community precedent.
- Wikipedia: Kobo eReader: historical context on the Kobo device line.
📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
0 Comments