Documentation · Try Xila · Community

Build embedded experiences with Xila, a modular, open-source operating system written in Rust. Xila brings together WebAssembly (Wasm) applications, an LVGL graphical interface, task management, networking, and storage for resource-constrained devices.

What you can explore

• Wasm applications: run guest programs with the Wasmi runtime and explore the included Calculator and Weather apps.
• Graphical interfaces: build on LVGL, the shared Shadcn theme, and Xila's graphical shell.
• OS building blocks: work with task scheduling, a virtual filesystem, device drivers, and networking through portable Rust crates.
• Native development: develop and investigate CPU and memory use on Linux before validating shared code on your intended embedded target.

Xila is under active development. Hardware support varies by target; native and browser examples provide development environments, not proof that a particular board is supported. See the capabilities and limits before choosing a target.

Start here

New to Xila? Follow the native tutorial for a guided first run, or the browser tutorial to build a Wasm guest and run Calculator in browser-hosted Xila. To create an application, start with building a guest.

This repository contains the OS implementation. The website repository contains the documentation and learning guides.

Build and check Core

Install mise. By default, this repository selects the development tasks. Tools are installed on demand per task; optionally preinstall all development task tools in one pass:

mise trust
mise install --include-task-tools # optional: preinstall development task tools
mise bootstrap packages apply --manager apt
mise run deps:npm
mise run check:all               # Linux host + WASM guest checks

No development container is required. .miserc.toml selects mise.development.toml by default; tasks select host or WASM targets, formatting or coverage tools as needed, including developer-only format:*, translate:* and dev:* tasks. mise.toml holds reusable namespaced tasks such as check:host and docs:all. CI selects mise.ci.toml, where tools are declared on individual tasks so a job installs only the tools its tasks use. On Debian/Ubuntu, native packages are provisioned from the selected environment with mise bootstrap packages apply --manager apt (mise requests sudo when needed). Developer Cargo build tasks are wrapped by mbx through Mise's native Rust integration. Tools are not activated globally: use mise run build:cargo -- ... or mise run run:cargo -- ... for ad-hoc Cargo commands with this setup. CI uses the mbx GitHub Action and its wrapper instead, avoiding a second mbx installation in CI. Formatting tasks select only rustfmt, Taplo or Node, with no build targets, Clippy, mbx, coverage tools or native-package bootstrap.

Other checks:

mise run clippy:all
mise run format:rust -- --check
mise run format:toml -- --check
MISE_ENV=ci mise run ci:quality-js

Native and browser assemblies, drivers, seed images, audio playback examples and hardware-specific setup now live in Platforms. Official guest and native applications live in Applications.

Some Core integration tests build official guests. Check out Applications at the revision listed in this workspace's Cargo.toml, and set:

export XILA_APPLICATIONS_MANIFEST=/absolute/path/to/applications/Cargo.toml
export XILA_APPLICATIONS_ROOT=/absolute/path/to/applications
export XILA_FONT_CATALOG_ROOTS=/absolute/path/to/applications

The manifest selects the external workspace for integration tests; the other variables supply guest catalogs to localization checks and CJK font generation. Cargo's Core source patch in the root manifest keeps development dependencies on Platforms and Applications on the same local Core crate identities.

Tool versions are centralized in [vars] in mise.toml; npm dependencies are pinned by package-lock.json. Local task names are listed by mise tasks and run with mise run <task>. Tool pins do not freeze untracked Cargo lockfiles or moving Git dependencies.

ESP-IDF, flashing and serial permissions need separate setup: follow the esp-rs Xtensa or RISC-V guides. Host/WASM checks do not prove ESP32, nRF, STM32 or other hardware correctness.

Localization

Xila embeds each language at compile time and tracks per-crate translations with Tolgee. English (en) is the fallback, with French (fr), Spanish (es), German (de), Brazilian Portuguese (pt-BR), Italian (it) and Polish (pl) catalogs. Build the host, Wasm applications, fonts and seed image with the same EMBEDDED_I18N_LOCALE value.

Simplified Chinese (zh-CN) catalogs are available for validation, with catalog-subsetted Source Han Sans SC glyphs alongside Montserrat. Native-speaker and embedded-target review are still pending; Chinese is not yet enabled for deployment. See the Chinese font and validation notes.

See localized build and contribution instructions for validation commands, translation review and artifact compatibility.

Graphics theme

Graphics uses lvgl_theme_shadcn with the Zinc dark palette and Xila's generated fonts. The theme compiles alongside LVGL using the same configuration and custom allocator. Manager::update_theme updates the shared palette, including existing widgets, under the LVGL lock.

Prefer graphics::theme::set_surface and LVGL's Shadcn variant/error helpers over local theme colors. Keep layout, transparent overlays, application branding and specialized typography local where needed. Theme helpers require the graphics lock, just like other LVGL calls.

Native profiling

Profiling tools, runtime instrumentation tests and the full measurement guide are maintained in Platforms.

Find your way around

Directory	Contents
core/	Public xila façade and re-exports.
devices/	VFS device class contracts (File::control commands and ABI payloads).
subsystems/	Runtime-owned services: tasks, VFS, networking, graphics, memory, and time.
libraries/	Reusable contracts, algorithms, adapters, and concrete implementations.
drivers/	Generic portable VFS device implementations and adapters.
Applications	Wasm host runtime, guest API, and ABI tests.
tools/	Core verification and localization tools.

The root Cargo manifest is a virtual workspace. A plain cargo check selects the xila façade; use cargo check --workspace to check all members.

The component map connects the source tree to architecture explanations and API references.

Contribute

Start with the contributor guide and AGENTS.md for development conventions. Browse open issues for planned work, report bugs with reproduction steps, or help improve translations.

Join the Xila Matrix room to discuss ideas or ask for help.

License

This project is under the Apache License 2.0.

---

Part of Xila · Repositories · Community

Special thanks to Martin Legand for generously designing the Xila logo.