Garrett’s Mint Setup

Install order

Templates: starter AGENTS.md, Zed settings.json, a Marimo notebook with inline metadata, and an example Agent Skill — linked from the sections that use them.

Interactive checklist

Manual steps. No install block completes these.

Mint concepts that differ from Windows

• Installing software = apt, not downloading .exe files. sudo apt install foo pulls from vetted repositories. Several sections add official vendor repos (Docker, GitHub, Cloudflare, Chrome) — same mechanism, more sources.
• sudo is per-command admin consent. It asks for your password, and only affects that one command.
• Your files live in /home/<you> (~). There are no drive letters. The terminal opens there by default.
• PATH additions go in ~/.bashrc. Each section’s PATH block appends a guarded entry; open a new terminal (or source ~/.bashrc) to pick them up.
• System Python is the OS’s — don’t touch it. All Python work here goes through uv, which keeps its own interpreters under ~/.local.
• Reboot after big changes. Kernel updates, the docker group, and GPU drivers all take effect on login/reboot.
• Timeshift snapshots. Mint ships Timeshift (Menu → Timeshift); take a snapshot before experimenting with drivers.

Terminal basics

pwd && ls -la        # where am I, what's here
cd ~/projects        # move around; `cd -` goes back
cat file             # print a file; `less file` pages it
grep -r "text" .     # search file contents recursively
ps aux | grep foo    # find a running process
kill <pid>           # stop it
man <command>         # built-in manual; `q` to exit

Tab completes paths and commands. Ctrl+C interrupts. Ctrl+R reverse-searches history. Up-arrow recalls the last command.

Troubleshooting

Ordered by likelihood.

• “command not found”
• Docker permission denied
• Zed won’t start
• Agent CLI login hangs
• apt-get update GPG errors
• Bun package issues
• Playwright browser install
• Python externally-managed error
• Cross-browser differences
• Godot won’t launch
• If problems persist

“command not found” after installing something

The installer put it somewhere your current shell doesn’t look. Fixes in order:

1. Open a new terminal (PATH entries in ~/.bashrc load at shell start).
2. source ~/.bashrc in the current shell.
3. ls ~/.local/bin — is the binary there but PATH lacks it? Re-paste the section’s PATH block and check echo $PATH.
4. Re-read the tool’s PATH note in its section.

Docker says “permission denied” / “cannot connect to the daemon”

You skipped the logout after the Docker section. Log out and back in (group membership applies at login), then docker run --rm hello-world. Stopgap for the current shell only: newgrp docker.

Zed won’t start (or renders nothing)

• Bare metal: open Driver Manager from the Mint menu and apply the recommended GPU driver, then reboot.
• VM: enable 3D acceleration in the VM settings (Zed needs Vulkan).
• SSH/headless: Zed is a GUI app — it needs a graphical session.

An agent CLI hangs at login / shows no models

Each CLI’s auth is separate. Confirm which account/plan backs each one, check date (TLS fails on a wrong clock — enable automatic date/time in Mint settings), and retry on a clean network before assuming the tool is broken. Corporate/school networks with TLS inspection break agent CLIs first and browsers last.

apt-get update fails with GPG/signature errors

The vendor keyring didn’t install cleanly. Re-paste the owning section’s repo-setup block. If one repo stays broken, work around it by temporarily moving its file out of /etc/apt/sources.list.d/, then sudo apt-get update to confirm the rest are healthy.

A Bun-installed package behaves oddly

Bun’s Node compatibility is high but partial. Confirm with Node semantics: does the package’s issue tracker mention Bun? Workarounds in order: run it via bun --bun explicitly, pin the package version, or install Node (sudo apt install nodejs npm — Mint’s version is old but diagnostic) to isolate Bun-vs-package.

Playwright: browsers won’t install / tests can’t launch Chromium

1. ls ~/.cache/ms-playwright — empty means the download failed; rerun bunx --bun playwright install chromium.
2. Missing shared libraries means the --deps step failed; rerun sudo $HOME/.bun/bin/bun x --bun playwright install-deps chromium.
3. Still failing: bunx playwright install --with-deps chromium from inside a project dir (foregrounds the error).

Python: “externally managed environment” pip errors

That’s apt protecting system Python. Never --break-system-packages: do the work with uv run / uv add in a project (Python, Marimo) instead.

