---
summary: How ScaiLabs builds, tests, scans and versions the six built-in bunker images,
  and what each image contains.
title: Platform images
path: concepts/platform-images
status: published
---

ScaiBunker ships six built-in images: `minimal`, `ubuntu-24.04`, `python-3.12`, `nodejs-22`, `rust-latest`
and `python-3.12-ml`. This page explains how they are made and what you can rely on.

## What an image is

A bunker is a Firecracker microVM that boots from an **ext4 root filesystem image**. The image holds:

- the operating system;
- one language runtime.

The worker supplies the rest:

- the kernel;
- the bunker agent, which runs as PID 1 and executes your commands;
- network and DNS configuration.

An image therefore contains **no init system, no kernel, and nothing that identifies the machine it was built on**.

## Built from distribution sources

Platform images are built directly from the distributions' own sources, not from third-party container images:

| Image | Base | Runtime | Root disk |
|---|---|---|---|
| `minimal` | Alpine Linux (latest stable) | busybox, `apk` | 200 MiB |
| `ubuntu-24.04` | Ubuntu 24.04 LTS | none; `apt` available | 500 MiB |
| `python-3.12` | Ubuntu 24.04 LTS | Python 3.12, pip, venv, headers | 800 MiB |
| `nodejs-22` | Ubuntu 24.04 LTS | Node.js 22 LTS (official nodejs.org build), npm 12 | 600 MiB |
| `rust-latest` | Ubuntu 24.04 LTS | Rust stable via rustup (minimal profile), gcc as linker | 2,500 MiB |
| `python-3.12-ml` | Ubuntu 24.04 LTS | Python 3.12 with PyTorch, torchvision and torchaudio; CUDA runtime libraries included | 12,000 MiB |

Notes:

- **Ubuntu images** include the `updates` and `security` pockets, so each build carries every security fix released up to its build date.
- **pip** installs system-wide in the Python images. A bunker is a disposable VM, so no virtual environment is required.
- **Rust** needs three variables in the bunker's environment: `RUSTUP_HOME=/usr/local/rustup`, `CARGO_HOME=/usr/local/cargo` and `/usr/local/cargo/bin` on `PATH`. The image sets them for login shells, through `/etc/profile.d` and `/etc/environment`, and lists them in its manifest.
- **GPU images** bundle the CUDA runtime libraries that match the PyTorch build. The NVIDIA driver isn't in the image: GPU bunkers get whole GPUs passed through, and ScaiBunker attaches a matching driver (in `/usr/local/nvidia`) to each one. The exact PyTorch and CUDA versions of each build are listed in its manifest (`boot_test`).

## How every image is built

Each build goes through the same pipeline. A failure at any step stops the build, and nothing is published.

1. **Assemble the root filesystem.**
   - **Ubuntu and Alpine:** the distribution's own signed package archives.
   - **Node.js and Rust:** the official downloads, which are checked against their published checksums before use.
   - **PyTorch:** installed from PyPI, with pip verifying package hashes.
2. **Strip host details.** Hostname, `machine-id`, `/etc/hosts` and DNS settings are reset or removed, and logs and caches are cleared. An automated check rejects any image whose configuration mentions the build environment.
3. **Create the ext4 image** at the image's root-disk size. File ownership and permissions (including setuid bits) are preserved exactly, and a filesystem check must pass.
4. **Boot test.**
   - A copy of the image boots in a real Firecracker microVM.
   - Inside the VM, an image-specific check runs. For example: Python imports `ssl`, `sqlite3` and `venv`; the Rust image compiles and runs a program; the ML image imports PyTorch, torchvision and torchaudio.
   - The published image never contains the test itself.
5. **Security scan.**
   - The root filesystem is scanned for known vulnerabilities, and a CycloneDX software bill of materials (SBOM) is generated.
   - A **critical vulnerability that already has a fix available** fails the build, because it means an update was missed.
6. **Compress and publish.**
   - The image is compressed with zstd. Unused disk space costs almost nothing to download.
   - It is published as a new, immutable version together with its manifest and SBOM.

## Versions and updates

- **Version numbers** take the form `1.<YYYYMMDD>.<n>`, e.g. `1.20261017.0`. A second build on the same day becomes `.1`.
- **Rebuilds** happen monthly. Images are also rebuilt off-cycle when an urgent security fix is published.
- **Published versions never change.** A rebuild always creates a new version, so a running bunker is never changed underneath you.
- **Rollout.** New bunkers get a new version once the workers have imported it, one worker at a time. Bunkers already running stay on their version. A bunker's `image_version` shows which version it runs.
- **Snapshots keep their version.** A snapshot records the version its bunker ran (`image_version`), and a restore always uses that version, even after the image has moved on. The restored bunker runs the old version; create a new bunker to get the new one.
- **Retention.** The newest version and the two before it stay available. Older versions are deprecated, and removed once no bunker runs on them and no snapshot needs them.

## The image manifest

Every version carries an `image.json` manifest. The fields you are most likely to use:

| Field | Meaning |
|---|---|
| `base` | Distribution and release, e.g. `{"distro": "ubuntu", "release": "24.04"}` |
| `entrypoint` | The bunker's shell: `/bin/bash`, or `/bin/sh` for `minimal` |
| `env` | Environment variables the runtime requires (empty except for Rust) |
| `rootfs.sha256` | SHA-256 of the uncompressed ext4 image. This is the image's identity: use it to verify the image after download |
| `rootfs.size_mib` | Root disk size |
| `boot_test` | What the boot check printed, such as the exact Python, Node.js, Rust or PyTorch version |
| `scan` | Vulnerability counts by severity at build time |
| `built_at` | Build time (UTC) |

ScaiBunker records this build-time scan on the image, tied to the image's `rootfs.sha256`. An image is scanned once, when it comes in. It's scanned again only when its content changes, which for platform images means a new version. New vulnerabilities are picked up by the monthly and urgent rebuilds, not by re-scanning an image that hasn't changed.

## Need something else?

If a built-in image lacks a tool you need, install it from inside the bunker, for example with `apt`, `pip`, `npm`, `cargo` or
`apk`, as far as the bunker's network profile allows. For a recurring need, register your own image; see
[Register a custom image](../tutorials/register-custom-image).
