Bitloom
YOCTO & BITBAKE · IN YOUR BROWSER AND YOUR TERMINAL

Bitloom: follow, diagnose and ship Yocto builds from a web dashboard or a terminal cockpit.

A web dashboard and a terminal cockpit on one build service: follow builds live, find the real cause of a failure, browse recipes by layer, check SBOMs and vulnerabilities for the CRA, and create your own distribution, all from the same place.

Web dashboardTerminal UIkas / kas-containerLauncher scriptsDocker / PodmanScarthgap & Wrynose
Actual Bitloom web dashboard following a running buildActual Bitloom terminal interface showing the idle demo workspace
Actual captures · the same build service in the browser and in the terminal
WORKS WITH HOW YOU BUILD

Your build stays yours.

Describe how the project builds once: the guided setup proposes the profile from the project folder. From then on builds, logs, the image explorer, SBOM checks, Studio and the migration assistant work the same, whatever runs BitBake.

BitBake on the machinePoky, split repositories, bitbake-setupsource oe-init-build-env
kaskas files with includes and overlayskas shell kas.yml -c …
kas-containerthe kas image, KAS_WORK_DIR on the hostkas-container shell -c …
Your build imageDocker or Podman, a container per commanddocker run -i … bash -c …
A running containerthe dev container you already work indocker exec -i …
Your launcher scriptone profile per productYML=board.yml ./run_build.sh build

A launcher script needs to forward shell -c "<command>", keep standard input open and keep the build folder on the machine. Bitloom runs next to your build, or inside your build container with bitloom.pyz: one file to mount, no image to rebuild. Where your build runs →

THE WEB DASHBOARD · IN ACTION

Your builds, one browser tab away.

bitloom --web opens the dashboard on the build service. Close the tab, open it on another machine through an SSH tunnel, or switch to the terminal: the queue, the history and the running build stay where they are.

Follow and diagnose

Live output with search and an errors-only view, progress and ETA, then a Toaster-style summary, sstate reuse, warnings, timings and a comparison with the previous run. A failed build starts with the diagnosis of its real cause.

What is in the image, and why

Browse what you built, file by file, with the package and recipe behind each one and what pulls it in, see what starts at boot, what listens on the network and where the space goes, and read the board's device tree. Which recipe installs… answers for any file; Change it opens the append, starting from the file as it is on the device.

Pick an image, press b

The target field lists the image recipes in your layers, the kas target and what is already built first. Any recipe, or several, can still be typed.

Recipes by layer

Every layer with its counts, folders that open on demand, filters for recipes, images, appends, classes and kas files, and a search that keeps the structure.

SBOM, CVEs and the CRA

SBOM quality gauges, vulnerabilities from sbom-cve-check, cve-check and Grype with Markdown, HTML, CSV, JSON and SARIF exports, release support and CRA readiness.

Studio, step by step

Pick what to create, then walk through it: every option says what it means, the preview shows where the files go and what they contain, the review lists exactly what Create will do, and the last screen offers what comes next.

Scarthgap → Wrynose, guided

Every rule of the official migration guides checked on your files, the mechanical changes applied with a diff and undo, and the new kas file written next to the old one with its own profile. The current build keeps working while you try the new one.

Write BitBake without guessing

Completion from your own layers (variables with their documentation, classes, overrides, recipes, features), and the mistakes a parse would hit shown as you type. bitloom --lint does the same in CI.

Best practices, your rules

See how far your layers follow the Yocto advice, where they do not and how to fix it. Switch rules off, change their weight, add your company's own, and fail CI with bitloom --practices.

Any project, set up in a minute

Point it at a folder: kas files, Poky checkouts and YML=… ./run_kas.sh build launcher scripts become profiles, one per product, with the build folder found for you.

A real BitBake force compile of busybox followed live in the dashboard, then its summary
A real run, recorded as it happened (about three times faster): force compile of busybox through a YML=… ./run_kas.sh launcher profile on Wrynose, then its summary.
INSPIRATION & THANKS

Inspired by the idea of yoctui.

Bitloom is inspired by the idea behind yoctui: bringing everyday Yocto and BitBake work into a terminal interface. Thank you to 0xbadcaffe, the author of yoctui, for the inspiration and for sharing the project with the community. Bitloom has its own implementation and interface.

EVERYDAY WORK, CONNECTED

From a recipe to a release.

Browse metadata, queue work and inspect evidence without losing the context of your build profile.

