# What's Pre-installed in a Sandboxer Sandbox?

> A new default sandbox runs Ubuntu 24.04 with Python 3.12, Node.js 22, Go, Rust, Bun, Docker with Compose, git, gh, Google Chrome and six coding agents, including Claude Code and Codex. Java, Ruby, PHP, .NET and Deno are not installed. You have passwordless sudo, so apt adds anything missing in seconds.

Source: https://sandboxer.com/guides/whats-preinstalled-in-a-sandbox. Updated 2026-10-27.

**Short answer:** A new default sandbox runs Ubuntu 24.04 with Python 3.12, Node.js 22, Go, Rust, Bun, Docker with Compose, git, gh, Google Chrome and six coding agents, including Claude Code and Codex. Java, Ruby, PHP, .NET and Deno are not installed. You have passwordless sudo, so apt adds anything missing in seconds.

This is a measured inventory, not a wish list. On 2026-10-27 we created one fresh `default` sandbox on prod, ran the script below inside it, and copied the output into these tables. The image is updated over time, so versions will move. Run the script yourself to see what your sandbox has today.

## The machine

| | Measured |
| - | - |
| OS | Ubuntu 24.04.5 LTS |
| Kernel | `6.18.56-sandboxer` (x86_64) |
| CPU | 4 vCPU; the model depends on the host machine (check with `lscpu`) |
| RAM | 7.8 GiB usable of 8 GB |
| Disk | `/` is 56 GB, 51 GB free on a new sandbox |
| User | `user`, home `/home/user`, passwordless `sudo`, in the `docker` and `kvm` groups |
| Virtualization | `/dev/kvm` present |
| Variables | `SANDBOXER_ID`, `SANDBOXER_SUBDOMAIN`, `SANDBOXER_API_URL`, `SANDBOXER_TOKEN` |

The CPU model depends on the host machine your sandbox lands on; run `lscpu` to see yours. Other sizes change the vCPU, RAM and disk numbers; see [Machines & sizes](/docs/machines).

## Languages and runtimes

| Tool | Installed | Version on 2026-10-27 |
| - | - | - |
| `python3` | Yes | 3.12.3 |
| `node` | Yes | v22.23.3 |
| `bun` | Yes | 1.4.3 |
| `go` | Yes | 1.27.2 (in `/usr/local/go`) |
| `rustc`, `cargo` | Yes | 1.99.1, through `rustup` 1.29.1 |
| `gcc` | Yes | 13.3.0 |
| `clang` | Yes | 18.1.3 |
| `perl` | Yes | 5.38.2 |
| `java` | No | `apt install openjdk-21-jdk-headless` |
| `ruby` | No | `apt install ruby-full` |
| `php` | No | `apt install php-cli` |
| `dotnet` | No | Microsoft's install script or apt feed |
| `deno` | No | Deno's install script |

## Package managers and build tools

| Tool | Installed | Version |
| - | - | - |
| `pip`, `pip3` | Yes | 24.0 (system Python 3.12) |
| `uv`, `uvx` | Yes | 0.13.1 |
| `pipx` | Yes | 1.4.3 |
| `npm`, `npx` | Yes | 10.9.9 |
| `pnpm` | Yes | 12.14.0 |
| `rustup` | Yes | 1.29.1 |
| `apt` | Yes | 2.8.3 |
| `make` | Yes | GNU Make 4.3 |
| `cmake` | Yes | 3.28.3 |
| `ninja` | Yes | 1.11.1 |
| `pkg-config` | Yes | 1.8.1 |
| `yarn` | No | `npm i -g yarn` or `corepack enable` |
| `snap`, `brew` | No | |

## Containers, version control and browsers

| Tool | Installed | Version |
| - | - | - |
| `docker` | Yes | 29.9.0, daemon running, `overlay2`, no `sudo` needed |
| `docker compose` | Yes | v5.6.0 |
| `docker buildx` | Yes | v0.38.0 |
| `podman`, `kubectl` | No | |
| `git` | Yes | 2.43.0 |
| `gh` | Yes | 2.102.0 |
| `git lfs` | No | `apt install git-lfs` |
| `google-chrome` | Yes | 155.0.8059.39, headless works out of the box |
| `chromium`, `firefox` | No | |
| Desktop | Yes | XFCE (`xfce4-session`), `Xvfb`, `x11vnc`, `xdotool` 3.20160805.1 |