Websites work in one browser but not another

See the Browsers section: private window first, then cross-engine comparison. If only Epiphany fails, the site likely assumes Chromium.

Godot binary won’t launch

chmod +x the binary (the install block does this; manual downloads forget it), then run ./Godot_*_stable_linux.x86_64 --version from ~/Applications to see the real error. Missing audio/display libs on minimal installs: sudo apt install libasound2 libx11-6 libxcursor1 libxinerama1 libgl1 covers the usual.

If problems persist

1. Re-paste the owning section’s blocks top to bottom — everything is re-paste-safe.
2. Read the tool’s official docs (linked from each section).
3. Paste the full error + what you ran into an agent CLI.

1System base

Do this section first. Everything else assumes an updated system with curl, git, and ripgrep available.

1. Update and upgrade

sudo apt-get update
sudo apt-get upgrade -y

2. Core tools

sqlite3, the C/C++ toolchain, and openssh-server live in their own sections (SQLite, C/C++ toolchain, Remote access):

sudo apt-get update
sudo apt-get install -y curl wget ca-certificates gnupg lsb-release git unzip zip xz-utils jq ripgrep fonts-jetbrains-mono

fonts-jetbrains-mono is the terminal/editor code font. lsb-release and gnupg are needed to add vendor apt repositories in later sections.

Verify

git --version && rg --version && jq --version

2Git + GitHub CLI

Prerequisite: System base (needs curl/git).

1. Add GitHub’s apt repository and install gh

From the official Linux install doc, verbatim:

(type -p wget >/dev/null || (sudo apt update && sudo apt install wget -y)) && sudo mkdir -p -m 755 /etc/apt/keyrings && out=$(mktemp) && wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg && cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null && sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg && sudo mkdir -p -m 755 /etc/apt/sources.list.d && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && sudo apt update && sudo apt install gh -y

2. Git defaults (fill in your identity)

git config --global init.defaultBranch main
git config --global pull.rebase false
git config --global user.name "Garrett <Last>"
git config --global user.email "you@example.com"

3. Log in to GitHub (interactive)

gh auth login
gh auth status

Verify

gh --version && git config --global user.name

3Remote access

Prerequisite: System base.

SSH from the main PC into the Mint box.

1. Install and enable the server

sudo apt-get update
sudo apt-get install -y openssh-server
sudo systemctl enable --now ssh

2. Connect from the main PC

On the Mint box, find its LAN address:

hostname -I

From Windows PowerShell/Terminal (ssh is built in) or any Linux/Mac terminal:

ssh garrett@192.168.1.42

Accept the host key on first connect. A changed-key warning later means the key changed — investigate before deleting known_hosts entries.

3. Switch to key auth

On the main PC:

ssh-keygen -t ed25519
ssh-copy-id garrett@192.168.1.42

If ssh-copy-id is missing (Windows), append the .pub contents to ~/.ssh/authorized_keys on the Mint box manually. Then, on the Mint box, confirm key login works from a second window before disabling passwords:

sudo sed -i 's/^#*PasswordAuthentication.*/PasswordAuthentication no/' /etc/ssh/sshd_config
sudo systemctl reload ssh

Keep the second window open until the next login succeeds.

Beyond the LAN (optional)

• Same-house use needs nothing else. Set a DHCP reservation in the router for a stable address, or re-check with hostname -I.
• For access away from home, use Tailscale (install on both machines, log in, SSH to the Tailscale IP). Official install: curl -fsSL https://tailscale.com/install.sh | sh
• Port-forwarding 22 exposes SSH to the internet.

Agent relevance

Agents run on the Mint box: SSH in, then launch claude/codex/etc. in a local shell. For sessions that survive a dropped connection, run them under a multiplexer (zellij or tmux).

Verify

systemctl is-active ssh

4C/C++ toolchain

Prerequisite: System base.

Editor wiring (clangd, formatting) is in the Zed section.

1. Install the toolchain

sudo apt-get update
sudo apt-get install -y build-essential clang clangd clang-format lldb gdb cmake ninja-build pkg-config

Compilers (gcc/g++, clang/clang++), debuggers (gdb, lldb), build (cmake + ninja), and clangd (the C/C++ language server).

2. First compile