▸

Build control

Independent reconnectable build service, serial queue, original-profile retries, task progress, persistent history, SDKs and per-recipe tasks.

◇

Metadata explorer

Expandable layer tree, source previews and content search with file/line locations across recipes, appends, classes and YAML. Ask BitBake about active layers, overlays and dependencies.

⌘

Development workflow

Modify, build, finish and upgrade recipes. Deploy to devices. Hand off to devshell, kernel menuconfig or QEMU.

≋

Failure investigation

Streaming output, contextual task-log diagnosis, error filters, warning groups and exportable evidence reports.

▣

Cache maintenance

Inspect size and age. Analyze reported cache hit rates. Audit downloads. Preview concrete prune plans and recheck each file before deletion.

⌕

Inspection workbench

Resolve and compare environment snapshots, browse dependency edges, inspect signatures and buildhistory changes.

⚙

Runtime profiles

Host, kas, fresh or existing containers and kas-container. Named profiles preserve the command's configuration. Browse and edit runtime-only files; export binary artifacts with SHA-256 verification.

◉

Explicit interruption

Let a build finish, request a graceful stop where supported, or force termination and select recipe recovery.

↗

Release context

Repository versions, layer-series checks, package/architecture manifest comparisons, image artifacts, licenses and command entry points for tests and security classes.

⌘

Developer workbench

F10 connects sixteen evidence views, layer/recipe creation, profile clones, IDE exports, offline verification and real device jobs.

⌨

Keyboard first

Numbered sections, single-letter actions on every button, nano editor keys and a built-in reference. All keys.

◎

Web dashboard

bitloom --web: the same build service in the browser, with live progress, toasts, summaries and a command palette. Web guide.

⚖

SBOM & CRA

Release-aware SBOM quality, VEX, CRA readiness and explained SBOM settings for Scarthgap and Wrynose. Compliance guide.

✦

Studio

Create your own distribution, machines, images, recipes and layers with explained, release-aware forms. Studio guide.

⌂

Projects

Open folders with automatic detection, create pinned Scarthgap/Wrynose projects, clone from Git; every project is a profile. Projects guide.

⚠

Vulnerabilities

sbom-cve-check, cve-check and Grype findings with severity, reviews, CSV and CI gates. Vulnerabilities.

⇄

CI and build servers

Headless CI matrices with JUnit, the build service as a system service, shared profiles, NFS and setup checks, image matrix, device fleet and console builds. CI and build servers.

Explore all 82 built-in operations →
LEARN BY DOING

A complete manual testbook.

Build and launch Bitloom, configure kas-container, create layers and recipes, develop with devtool and verify every implemented command. Each case lists prerequisites, inputs and expected evidence; optional hardware and classes are identified explicitly.

Open the testbook

DEVELOPER WORKBENCH · F10

Follow a change from source to image.

Sixteen connected views implement all fourteen researched workflows: variable origins, recipe and container files, rebuild signatures, task failures, IDE SDKs, image regressions, measured performance, kas/multiconfig, offline checks, CVE/SPDX, kernel and upgrade review, boards and shutdown evidence.

Preview complete licensed CMake, Meson, Make, Python or Rust fixtures, create and register a layer, clone a profile, capture a baseline and compare after rebuilding. Optional tasks are checked against the selected release. Real device operations retain job/transcript evidence; missing equipment and reports remain unavailable.

Open the Developer guide Run all fourteen experiments → Research and sources →

Actual Bitloom Developer views displaying real kas-container evidence
Actual terminal captures · real BitBake metadata and measured buildstats
RELEASE PACKAGES

Install Bitloom.

Download your version from GitHub Releases. Debian and Ubuntu users can install the .deb with bundled Python dependencies; other Linux distributions and WSL2 can use the source archive or wheel. Python 3.10+ is required.

Debian / Ubuntu · replace 1.2.3 with your version
sudo apt install ./bitloom_1.2.3_all.deb
bitloom --demo

Source archive, wheel, checksum verification and removal instructions

QUICK START

From a checkout
to a dashboard in a minute.

The setup script creates a virtual environment, installs Bitloom and prepares two sample workspaces (Scarthgap and Wrynose). Open them in the browser or in the terminal; the samples hold metadata only, so nothing claims a real build.

In your own project, bitloom --web opens the guided setup on the folder it starts in. Requires Python 3.10+ on Linux or WSL2. Read the quickstart.