The desktop pieces are there so `sbx desktop` can stream a screen; see [Desktop](/docs/desktop).

## Coding agents

| Command | Installed | Version |
| - | - | - |
| `claude` (Claude Code) | Yes | 2.1.301 |
| `codex` (Codex CLI) | Yes | 0.163.0 |
| `opencode` | Yes | 1.19.3 |
| `pi` | Yes | 0.73.1 |
| `kimi` | Yes | 1.52.0 |
| `vibe` (Mistral) | Yes | 2.26.1 |
| `gemini`, `aider`, `cursor-agent` | No | |

The agents are installed but not signed in. Your environment's credential switches decide which logins a sandbox receives; see [Environments & secrets](/docs/environments).

## Utilities and Sandboxer tools

| Tool | Installed | Version |
| - | - | - |
| `curl` | Yes | 8.5.0 |
| `wget` | Yes | 1.21.4 |
| `jq` | Yes | 1.7 |
| `rg` (ripgrep) | Yes | 14.1.0 |
| `tmux` | Yes | 3.4 |
| `htop` | Yes | 3.3.0 |
| `vim`, `nano` | Yes | 9.1, 7.2 |
| `ffmpeg` | Yes | 6.1.1 |
| `rsync` | Yes | 3.2.7 |
| `ssh` | Yes | OpenSSH 9.6p1 |
| `zip`, `unzip` | Yes | 3.0, 6.00 |
| `sqlite3`, `psql`, `redis-cli` | No | `apt install sqlite3 postgresql-client redis-tools` |
| `fd`, `fzf`, `bat`, `tree`, `yq`, `screen` | No | apt has all of them |
| `host` | Yes | Sandboxer's port-hosting helper, not the DNS lookup tool |
| `sbx` | Not on `PATH` in our sandbox | See below |

`host 3000` gives a port inside the sandbox an HTTPS URL, the same as `sbx host` from your laptop. Note that it shadows the BIND `host` DNS tool; use `dig` or `getent hosts` for lookups.

## Check it yourself

Save this as `inventory.sh`, copy it in and run it. Any tool that is missing prints `missing`, so it is safe on any Linux box.

```bash
#!/usr/bin/env bash
v() { local name=$1; shift
  if command -v "${1%% *}" >/dev/null 2>&1; then
    printf '%-16s %s\n' "$name" "$("$@" 2>&1 | grep -m1 -v '^\s*$' | cut -c1-80)"
  else printf '%-16s %s\n' "$name" missing; fi; }
printf '%-16s %s\n' os "$(. /etc/os-release; echo "$PRETTY_NAME")"
printf '%-16s %s\n' kernel "$(uname -r)"
printf '%-16s %s\n' cpu "$(nproc) x $(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2 | xargs)"
printf '%-16s %s\n' ram "$(free -h | awk '/Mem:/{print $2}')"
printf '%-16s %s\n' disk "$(df -h "$HOME" | awk 'NR==2{print $2" total, "$4" free"}')"
v python3 python3 --version; v node node --version; v go go version
v rustc rustc --version;     v java java -version;    v bun bun --version
v deno deno --version;       v uv uv --version;       v pnpm pnpm --version
v docker docker --version;   v compose docker compose version
v git git --version;         v gh gh --version;       v chrome google-chrome --version
v claude claude --version;   v codex codex --version; v opencode opencode --version
v pi pi --version;           v rg rg --version;       v sbx sbx --version
```

```bash
sbx scp ./inventory.sh sb_0ergpfe5w6:/home/user/
sbx exec sb_0ergpfe5w6 --timeout 300 bash -lc "bash ~/inventory.sh"
```

```text
os               Ubuntu 24.04.5 LTS
kernel           6.18.56-sandboxer
cpu              4 x …
ram              7.8Gi
disk             56G total, 51G free
python3          Python 3.12.3
node             v22.23.3
go               go version go1.27.2 linux/amd64
rustc            rustc 1.99.1 (58cf8f9c3 2026-10-13)
java             missing
…
claude           2.1.301 (Claude Code)
codex            codex-cli 0.163.0
…
sbx              missing
```