mkdir -p ~/projects/hello-c && cd ~/projects/hello-c
cat > main.c <<'EOF'
#include <stdio.h>
int main(void) { printf("hello from C\n"); return 0; }
EOF
gcc -Wall -Wextra -g main.c -o hello && ./hello

CMake project with editor support (compile_commands.json feeds clangd):

mkdir -p ~/projects/hello-cmake && cd ~/projects/hello-cmake
cat > CMakeLists.txt <<'EOF'
cmake_minimum_required(VERSION 3.28)
project(hello CXX)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
add_executable(hello main.cpp)
EOF
echo '#include <cstdio>\nint main() { std::puts("hello from C++"); }' > main.cpp
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug
cmake --build build && ./build/hello
ln -sf build/compile_commands.json .

Verify

gcc --version | head -1 && clang --version | head -1 && cmake --version | head -1 && which clangd

5Python

Prerequisite: System base (needs curl).

System Python belongs to the OS — leave it alone. uv fetches its own interpreters and keeps one environment per project. Never pip install into system Python (and never --break-system-packages).

1. Install uv

curl -LsSf https://astral.sh/uv/install.sh | sh

# uv on PATH for this and future shells (guarded: safe to paste twice)
grep -qF '# garrett-mint-setup: local-bin on PATH' ~/.bashrc 2>/dev/null || {
  printf '\n# garrett-mint-setup: local-bin on PATH\nexport PATH="$HOME/.local/bin:$PATH"\n' >> ~/.bashrc
}
export PATH="$HOME/.local/bin:$PATH"

2. Managed Python + Ruff + Ty

uv python install 3.13
uv tool install ruff@latest
uv tool install ty@latest

3. Daily workflow

mkdir -p ~/projects/hello-py && cd ~/projects/hello-py
uv init --name hello-py --python 3.13 --no-readme
uv add httpx
uv run python -c "import sys, httpx; print(sys.version.split()[0], httpx.__version__)"
ruff check . && ruff format --check .
ty check .

uv add polars altair               # add deps (updates pyproject + lockfile)
uv remove altair                   # drop a dep
uv run python main.py              # run inside the project env
uv python list                     # interpreters uv manages

If a command touches project packages, prefix it with uv run; for a one-shot tool, use uvx (e.g. uvx pycowsay hi). ruff and ty are global tools (step 2), so call them directly.

Single-file scripts with dependencies and no project directory use inline metadata (PEP 723) — see Marimo and the Marimo template notebook:

uv run --script myscript.py

Ruff and Ty

Ruff is lint + format in one binary (ruff check, ruff format). Ty is Astral’s typechecker (ty check). Both also run inside Zed as built-in language servers (Zed).

Verify

uv --version && ruff --version && ty version && uv python list

6Marimo

Prerequisite: Python (needs uv).

Marimo notebooks are plain .py files — diffable, runnable as scripts — where cells re-execute automatically when their dependencies change.

1. Install (persistent)

uv tool install marimo

2. Run the template notebook (ephemeral sandbox, no project setup)

Save the template notebook from the templates section as ~/projects/marimo-hello.py, then:

cd ~/projects
marimo edit --sandbox marimo-hello.py

--sandbox resolves the notebook’s # /// script metadata block with uv, so it runs on any machine with marimo + uv and zero project setup.

Verify

marimo --version

7SQLite

Prerequisite: System base.

SQLite is zero-config, one file, everywhere. SQLite fits app state and small tables; DuckDB (next section) fits local analysis over large files. Keep databases out of git (add *.db *.duckdb to .gitignore).

1. Install

sudo apt-get update
sudo apt-get install -y sqlite3 libsqlite3-dev

2. First database

sqlite3 notes.db "CREATE TABLE n(id INTEGER PRIMARY KEY, body TEXT); INSERT INTO n(body) VALUES ('first'); SELECT * FROM n;"

Verify

sqlite3 --version

8DuckDB

Prerequisite: System base (needs curl).

DuckDB is the embedded OLAP counterpart to SQLite — same zero-config shape, but a columnar engine that queries Parquet/CSV directly. Keep databases out of git (add *.db *.duckdb to .gitignore).

1. Install

curl https://install.duckdb.org | bash