Terminal
./setup-demo.sh --no-launch
.venv/bin/bitloom --web --demo     # the dashboard
.venv/bin/bitloom --demo           # the terminal UI
1–6 Sections b Build q Operations Ctrl K Palette ? Keys

Wheel build, local kas test and reconnect instructions ↗

THE PROFILE BEHIND EACH

One small profile per setup.

Use your initialized Yocto checkout.

Source an init script automatically or run from your existing environment. Every target is passed as a quoted argument.

{
  "name": "host",
  "root": "/work/poky",
  "build_dir": "build-qemu",
  "mode": "host",
  "init_script": "oe-init-build-env"
}

Full schema and path rules: user guide · Copy-ready profiles: profile examples

METADATA WORKFLOW

Create recipes without leaving the terminal.

New file opens an editor with recipe and .bbappend templates in the selected host or container runtime. Parent directories are created, and existing files are preserved. Local metadata changes refresh every five seconds; open runtime directory listings refresh every fifteen seconds while idle.

File creation and refresh guide

Actual Bitloom new-file editor displaying a sample recipe
DAILY WORKFLOWS

Work through the problem.

01 · Build an image or one recipe

Choose a profile, enter a target, press F2 and filter the action list. Queue a normal build, compile task, dry run or SDK. The history row records the original profile and exact exit result.

02 · Investigate a failed task

Select the failed history row. Toggle Errors only or search a phrase with context. Open Task logs for the recipe's own compile/fetch log. Export the complete original log or open a concise build report.

03 · Develop and finish a recipe

Find a recipe in Layers & recipes, choose Modify, and use devtool build while editing its sources. Finish into the selected layer when ready. Interactive commands use your real terminal.

04 · Stop a build intentionally

Let finish leaves the build running. Graceful stop sends one SIGINT to a host client or a newly managed container and waits. Force terminates and offers clean for observed active recipes. Owned kas-container force stops record the exact container result; external wrappers require server verification before recovery.

05 · Inspect shared state and downloads

Scan the cache, filter files, select an age and review the concrete prune plan. No automatic deletion. Externally shared caches require coordination. Fetch tasks validate recipe sources with BitBake's checksums.

06 · Compare configurations and releases

Resolve two environment snapshots for a target and compare their values. Load dependency graphs from host or container and inspect reverse dependencies. Inspect buildhistory diffs and local repository versions. Keep release builds in separate profiles/directories.

NEW CONNECTED WORKFLOWS

Ask why. Keep the evidence.

Explain rebuild signatures, trace an image file to its recipe and packagegroup, inspect runtime preflight, compare build snapshots and export redacted reproducibility references. Review source changes before devtool finish/reset. Advisory locks coordinate cooperating cache users; unproven references never trigger automatic removal.

Read inputs, workflow details and practical limits

Actual Yocto build, runtime preflight and file inclusion reports
Actual kas-container evidence · file /bin/sh → busybox → packagegroup-core-boot
YOUR TERMINAL, YOUR PALETTE

Fourteen themes. One workspace.

Press F7 to preview Bitloom, Soft Slate, Linen, Nord, Dracula, Tokyo Night, Catppuccin Mocha, Gruvbox, Solarized Dark, Ocean, Forest, Ember, Paper or High Contrast. Save restores the palette next session; Cancel restores your previous choice. Light and dark themes adapt tables, dialogs, logs and editor backgrounds.

Actual Bitloom terminal switching through fourteen themes
Actual Textual captures · labelled demo workspace

Theme controls and persistence

DOCUMENTATION

Everything, written down.

Task-oriented guides with screenshots, a generated command and keyboard reference, and the evidence of real builds. Every page has search (/), a table of contents and light and dark themes.

EVIDENCE, NOT A DEMO CLAIM

4,064 tasks. A verified root filesystem.

Unit/UI tests cover command quoting, queueing, history, cancellation, metadata, cache boundaries and interface interaction. On 2026-10-10, core-image-minimal for qemux86-64 completed through Runner and kas-container in 57m 10s. All 4,064 tasks succeeded; the rootfs archive and eight post-build runtime probes were verified.

Verified actual kas-container build with all 4064 tasks succeeded
Actual successful image build · persisted Runner history

Class-dependent actions need matching release configuration. Cache inventories and dependency graphs are bounded. Layer compatibility parsing is advisory; BitBake metadata parsing is authoritative.

Enlarged Bitloom screenshot