Our full script also checks the package managers, build tools, desktop pieces and utilities in the tables above. Use `bash -lc` so the login `PATH` applies: `uv`, `bun`, `cargo` and your `~/.local/bin` are added there.

## Add what's missing

You have root, so the simplest fix is apt. In the same sandbox this installed Java 21, SQLite and Git LFS in 10 seconds:

```bash
sudo apt-get update -qq
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-21-jdk-headless sqlite3 git-lfs
java -version      # openjdk version "21.0.12.1" 2026-08-18
sqlite3 --version  # 3.45.1 2024-01-30 …
git lfs version    # git-lfs/3.4.1 (GitHub; linux amd64; go 1.22.2)
```

### The sbx CLI inside a sandbox

`sbx` was not on the `PATH` of our fresh sandbox. The Linux installer puts it in `~/.local/bin`, and the sandbox's own scoped key works as its API key:

```bash
curl -fsSL https://sandboxer.com/install | sh
SANDBOXER_API_KEY="$SANDBOXER_TOKEN" sbx info self --json | jq -c '{id: .sandbox.id, state: .sandbox.state}'
# {"id":"sb_0ergpfe5w6","state":"ready"}
```

`SANDBOXER_TOKEN` can only act on this one sandbox, so this doesn't give the sandbox your account.

### Install it once, not every time

To add the same packages to each new sandbox, pass a setup script on create. It runs in the background once the sandbox is ready, and `setupStatus` tells you when it has finished:

```bash
cat > setup.sh <<'EOF'
#!/usr/bin/env bash
set -e
sudo apt-get update -qq
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq sqlite3 openjdk-21-jdk-headless
EOF

sbx new --type default --setup-file ./setup.sh
sbx info sb_70nzuovdqr --json | jq -c '{setupStatus: .sandbox.setupStatus, setupError: .sandbox.setupError}'
# {"setupStatus":"running",…}  then, about 10 seconds later:
# {"setupStatus":"done","setupError":null}
sbx exec sb_70nzuovdqr bash -lc "java -version 2>&1 | head -1"
# openjdk version "21.0.12.1" 2026-08-18
```

Wait for `done` before you rely on what the script installs: in our run, `java` was still `missing` while `setupStatus` was `running`.

Packages you install live on the sandbox disk, so they are kept across `sbx stop` and `sbx resume`, and a fork copies them. To start every new sandbox with your extras, set the sandbox up once and save it as a template: see [Turn a sandbox into a reusable template](/guides/turn-a-sandbox-into-a-reusable-template). For repositories with their own setup script, use an [environment](/docs/environments).

## FAQ

### Which Python and Node.js versions does a Sandboxer sandbox have?

On 2026-10-27, Python 3.12.3 (Ubuntu's system Python) and Node.js v22.23.3 with npm 10.9.9 and pnpm 12.14.0. `uv` 0.13.1 is installed if you need another Python version.

### Is Docker pre-installed and running?

Yes. Docker 29.9.0 with Compose v5.6.0 and buildx v0.38.0 is installed, the daemon runs at boot, and `user` is in the `docker` group, so `docker run` works without `sudo`.

### Are Claude Code and Codex pre-installed?

Yes. `claude` 2.1.301, `codex` 0.163.0, `opencode`, `pi`, `kimi` and `vibe` are installed globally. They are not signed in until you sign in or your environment passes your logins.

### Is Java or Ruby installed?

No. Install them with apt (`openjdk-21-jdk-headless`, `ruby-full`) or a version manager such as sdkman or rbenv. Java 21 installed in about 10 seconds in our test.

### Will the versions on this page stay the same?

No. The image is updated over time, and these are the versions we measured on 2026-10-27. Run the inventory script in your own sandbox to see what it has now.

## Related

- [Machines & sizes](/docs/machines)
- [Environments & secrets](/docs/environments)
- [Turn a sandbox into a reusable template](/guides/turn-a-sandbox-into-a-reusable-template)
- [Run a computer-use agent on a Linux desktop](/guides/run-a-computer-use-agent-on-a-linux-desktop)