# DuckDB on PATH for this and future shells (guarded: safe to paste twice)
grep -qF '# garrett-mint-setup: duckdb on PATH' ~/.bashrc 2>/dev/null || {
  printf '\n# garrett-mint-setup: duckdb on PATH\nexport PATH="$HOME/.duckdb/cli/latest:$PATH"\n' >> ~/.bashrc
}
export PATH="$HOME/.duckdb/cli/latest:$PATH"

2. First query

duckdb data.duckdb "SELECT count(*) FROM read_csv('input.csv');"

Verify

duckdb --version

9Bun

Prerequisite: System base (needs curl, unzip).

Bun replaces Node + npm here. Node compatibility is high but not 100% — see the troubleshooting section if a package fails. Bun’s test runner covers unit tests; Playwright (Playwright) covers tests that need a real browser.

1. Install

curl -fsSL https://bun.com/install | bash

# Bun on PATH for this and future shells (guarded: safe to paste twice)
grep -qF '# garrett-mint-setup: bun on PATH' ~/.bashrc 2>/dev/null || {
  printf '\n# garrett-mint-setup: bun on PATH\nexport BUN_INSTALL="$HOME/.bun"\nexport PATH="$BUN_INSTALL/bin:$PATH"\n' >> ~/.bashrc
}
export BUN_INSTALL="$HOME/.bun"
export PATH="$BUN_INSTALL/bin:$PATH"

2. First project

mkdir -p ~/projects/hello-ts && cd ~/projects/hello-ts
bun init -y
bun add zod
bun run index.ts
bun test

bun add hono            # install a dep
bunx tsc --noEmit       # one-shot tools without installing

Typecheck via the TypeScript compiler in the project (bun add -d typescript, then bunx tsc --noEmit), or rely on Zed’s built-in TS support as you type.

Verify

bun --version

10Zed

Prerequisite: System base (needs curl).

Native editor for C, C++, Python, and JS/TS, with a built-in agent panel and terminal. Zed auto-updates.

1. Install

curl -f https://zed.dev/install.sh | sh

# Zed launcher on PATH for this and future shells (guarded: safe to paste twice)
grep -qF '# garrett-mint-setup: local-bin on PATH' ~/.bashrc 2>/dev/null || {
  printf '\n# garrett-mint-setup: local-bin on PATH\nexport PATH="$HOME/.local/bin:$PATH"\n' >> ~/.bashrc
}
export PATH="$HOME/.local/bin:$PATH"

2. Starter settings (installed once, never overwritten)

mkdir -p ~/.config/zed

Then copy the starter settings from the templates section into ~/.config/zed/settings.json. If that file already exists, leave it alone — this step never overwrites.

3. First launch checklist

1. zed from the terminal (a directory argument opens it there).
2. Ctrl+, opens settings — confirm your starter file loaded.
3. Ctrl+Shift+P is the command palette; Ctrl+P jumps to files.
4. Open the agent panel (Ctrl+Shift+A) and sign in to at least one provider.
5. Open a terminal inside Zed (Ctrl+`) and run which clangd clang-format ruff ty bun to confirm the toolchain is visible.

Language support (what to expect)

Zed discovers most of this automatically once the underlying tools exist — which the other sections in this guide install. Each page below lists the exact language server / formatter Zed uses.

• C: https://zed.dev/docs/languages/c — clangd-based. Needs compile_commands.json for cross-file accuracy; CMake generates it with set(CMAKE_EXPORT_COMPILE_COMMANDS ON) (the C/C++ section shows how).
• C++: https://zed.dev/docs/languages/cpp — same clangd setup as C.
• Python: https://zed.dev/docs/languages/python — uses your environment’s interpreter; with uv projects Zed picks up .venv automatically. Basedpyright typechecks by default and Ruff handles lint+format; ty is an alternate language server. Select servers under Settings → Languages → Python.
• JavaScript: https://zed.dev/docs/languages/javascript and TypeScript: https://zed.dev/docs/languages/typescript — Bun works as the runtime; language support defaults to vtsls, with typescript-language-server as the alternate.

If a language shows no diagnostics or formatting: open the language page above, check which tool it expects, and confirm that tool is on PATH in Zed’s integrated terminal (which clangd clang-format ruff ty bun).

Requirements note

Zed on Linux needs a Vulkan-compatible GPU. On bare metal, Mint’s Driver Manager GPU drivers suffice. In a VM, enable 3D acceleration — see the troubleshooting section.

Verify

zed --version

11Zeal

Prerequisite: System base.

Zeal is an offline documentation browser: a searchable local library of docsets. Docsets come from Zeal’s built-in feed (Dash-compatible) and are downloaded from inside the app: Tools → Docsets.

1. Install

sudo apt update
sudo apt install zeal

The official download page lists this under Ubuntu (official repositories). When the official package is outdated, the page points to the ppa:zealdocs PPA for up-to-date stable releases.

2. Download docsets

Launch Zeal, then Tools → Docsets to browse and download docsets. Limit a search to one docset with docset:query (e.g. python:string).

Verify

which zeal

12Docker

Prerequisite: System base (needs curl).

Docker does not officially support Mint (an Ubuntu derivative), though this method works; Mint sets UBUNTU_CODENAME, so the Suites line below resolves to the underlying Ubuntu release.

1. Add Docker’s apt repository and install

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-compose-v2 docker-doc docker-buildx podman-docker containerd runc | cut -f1)
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

2. Join the docker group

sudo groupadd docker
sudo usermod -aG docker $USER

Log out and back in now — group membership applies at login. Stopgap for the current shell only: newgrp docker.

3. First container (after re-login)

sudo systemctl status docker

If Docker is not running, start it manually:

sudo systemctl start docker

docker run --rm hello-world
docker --version && docker compose version

A starter compose file for local services:

# compose.yaml
services:
  db:
    image: postgres:17
    environment:
      POSTGRES_PASSWORD: dev-only-not-a-secret
    ports: ["5432:5432"]
    volumes: ["pgdata:/var/lib/postgresql/data"]
volumes:
  pgdata:

docker compose up -d && docker compose ps && docker compose down

Disk usage: docker system df shows usage; docker system prune reclaims it.

Verify

docker run --rm hello-world

13Browsers

Prerequisite: System base.

First-launch each from the Mint menu once to clear default-browser and keyring prompts.

1. Install Firefox + Epiphany

sudo apt-get update
sudo apt-get install -y firefox epiphany-browser

2. Install Chrome (.deb from Google)

TMP_DEB="$(mktemp --suffix=.deb)"
curl -fsSL -o "$TMP_DEB" https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt-get install -y "$TMP_DEB"
rm -f "$TMP_DEB"

The .deb also configures Google’s apt repository, so Chrome updates with the system.

Cross-browser differences

1. Reproduce in a private window (rules out extensions).
2. Check the other two engines to isolate WebKit vs Gecko vs Chromium.
3. For Playwright flakes: rerun with --repeat-each=3 and keep the trace.

Verify

firefox --version && epiphany --version && google-chrome --version

14Playwright

Prerequisite: Bun (Playwright runs through Bun here).

Bun 1.4 runs Playwright: playwright test with a playwright.config.ts, connectOverCDP(), and --ui all work.

1. Install Chromium + OS deps

bunx --bun playwright install chromium
sudo env HOME="$HOME" "$HOME/.bun/bin/bun" x --bun playwright install-deps chromium

The second command needs root for system libraries, so it runs Bun by absolute path under sudo.

2. Per-project usage

cd myapp
bun add -d @playwright/test
bunx --bun playwright install chromium
bunx --bun playwright test
bunx --bun playwright test --ui

Verify

ls ~/.cache/ms-playwright && bunx --bun playwright --version

15Wrangler

Prerequisite: Bun (Wrangler installs per-project through Bun).

1. Install (per project)

bun add -d wrangler@latest

Cloudflare recommends a per-project install over a global one; run it with bunx wrangler.

2. Log in and start a worker (interactive)

bunx wrangler login
bunx create-cloudflare@latest my-worker
cd my-worker && bunx wrangler dev

wrangler dev serves locally; wrangler deploy ships. Project config lives in wrangler.jsonc.

Verify

bunx wrangler --version

16Tunnel

Prerequisite: System base (needs curl).

Expose local work over cloudflared tunnels.

1. Add Cloudflare’s apt repository and install

sudo mkdir -p --mode=0755 /usr/share/keyrings
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null
echo "deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main" | sudo tee /etc/apt/sources.list.d/cloudflared.list
sudo apt-get update && sudo apt-get install cloudflared

2. Quick share (ephemeral demo URL)

cloudflared tunnel --url http://localhost:5173

That prints a public *.trycloudflare.com URL. Quick tunnels are for testing and development, with no uptime guarantee.

3. Named tunnel (stable hostname, interactive setup)

cloudflared tunnel login
cloudflared tunnel create devbox
cloudflared tunnel route dns devbox devbox.example.com
cloudflared tunnel run devbox

run reads ~/.cloudflared/config.yml (tunnel: plus credentials-file: plus ingress rules).

Verify

cloudflared --version

17Claude Code

Prerequisite: System base (needs curl). Install all four agent CLIs, then run the same first prompt in each (below).

1. Install

curl -fsSL https://claude.ai/install.sh | bash

Native installs auto-update in the background.

2. First run (auth is interactive)

cd ~/some-project
claude        # log in when prompted, then: "Tell me about this project"

Auth: Pro/Max/Team/Enterprise subscription, Console, or Bedrock/Vertex (/login re-authenticates). Run the same prompt in Codex, Antigravity, and Devin to compare agents on identical input.

Costs and data

Each CLI bills through its vendor’s plan or credits — no shared pool. Prompts, including pasted code, are sent to the vendor.

Verify

claude --version

18Codex CLI

Prerequisite: System base (needs curl).

1. Install

curl -fsSL https://chatgpt.com/codex/install.sh | sh

Update by rerunning the install script.

2. First run (auth is interactive)

cd ~/some-project
codex         # Sign in with ChatGPT, then: "Tell me about this project"

Same calibration prompt as the other three agents.

Verify

codex --version

19Antigravity CLI

Prerequisite: System base (needs curl).

1. Install

curl -fsSL https://antigravity.google/cli/install.sh | bash

Installs the agy binary to ~/.local/bin/agy. Update by rerunning the install script.

2. First run (auth is interactive)

cd ~/some-project
agy           # Google sign-in in the browser, then: "Tell me about this project"

Same calibration prompt as the other three agents.

Verify

agy --version

20Devin CLI

Prerequisite: System base (needs curl).

1. Install

curl -fsSL https://cli.devin.ai/install.sh | bash

Restart your terminal after installing.

2. First run (auth is interactive)

cd ~/some-project
devin         # Devin account on first run, then: "Tell me about this project"

Verify

devin --version

21Blender

Prerequisite: System base.

1. Install

sudo apt-get update
sudo apt-get install -y blender

The distro package can lag official releases and may lack Cycles GPU rendering support (per the Blender manual). For current releases, use the tarball from blender.org or the Flatpak in Mint’s Software Manager; each coexists with the apt install. Blender is a GUI app: launch from the Mint menu.

For GPU rendering on NVIDIA cards, use Driver Manager (Mint menu) to select the vendor driver; AMD/Intel use the in-kernel drivers.

Verify

blender --version

22GIMP

Prerequisite: System base.

Fills texture/UI gaps alongside Inkscape (Inkscape) and Blender (Blender).

1. Install

sudo apt-get update
sudo apt-get install -y gimp

The distro package can lag official releases (current stable is a 3.x series). For the current release, use the AppImage or Flatpak from the downloads page, or the Flatpak in Mint’s Software Manager; each coexists with the apt install. GIMP is a GUI app: launch from the Mint menu.

Verify

gimp --version

23Inkscape

Prerequisite: System base.

Fills texture/UI gaps alongside GIMP (GIMP) and Blender (Blender).

1. Install

sudo apt-get update
sudo apt-get install -y inkscape

The distro package can lag official releases. For the current release, use the AppImage or Flatpak from the release page, the Flatpak in Mint’s Software Manager, or the official PPA (ppa:inkscape.dev/stable). Inkscape is a GUI app: launch from the Mint menu.

Verify

inkscape --version

24Three.js

Prerequisite: Bun (Three.js is an npm package — no system install).

1. First scene

mkdir -p ~/projects/hello-three && cd ~/projects/hello-three
bun init -y
bun add three
bun add -d @types/three typescript

Then follow https://threejs.org/manual/ for a first scene, served with bun --hot index.html, or scaffolded with Vite (bun create vite my-scene --template vanilla-ts, then bun add three).

Verify

bun pm ls | grep three

25Godot

Prerequisite: System base (needs curl, jq, unzip).

No account required. Steam is an alternative installer (auto-updates, same builds except store builds exclude .NET/C# support).

1. Install the latest stable Linux binary

Godot is self-contained: download, extract, run — no installation step.

sudo apt-get update
sudo apt-get install -y jq unzip
mkdir -p ~/Applications ~/.local/bin
ASSET_URL="$(curl -fsSL https://api.github.com/godotengine/godot/releases/latest | jq -r '.assets[] | select(.name | test("Godot_v.*_stable_linux\\.x86_64\\.zip$")) | .browser_download_url')"
TMP_ZIP="$(mktemp --suffix=.zip)"
curl -fsSL -o "$TMP_ZIP" "$ASSET_URL"
unzip -o -q "$TMP_ZIP" -d ~/Applications
rm -f "$TMP_ZIP"
GODOT_BIN="$(ls ~/Applications/Godot_*_stable_linux.x86_64 2>/dev/null | head -1)"
chmod +x "$GODOT_BIN"
ln -sf "$GODOT_BIN" ~/.local/bin/godot

grep -qF '# garrett-mint-setup: local-bin on PATH' ~/.bashrc 2>/dev/null || {
  printf '\n# garrett-mint-setup: local-bin on PATH\nexport PATH="$HOME/.local/bin:$PATH"\n' >> ~/.bashrc
}
export PATH="$HOME/.local/bin:$PATH"

If ASSET_URL comes back empty, download the zip from https://godotengine.org/download/linux/ or install via Steam instead.

2. First project

The official “Your first 2D game” tutorial is in the Godot docs. Exclude the .godot/ import cache from version control.

Verify

godot --version

26Unreal

Advanced and optional; docs only. On Linux, Unreal requires an Epic account linked to GitHub, a ~100 GB source clone, and a multi-hour compile.

Path when ready

1. Epic account → linked GitHub account (https://www.unrealengine.com/ue-on-github)
2. Clone EpicGames/UnrealEngine, run Setup.sh + GenerateProjectFiles.sh
3. Build with make (expect hours and 100+ GB disk)

27Agentic standards

No install — four standards, four different jobs.

1. AGENTS.md — per-repo instructions

A Markdown file at the repo root naming the commands, stack, and rules for that project. The CLIs and Zed’s agent read it. Template: the starter AGENTS.md below — copy it into every project and fill in the real commands: real test/lint/typecheck commands, real rules.

2. Agent Skills — reusable how-to packs

A skill is a folder with a SKILL.md (name + description frontmatter, then instructions) plus any scripts or references it needs. Agents discover skills by description and load the instructions only when relevant. Example: the example skill below; format details are in the specification.

Each agent documents its own skills directory; check the current docs per agent.

3. MCP — tools and data for agents

The Model Context Protocol lets an agent call tools exposed by MCP servers: read a database, query an API, drive a browser. A server is a program speaking JSON-RPC over stdio (local) or Streamable HTTP (remote); clients list configured servers and hand their tool schemas to the model.

Each server is ambient authority: an agent can call any tool it sees. Zed documents its side at https://zed.dev/docs/ai/mcp.

Reference servers include a fetch server (uvx mcp-server-fetch).

4. ACP — editors embedding agents

The Agent Client Protocol standardizes how an editor talks to an agent backend: same agent, any ACP-speaking editor. Zed’s agent panel speaks ACP.

How they fit together

• AGENTS.md: “in this repo, do it this way”
• Skills: “whenever this kind of task appears, follow this playbook”
• MCP: “here are tools you may call to touch the outside world”
• ACP: “the editor and the agent talk over this wire”

Verify

for u in https://agents.md https://agentskills.io https://modelcontextprotocol.io https://agentclientprotocol.com; do curl -fsSI "$u" >/dev/null && echo "OK $u" || echo "FAIL $u"; done

Templates

Starter files referenced by the guides above, reproduced here in full. Copy each one into a file at the destination its guide names.

• AGENTS.md starter — used by Agentic standards
• Zed settings — used by Zed
• Marimo notebook — used by Marimo and Python
• Example Agent Skill — used by Agentic standards

AGENTS.md — starter template

Copy the text below to the root of a project as AGENTS.md and fill in the blanks. Coding agents (Claude Code, Codex, Antigravity, Devin, Zed’s agent, and others) read it for project-specific instructions. Keep it short: commands the agent must run, constraints it must respect, nothing else.

# AGENTS.md — starter template

## Commands

- Install: `...`
- Dev server: `...`
- Tests: `...`
- Lint: `...` (must pass before finishing a task)
- Format: `...`
- Typecheck: `...` (must pass before finishing a task)

## Stack

- Language + version: `...`
- Package manager: `...` (use only this one — never mix with alternatives)
- Frameworks: `...`

## Rules

- Explain the plan before editing more than three files.
- Run the full test command after behavior changes; report failures instead
  of working around them.
- Do not commit unless asked. Do not push, publish, or deploy unless asked.
- Prefer editing existing helpers over adding new dependencies.
- Match surrounding code style; no drive-by refactors.

## Layout

- `src/` — ...
- `tests/` — ...
- `docs/` — ...

## Glossary

- Term: one-line meaning. (Add project-specific terms agents keep misusing.)

Zed starter settings

Save as ~/.config/zed/settings.json (the Zed section’s copy step).

{
  // Starter Zed settings. Lives at ~/.config/zed/settings.json.
  // Zed validates on save — an unknown key gets a squiggle, not a crash.
  "auto_update": true,
  "format_on_save": "on",
  "remove_trailing_whitespace_on_save": true,
  "preferred_line_length": 100,
  "tab_size": 4,
  "ui_font_family": "JetBrains Mono",
  "buffer_font_family": "JetBrains Mono",
  "buffer_font_size": 14,
  "terminal": {
    "font_family": "JetBrains Mono",
    "font_size": 13
  },
  "languages": {
    "Python": {
      "format_on_save": "on",
      "preferred_line_length": 100,
      "tab_size": 4
    },
    "JavaScript": { "preferred_line_length": 100 },
    "TypeScript": { "preferred_line_length": 100 },
    "C": { "tab_size": 4 },
    "C++": { "tab_size": 4 }
  }

  // MCP servers (Zed: agent panel → MCP / docs at https://zed.dev/docs/ai/mcp).
  // Key names shift between Zed releases — check the current docs before
  // uncommenting, then restart Zed.
  // "context_servers": {
  //   "fetch": {
  //     "command": "uvx",
  //     "args": ["mcp-server-fetch"]
  //   }
  // }
}

Marimo hello notebook

Save as ~/projects/marimo-hello.py (the Marimo section’s run step).

# /// script
# requires-python = ">=3.12"
# dependencies = ["marimo", "polars"]
# ///
"""Reactive notebook with inline script metadata.

Open it with an ephemeral sandbox (no installs, deps resolved from the
block above):
    marimo edit --sandbox marimo-hello.py

Or install marimo once and open normally:
    uv tool install marimo
    marimo edit marimo-hello.py
"""

import marimo as mo
import polars as pl

app = mo.App()


@app.cell
def _():
    mo.md("# Hello from marimo\nMove the slider — every cell below re-runs.")
    return


@app.cell
def _():
    n = mo.ui.slider(1, 20, value=8, label="Rows")
    n
    return (n,)


@app.cell
def _(n):
    df = pl.DataFrame({"x": range(n.value), "square": [i * i for i in range(n.value)]})
    mo.ui.table(df)
    return


if __name__ == "__main__":
    app.run()

Example Agent Skill — new-python-script

Save as SKILL.md inside a folder named new-python-script (see Agentic standards).

---
name: new-python-script
description: Scaffold a uv inline-metadata Python script with declared dependencies. Use when the user wants a standalone script with third-party packages and no project directory.
---

# New Python Script

Create single-file Python tools with dependencies declared in an inline
metadata block (PEP 723), run via `uv run --script`.

## Steps

1. Ask for the script name and what it does if not already clear.
2. Write `<name>.py` with this header, listing every third-party import:

```python
# /// script
# requires-python = ">=3.12"
# dependencies = ["httpx"]
# ///
```

3. Keep the script dependency-free except for the declared packages.
4. Verify with `uv run --script <name>.py` and show the output.
5. Mention the file runs anywhere uv is installed with no setup step.