Clarify Agentbox names and invariants

Co-authored-by: codegirl007 <codegirl-007@users.noreply.github.com>

.github/workflows/ci.yml

@@ -0,0 +1,59 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [master, main]
+
+jobs:
+  test:
+    name: Engine tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # Ubuntu 24.04 does not ship libsdl3-dev; build/install SDL3 from source (cached).
+      - name: Setup SDL3
+        id: sdl
+        uses: libsdl-org/setup-sdl@main
+        with:
+          version: 3-latest
+          install-linux-dependencies: true
+          add-to-environment: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Export SDL3 paths for the linker
+        run: |
+          PREFIX="${{ steps.sdl.outputs.prefix }}"
+          echo "PKG_CONFIG_PATH=${PREFIX}/lib/pkgconfig:${PKG_CONFIG_PATH:-}" >> "$GITHUB_ENV"
+          echo "LIBRARY_PATH=${PREFIX}/lib:${LIBRARY_PATH:-}" >> "$GITHUB_ENV"
+          echo "LD_LIBRARY_PATH=${PREFIX}/lib:${LD_LIBRARY_PATH:-}" >> "$GITHUB_ENV"
+          echo "C_INCLUDE_PATH=${PREFIX}/include:${C_INCLUDE_PATH:-}" >> "$GITHUB_ENV"
+          # Help some linkers find the shared lib without rpath surprises
+          if [ -d "${PREFIX}/lib" ]; then
+            echo "${PREFIX}/lib" | sudo tee /etc/ld.so.conf.d/sdl3-ci.conf >/dev/null
+            sudo ldconfig
+          fi
+
+      - name: Setup Odin
+        uses: laytan/setup-odin@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          # Match local toolchain: odin version dev-2026-05
+          release: dev-2026-05
+
+      - name: Odin version
+        run: odin version
+
+      # assetbake tests need vendor:stb native libs
+      - name: Build Odin STB libraries
+        run: make -C "$(odin root)/vendor/stb/src"
+
+      - name: Unit tests
+        run: make test
+
+      - name: Typecheck toad example
+        run: make check

.gitignore

@@ -1,2 +1,14 @@
 *.bin
 tutorials/
+
+# Flamegraph / perf profiling artifacts
+tools/FlameGraph/
+perf.data
+perf.data.old
+flame-*.svg
+flame-*.jpg
+flame-*-report.txt
+flame.svg
+flame.jpg
+flame-report.txt
+*_perf

Makefile

@@ -1,14 +1,42 @@
-.PHONY: shaders-vulkan shaders-d3d12 shaders-metal shaders-all toad check test help
+.PHONY: shaders-vulkan shaders-d3d12 shaders-metal shaders-all bake toad hello_sprite crowd crowd_batch crowd_overdraw clip_thrash camera_sandbox clips check test help
+.PHONY: flame flame-build flame-record flame-svg flame-report flame-tools
+
+# Flamegraph profiling (needs: pacman -S perf). Example: make flame  or  make flame FLAME_EXAMPLE=crowd_batch
+FLAME_EXAMPLE ?= crowd
+FLAME_BIN := $(FLAME_EXAMPLE)_perf
+FLAMEGRAPH_DIR ?= tools/FlameGraph
+FLAME_OUT_DIR ?= flame
+# One stamp per `make` invocation so svg/jpg/report share a name.
+ifndef FLAME_STAMP
+FLAME_STAMP := $(shell date +%Y%m%d-%H%M%S)
+endif
+FLAME_PREFIX := $(FLAME_OUT_DIR)/$(FLAME_EXAMPLE)-$(FLAME_STAMP)
 
 help:
 	@echo "Targets:"
-	@echo "  shaders-vulkan  Compile SPIR-V into shaders/vulkan/"
-	@echo "  shaders-d3d12   Compile DXIL into shaders/d3d12/ (needs shadercross)"
-	@echo "  shaders-metal   Compile MSL into shaders/metal/ (needs shadercross)"
-	@echo "  shaders-all     Build all shader backends"
-	@echo "  test            Run engine unit tests"
-	@echo "  check           Typecheck examples/toad"
-	@echo "  toad            Run the toad example"
+	@echo "  bake             Bake all characters under content/characters/"
+	@echo "  shaders-vulkan   Compile SPIR-V into shaders/vulkan/"
+	@echo "  shaders-d3d12    Compile DXIL into shaders/d3d12/ (needs shadercross)"
+	@echo "  shaders-metal    Compile MSL into shaders/metal/ (needs shadercross)"
+	@echo "  shaders-all      Build all shader backends"
+	@echo "  test             Run engine unit tests"
+	@echo "  check            Typecheck all examples"
+	@echo "  toad             Run the toad example (full demo)"
+	@echo "  hello_sprite     Minimal load + draw"
+	@echo "  crowd            Many sprites, one Character_Data"
+	@echo "  crowd_batch      Multi-texture batching stress (two toad loads)"
+	@echo "  crowd_overdraw   Stacked sprites overdraw stress"
+	@echo "  clip_thrash      Per-frame idle/walk clip flip stress"
+	@echo "  camera_sandbox   Pan camera / Space toggles follow"
+	@echo "  clips            Keys 1/2 switch idle/walk"
+	@echo "  flame            Build+record+SVG+JPG+text report (FLAME_EXAMPLE=$(FLAME_EXAMPLE))"
+	@echo "  flame-build      Optimized debug binary ($(FLAME_BIN))"
+	@echo "  flame-record     perf record (play, then quit)"
+	@echo "  flame-svg        Convert perf.data -> $(FLAME_PREFIX).svg/.jpg"
+	@echo "  flame-report     Convert perf.data -> $(FLAME_PREFIX)-report.txt"
+
+bake:
+	./scripts/bake_all.sh
 
 shaders-vulkan:
 	./scripts/shaders_vulkan.sh
@@ -23,9 +51,68 @@ shaders-all: shaders-vulkan shaders-d3d12 shaders-metal
 
 test:
 	odin test engine
+	odin test assetbake
 
 check:
 	odin check examples/toad -collection:pkg=.
+	odin check examples/hello_sprite -collection:pkg=.
+	odin check examples/crowd -collection:pkg=.
+	odin check examples/crowd_batch -collection:pkg=.
+	odin check examples/crowd_overdraw -collection:pkg=.
+	odin check examples/clip_thrash -collection:pkg=.
+	odin check examples/camera_sandbox -collection:pkg=.
+	odin check examples/clips -collection:pkg=.
 
 toad:
 	odin run examples/toad -collection:pkg=.
+
+hello_sprite:
+	odin run examples/hello_sprite -collection:pkg=.
+
+crowd:
+	odin run examples/crowd -collection:pkg=.
+
+crowd_batch:
+	odin run examples/crowd_batch -collection:pkg=.
+
+crowd_overdraw:
+	odin run examples/crowd_overdraw -collection:pkg=.
+
+clip_thrash:
+	odin run examples/clip_thrash -collection:pkg=.
+
+camera_sandbox:
+	odin run examples/camera_sandbox -collection:pkg=.
+
+clips:
+	odin run examples/clips -collection:pkg=.
+
+flame-tools:
+	@if [ ! -x "$(FLAMEGRAPH_DIR)/stackcollapse-perf.pl" ] || [ ! -x "$(FLAMEGRAPH_DIR)/flamegraph.pl" ]; then \
+		echo "Cloning FlameGraph scripts into $(FLAMEGRAPH_DIR)..."; \
+		git clone --depth 1 https://github.com/brendangregg/FlameGraph.git "$(FLAMEGRAPH_DIR)"; \
+	fi
+
+flame-build:
+	odin build examples/$(FLAME_EXAMPLE) -collection:pkg=. -out:$(FLAME_BIN) -debug -o:speed
+
+flame-record: flame-build
+	@echo ">>> Profiling ./$(FLAME_BIN) — play for ~10–20s under load, then quit the window."
+	@echo ">>> If perf fails with permissions: sudo sysctl kernel.perf_event_paranoid=1"
+	perf record -F 99 -g --call-graph dwarf -- ./$(FLAME_BIN)
+
+flame-svg: flame-tools
+	@test -f perf.data || { echo "No perf.data — run: make flame-record"; exit 1; }
+	@mkdir -p "$(FLAME_OUT_DIR)"
+	perf script | "$(FLAMEGRAPH_DIR)/stackcollapse-perf.pl" | "$(FLAMEGRAPH_DIR)/flamegraph.pl" > "$(FLAME_PREFIX).svg"
+	magick "$(FLAME_PREFIX).svg" "$(FLAME_PREFIX).jpg"
+	@echo "Wrote $(FLAME_PREFIX).svg and $(FLAME_PREFIX).jpg"
+
+flame-report:
+	@test -f perf.data || { echo "No perf.data — run: make flame-record"; exit 1; }
+	@mkdir -p "$(FLAME_OUT_DIR)"
+	perf report --stdio --no-children > "$(FLAME_PREFIX)-report.txt"
+	@echo "Wrote $(FLAME_PREFIX)-report.txt"
+
+flame: flame-record flame-svg flame-report
+	@echo "Artifacts: $(FLAME_PREFIX).{svg,jpg} $(FLAME_PREFIX)-report.txt"

agentbox/.gitignore

@@ -0,0 +1,3 @@
+.agentbox/
+/agentbox
+examples/mover/mover

agentbox/Makefile

@@ -0,0 +1,16 @@
+.PHONY: build demo demo-binary phase1 test
+
+build:
+	go build -o agentbox ./cmd/agentbox
+
+demo-binary:
+	./scripts/build_demo.sh
+
+demo: build demo-binary
+	./agentbox run ./examples/mover --task "Launch the application, move the character to the right, and describe what happened."
+
+phase1:
+	go run ./cmd/agentbox phase1
+
+test:
+	go test ./...

agentbox/README.md

@@ -0,0 +1,129 @@
+# Agentbox
+
+This is a local technical spike for a programmable graphical Linux
+environment. It proves that a controller can launch an ordinary GUI process
+headlessly, observe pixels and logs, inject keyboard and mouse input, drive the
+application through a replaceable agent, record a trace, and shut the
+environment down.
+
+The default agent is deterministic and requires no API credentials. One
+optional OpenAI Responses adapter demonstrates screenshot + text model control.
+This is still a local spike, not a cloud control plane or production sandbox.
+See [the architecture decision](docs/architecture.md) for the choices and
+security boundary.
+
+## Requirements
+
+- Linux
+- Go 1.22 or newer
+- Docker Engine with a running daemon
+- permission to use Docker without an interactive `sudo` prompt
+
+No X server, window manager, or C compiler is required on the host; those
+dependencies are built into the container image.
+
+## One-command demo
+
+From this directory:
+
+```sh
+make demo
+```
+
+That one command:
+
+1. builds the `agentbox` CLI and mover executable;
+2. creates a restricted Xvfb/Openbox environment;
+3. stages and launches the executable;
+4. runs the deterministic observe/press/wait/release/observe loop;
+5. records screenshots, actions, decisions, logs, and final status;
+6. stops and removes the environment, including on failure or interruption.
+
+The equivalent explicit commands are:
+
+```sh
+make build demo-binary
+./agentbox run ./examples/mover \
+  --task "Launch the application, move the character to the right, and describe what happened."
+```
+
+Flags can appear before or after the path.
+
+## Run a private executable
+
+Pass a prebuilt Linux executable:
+
+```sh
+./agentbox run ./path/to/application --task "Open the menu and click Settings."
+```
+
+For a directory, add `agentbox.json`:
+
+```json
+{
+  "command": "game",
+  "args": ["--windowed"],
+  "env": {"EXAMPLE": "value"},
+  "window_title": "My Game"
+}
+```
+
+The command is resolved relative to the manifest. The current runtime is
+Debian-based, so dynamically linked executables must have compatible libraries.
+
+## Model agent
+
+The model adapter is opt-in:
+
+```sh
+export OPENAI_API_KEY="..."
+./agentbox run ./path/to/application \
+  --task "Move the character right and report the result." \
+  --agent openai \
+  --model gpt-5
+```
+
+Each request contains the task, current screenshot, previous actions, step
+history, and recent application logs. Strict structured output allows one
+backend-neutral input action or completion. Use `--max-steps` to bound a run.
+The environment itself still has no network access.
+
+## Runs and inspection
+
+```sh
+./agentbox runs
+./agentbox inspect <run-id>
+```
+
+Each run writes:
+
+```text
+.agentbox/runs/<run-id>/
+├── run.json
+├── actions.jsonl
+├── steps.jsonl
+├── screenshots/
+│   ├── 0001.png
+│   └── ...
+├── stdout.log
+└── stderr.log
+```
+
+`run.json` has `schema_version: "1"` plus task, application, agent, timestamps,
+status, and step count. `steps.jsonl` records each observation reference, agent
+message, and action. `actions.jsonl` is a compact action-only stream.
+
+## Original environment proof
+
+The visual centroid test from Phase 1 remains available:
+
+```sh
+make phase1
+```
+
+## Development checks
+
+```sh
+make test
+go vet ./...
+```

agentbox/cmd/agentbox/history_commands.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+
+	"agentbox/internal/trace"
+)
+
+func listRuns() error {
+	projectRoot, err := findProjectRoot()
+	if err != nil {
+		return err
+	}
+	runs, err := trace.List(projectRoot)
+	if err != nil {
+		return err
+	}
+	if len(runs) == 0 {
+		fmt.Println("No recorded runs.")
+		return nil
+	}
+	for _, run := range runs {
+		fmt.Printf("%s  %-8s  %-20s  %s\n",
+			run.ID, run.Status, run.Agent, run.Task)
+	}
+	return nil
+}
+
+func inspect(args []string) error {
+	if len(args) != 1 {
+		return errors.New("inspect requires one run ID")
+	}
+	projectRoot, err := findProjectRoot()
+	if err != nil {
+		return err
+	}
+	runID := args[0]
+	run, err := trace.Read(projectRoot, runID)
+	if err != nil {
+		return err
+	}
+	steps, err := trace.ReadSteps(projectRoot, runID)
+	if err != nil {
+		return err
+	}
+	output := struct {
+		Run       trace.Run          `json:"run"`
+		Steps     []trace.StepRecord `json:"steps"`
+		Directory string             `json:"directory"`
+	}{
+		Run:       run,
+		Steps:     steps,
+		Directory: filepath.Join(projectRoot, ".agentbox", "runs", run.ID),
+	}
+	data, err := json.MarshalIndent(output, "", "  ")
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(data))
+	return nil
+}

agentbox/cmd/agentbox/main.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"agentbox/internal/phase1"
+)
+
+func main() {
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer cancel()
+
+	if len(os.Args) < 2 {
+		usage()
+		os.Exit(2)
+	}
+
+	var err error
+	switch os.Args[1] {
+	case "phase1":
+		err = phase1.Run(ctx)
+	case "run":
+		err = run(ctx, os.Args[2:])
+	case "runs":
+		err = listRuns()
+	case "inspect":
+		err = inspect(os.Args[2:])
+	default:
+		usage()
+		os.Exit(2)
+	}
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "agentbox: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func usage() {
+	fmt.Fprintln(os.Stderr, `usage:
+  agentbox run <path> --task "<task>" [--agent deterministic|openai] [--model <model>]
+  agentbox runs
+  agentbox inspect <run-id>
+  agentbox phase1`)
+}

agentbox/cmd/agentbox/main_test.go

@@ -0,0 +1,17 @@
+package main
+
+import "testing"
+
+func TestParseRunOptionsAllowsFlagsAfterPath(t *testing.T) {
+	options, err := parseRunOptions([]string{
+		"./game", "--task", "move right", "--max-steps=7",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if options.applicationPath != "./game" ||
+		options.task != "move right" ||
+		options.maxSteps != 7 {
+		t.Fatalf("options = %#v", options)
+	}
+}

agentbox/cmd/agentbox/project.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+)
+
+// findProjectRoot lets commands work from any directory inside the Agentbox
+// module. The module declaration is a stronger marker than a directory name.
+func findProjectRoot() (string, error) {
+	currentDirectory, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	for {
+		goModule, readErr := os.ReadFile(filepath.Join(currentDirectory, "go.mod"))
+		if readErr == nil && bytes.Contains(goModule, []byte("module agentbox")) {
+			return currentDirectory, nil
+		}
+		parentDirectory := filepath.Dir(currentDirectory)
+		if parentDirectory == currentDirectory {
+			return "", errors.New("run agentbox from inside its module directory")
+		}
+		currentDirectory = parentDirectory
+	}
+}

agentbox/cmd/agentbox/run_command.go

@@ -0,0 +1,141 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"agentbox/internal/agent"
+	"agentbox/internal/appspec"
+	"agentbox/internal/environment/dockerx11"
+	agentRuntime "agentbox/internal/runtime"
+	"agentbox/internal/trace"
+)
+
+type runOptions struct {
+	applicationPath string
+	task            string
+	agentName       string
+	modelName       string
+	maxSteps        int
+}
+
+func run(ctx context.Context, args []string) error {
+	options, err := parseRunOptions(args)
+	if err != nil {
+		return err
+	}
+	projectRoot, err := findProjectRoot()
+	if err != nil {
+		return err
+	}
+	applicationCommand, err := appspec.Resolve(options.applicationPath)
+	if err != nil {
+		return err
+	}
+	controller, err := newAgent(options)
+	if err != nil {
+		return err
+	}
+	traceStore, err := trace.New(
+		projectRoot,
+		options.task,
+		options.applicationPath,
+		controller.Name(),
+	)
+	if err != nil {
+		return err
+	}
+	desktopEnvironment := dockerx11.New(dockerx11.Config{
+		ProjectRoot: projectRoot,
+		RunID:       traceStore.ID(),
+		Output:      os.Stdout,
+	})
+	err = agentRuntime.Run(ctx, agentRuntime.Config{
+		Task:        options.task,
+		Command:     applicationCommand,
+		Controller:  controller,
+		Environment: desktopEnvironment,
+		TraceStore:  traceStore,
+		MaxSteps:    options.maxSteps,
+		Output:      os.Stdout,
+	})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Run artifacts: %s\n", traceStore.Directory())
+		return err
+	}
+	fmt.Printf("Run artifacts written to:\n%s\n", traceStore.Directory())
+	return nil
+}
+
+// parseRunOptions accepts flags before or after the application path so the CLI
+// matches the natural "agentbox run ./app --task ..." form shown in the docs.
+func parseRunOptions(args []string) (runOptions, error) {
+	options := runOptions{
+		agentName: "deterministic",
+		modelName: "gpt-5",
+		maxSteps:  20,
+	}
+	for index := 0; index < len(args); index++ {
+		argument := args[index]
+		if !strings.HasPrefix(argument, "--") {
+			if options.applicationPath != "" {
+				return options, errors.New("run accepts exactly one application path")
+			}
+			options.applicationPath = argument
+			continue
+		}
+
+		flagName, flagValue, _ := strings.Cut(strings.TrimPrefix(argument, "--"), "=")
+		if flagValue == "" {
+			index++
+			if index >= len(args) {
+				return options, fmt.Errorf("--%s requires a value", flagName)
+			}
+			flagValue = args[index]
+		}
+		switch flagName {
+		case "task":
+			options.task = flagValue
+		case "agent":
+			options.agentName = flagValue
+		case "model":
+			options.modelName = flagValue
+		case "max-steps":
+			maxSteps, err := strconv.Atoi(flagValue)
+			if err != nil || maxSteps < 1 {
+				return options, errors.New("--max-steps must be a positive integer")
+			}
+			options.maxSteps = maxSteps
+		default:
+			return options, fmt.Errorf("unknown flag --%s", flagName)
+		}
+	}
+	if options.applicationPath == "" {
+		return options, errors.New("run requires an application path")
+	}
+	if options.task == "" {
+		return options, errors.New("run requires --task")
+	}
+	return options, nil
+}
+
+func newAgent(options runOptions) (agent.Agent, error) {
+	switch options.agentName {
+	case "deterministic":
+		return &agent.Deterministic{}, nil
+	case "openai":
+		return agent.NewOpenAI(agent.OpenAIConfig{
+			APIKey: os.Getenv("OPENAI_API_KEY"),
+			Model:  options.modelName,
+		})
+	default:
+		return nil, fmt.Errorf(
+			"unknown agent %q (want deterministic or openai)",
+			options.agentName,
+		)
+	}
+}

agentbox/docs/architecture.md

@@ -0,0 +1,290 @@
+# How Agentbox works
+
+This document explains the prototype in simple terms. The exact technical names
+are included in parentheses for readers who want to dig deeper.
+
+## The big idea
+
+Imagine giving a robot its own computer in a locked room.
+
+The robot cannot look inside the program or use secret game controls. It can
+only:
+
+- look at the screen;
+- press and release keyboard keys;
+- move and click the mouse;
+- read messages printed by the program.
+
+Agentbox builds that room, starts the program, lets the robot interact with it,
+and records everything that happened.
+
+## The main parts
+
+Each part has one job:
+
+```text
+You type a command
+        |
+        v
+CLI: understands what you asked for
+        |
+        v
+Runtime: runs the experiment step by step
+       / \
+      v   v
+Environment       Agent
+"the computer"    "the robot"
+      |              |
+      +------v-------+
+             |
+           Trace
+     "the experiment notebook"
+```
+
+- **CLI:** The `agentbox` command you run in a terminal.
+- **Runtime:** The referee. It asks the environment for a screenshot, gives it
+  to the agent, carries out the agent's next action, and repeats.
+- **Environment:** The temporary Linux computer containing the application.
+- **Application:** The game or other interactive program being tested.
+- **Agent:** The decision-maker. It can be a fixed test script or an AI model.
+- **Trace:** The saved screenshots, actions, logs, and final result.
+
+The important rule is that these parts do not cheat by reaching into each
+other. The agent does not know about Docker or X11. The environment does not
+know whether the agent is OpenAI, another model, or a fixed script.
+
+## What happens during one run
+
+When you run:
+
+```sh
+agentbox run ./my-game --task "Move the character right."
+```
+
+Agentbox does this:
+
+1. Creates a fresh temporary room.
+2. Copies the executable into that room.
+3. Starts a pretend monitor inside the room.
+4. Launches the application on that monitor.
+5. Takes a screenshot.
+6. Gives the screenshot, task, recent logs, and earlier actions to the agent.
+7. Receives one action, such as `key_down RIGHT`.
+8. Sends that action to the temporary computer.
+9. Repeats until the agent says it is finished or reaches the step limit.
+10. Saves the experiment and destroys the temporary room.
+
+Stopping on errors is important. Even if the application or agent fails,
+Agentbox still tries to save the logs and remove the environment.
+
+## How the pretend computer works
+
+The temporary room is a **Docker container**. A container is like a lightweight
+box around a group of programs. It keeps files and processes separate enough
+for this experiment, but it is not strong enough to safely hold a determined
+attacker. The security section explains that limitation.
+
+There is no physical monitor in the container, so we use a pretend one:
+
+- **Xvfb** is a screen that exists only in memory. The application thinks it is
+  drawing to a normal 640×480 monitor.
+- **Openbox** acts like a tiny desktop. It puts windows in the right place and
+  decides which window receives keyboard input.
+- **scrot** takes a picture of the pretend monitor and saves it as a PNG.
+- **xdotool** sends ordinary-looking keyboard and mouse events.
+
+The application is not modified to accept special Agentbox commands. From its
+point of view, a person pressed a key or clicked the mouse.
+
+## Why use these old-looking tools?
+
+### Why X11 instead of Wayland?
+
+Linux has two common ways to manage graphical windows: X11 and Wayland.
+
+Wayland is newer and safer for everyday desktops. One of its safety features is
+that programs cannot freely spy on the whole screen or pretend to be the
+keyboard. Those are exactly the powers Agentbox needs, so a headless Wayland
+version would need more complicated, compositor-specific plumbing.
+
+X11 already has small, well-understood tools for this experiment. Because all
+X11 details are hidden behind the `Environment` interface, we can replace this
+backend later without changing the agent.
+
+One X11 screen is used per environment. Programs sharing an X11 screen can
+interfere with each other, so unrelated runs must never share one.
+
+### Why no VNC or browser viewer?
+
+VNC would let a human watch the desktop live. That sounds useful, but the agent
+only needs screenshots and input for now. Adding VNC would mean more servers,
+network ports, and video encoding without proving anything new. It can be added
+later as a viewer without changing how the agent thinks.
+
+### What about a graphics card?
+
+This version draws with the CPU instead of a GPU. That is enough for the simple
+demo and many desktop applications. A demanding 3D game may need a future
+environment that supplies a virtual or real GPU.
+
+### Why is the demo written with Xlib?
+
+The demo uses a tiny C/Xlib program because it has very few dependencies. It
+proves the screen and input path directly. Agentbox is not tied to Xlib: a
+staged application may use Raylib, SDL, Qt, GTK, a browser, or another toolkit
+that can display through X11.
+
+## Why the pieces are kept separate
+
+Think about a toy car with replaceable batteries. The car should not care which
+brand of battery powers it, and the battery should not need to know where the
+car is driving.
+
+Agentbox follows the same idea:
+
+- The **Environment interface** is a remote control for a computer:
+  `Start`, `Launch`, `Screenshot`, `SendInput`, `Logs`, and `Stop`.
+- The **Agent interface** receives an observation and chooses the next action.
+- The **Runtime** connects the two interfaces.
+
+This lets us swap parts independently:
+
+- Docker today could become a microVM or cloud machine later.
+- X11 today could become a Wayland or GPU backend later.
+- The fixed test agent could become OpenAI, Claude, Gemini, or a local model.
+- The mover game could become a browser, drawing program, or other application.
+
+Only `internal/environment/dockerx11` knows the current Linux tricks. Model
+code never imports that package.
+
+## The two current agents
+
+### Deterministic agent
+
+This is a fixed test script:
+
+1. Look at the first screenshot.
+2. Hold the RIGHT key.
+3. Wait one second.
+4. Check another screenshot.
+5. Fail unless the green square moved at least 100 pixels.
+6. Release the key and finish.
+
+It is intentionally specific to the demo. Its purpose is to test the whole
+system without paying for or depending on a model API.
+
+### OpenAI adapter
+
+This optional adapter sends the model:
+
+- the user's task;
+- the current screenshot;
+- earlier actions;
+- recent application logs;
+- a short history of the run.
+
+The model must return a small JSON object containing either one allowed action
+or `done`. It cannot directly call Docker or run shell commands. The adapter is
+one example, not a giant framework for every model company.
+
+## How an application gets inside
+
+`agentbox run` accepts a prebuilt Linux executable.
+
+If the given path is a directory, an `agentbox.json` file says which executable
+to run, what arguments to pass, which environment variables to set, and
+optionally which window title to wait for.
+
+Agentbox streams the executable into temporary memory inside the container. It
+does not share the developer's whole folder with the container. The temporary
+copy disappears when the run ends.
+
+There is one practical limit: the executable and its libraries must work in the
+Debian-based runtime image. Agentbox does not yet package missing libraries or
+convert Windows and macOS programs.
+
+## What gets recorded
+
+The trace is an experiment notebook:
+
+- `run.json` says what ran, which agent controlled it, and whether it finished;
+- `steps.jsonl` records every observation, decision, and action in order;
+- `actions.jsonl` is a smaller action-only list;
+- `screenshots/` contains the pictures the agent saw;
+- `stdout.log` and `stderr.log` contain application messages.
+
+The trace format has a version number. Screenshots are separate files instead
+of giant blobs inside JSON. This keeps traces easy to inspect and leaves room
+for replay, comparisons, tests, or training data later.
+
+## Is the container safe?
+
+Not safe enough for strangers' programs.
+
+Docker is more like a locked bedroom than a bank vault. It keeps ordinary
+programs apart, but every container still shares the host's Linux kernel. A
+serious kernel or Docker bug might let a hostile program break out.
+
+This prototype adds useful guardrails:
+
+- no network access inside the environment;
+- a read-only main filesystem;
+- a small, temporary writable area;
+- an unprivileged user;
+- no extra Linux capabilities;
+- limits on CPU, memory, and process count;
+- automatic destruction after the run.
+
+These rules reduce accidents. They do not make Docker a trustworthy boundary
+for arbitrary customer code. Do not use this prototype to run unknown binaries
+on an important machine or a machine shared by multiple customers.
+
+## What production would need
+
+Before accepting untrusted uploads, the room needs walls built with hardware
+virtualization. A small virtual machine, such as Firecracker or Kata
+Containers, gives each run its own kernel. gVisor may be another option when it
+supports the applications we need.
+
+A real service would also need to:
+
+- build uploaded programs away from runtime hosts;
+- limit upload size, expanded file size, disk use, runtime, and network access;
+- keep every customer's files, logs, secrets, and encryption keys separate;
+- authenticate every control request;
+- patch and replace base images regularly;
+- monitor hosts and destroy every machine after its run.
+
+## What this experiment proves
+
+It proves the interaction model:
+
+1. launch a normal graphical Linux application without a physical monitor;
+2. observe it through screenshots and logs;
+3. control it with keyboard and mouse actions;
+4. keep the environment and agent replaceable;
+5. save enough information to understand what happened;
+6. shut everything down cleanly.
+
+It does **not** prove production security, GPU game support, cloud scaling,
+Windows/macOS support, billing, or authentication.
+
+## Small glossary
+
+- **Container:** A lightweight box around processes and files.
+- **Backend:** One implementation hidden behind a common interface.
+- **X11:** A Linux system for drawing windows and handling input.
+- **Headless:** Running without a physical monitor.
+- **Synthetic input:** Keyboard or mouse events created by software.
+- **Trace:** The saved record of a run.
+- **Kernel:** The deepest part of the operating system that controls hardware
+  and processes.
+- **MicroVM:** A small virtual machine with its own kernel.
+
+## Sources
+
+- [X.Org Xvfb manual](https://www.x.org/releases/X11R7.6/doc/man/man1/Xvfb.1.xhtml)
+- [xdotool project and XTEST behavior](https://github.com/jordansissel/xdotool)
+- [Docker Engine security](https://docs.docker.com/engine/security/)
+- [gVisor security model](https://gvisor.dev/docs/architecture_guide/security/)
+- [Firecracker design](https://firecracker-microvm.github.io/)

agentbox/environment/Dockerfile

@@ -0,0 +1,31 @@
+FROM debian:bookworm-slim AS builder
+
+RUN apt-get update \
+    && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+        build-essential \
+        libx11-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY examples/mover/main.c /src/main.c
+RUN cc -std=c11 -O2 -Wall -Wextra -Werror /src/main.c -lX11 -o /mover
+
+FROM debian:bookworm-slim
+
+RUN apt-get update \
+    && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+        libx11-6 \
+        openbox \
+        scrot \
+        x11-utils \
+        xdotool \
+        xvfb \
+    && rm -rf /var/lib/apt/lists/* \
+    && useradd --create-home --uid 10001 agentbox
+
+COPY --from=builder /mover /opt/agentbox/mover
+COPY environment/entrypoint.sh /opt/agentbox/entrypoint.sh
+RUN chmod 0755 /opt/agentbox/entrypoint.sh /opt/agentbox/mover
+
+USER agentbox
+ENV DISPLAY=:99
+ENTRYPOINT ["/opt/agentbox/entrypoint.sh"]

agentbox/environment/entrypoint.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+set -eu
+
+export HOME=/tmp/home
+export XDG_RUNTIME_DIR=/tmp/runtime
+mkdir -p "$HOME" "$XDG_RUNTIME_DIR"
+chmod 0700 "$XDG_RUNTIME_DIR"
+
+cleanup() {
+    rm -f /tmp/agentbox-ready
+    kill "${OPENBOX_PID:-}" "${XVFB_PID:-}" 2>/dev/null || true
+    wait "${OPENBOX_PID:-}" "${XVFB_PID:-}" 2>/dev/null || true
+}
+
+terminate() {
+    trap - EXIT INT TERM
+    cleanup
+    exit 0
+}
+
+trap cleanup EXIT
+trap terminate INT TERM
+
+Xvfb "$DISPLAY" -screen 0 640x480x24 -nolisten tcp -noreset &
+XVFB_PID=$!
+
+attempt=0
+until xdpyinfo -display "$DISPLAY" >/dev/null 2>&1; do
+    attempt=$((attempt + 1))
+    if [ "$attempt" -ge 100 ]; then
+        echo "Xvfb did not become ready" >&2
+        exit 1
+    fi
+    sleep 0.05
+done
+
+openbox --sm-disable >/tmp/openbox.log 2>&1 &
+OPENBOX_PID=$!
+
+attempt=0
+while :; do
+    wm_info=$(xprop -root _NET_SUPPORTING_WM_CHECK 2>/dev/null || true)
+    case "$wm_info" in
+        *"window id #"*) break ;;
+    esac
+    if ! kill -0 "$OPENBOX_PID" 2>/dev/null; then
+        echo "Openbox exited before becoming ready" >&2
+        exit 1
+    fi
+    attempt=$((attempt + 1))
+    if [ "$attempt" -ge 100 ]; then
+        echo "Openbox did not become ready" >&2
+        exit 1
+    fi
+    sleep 0.05
+done
+
+touch /tmp/agentbox-ready
+
+while :; do
+    sleep 3600 &
+    wait $!
+done

agentbox/examples/mover/agentbox.json

@@ -0,0 +1,4 @@
+{
+  "command": "mover",
+  "window_title": "Agentbox Mover"
+}

agentbox/examples/mover/main.c

@@ -0,0 +1,136 @@
+#define _POSIX_C_SOURCE 199309L
+
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+enum {
+    WINDOW_WIDTH = 640,
+    WINDOW_HEIGHT = 480,
+    SQUARE_SIZE = 50,
+};
+
+static double monotonic_seconds(void) {
+    struct timespec now;
+    if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
+        perror("clock_gettime");
+        exit(1);
+    }
+    return (double)now.tv_sec + (double)now.tv_nsec / 1000000000.0;
+}
+
+static void set_key_state(KeySym key, bool down, bool *left, bool *right,
+                          bool *up, bool *down_key) {
+    switch (key) {
+    case XK_Left:
+        *left = down;
+        break;
+    case XK_Right:
+        *right = down;
+        break;
+    case XK_Up:
+        *up = down;
+        break;
+    case XK_Down:
+        *down_key = down;
+        break;
+    default:
+        break;
+    }
+}
+
+int main(void) {
+    setvbuf(stdout, NULL, _IOLBF, 0);
+
+    Display *display = XOpenDisplay(NULL);
+    if (display == NULL) {
+        fputs("unable to open X display\n", stderr);
+        return 1;
+    }
+
+    int screen = DefaultScreen(display);
+    Window window = XCreateSimpleWindow(
+        display, RootWindow(display, screen), 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT,
+        0, BlackPixel(display, screen), BlackPixel(display, screen));
+    XStoreName(display, window, "Agentbox Mover");
+    XSelectInput(display, window,
+                 ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask);
+    XMapWindow(display, window);
+
+    GC gc = XCreateGC(display, window, 0, NULL);
+    Colormap colors = DefaultColormap(display, screen);
+    XColor green;
+    XColor red;
+    if (!XParseColor(display, colors, "#00ff66", &green) ||
+        !XAllocColor(display, colors, &green) ||
+        !XParseColor(display, colors, "#ff3355", &red) ||
+        !XAllocColor(display, colors, &red)) {
+        fputs("unable to allocate colors\n", stderr);
+        XCloseDisplay(display);
+        return 1;
+    }
+
+    double x = (WINDOW_WIDTH - SQUARE_SIZE) / 2.0;
+    double y = (WINDOW_HEIGHT - SQUARE_SIZE) / 2.0;
+    bool left = false;
+    bool right = false;
+    bool up = false;
+    bool down = false;
+    bool marker_visible = false;
+    int marker_x = 0;
+    int marker_y = 0;
+    double previous = monotonic_seconds();
+
+    printf("mover started at x=%.1f y=%.1f\n", x, y);
+
+    for (;;) {
+        while (XPending(display) > 0) {
+            XEvent event;
+            XNextEvent(display, &event);
+            if (event.type == KeyPress || event.type == KeyRelease) {
+                set_key_state(XLookupKeysym(&event.xkey, 0),
+                              event.type == KeyPress, &left, &right, &up, &down);
+            } else if (event.type == ButtonPress) {
+                marker_visible = true;
+                marker_x = event.xbutton.x;
+                marker_y = event.xbutton.y;
+                printf("mouse click at x=%d y=%d\n", marker_x, marker_y);
+            }
+        }
+
+        double now = monotonic_seconds();
+        double delta = now - previous;
+        previous = now;
+        const double speed = 180.0;
+        x += ((right ? 1.0 : 0.0) - (left ? 1.0 : 0.0)) * speed * delta;
+        y += ((down ? 1.0 : 0.0) - (up ? 1.0 : 0.0)) * speed * delta;
+
+        if (x < 0.0) {
+            x = 0.0;
+        } else if (x > WINDOW_WIDTH - SQUARE_SIZE) {
+            x = WINDOW_WIDTH - SQUARE_SIZE;
+        }
+        if (y < 0.0) {
+            y = 0.0;
+        } else if (y > WINDOW_HEIGHT - SQUARE_SIZE) {
+            y = WINDOW_HEIGHT - SQUARE_SIZE;
+        }
+
+        XClearWindow(display, window);
+        XSetForeground(display, gc, green.pixel);
+        XFillRectangle(display, window, gc, (int)x, (int)y, SQUARE_SIZE,
+                       SQUARE_SIZE);
+        if (marker_visible) {
+            XSetForeground(display, gc, red.pixel);
+            XFillRectangle(display, window, gc, marker_x - 4, marker_y - 4, 9,
+                           9);
+        }
+        XFlush(display);
+
+        struct timespec frame = {.tv_sec = 0, .tv_nsec = 16000000};
+        nanosleep(&frame, NULL);
+    }
+}

agentbox/go.mod

@@ -0,0 +1,3 @@
+module agentbox
+
+go 1.22

agentbox/internal/agent/agent.go

@@ -0,0 +1,42 @@
+package agent
+
+import (
+	"context"
+	"time"
+
+	"agentbox/internal/environment"
+)
+
+type Observation struct {
+	Screenshot      []byte
+	Timestamp       time.Time
+	Logs            []environment.LogEntry
+	PreviousActions []environment.InputAction
+}
+
+// Step is the compact history passed back to an agent on its next decision.
+type Step struct {
+	Number         int
+	Timestamp      time.Time
+	ScreenshotPath string
+	Message        string
+	Action         *environment.InputAction
+}
+
+// Decision contains either one action or Done. Returning neither is invalid.
+type Decision struct {
+	Reason string
+	Action *environment.InputAction
+	Done   bool
+}
+
+// Agent chooses one backend-neutral action from the latest observation.
+type Agent interface {
+	Name() string
+	NextAction(
+		ctx context.Context,
+		task string,
+		history []Step,
+		observation Observation,
+	) (Decision, error)
+}

agentbox/internal/agent/deterministic.go

@@ -0,0 +1,93 @@
+package agent
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"image/png"
+
+	"agentbox/internal/environment"
+)
+
+type Deterministic struct {
+	nextStep           int
+	initialSquareX     float64
+	hasInitialPosition bool
+}
+
+func (deterministicAgent *Deterministic) Name() string {
+	return "deterministic-right"
+}
+
+func (deterministicAgent *Deterministic) NextAction(
+	_ context.Context,
+	_ string,
+	_ []Step,
+	observation Observation,
+) (Decision, error) {
+	var decision Decision
+	switch deterministicAgent.nextStep {
+	case 0:
+		initialSquareX, err := greenCentroidX(observation.Screenshot)
+		if err != nil {
+			return Decision{}, fmt.Errorf("inspect initial screenshot: %w", err)
+		}
+		deterministicAgent.initialSquareX = initialSquareX
+		deterministicAgent.hasInitialPosition = true
+		action := environment.InputAction{Type: environment.KeyDown, Key: "RIGHT"}
+		decision = Decision{Reason: "Press RIGHT to start moving.", Action: &action}
+	case 1:
+		action := environment.InputAction{Type: environment.Wait, DurationMS: 1000}
+		decision = Decision{Reason: "Keep RIGHT held for one second.", Action: &action}
+	case 2:
+		currentSquareX, err := greenCentroidX(observation.Screenshot)
+		if err != nil {
+			return Decision{}, fmt.Errorf("inspect moved screenshot: %w", err)
+		}
+		distanceMoved := currentSquareX - deterministicAgent.initialSquareX
+		if !deterministicAgent.hasInitialPosition || distanceMoved < 100 {
+			return Decision{}, fmt.Errorf(
+				"visual verification failed: square moved %.1f pixels right, want at least 100",
+				distanceMoved,
+			)
+		}
+		action := environment.InputAction{Type: environment.KeyUp, Key: "RIGHT"}
+		decision = Decision{
+			Reason: fmt.Sprintf(
+				"The square moved %.1f pixels right; release RIGHT.",
+				distanceMoved,
+			),
+			Action: &action,
+		}
+	default:
+		decision = Decision{Reason: "The movement sequence is complete.", Done: true}
+	}
+	deterministicAgent.nextStep++
+	return decision, nil
+}
+
+func greenCentroidX(screenshot []byte) (float64, error) {
+	renderedImage, err := png.Decode(bytes.NewReader(screenshot))
+	if err != nil {
+		return 0, err
+	}
+	var xCoordinateSum, greenPixelCount uint64
+	bounds := renderedImage.Bounds()
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			red, green, blue, _ := renderedImage.At(x, y).RGBA()
+			// Match the mover's #00ff66 square. Requiring 1,000 matching pixels
+			// prevents a small green UI detail from passing verification.
+			if green > 0xc000 && red < 0x4000 && blue < 0x8000 {
+				xCoordinateSum += uint64(x)
+				greenPixelCount++
+			}
+		}
+	}
+	if greenPixelCount < 1000 {
+		return 0, fmt.Errorf("found only %d green square pixels", greenPixelCount)
+	}
+	return float64(xCoordinateSum) / float64(greenPixelCount), nil
+}
+
+var _ Agent = (*Deterministic)(nil)

agentbox/internal/agent/deterministic_test.go

@@ -0,0 +1,75 @@
+package agent
+
+import (
+	"bytes"
+	"context"
+	"image"
+	"image/color"
+	"image/png"
+	"testing"
+
+	"agentbox/internal/environment"
+)
+
+func TestDeterministicSequence(t *testing.T) {
+	controller := &Deterministic{}
+	want := []struct {
+		action environment.InputType
+		done   bool
+	}{
+		{environment.KeyDown, false},
+		{environment.Wait, false},
+		{environment.KeyUp, false},
+		{"", true},
+	}
+	for index, expected := range want {
+		x := 20
+		if index >= 2 {
+			x = 140
+		}
+		decision, err := controller.NextAction(context.Background(), "", nil, Observation{
+			Screenshot: screenshotWithSquare(t, x),
+		})
+		if err != nil {
+			t.Fatalf("step %d: %v", index, err)
+		}
+		if decision.Done != expected.done {
+			t.Fatalf("step %d done = %v, want %v", index, decision.Done, expected.done)
+		}
+		if expected.action != "" && (decision.Action == nil || decision.Action.Type != expected.action) {
+			t.Fatalf("step %d action = %#v, want %s", index, decision.Action, expected.action)
+		}
+	}
+}
+
+func TestDeterministicRejectsMissingMovement(t *testing.T) {
+	controller := &Deterministic{}
+	for step := 0; step < 2; step++ {
+		if _, err := controller.NextAction(context.Background(), "", nil, Observation{
+			Screenshot: screenshotWithSquare(t, 20),
+		}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if _, err := controller.NextAction(context.Background(), "", nil, Observation{
+		Screenshot: screenshotWithSquare(t, 20),
+	}); err == nil {
+		t.Fatal("movement verification error = nil")
+	}
+}
+
+func screenshotWithSquare(t *testing.T, startX int) []byte {
+	t.Helper()
+	img := image.NewRGBA(image.Rect(0, 0, 240, 100))
+	green := color.RGBA{G: 255, B: 102, A: 255}
+	for y := 20; y < 60; y++ {
+		for x := startX; x < startX+40; x++ {
+			img.Set(x, y, green)
+		}
+	}
+	var output bytes.Buffer
+	if err := png.Encode(&output, img); err != nil {
+		t.Fatal(err)
+	}
+	return output.Bytes()
+}

agentbox/internal/agent/openai.go

@@ -0,0 +1,98 @@
+package agent
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type OpenAIConfig struct {
+	APIKey  string
+	Model   string
+	BaseURL string
+	Client  *http.Client
+}
+
+// OpenAI adapts the Responses API to Agentbox's provider-neutral Agent
+// contract. HTTP and wire-format details do not leak into the runtime.
+type OpenAI struct {
+	config OpenAIConfig
+}
+
+func NewOpenAI(config OpenAIConfig) (*OpenAI, error) {
+	if config.APIKey == "" {
+		return nil, errors.New("OPENAI_API_KEY is required for --agent openai")
+	}
+	if config.Model == "" {
+		config.Model = "gpt-5"
+	}
+	if config.BaseURL == "" {
+		config.BaseURL = "https://api.openai.com/v1"
+	}
+	if config.Client == nil {
+		config.Client = &http.Client{Timeout: 90 * time.Second}
+	}
+	return &OpenAI{config: config}, nil
+}
+
+func (openAI *OpenAI) Name() string {
+	return "openai:" + openAI.config.Model
+}
+
+func (openAI *OpenAI) NextAction(
+	ctx context.Context,
+	task string,
+	history []Step,
+	observation Observation,
+) (Decision, error) {
+	requestBody, err := buildResponsesRequest(
+		openAI.config.Model,
+		task,
+		history,
+		observation,
+	)
+	if err != nil {
+		return Decision{}, err
+	}
+	request, err := http.NewRequestWithContext(
+		ctx,
+		http.MethodPost,
+		strings.TrimRight(openAI.config.BaseURL, "/")+"/responses",
+		bytes.NewReader(requestBody),
+	)
+	if err != nil {
+		return Decision{}, err
+	}
+	request.Header.Set("Authorization", "Bearer "+openAI.config.APIKey)
+	request.Header.Set("Content-Type", "application/json")
+
+	httpResponse, err := openAI.config.Client.Do(request)
+	if err != nil {
+		return Decision{}, err
+	}
+	defer httpResponse.Body.Close()
+
+	responseBody, err := io.ReadAll(io.LimitReader(httpResponse.Body, 4<<20))
+	if err != nil {
+		return Decision{}, err
+	}
+	if httpResponse.StatusCode < 200 || httpResponse.StatusCode >= 300 {
+		return Decision{}, fmt.Errorf(
+			"OpenAI response %s: %s",
+			httpResponse.Status,
+			strings.TrimSpace(string(responseBody)),
+		)
+	}
+	outputText, err := extractResponseText(responseBody)
+	if err != nil {
+		return Decision{}, err
+	}
+	return parseModelDecision(outputText)
+}
+
+var _ Agent = (*OpenAI)(nil)

agentbox/internal/agent/openai_protocol.go

@@ -0,0 +1,206 @@
+package agent
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"agentbox/internal/environment"
+)
+
+type responsesRequest struct {
+	Model string                `json:"model"`
+	Input []responsesInput      `json:"input"`
+	Text  responsesTextSettings `json:"text"`
+}
+
+type responsesInput struct {
+	Role    string             `json:"role"`
+	Content []responsesContent `json:"content"`
+}
+
+type responsesContent struct {
+	Type     string `json:"type"`
+	Text     string `json:"text,omitempty"`
+	ImageURL string `json:"image_url,omitempty"`
+}
+
+type responsesTextSettings struct {
+	Format responsesFormat `json:"format"`
+}
+
+type responsesFormat struct {
+	Type   string         `json:"type"`
+	Name   string         `json:"name"`
+	Strict bool           `json:"strict"`
+	Schema map[string]any `json:"schema"`
+}
+
+func buildResponsesRequest(
+	model string,
+	task string,
+	history []Step,
+	observation Observation,
+) ([]byte, error) {
+	prompt, err := modelPrompt(task, history, observation)
+	if err != nil {
+		return nil, err
+	}
+	request := responsesRequest{
+		Model: model,
+		Input: []responsesInput{{
+			Role: "user",
+			Content: []responsesContent{
+				{Type: "input_text", Text: prompt},
+				{
+					Type: "input_image",
+					ImageURL: "data:image/png;base64," +
+						base64.StdEncoding.EncodeToString(observation.Screenshot),
+				},
+			},
+		}},
+		Text: responsesTextSettings{Format: responsesFormat{
+			Type:   "json_schema",
+			Name:   "agentbox_action",
+			Strict: true,
+			Schema: decisionSchema(),
+		}},
+	}
+	return json.Marshal(request)
+}
+
+func modelPrompt(task string, history []Step, observation Observation) (string, error) {
+	contextData := struct {
+		Task            string                    `json:"task"`
+		History         []Step                    `json:"history"`
+		RecentLogs      []environment.LogEntry    `json:"recent_logs"`
+		PreviousActions []environment.InputAction `json:"previous_actions"`
+	}{
+		Task:            task,
+		History:         history,
+		RecentLogs:      observation.Logs,
+		PreviousActions: observation.PreviousActions,
+	}
+	data, err := json.Marshal(contextData)
+	if err != nil {
+		return "", err
+	}
+	return "You control an interactive Linux application from screenshots. " +
+		"Choose exactly one allowed input action, or mark done when the task is complete. " +
+		"Use logical key names such as RIGHT, ENTER, or ESCAPE. Keep waits under 5000 ms.\n" +
+		string(data), nil
+}
+
+func decisionSchema() map[string]any {
+	// Strict structured output requires every action property to be present,
+	// even when a particular action ignores most of them.
+	actionProperties := map[string]any{
+		"type": map[string]any{
+			"type": "string",
+			"enum": []string{
+				string(environment.KeyDown), string(environment.KeyUp),
+				string(environment.MouseMove), string(environment.MouseDown),
+				string(environment.MouseUp), string(environment.Wait),
+			},
+		},
+		"key":         map[string]any{"type": "string"},
+		"x":           map[string]any{"type": "integer"},
+		"y":           map[string]any{"type": "integer"},
+		"button":      map[string]any{"type": "integer"},
+		"duration_ms": map[string]any{"type": "integer"},
+	}
+	return map[string]any{
+		"type":                 "object",
+		"additionalProperties": false,
+		"properties": map[string]any{
+			"reason": map[string]any{"type": "string"},
+			"done":   map[string]any{"type": "boolean"},
+			"action": map[string]any{
+				"anyOf": []any{
+					map[string]any{
+						"type":                 "object",
+						"additionalProperties": false,
+						"properties":           actionProperties,
+						"required": []string{
+							"type", "key", "x", "y", "button", "duration_ms",
+						},
+					},
+					map[string]any{"type": "null"},
+				},
+			},
+		},
+		"required": []string{"reason", "done", "action"},
+	}
+}
+
+func extractResponseText(data []byte) (string, error) {
+	var response struct {
+		Output []struct {
+			Content []struct {
+				Type string `json:"type"`
+				Text string `json:"text"`
+			} `json:"content"`
+		} `json:"output"`
+	}
+	if err := json.Unmarshal(data, &response); err != nil {
+		return "", fmt.Errorf("decode OpenAI response: %w", err)
+	}
+	for _, output := range response.Output {
+		for _, content := range output.Content {
+			if content.Type == "output_text" && content.Text != "" {
+				return content.Text, nil
+			}
+		}
+	}
+	return "", errors.New("OpenAI response contained no output_text")
+}
+
+type modelDecision struct {
+	Reason string       `json:"reason"`
+	Done   bool         `json:"done"`
+	Action *modelAction `json:"action"`
+}
+
+type modelAction struct {
+	Type       environment.InputType `json:"type"`
+	Key        string                `json:"key"`
+	X          int                   `json:"x"`
+	Y          int                   `json:"y"`
+	Button     int                   `json:"button"`
+	DurationMS int                   `json:"duration_ms"`
+}
+
+func parseModelDecision(text string) (Decision, error) {
+	var modelOutput modelDecision
+	if err := json.Unmarshal([]byte(text), &modelOutput); err != nil {
+		return Decision{}, fmt.Errorf("decode model decision: %w", err)
+	}
+	if modelOutput.Reason == "" {
+		return Decision{}, errors.New("model decision requires reason")
+	}
+	if modelOutput.Done {
+		return Decision{Reason: modelOutput.Reason, Done: true}, nil
+	}
+	if modelOutput.Action == nil {
+		return Decision{}, errors.New("model decision requires action when not done")
+	}
+	if modelOutput.Action.DurationMS < 0 || modelOutput.Action.DurationMS > 5000 {
+		return Decision{}, errors.New("model wait must be between 0 and 5000 ms")
+	}
+	action := environment.InputAction{
+		Type:       modelOutput.Action.Type,
+		Key:        modelOutput.Action.Key,
+		X:          modelOutput.Action.X,
+		Y:          modelOutput.Action.Y,
+		Button:     modelOutput.Action.Button,
+		DurationMS: modelOutput.Action.DurationMS,
+	}
+	switch action.Type {
+	case environment.KeyDown, environment.KeyUp, environment.MouseMove,
+		environment.MouseDown, environment.MouseUp, environment.Wait:
+	default:
+		return Decision{}, fmt.Errorf("model returned unsupported action %q", action.Type)
+	}
+	return Decision{Reason: modelOutput.Reason, Action: &action}, nil
+}

agentbox/internal/agent/openai_test.go

@@ -0,0 +1,59 @@
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"agentbox/internal/environment"
+)
+
+func TestOpenAISendsScreenshotAndParsesDecision(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
+		if request.URL.Path != "/responses" {
+			t.Errorf("path = %q, want /responses", request.URL.Path)
+		}
+		if request.Header.Get("Authorization") != "Bearer test-key" {
+			t.Errorf("missing bearer token")
+		}
+		body, err := io.ReadAll(request.Body)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(string(body), "data:image/png;base64,AQID") {
+			t.Errorf("request does not contain screenshot data URL: %s", body)
+		}
+		response.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(response, `{
+			"output":[{"content":[{"type":"output_text","text":"{\"reason\":\"move right\",\"done\":false,\"action\":{\"type\":\"key_down\",\"key\":\"RIGHT\",\"x\":0,\"y\":0,\"button\":0,\"duration_ms\":0}}"}]}]
+		}`)
+	}))
+	defer server.Close()
+
+	controller, err := NewOpenAI(OpenAIConfig{
+		APIKey: "test-key", Model: "test-model", BaseURL: server.URL, Client: server.Client(),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	decision, err := controller.NextAction(context.Background(), "move", nil, Observation{
+		Screenshot: []byte{1, 2, 3},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if decision.Action == nil || decision.Action.Type != environment.KeyDown ||
+		decision.Action.Key != "RIGHT" {
+		t.Fatalf("decision = %#v", decision)
+	}
+}
+
+func TestDecisionSchemaIsJSONSerializable(t *testing.T) {
+	if _, err := json.Marshal(decisionSchema()); err != nil {
+		t.Fatal(err)
+	}
+}

agentbox/internal/appspec/appspec.go

@@ -0,0 +1,66 @@
+package appspec
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"agentbox/internal/environment"
+)
+
+type manifest struct {
+	Command              string            `json:"command"`
+	Args                 []string          `json:"args"`
+	EnvironmentVariables map[string]string `json:"env"`
+	WindowTitle          string            `json:"window_title"`
+}
+
+// Resolve turns either an executable path or a directory containing
+// agentbox.json into the backend-neutral launch command.
+func Resolve(path string) (environment.Command, error) {
+	absolute, err := filepath.Abs(path)
+	if err != nil {
+		return environment.Command{}, fmt.Errorf("resolve application path: %w", err)
+	}
+	info, err := os.Stat(absolute)
+	if err != nil {
+		return environment.Command{}, fmt.Errorf("inspect application path: %w", err)
+	}
+	if !info.IsDir() {
+		if !info.Mode().IsRegular() {
+			return environment.Command{}, errors.New("application must be a regular executable file")
+		}
+		return environment.Command{Path: absolute}, nil
+	}
+
+	data, err := os.ReadFile(filepath.Join(absolute, "agentbox.json"))
+	if err != nil {
+		return environment.Command{}, fmt.Errorf("read directory manifest agentbox.json: %w", err)
+	}
+	var config manifest
+	if err := json.Unmarshal(data, &config); err != nil {
+		return environment.Command{}, fmt.Errorf("parse agentbox.json: %w", err)
+	}
+	if config.Command == "" {
+		return environment.Command{}, errors.New("agentbox.json requires command")
+	}
+	commandPath := config.Command
+	if !filepath.IsAbs(commandPath) {
+		commandPath = filepath.Join(absolute, commandPath)
+	}
+	commandInfo, err := os.Stat(commandPath)
+	if err != nil {
+		return environment.Command{}, fmt.Errorf("inspect manifest command: %w", err)
+	}
+	if !commandInfo.Mode().IsRegular() {
+		return environment.Command{}, errors.New("manifest command must be a regular executable file")
+	}
+	return environment.Command{
+		Path:                 commandPath,
+		Args:                 config.Args,
+		EnvironmentVariables: config.EnvironmentVariables,
+		WindowTitle:          config.WindowTitle,
+	}, nil
+}

agentbox/internal/appspec/appspec_test.go

@@ -0,0 +1,28 @@
+package appspec
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveDirectoryManifest(t *testing.T) {
+	directory := t.TempDir()
+	executable := filepath.Join(directory, "game")
+	if err := os.WriteFile(executable, []byte("binary"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	manifest := `{"command":"game","args":["--demo"],"window_title":"Demo"}`
+	if err := os.WriteFile(filepath.Join(directory, "agentbox.json"), []byte(manifest), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	command, err := Resolve(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if command.Path != executable || command.WindowTitle != "Demo" ||
+		len(command.Args) != 1 || command.Args[0] != "--demo" {
+		t.Fatalf("command = %#v", command)
+	}
+}

agentbox/internal/environment/dockerx11/application.go

@@ -0,0 +1,175 @@
+package dockerx11
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"agentbox/internal/environment"
+)
+
+const stagedApplicationPath = "/tmp/application"
+
+func (environmentBackend *Environment) Launch(
+	ctx context.Context,
+	application environment.Command,
+) error {
+	fmt.Fprintln(environmentBackend.config.Output, "Staging application...")
+	executable, err := os.Open(application.Path)
+	if err != nil {
+		return fmt.Errorf("open application: %w", err)
+	}
+	defer executable.Close()
+
+	// Stream instead of bind-mounting the developer's directory. The container
+	// sees only the requested executable, and the copy disappears at teardown.
+	stageCommand := exec.CommandContext(
+		ctx,
+		"docker",
+		"exec",
+		"-i",
+		environmentBackend.containerName,
+		"sh",
+		"-c",
+		"cat > "+stagedApplicationPath+" && chmod 0500 "+stagedApplicationPath,
+	)
+	stageCommand.Stdin = executable
+	if output, err := stageCommand.CombinedOutput(); err != nil {
+		return fmt.Errorf(
+			"stage application: %w: %s",
+			err,
+			strings.TrimSpace(string(output)),
+		)
+	}
+
+	fmt.Fprintln(environmentBackend.config.Output, "Launching application...")
+	dockerArguments := []string{"exec", "-d"}
+	for variableName, variableValue := range application.EnvironmentVariables {
+		dockerArguments = append(
+			dockerArguments,
+			"-e",
+			variableName+"="+variableValue,
+		)
+	}
+	dockerArguments = append(
+		dockerArguments,
+		environmentBackend.containerName,
+		"sh",
+		"-c",
+	)
+	shellCommand := []string{"exec", stagedApplicationPath}
+	for _, applicationArgument := range application.Args {
+		shellCommand = append(shellCommand, shellQuote(applicationArgument))
+	}
+	shellCommand = append(
+		shellCommand,
+		">/tmp/stdout.log",
+		"2>/tmp/stderr.log",
+	)
+	dockerArguments = append(dockerArguments, strings.Join(shellCommand, " "))
+	if _, err := environmentBackend.runDocker(ctx, dockerArguments...); err != nil {
+		return fmt.Errorf("launch application: %w", err)
+	}
+
+	return environmentBackend.focusApplicationWindow(ctx, application.WindowTitle)
+}
+
+func (environmentBackend *Environment) focusApplicationWindow(
+	ctx context.Context,
+	windowTitle string,
+) error {
+	if windowTitle == "" {
+		// Applications without a title cannot be searched reliably. Give the
+		// process a brief startup window before the first screenshot.
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(500 * time.Millisecond):
+			return nil
+		}
+	}
+
+	var windowID string
+	if err := waitFor(ctx, 10*time.Second, func() bool {
+		output, searchErr := environmentBackend.runDocker(
+			ctx,
+			"exec",
+			environmentBackend.containerName,
+			"xdotool",
+			"search",
+			"--name",
+			windowTitle,
+		)
+		if searchErr != nil {
+			return false
+		}
+		windowID = strings.TrimSpace(strings.Split(string(output), "\n")[0])
+		return windowID != ""
+	}); err != nil {
+		return fmt.Errorf("wait for application window %q: %w", windowTitle, err)
+	}
+	if _, err := environmentBackend.runDocker(
+		ctx,
+		"exec",
+		environmentBackend.containerName,
+		"xdotool",
+		"windowactivate",
+		"--sync",
+		windowID,
+	); err != nil {
+		return fmt.Errorf("focus application window: %w", err)
+	}
+	return nil
+}
+
+func (environmentBackend *Environment) Screenshot(ctx context.Context) ([]byte, error) {
+	const screenshotPath = "/tmp/screenshot.png"
+	if _, err := environmentBackend.runDocker(
+		ctx,
+		"exec",
+		environmentBackend.containerName,
+		"scrot",
+		"-o",
+		screenshotPath,
+	); err != nil {
+		return nil, fmt.Errorf("capture screenshot: %w", err)
+	}
+	screenshot, err := environmentBackend.runDocker(
+		ctx,
+		"exec",
+		environmentBackend.containerName,
+		"cat",
+		screenshotPath,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("extract screenshot: %w", err)
+	}
+	return screenshot, nil
+}
+
+func (environmentBackend *Environment) Logs(
+	ctx context.Context,
+) ([]environment.LogEntry, error) {
+	var logEntries []environment.LogEntry
+	for _, streamName := range []string{"stdout", "stderr"} {
+		logContents, err := environmentBackend.runDocker(
+			ctx,
+			"exec",
+			environmentBackend.containerName,
+			"cat",
+			"/tmp/"+streamName+".log",
+		)
+		if err != nil || len(logContents) == 0 {
+			continue
+		}
+		logEntries = append(logEntries, environment.LogEntry{
+			Stream:  streamName,
+			Message: string(logContents),
+			Time:    time.Now().UTC(),
+		})
+	}
+	return logEntries, nil
+}

agentbox/internal/environment/dockerx11/commands.go

@@ -0,0 +1,61 @@
+package dockerx11
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+func (environmentBackend *Environment) runDocker(
+	ctx context.Context,
+	arguments ...string,
+) ([]byte, error) {
+	command := exec.CommandContext(ctx, "docker", arguments...)
+	output, err := command.CombinedOutput()
+	if err != nil {
+		return output, fmt.Errorf(
+			"docker %s: %w: %s",
+			arguments[0],
+			err,
+			strings.TrimSpace(string(output)),
+		)
+	}
+	return output, nil
+}
+
+func (environmentBackend *Environment) streamDockerOutput(
+	ctx context.Context,
+	arguments ...string,
+) error {
+	command := exec.CommandContext(ctx, "docker", arguments...)
+	command.Stdout = environmentBackend.config.Output
+	command.Stderr = environmentBackend.config.Output
+	return command.Run()
+}
+
+func waitFor(ctx context.Context, timeout time.Duration, ready func() bool) error {
+	timeoutTimer := time.NewTimer(timeout)
+	defer timeoutTimer.Stop()
+	retryTicker := time.NewTicker(100 * time.Millisecond)
+	defer retryTicker.Stop()
+
+	for {
+		if ready() {
+			return nil
+		}
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-timeoutTimer.C:
+			return errors.New("timed out")
+		case <-retryTicker.C:
+		}
+	}
+}
+
+func shellQuote(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", "'\"'\"'") + "'"
+}

agentbox/internal/environment/dockerx11/docker.go

@@ -0,0 +1,37 @@
+package dockerx11
+
+import (
+	"io"
+	"sync"
+
+	"agentbox/internal/environment"
+)
+
+const runtimeImageName = "agentbox-runtime:local"
+
+// Config contains host-side values needed to create one isolated desktop.
+type Config struct {
+	ProjectRoot string
+	RunID       string
+	Output      io.Writer
+}
+
+// Environment implements the backend-neutral environment contract with one
+// Docker container, one X11 display, and one application process.
+type Environment struct {
+	config        Config
+	containerName string
+
+	stopMutex        sync.Mutex
+	containerCreated bool
+	containerStopped bool
+}
+
+func New(config Config) *Environment {
+	return &Environment{
+		config:        config,
+		containerName: "agentbox-run-" + config.RunID,
+	}
+}
+
+var _ environment.Environment = (*Environment)(nil)

agentbox/internal/environment/dockerx11/docker_test.go

@@ -0,0 +1,18 @@
+package dockerx11
+
+import "testing"
+
+func TestX11KeyTranslatesLogicalNames(t *testing.T) {
+	tests := map[string]string{
+		"RIGHT":  "Right",
+		"LEFT":   "Left",
+		"ENTER":  "Return",
+		"ESCAPE": "Escape",
+		"A":      "a",
+	}
+	for input, want := range tests {
+		if got := toX11KeyName(input); got != want {
+			t.Errorf("toX11KeyName(%q) = %q, want %q", input, got, want)
+		}
+	}
+}

agentbox/internal/environment/dockerx11/input.go

@@ -0,0 +1,95 @@
+package dockerx11
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"agentbox/internal/environment"
+)
+
+func (environmentBackend *Environment) SendInput(
+	ctx context.Context,
+	action environment.InputAction,
+) error {
+	var xdotoolArguments []string
+	switch action.Type {
+	case environment.KeyDown:
+		if action.Key == "" {
+			return errors.New("key_down requires key")
+		}
+		xdotoolArguments = []string{"keydown", toX11KeyName(action.Key)}
+	case environment.KeyUp:
+		if action.Key == "" {
+			return errors.New("key_up requires key")
+		}
+		xdotoolArguments = []string{"keyup", toX11KeyName(action.Key)}
+	case environment.MouseMove:
+		xdotoolArguments = []string{
+			"mousemove",
+			strconv.Itoa(action.X),
+			strconv.Itoa(action.Y),
+		}
+	case environment.MouseDown:
+		xdotoolArguments = []string{"mousedown", strconv.Itoa(action.Button)}
+	case environment.MouseUp:
+		xdotoolArguments = []string{"mouseup", strconv.Itoa(action.Button)}
+	case environment.Wait:
+		if action.DurationMS < 0 {
+			return errors.New("wait duration cannot be negative")
+		}
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(time.Duration(action.DurationMS) * time.Millisecond):
+			return nil
+		}
+	default:
+		return fmt.Errorf("unsupported input action %q", action.Type)
+	}
+
+	dockerArguments := []string{
+		"exec",
+		environmentBackend.containerName,
+		"xdotool",
+	}
+	dockerArguments = append(dockerArguments, xdotoolArguments...)
+	if _, err := environmentBackend.runDocker(ctx, dockerArguments...); err != nil {
+		return fmt.Errorf("send %s: %w", action.Type, err)
+	}
+	return nil
+}
+
+// toX11KeyName keeps X11 spellings out of the public action API. Agents can use
+// logical names such as RIGHT even though xdotool expects Right.
+func toX11KeyName(logicalName string) string {
+	switch strings.ToUpper(logicalName) {
+	case "LEFT":
+		return "Left"
+	case "RIGHT":
+		return "Right"
+	case "UP":
+		return "Up"
+	case "DOWN":
+		return "Down"
+	case "ENTER", "RETURN":
+		return "Return"
+	case "ESC", "ESCAPE":
+		return "Escape"
+	case "SPACE":
+		return "space"
+	case "TAB":
+		return "Tab"
+	case "BACKSPACE":
+		return "BackSpace"
+	case "DELETE":
+		return "Delete"
+	}
+	if len(logicalName) == 1 {
+		return strings.ToLower(logicalName)
+	}
+	return logicalName
+}

agentbox/internal/environment/dockerx11/lifecycle.go

@@ -0,0 +1,121 @@
+package dockerx11
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"path/filepath"
+	"time"
+)
+
+func (environmentBackend *Environment) Start(ctx context.Context) error {
+	if environmentBackend.config.Output == nil {
+		environmentBackend.config.Output = io.Discard
+	}
+	if _, err := environmentBackend.runDocker(
+		ctx,
+		"version",
+		"--format",
+		"{{.Server.Version}}",
+	); err != nil {
+		return fmt.Errorf("Docker is required and the daemon must be accessible: %w", err)
+	}
+
+	fmt.Fprintln(environmentBackend.config.Output, "Creating environment...")
+	dockerfilePath := filepath.Join(
+		environmentBackend.config.ProjectRoot,
+		"environment",
+		"Dockerfile",
+	)
+	if err := environmentBackend.streamDockerOutput(
+		ctx,
+		"build",
+		"-q",
+		"-t",
+		runtimeImageName,
+		"-f",
+		dockerfilePath,
+		environmentBackend.config.ProjectRoot,
+	); err != nil {
+		return fmt.Errorf("build environment image: %w", err)
+	}
+
+	// These restrictions reduce accidental damage. They are defense in depth,
+	// not a safe boundary for hostile customer code; see docs/architecture.md.
+	_, err := environmentBackend.runDocker(
+		ctx,
+		"create",
+		"--name", environmentBackend.containerName,
+		"--init",
+		"--network=none",
+		"--read-only",
+		"--tmpfs=/tmp:rw,exec,nosuid,nodev,size=128m",
+		"--cap-drop=ALL",
+		"--security-opt=no-new-privileges",
+		"--pids-limit=128",
+		"--memory=512m",
+		"--cpus=1",
+		runtimeImageName,
+	)
+	if err != nil {
+		return fmt.Errorf("create environment: %w", err)
+	}
+	environmentBackend.containerCreated = true
+
+	if _, err := environmentBackend.runDocker(
+		ctx,
+		"start",
+		environmentBackend.containerName,
+	); err != nil {
+		return fmt.Errorf("start environment: %w", err)
+	}
+	// entrypoint.sh creates this file only after both Xvfb and Openbox accept
+	// requests. It is the readiness handshake between host and container.
+	if err := waitFor(ctx, 10*time.Second, func() bool {
+		_, readyErr := environmentBackend.runDocker(
+			ctx,
+			"exec",
+			environmentBackend.containerName,
+			"test",
+			"-f",
+			"/tmp/agentbox-ready",
+		)
+		return readyErr == nil
+	}); err != nil {
+		return fmt.Errorf("wait for graphical environment: %w", err)
+	}
+	return nil
+}
+
+// Stop is idempotent because both normal completion and deferred cleanup may
+// try to tear down the same environment.
+func (environmentBackend *Environment) Stop(ctx context.Context) error {
+	environmentBackend.stopMutex.Lock()
+	defer environmentBackend.stopMutex.Unlock()
+
+	if !environmentBackend.containerCreated || environmentBackend.containerStopped {
+		return nil
+	}
+	environmentBackend.containerStopped = true
+	fmt.Fprintln(environmentBackend.config.Output, "Shutting environment down...")
+
+	_, stopErr := environmentBackend.runDocker(
+		ctx,
+		"stop",
+		"--time=3",
+		environmentBackend.containerName,
+	)
+	_, removeErr := environmentBackend.runDocker(
+		ctx,
+		"rm",
+		"-f",
+		environmentBackend.containerName,
+	)
+	if stopErr != nil {
+		return fmt.Errorf("stop environment: %w", stopErr)
+	}
+	if removeErr != nil {
+		return fmt.Errorf("remove environment: %w", removeErr)
+	}
+	return nil
+}

agentbox/internal/environment/environment.go

@@ -0,0 +1,56 @@
+package environment
+
+import (
+	"context"
+	"time"
+)
+
+// Command describes a host executable and how it should start in an
+// environment. Environment implementations decide how to stage the file.
+type Command struct {
+	Path                 string
+	Args                 []string
+	EnvironmentVariables map[string]string
+	WindowTitle          string
+}
+
+// InputType identifies one backend-neutral keyboard, mouse, or timing action.
+type InputType string
+
+const (
+	KeyDown   InputType = "key_down"
+	KeyUp     InputType = "key_up"
+	MouseMove InputType = "mouse_move"
+	MouseDown InputType = "mouse_down"
+	MouseUp   InputType = "mouse_up"
+	Wait      InputType = "wait"
+)
+
+// InputAction contains only fields relevant to Type. DurationMS is used by Wait.
+type InputAction struct {
+	Type       InputType `json:"type"`
+	Key        string    `json:"key,omitempty"`
+	X          int       `json:"x,omitempty"`
+	Y          int       `json:"y,omitempty"`
+	Button     int       `json:"button,omitempty"`
+	DurationMS int       `json:"duration_ms,omitempty"`
+}
+
+// LogEntry is a cumulative snapshot of one application output stream. Time is
+// when Agentbox captured the snapshot, not when the application emitted it.
+type LogEntry struct {
+	Stream  string    `json:"stream"`
+	Message string    `json:"message"`
+	Time    time.Time `json:"time"`
+}
+
+// Environment is the programmable-computer boundary used by the runtime.
+// Implementations may use containers, virtual machines, or remote hosts.
+type Environment interface {
+	Start(context.Context) error
+	Launch(context.Context, Command) error
+	Screenshot(context.Context) ([]byte, error)
+	SendInput(context.Context, InputAction) error
+	Logs(context.Context) ([]LogEntry, error)
+	Stop(context.Context) error
+}

agentbox/internal/phase1/run.go

@@ -0,0 +1,414 @@
+package phase1
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"image/png"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const imageName = "agentbox-phase1:local"
+
+type point struct {
+	X float64 `json:"x"`
+	Y float64 `json:"y"`
+}
+
+type runRecord struct {
+	ID              string    `json:"id"`
+	Phase           string    `json:"phase"`
+	Status          string    `json:"status"`
+	StartedAt       time.Time `json:"started_at"`
+	FinishedAt      time.Time `json:"finished_at"`
+	ContainerEngine string    `json:"container_engine"`
+	Before          *point    `json:"square_before,omitempty"`
+	After           *point    `json:"square_after,omitempty"`
+	MovementPixels  float64   `json:"movement_pixels,omitempty"`
+	Error           string    `json:"error,omitempty"`
+}
+
+type actionRecord struct {
+	Timestamp time.Time `json:"timestamp"`
+	Type      string    `json:"type"`
+	Key       string    `json:"key,omitempty"`
+	X         int       `json:"x,omitempty"`
+	Y         int       `json:"y,omitempty"`
+	Button    int       `json:"button,omitempty"`
+	Duration  string    `json:"duration,omitempty"`
+}
+
+type runner struct {
+	root          string
+	runDir        string
+	containerName string
+	containerMade bool
+	actions       *os.File
+	record        runRecord
+}
+
+func Run(ctx context.Context) (runErr error) {
+	root, err := findRoot()
+	if err != nil {
+		return err
+	}
+	id, err := runID()
+	if err != nil {
+		return fmt.Errorf("create run ID: %w", err)
+	}
+
+	runDir := filepath.Join(root, ".agentbox", "runs", id)
+	if err := os.MkdirAll(filepath.Join(runDir, "screenshots"), 0o755); err != nil {
+		return fmt.Errorf("create run directory: %w", err)
+	}
+	actions, err := os.Create(filepath.Join(runDir, "actions.jsonl"))
+	if err != nil {
+		return fmt.Errorf("create action trace: %w", err)
+	}
+
+	r := &runner{
+		root:          root,
+		runDir:        runDir,
+		containerName: "agentbox-phase1-" + id,
+		actions:       actions,
+		record: runRecord{
+			ID:        id,
+			Phase:     "environment-prototype",
+			Status:    "running",
+			StartedAt: time.Now().UTC(),
+		},
+	}
+	defer func() {
+		cleanupErr := r.cleanup()
+		r.record.FinishedAt = time.Now().UTC()
+		if runErr == nil && cleanupErr != nil {
+			runErr = cleanupErr
+		}
+		if runErr != nil {
+			r.record.Status = "failed"
+			r.record.Error = runErr.Error()
+		} else {
+			r.record.Status = "passed"
+		}
+		if err := r.writeRecord(); err != nil && runErr == nil {
+			runErr = err
+		}
+	}()
+
+	fmt.Println("Checking container engine...")
+	version, err := r.docker(ctx, "version", "--format", "{{.Server.Version}}")
+	if err != nil {
+		return fmt.Errorf("Docker is required and the daemon must be accessible: %w", err)
+	}
+	r.record.ContainerEngine = "Docker " + strings.TrimSpace(string(version))
+
+	fmt.Println("Building Phase 1 environment...")
+	if err := r.dockerStream(ctx, "build", "-t", imageName, "-f",
+		filepath.Join(root, "environment", "Dockerfile"), root); err != nil {
+		return fmt.Errorf("build environment image: %w", err)
+	}
+
+	fmt.Println("Creating restricted graphical environment...")
+	_, err = r.docker(ctx,
+		"create",
+		"--name", r.containerName,
+		"--init",
+		"--network=none",
+		"--read-only",
+		"--tmpfs=/tmp:rw,nosuid,nodev,size=64m",
+		"--cap-drop=ALL",
+		"--security-opt=no-new-privileges",
+		"--pids-limit=128",
+		"--memory=512m",
+		"--cpus=1",
+		imageName,
+	)
+	if err != nil {
+		return fmt.Errorf("create environment: %w", err)
+	}
+	r.containerMade = true
+	if _, err := r.docker(ctx, "start", r.containerName); err != nil {
+		return fmt.Errorf("start environment: %w", err)
+	}
+	if err := r.waitFor(ctx, 10*time.Second, func() bool {
+		_, readyErr := r.docker(ctx, "exec", r.containerName, "test", "-f", "/tmp/agentbox-ready")
+		return readyErr == nil
+	}); err != nil {
+		return fmt.Errorf("wait for graphical environment: %w", err)
+	}
+
+	fmt.Println("Launching graphical mover demo...")
+	if _, err := r.docker(ctx, "exec", "-d", r.containerName, "sh", "-c",
+		"exec /opt/agentbox/mover >/tmp/stdout.log 2>/tmp/stderr.log"); err != nil {
+		return fmt.Errorf("launch demo: %w", err)
+	}
+
+	var windowID string
+	if err := r.waitFor(ctx, 10*time.Second, func() bool {
+		output, searchErr := r.docker(ctx, "exec", r.containerName, "xdotool",
+			"search", "--name", "Agentbox Mover")
+		if searchErr != nil {
+			return false
+		}
+		windowID = strings.TrimSpace(strings.Split(string(output), "\n")[0])
+		return windowID != ""
+	}); err != nil {
+		return fmt.Errorf("wait for demo window: %w", err)
+	}
+	if _, err := r.docker(ctx, "exec", r.containerName, "xdotool",
+		"windowactivate", "--sync", windowID); err != nil {
+		return fmt.Errorf("focus demo window: %w", err)
+	}
+
+	beforePath := filepath.Join(r.runDir, "screenshots", "before.png")
+	fmt.Println("Capturing screenshot before input...")
+	if err := r.screenshot(ctx, "/tmp/before.png", beforePath); err != nil {
+		return err
+	}
+	before, err := squareCentroid(beforePath)
+	if err != nil {
+		return fmt.Errorf("inspect before screenshot: %w", err)
+	}
+	r.record.Before = &before
+
+	fmt.Println("Sending synthetic mouse input...")
+	if _, err := r.docker(ctx, "exec", r.containerName, "xdotool",
+		"mousemove", "--window", windowID, "100", "100", "mousedown", "1", "mouseup", "1"); err != nil {
+		return fmt.Errorf("send mouse input: %w", err)
+	}
+	if err := r.trace(actionRecord{
+		Timestamp: time.Now().UTC(), Type: "mouse_move", X: 100, Y: 100,
+	}); err != nil {
+		return err
+	}
+	if err := r.trace(actionRecord{
+		Timestamp: time.Now().UTC(), Type: "mouse_down", Button: 1,
+	}); err != nil {
+		return err
+	}
+	if err := r.trace(actionRecord{
+		Timestamp: time.Now().UTC(), Type: "mouse_up", Button: 1,
+	}); err != nil {
+		return err
+	}
+
+	fmt.Println("Holding RIGHT for one second...")
+	if _, err := r.docker(ctx, "exec", r.containerName, "xdotool", "keydown", "Right"); err != nil {
+		return fmt.Errorf("send key down: %w", err)
+	}
+	if err := r.trace(actionRecord{
+		Timestamp: time.Now().UTC(), Type: "key_down", Key: "RIGHT",
+	}); err != nil {
+		return err
+	}
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-time.After(time.Second):
+	}
+	if _, err := r.docker(ctx, "exec", r.containerName, "xdotool", "keyup", "Right"); err != nil {
+		return fmt.Errorf("send key up: %w", err)
+	}
+	if err := r.trace(actionRecord{
+		Timestamp: time.Now().UTC(), Type: "key_up", Key: "RIGHT", Duration: "1s",
+	}); err != nil {
+		return err
+	}
+	time.Sleep(100 * time.Millisecond)
+
+	afterPath := filepath.Join(r.runDir, "screenshots", "after.png")
+	fmt.Println("Capturing screenshot after input...")
+	if err := r.screenshot(ctx, "/tmp/after.png", afterPath); err != nil {
+		return err
+	}
+	after, err := squareCentroid(afterPath)
+	if err != nil {
+		return fmt.Errorf("inspect after screenshot: %w", err)
+	}
+	r.record.After = &after
+	r.record.MovementPixels = after.X - before.X
+	if r.record.MovementPixels < 100 {
+		return fmt.Errorf("visual verification failed: square moved %.1f pixels right, want at least 100", r.record.MovementPixels)
+	}
+
+	fmt.Printf("Verified: square moved %.1f pixels to the right.\n", r.record.MovementPixels)
+	fmt.Printf("Phase 1 passed. Artifacts: %s\n", runDir)
+	return nil
+}
+
+func findRoot() (string, error) {
+	current, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("get working directory: %w", err)
+	}
+	for {
+		data, readErr := os.ReadFile(filepath.Join(current, "go.mod"))
+		if readErr == nil && bytes.Contains(data, []byte("module agentbox")) {
+			return current, nil
+		}
+		parent := filepath.Dir(current)
+		if parent == current {
+			return "", errors.New("run from the agentbox module directory")
+		}
+		current = parent
+	}
+}
+
+func runID() (string, error) {
+	random := make([]byte, 3)
+	if _, err := rand.Read(random); err != nil {
+		return "", err
+	}
+	return time.Now().UTC().Format("20060102T150405") + "-" + hex.EncodeToString(random), nil
+}
+
+func (r *runner) waitFor(ctx context.Context, timeout time.Duration, check func() bool) error {
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		if check() {
+			return nil
+		}
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-timer.C:
+			return errors.New("timed out")
+		case <-ticker.C:
+		}
+	}
+}
+
+func (r *runner) screenshot(ctx context.Context, containerPath, hostPath string) error {
+	if _, err := r.docker(ctx, "exec", r.containerName, "scrot", "-o", containerPath); err != nil {
+		return fmt.Errorf("capture screenshot: %w", err)
+	}
+	if err := r.extract(ctx, containerPath, hostPath); err != nil {
+		return fmt.Errorf("extract screenshot: %w", err)
+	}
+	return nil
+}
+
+func (r *runner) extract(ctx context.Context, containerPath, hostPath string) error {
+	data, err := r.docker(ctx, "exec", r.containerName, "cat", containerPath)
+	if err != nil {
+		return err
+	}
+	if err := os.WriteFile(hostPath, data, 0o644); err != nil {
+		return fmt.Errorf("write %s: %w", hostPath, err)
+	}
+	return nil
+}
+
+func squareCentroid(path string) (point, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return point{}, err
+	}
+	defer file.Close()
+	img, err := png.Decode(file)
+	if err != nil {
+		return point{}, err
+	}
+
+	var sumX, sumY, count uint64
+	bounds := img.Bounds()
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			red, green, blue, _ := img.At(x, y).RGBA()
+			// Match the demo square's #00ff66 color with enough tolerance for
+			// image conversion while rejecting the black background.
+			if green > 0xc000 && red < 0x4000 && blue < 0x8000 {
+				sumX += uint64(x)
+				sumY += uint64(y)
+				count++
+			}
+		}
+	}
+	if count < 1000 {
+		return point{}, fmt.Errorf("found only %d green square pixels", count)
+	}
+	return point{
+		X: float64(sumX) / float64(count),
+		Y: float64(sumY) / float64(count),
+	}, nil
+}
+
+func (r *runner) trace(action actionRecord) error {
+	encoded, err := json.Marshal(action)
+	if err != nil {
+		return fmt.Errorf("encode action: %w", err)
+	}
+	if _, err := r.actions.Write(append(encoded, '\n')); err != nil {
+		return fmt.Errorf("write action trace: %w", err)
+	}
+	return nil
+}
+
+func (r *runner) cleanup() error {
+	if r.actions != nil {
+		_ = r.actions.Close()
+	}
+	if !r.containerMade {
+		return nil
+	}
+
+	fmt.Println("Stopping environment...")
+	stopCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	for _, name := range []string{"stdout.log", "stderr.log"} {
+		_ = r.extract(stopCtx, "/tmp/"+name, filepath.Join(r.runDir, name))
+	}
+	_, stopErr := r.docker(stopCtx, "stop", "--time=3", r.containerName)
+	_, removeErr := r.docker(stopCtx, "rm", "-f", r.containerName)
+	if stopErr != nil {
+		return fmt.Errorf("stop environment: %w", stopErr)
+	}
+	if removeErr != nil {
+		return fmt.Errorf("remove environment: %w", removeErr)
+	}
+	fmt.Println("Environment stopped cleanly.")
+	return nil
+}
+
+func (r *runner) writeRecord() error {
+	data, err := json.MarshalIndent(r.record, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encode run record: %w", err)
+	}
+	data = append(data, '\n')
+	if err := os.WriteFile(filepath.Join(r.runDir, "run.json"), data, 0o644); err != nil {
+		return fmt.Errorf("write run record: %w", err)
+	}
+	return nil
+}
+
+func (r *runner) docker(ctx context.Context, args ...string) ([]byte, error) {
+	command := exec.CommandContext(ctx, "docker", args...)
+	output, err := command.CombinedOutput()
+	if err != nil {
+		return output, fmt.Errorf("docker %s: %w: %s", args[0], err, strings.TrimSpace(string(output)))
+	}
+	return output, nil
+}
+
+func (r *runner) dockerStream(ctx context.Context, args ...string) error {
+	command := exec.CommandContext(ctx, "docker", args...)
+	command.Stdout = os.Stdout
+	command.Stderr = os.Stderr
+	if err := command.Run(); err != nil {
+		return fmt.Errorf("docker %s: %w", strconv.Quote(strings.Join(args, " ")), err)
+	}
+	return nil
+}

agentbox/internal/phase1/run_test.go

@@ -0,0 +1,54 @@
+package phase1
+
+import (
+	"image"
+	"image/color"
+	"image/png"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestSquareCentroid(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "screenshot.png")
+	img := image.NewRGBA(image.Rect(0, 0, 200, 100))
+	green := color.RGBA{R: 0, G: 255, B: 102, A: 255}
+	for y := 20; y < 60; y++ {
+		for x := 80; x < 120; x++ {
+			img.Set(x, y, green)
+		}
+	}
+	writePNG(t, path, img)
+
+	got, err := squareCentroid(path)
+	if err != nil {
+		t.Fatalf("squareCentroid() error = %v", err)
+	}
+	if got.X != 99.5 || got.Y != 39.5 {
+		t.Fatalf("squareCentroid() = (%.1f, %.1f), want (99.5, 39.5)", got.X, got.Y)
+	}
+}
+
+func TestSquareCentroidRejectsMissingSquare(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "empty.png")
+	writePNG(t, path, image.NewRGBA(image.Rect(0, 0, 200, 100)))
+
+	if _, err := squareCentroid(path); err == nil {
+		t.Fatal("squareCentroid() error = nil, want missing-square error")
+	}
+}
+
+func writePNG(t *testing.T, path string, img image.Image) {
+	t.Helper()
+	file, err := os.Create(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := png.Encode(file, img); err != nil {
+		_ = file.Close()
+		t.Fatal(err)
+	}
+	if err := file.Close(); err != nil {
+		t.Fatal(err)
+	}
+}

agentbox/internal/runtime/runtime.go

@@ -0,0 +1,182 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"time"
+
+	"agentbox/internal/agent"
+	"agentbox/internal/environment"
+	"agentbox/internal/trace"
+)
+
+// Config wires replaceable environment, agent, and trace implementations into
+// one run. The runtime itself has no Docker, X11, or model-provider knowledge.
+type Config struct {
+	Task        string
+	Command     environment.Command
+	Controller  agent.Agent
+	Environment environment.Environment
+	TraceStore  *trace.Store
+	MaxSteps    int
+	Output      io.Writer
+}
+
+func Run(ctx context.Context, config Config) (runErr error) {
+	if config.MaxSteps <= 0 {
+		config.MaxSteps = 20
+	}
+	if config.Output == nil {
+		config.Output = io.Discard
+	}
+	if config.Controller == nil || config.Environment == nil || config.TraceStore == nil {
+		return errors.New("runtime requires agent, environment, and trace")
+	}
+
+	defer func() {
+		runErr = finalizeRun(config, runErr)
+	}()
+
+	if err := config.Environment.Start(ctx); err != nil {
+		return err
+	}
+	if err := config.Environment.Launch(ctx, config.Command); err != nil {
+		return err
+	}
+	fmt.Fprintln(config.Output, "Agent loop started.")
+
+	var stepHistory []agent.Step
+	var actionHistory []environment.InputAction
+	runStartedAt := time.Now()
+	for stepNumber := 1; stepNumber <= config.MaxSteps; stepNumber++ {
+		screenshot, err := config.Environment.Screenshot(ctx)
+		if err != nil {
+			return err
+		}
+		screenshotPath, err := config.TraceStore.SaveScreenshot(stepNumber, screenshot)
+		if err != nil {
+			return err
+		}
+		applicationLogs, err := config.Environment.Logs(ctx)
+		if err != nil {
+			return err
+		}
+		observedAt := time.Now().UTC()
+		previousActions := append([]environment.InputAction(nil), actionHistory...)
+		observation := agent.Observation{
+			Screenshot:      screenshot,
+			Timestamp:       observedAt,
+			Logs:            applicationLogs,
+			PreviousActions: previousActions,
+		}
+		fmt.Fprintf(config.Output, "[%s] screenshot captured\n", elapsed(runStartedAt))
+
+		decision, err := config.Controller.NextAction(
+			ctx,
+			config.Task,
+			stepHistory,
+			observation,
+		)
+		if err != nil {
+			return fmt.Errorf("agent next action: %w", err)
+		}
+		fmt.Fprintf(
+			config.Output,
+			"[%s] agent: %s\n",
+			elapsed(runStartedAt),
+			decision.Reason,
+		)
+		if err := config.TraceStore.Record(trace.StepRecord{
+			Step:      stepNumber,
+			Timestamp: observedAt,
+			Observation: trace.ObservationRecord{
+				Screenshot:      screenshotPath,
+				Logs:            applicationLogs,
+				PreviousActions: previousActions,
+			},
+			Agent:  trace.AgentRecord{Message: decision.Reason},
+			Action: decision.Action,
+			Done:   decision.Done,
+		}); err != nil {
+			return err
+		}
+		stepHistory = append(stepHistory, agent.Step{
+			Number:         stepNumber,
+			Timestamp:      observedAt,
+			ScreenshotPath: screenshotPath,
+			Message:        decision.Reason,
+			Action:         decision.Action,
+		})
+
+		if decision.Done {
+			fmt.Fprintln(config.Output, "Task complete.")
+			return nil
+		}
+		if decision.Action == nil {
+			return errors.New("agent returned neither action nor completion")
+		}
+		fmt.Fprintf(
+			config.Output,
+			"[%s] action: %s%s\n",
+			elapsed(runStartedAt),
+			decision.Action.Type,
+			actionDetail(*decision.Action),
+		)
+		if err := config.Environment.SendInput(ctx, *decision.Action); err != nil {
+			return err
+		}
+		actionHistory = append(actionHistory, *decision.Action)
+	}
+	return fmt.Errorf("agent exceeded maximum of %d steps", config.MaxSteps)
+}
+
+// finalizeRun uses a fresh timeout because the caller's context may already be
+// canceled. Preserving logs and removing the environment must still be tried.
+func finalizeRun(
+	config Config,
+	runErr error,
+) error {
+	cleanupCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if logs, err := config.Environment.Logs(cleanupCtx); err == nil {
+		if logErr := config.TraceStore.WriteLogs(logs); runErr == nil && logErr != nil {
+			runErr = logErr
+		}
+	}
+	// Stop is idempotent, so always call it. Start may have created a container
+	// before returning an error while waiting for its graphical services.
+	if stopErr := config.Environment.Stop(cleanupCtx); runErr == nil && stopErr != nil {
+		runErr = stopErr
+	}
+	if finishErr := config.TraceStore.Finish(runErr); runErr == nil && finishErr != nil {
+		runErr = finishErr
+	}
+	return runErr
+}
+
+func elapsed(start time.Time) string {
+	duration := time.Since(start).Round(time.Second)
+	return fmt.Sprintf(
+		"%02d:%02d",
+		int(duration.Minutes()),
+		int(duration.Seconds())%60,
+	)
+}
+
+func actionDetail(action environment.InputAction) string {
+	switch action.Type {
+	case environment.KeyDown, environment.KeyUp:
+		return " " + action.Key
+	case environment.MouseMove:
+		return fmt.Sprintf(" %d,%d", action.X, action.Y)
+	case environment.MouseDown, environment.MouseUp:
+		return fmt.Sprintf(" %d", action.Button)
+	case environment.Wait:
+		return fmt.Sprintf(" %dms", action.DurationMS)
+	default:
+		return ""
+	}
+}

agentbox/internal/runtime/runtime_test.go

@@ -0,0 +1,63 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+	"io"
+	"testing"
+
+	"agentbox/internal/agent"
+	"agentbox/internal/environment"
+	"agentbox/internal/trace"
+)
+
+type failingStartEnvironment struct {
+	stopCalled bool
+}
+
+func (fake *failingStartEnvironment) Start(context.Context) error {
+	return errors.New("startup failed")
+}
+
+func (fake *failingStartEnvironment) Launch(context.Context, environment.Command) error {
+	return nil
+}
+
+func (fake *failingStartEnvironment) Screenshot(context.Context) ([]byte, error) {
+	return nil, nil
+}
+
+func (fake *failingStartEnvironment) SendInput(context.Context, environment.InputAction) error {
+	return nil
+}
+
+func (fake *failingStartEnvironment) Logs(context.Context) ([]environment.LogEntry, error) {
+	return nil, nil
+}
+
+func (fake *failingStartEnvironment) Stop(context.Context) error {
+	fake.stopCalled = true
+	return nil
+}
+
+func TestRunStopsEnvironmentWhenStartFails(t *testing.T) {
+	traceStore, err := trace.New(t.TempDir(), "task", "application", "test-agent")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fakeEnvironment := &failingStartEnvironment{}
+
+	err = Run(context.Background(), Config{
+		Task:        "task",
+		Controller:  &agent.Deterministic{},
+		Environment: fakeEnvironment,
+		TraceStore:  traceStore,
+		Output:      io.Discard,
+	})
+	if err == nil {
+		t.Fatal("Run() error = nil, want startup error")
+	}
+	if !fakeEnvironment.stopCalled {
+		t.Fatal("Run() did not stop environment after startup failure")
+	}
+}

agentbox/internal/trace/doc.go

@@ -0,0 +1,4 @@
+// Package trace stores durable run records. steps.jsonl contains complete
+// observations and decisions, actions.jsonl is an action-only view, and PNG
+// screenshots remain separate files referenced by relative paths.
+package trace

agentbox/internal/trace/reader.go

@@ -0,0 +1,97 @@
+package trace
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"sort"
+)
+
+func List(projectRoot string) ([]Run, error) {
+	runsDirectory := filepath.Join(projectRoot, ".agentbox", "runs")
+	directoryEntries, err := os.ReadDir(runsDirectory)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	var runs []Run
+	for _, entry := range directoryEntries {
+		if !entry.IsDir() {
+			continue
+		}
+		run, err := Read(projectRoot, entry.Name())
+		// Old or malformed trace directories are intentionally hidden rather
+		// than making the entire run listing fail.
+		if err == nil && run.SchemaVersion == SchemaVersion {
+			runs = append(runs, run)
+		}
+	}
+	sort.Slice(runs, func(left, right int) bool {
+		return runs[left].StartedAt.After(runs[right].StartedAt)
+	})
+	return runs, nil
+}
+
+func Read(projectRoot, runID string) (Run, error) {
+	if err := validateRunID(runID); err != nil {
+		return Run{}, err
+	}
+	runPath := filepath.Join(
+		projectRoot,
+		".agentbox",
+		"runs",
+		runID,
+		"run.json",
+	)
+	data, err := os.ReadFile(runPath)
+	if err != nil {
+		return Run{}, err
+	}
+	var run Run
+	if err := json.Unmarshal(data, &run); err != nil {
+		return Run{}, err
+	}
+	return run, nil
+}
+
+func ReadSteps(projectRoot, runID string) ([]StepRecord, error) {
+	if err := validateRunID(runID); err != nil {
+		return nil, err
+	}
+	stepsPath := filepath.Join(
+		projectRoot,
+		".agentbox",
+		"runs",
+		runID,
+		"steps.jsonl",
+	)
+	stepsFile, err := os.Open(stepsPath)
+	if err != nil {
+		return nil, err
+	}
+	defer stepsFile.Close()
+
+	var steps []StepRecord
+	scanner := bufio.NewScanner(stepsFile)
+	for scanner.Scan() {
+		var step StepRecord
+		if err := json.Unmarshal(scanner.Bytes(), &step); err != nil {
+			return nil, err
+		}
+		steps = append(steps, step)
+	}
+	return steps, scanner.Err()
+}
+
+func validateRunID(runID string) error {
+	// Run IDs become path components, so reject separators and traversal.
+	if filepath.Base(runID) != runID {
+		return errors.New("invalid run ID")
+	}
+	return nil
+}

agentbox/internal/trace/store.go

@@ -0,0 +1,180 @@
+package trace
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"agentbox/internal/environment"
+)
+
+// Store writes one run's metadata and append-only event streams.
+type Store struct {
+	runDirectory string
+	run          Run
+	stepsFile    *os.File
+	actionsFile  *os.File
+}
+
+func New(projectRoot, task, application, agentName string) (*Store, error) {
+	runID, err := newRunID()
+	if err != nil {
+		return nil, err
+	}
+	runDirectory := filepath.Join(projectRoot, ".agentbox", "runs", runID)
+	screenshotDirectory := filepath.Join(runDirectory, "screenshots")
+	if err := os.MkdirAll(screenshotDirectory, 0o755); err != nil {
+		return nil, fmt.Errorf("create run directory: %w", err)
+	}
+	stepsFile, err := os.Create(filepath.Join(runDirectory, "steps.jsonl"))
+	if err != nil {
+		return nil, fmt.Errorf("create step trace: %w", err)
+	}
+	actionsFile, err := os.Create(filepath.Join(runDirectory, "actions.jsonl"))
+	if err != nil {
+		_ = stepsFile.Close()
+		return nil, fmt.Errorf("create action trace: %w", err)
+	}
+
+	store := &Store{
+		runDirectory: runDirectory,
+		stepsFile:    stepsFile,
+		actionsFile:  actionsFile,
+		run: Run{
+			SchemaVersion: SchemaVersion,
+			ID:            runID,
+			Task:          task,
+			Application:   application,
+			Agent:         agentName,
+			Status:        "running",
+			StartedAt:     time.Now().UTC(),
+		},
+	}
+	if err := store.writeRunSummary(); err != nil {
+		_ = stepsFile.Close()
+		_ = actionsFile.Close()
+		return nil, err
+	}
+	return store, nil
+}
+
+func (store *Store) ID() string {
+	return store.run.ID
+}
+
+func (store *Store) Directory() string {
+	return store.runDirectory
+}
+
+func (store *Store) SaveScreenshot(stepNumber int, screenshot []byte) (string, error) {
+	relativePath := filepath.Join(
+		"screenshots",
+		fmt.Sprintf("%04d.png", stepNumber),
+	)
+	absolutePath := filepath.Join(store.runDirectory, relativePath)
+	if err := os.WriteFile(absolutePath, screenshot, 0o644); err != nil {
+		return "", fmt.Errorf("write screenshot: %w", err)
+	}
+	// Trace paths always use slash separators so traces are portable.
+	return filepath.ToSlash(relativePath), nil
+}
+
+func (store *Store) Record(step StepRecord) error {
+	if err := appendJSONLine(store.stepsFile, step); err != nil {
+		return fmt.Errorf("record step: %w", err)
+	}
+	if step.Action != nil {
+		action := actionRecord{
+			Step:      step.Step,
+			Timestamp: step.Timestamp,
+			Action:    *step.Action,
+		}
+		if err := appendJSONLine(store.actionsFile, action); err != nil {
+			return fmt.Errorf("record action: %w", err)
+		}
+	}
+	store.run.StepCount = step.Step
+	return store.writeRunSummary()
+}
+
+func (store *Store) WriteLogs(logEntries []environment.LogEntry) error {
+	var standardOutput, standardError string
+	for _, entry := range logEntries {
+		switch entry.Stream {
+		case "stdout":
+			standardOutput = entry.Message
+		case "stderr":
+			standardError = entry.Message
+		}
+	}
+	if err := os.WriteFile(
+		filepath.Join(store.runDirectory, "stdout.log"),
+		[]byte(standardOutput),
+		0o644,
+	); err != nil {
+		return err
+	}
+	return os.WriteFile(
+		filepath.Join(store.runDirectory, "stderr.log"),
+		[]byte(standardError),
+		0o644,
+	)
+}
+
+func (store *Store) Finish(runErr error) error {
+	store.closeEventFiles()
+	store.run.FinishedAt = time.Now().UTC()
+	if runErr != nil {
+		store.run.Status = "failed"
+		store.run.Error = runErr.Error()
+	} else {
+		store.run.Status = "complete"
+	}
+	return store.writeRunSummary()
+}
+
+func (store *Store) closeEventFiles() {
+	if store.stepsFile != nil {
+		_ = store.stepsFile.Close()
+		store.stepsFile = nil
+	}
+	if store.actionsFile != nil {
+		_ = store.actionsFile.Close()
+		store.actionsFile = nil
+	}
+}
+
+// Sync each JSONL record so an interrupted run retains its latest complete
+// decision. Performance is secondary to debuggability in this local spike.
+func appendJSONLine(file *os.File, value any) error {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	if _, err := file.Write(append(data, '\n')); err != nil {
+		return err
+	}
+	return file.Sync()
+}
+
+func (store *Store) writeRunSummary() error {
+	data, err := json.MarshalIndent(store.run, "", "  ")
+	if err != nil {
+		return err
+	}
+	runPath := filepath.Join(store.runDirectory, "run.json")
+	return os.WriteFile(runPath, append(data, '\n'), 0o644)
+}
+
+func newRunID() (string, error) {
+	randomSuffix := make([]byte, 3)
+	if _, err := rand.Read(randomSuffix); err != nil {
+		return "", err
+	}
+	timestamp := time.Now().UTC().Format("20060102T150405")
+	return timestamp + "-" + hex.EncodeToString(randomSuffix), nil
+}

agentbox/internal/trace/types.go

@@ -0,0 +1,50 @@
+package trace
+
+import (
+	"time"
+
+	"agentbox/internal/environment"
+)
+
+// SchemaVersion changes only when existing trace readers need new logic.
+const SchemaVersion = "1"
+
+// Run is the summary stored in run.json.
+type Run struct {
+	SchemaVersion string    `json:"schema_version"`
+	ID            string    `json:"id"`
+	Task          string    `json:"task"`
+	Application   string    `json:"application"`
+	Agent         string    `json:"agent"`
+	Status        string    `json:"status"`
+	StartedAt     time.Time `json:"started_at"`
+	FinishedAt    time.Time `json:"finished_at,omitempty"`
+	StepCount     int       `json:"step_count"`
+	Error         string    `json:"error,omitempty"`
+}
+
+type ObservationRecord struct {
+	Screenshot      string                    `json:"screenshot"`
+	Logs            []environment.LogEntry    `json:"logs,omitempty"`
+	PreviousActions []environment.InputAction `json:"previous_actions,omitempty"`
+}
+
+type AgentRecord struct {
+	Message string `json:"message"`
+}
+
+// StepRecord is one append-only line in steps.jsonl.
+type StepRecord struct {
+	Step        int                      `json:"step"`
+	Timestamp   time.Time                `json:"timestamp"`
+	Observation ObservationRecord        `json:"observation"`
+	Agent       AgentRecord              `json:"agent"`
+	Action      *environment.InputAction `json:"action,omitempty"`
+	Done        bool                     `json:"done,omitempty"`
+}
+
+type actionRecord struct {
+	Step      int                     `json:"step"`
+	Timestamp time.Time               `json:"timestamp"`
+	Action    environment.InputAction `json:"action"`
+}

agentbox/scripts/build_demo.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+set -eu
+
+root=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
+image=agentbox-runtime:local
+output="$root/examples/mover/mover"
+temporary="$output.tmp"
+
+cleanup() {
+    rm -f "$temporary"
+}
+trap cleanup EXIT INT TERM
+
+docker build -q -t "$image" -f "$root/environment/Dockerfile" "$root" >/dev/null
+docker run --rm --network=none --entrypoint cat "$image" /opt/agentbox/mover >"$temporary"
+chmod 0755 "$temporary"
+mv "$temporary" "$output"

assetbake/main.odin

@@ -56,10 +56,12 @@ Char_Def :: struct {
 
 // Packed atlas pixels + per-frame rects (indexed like the combined frames list)
 Atlas :: struct {
-	pixels: []u8,
-	width:  int,
-	height: int,
-	rects:  [][4]int, // [x, y, w, h] per frame; sizes may differ across clips
+	pixels:        []u8,
+	width:         int,
+	height:        int,
+	rects:         [][4]int,
+	source_sizes:  [][2]int,
+	trim_offsets:  [][2]int,
 }
 
 // Where one clip's frames sit inside the packed atlas frame list
@@ -95,6 +97,8 @@ bake_character :: proc(in_dir, out_dir: string) {
 	atlas := pack_atlas(frames)
 	defer delete(atlas.pixels)
 	defer delete(atlas.rects)
+	defer delete(atlas.source_sizes)
+	defer delete(atlas.trim_offsets)
 
 	ensure_dir(out_dir)
 
@@ -283,22 +287,60 @@ destroy_frames :: proc(frames: []^image.Image) {
 	delete(frames)
 }
 
-// pack_atlas packs variable-size frames with stb_rect_pack and blits them into one sheet.
-// Caller owns atlas.pixels and atlas.rects.
+opaque_bounds_rgba :: proc(pixels: []u8, iw, ih: int, alpha_min: u8 = 1) -> (x, y, w, h: int) {
+	min_x, min_y := iw, ih
+	max_x, max_y := -1, -1
+
+	for py in 0 ..< ih {
+		for px in 0 ..< iw {
+			i := (py * iw + px) * 4
+			if i + 3 >= len(pixels) do continue
+			a := pixels[i + 3]
+			if a >= alpha_min {
+				if px < min_x do min_x = px
+				if py < min_y do min_y = py
+				if px > max_x do max_x = px
+				if py > max_y do max_y = py
+			}
+		}
+	}
+
+	if max_x < min_x {
+		return 0, 0, 1, 1
+	}
+	return min_x, min_y, max_x - min_x + 1, max_y - min_y + 1
+}
+
+opaque_bounds :: proc(img: ^image.Image, alpha_min: u8 = 1) -> (x, y, w, h: int) {
+	iw, ih := int(img.width), int(img.height)
+	pixels := bytes.buffer_to_bytes(&img.pixels)
+	return opaque_bounds_rgba(pixels, iw, ih, alpha_min)
+}
+
 pack_atlas :: proc(frames: []^image.Image) -> Atlas {
-	PADDING :: 1 // 1px gap to reduce bleeding if filtered later
+	PADDING :: 1
 
 	pack_rects := make([]stbrp.Rect, len(frames))
 	defer delete(pack_rects)
 
+	trims := make([][4]int, len(frames))
+	defer delete(trims)
+	source_sizes := make([][2]int, len(frames))
+	trim_offsets := make([][2]int, len(frames))
+
 	total_area := 0
 	max_w := 0
 	max_h := 0
 	for frame, i in frames {
-		w := frame.width + PADDING
-		h := frame.height + PADDING
+		tx, ty, tw, th := opaque_bounds(frame)
+		trims[i] = {tx, ty, tw, th}
+		source_sizes[i] = {int(frame.width), int(frame.height)}
+		trim_offsets[i] = {tx, ty}
+
+		w := tw + PADDING
+		h := th + PADDING
 		pack_rects[i] = stbrp.Rect {
-			id = c.int(i), // pack_rects may reorder; id maps back to frame index
+			id = c.int(i),
 			w  = stbrp.Coord(w),
 			h  = stbrp.Coord(h),
 		}
@@ -307,7 +349,6 @@ pack_atlas :: proc(frames: []^image.Image) -> Atlas {
 		max_h = max(max_h, h)
 	}
 
-	// Grow a square-ish atlas until everything fits
 	side := max(max_w, max_h, int(math.ceil(math.sqrt(f64(total_area)))))
 	atlas_w, atlas_h := 0, 0
 	packed := false
@@ -326,10 +367,9 @@ pack_atlas :: proc(frames: []^image.Image) -> Atlas {
 		os.exit(1)
 	}
 
-	pixels := make([]u8, atlas_w * atlas_h * 4) // transparent
+	pixels := make([]u8, atlas_w * atlas_h * 4)
 	rects := make([][4]int, len(frames))
 
-	// Blit using each rect's id (array order may have changed during packing)
 	for pr in pack_rects {
 		if !pr.was_packed {
 			fmt.eprintfln("frame %d was not packed", pr.id)
@@ -337,27 +377,30 @@ pack_atlas :: proc(frames: []^image.Image) -> Atlas {
 		}
 		idx := int(pr.id)
 		frame := frames[idx]
-		fw := frame.width
-		fh := frame.height
+		trim := trims[idx]
+		tx, ty, tw, th := trim[0], trim[1], trim[2], trim[3]
 		dst_x := int(pr.x)
 		dst_y := int(pr.y)
 
 		src := bytes.buffer_to_bytes(&frame.pixels)
-		for y in 0 ..< fh {
-			src_row := src[y * fw * 4:(y + 1) * fw * 4]
+		src_w := int(frame.width)
+		for y in 0 ..< th {
+			src_row := src[((ty + y) * src_w + tx) * 4:][:tw * 4]
 			dst_i := ((dst_y + y) * atlas_w + dst_x) * 4
 			copy(pixels[dst_i:], src_row)
 		}
 
-		rects[idx] = {dst_x, dst_y, fw, fh}
+		rects[idx] = {dst_x, dst_y, tw, th}
 	}
 
 	fmt.printfln("packed atlas %dx%d", atlas_w, atlas_h)
 	return Atlas {
-		pixels = pixels,
-		width  = atlas_w,
-		height = atlas_h,
-		rects  = rects,
+		pixels       = pixels,
+		width        = atlas_w,
+		height       = atlas_h,
+		rects        = rects,
+		source_sizes = source_sizes,
+		trim_offsets = trim_offsets,
 	}
 }
 
@@ -422,8 +465,8 @@ build_char_def :: proc(
 			r := atlas.rects[slot]
 			frame_defs[i] = Frame_Def {
 				rect        = r,
-				source_size = {r[2], r[3]},
-				trim_offset = {0, 0}, // no trimming in v1
+				source_size = atlas.source_sizes[slot],
+				trim_offset = atlas.trim_offsets[slot],
 			}
 		}
 

assetbake/opaque_bounds_test.odin

@@ -0,0 +1,46 @@
+package main
+
+import "core:testing"
+
+@(test)
+opaque_bounds_inset :: proc(t: ^testing.T) {
+	// 4x4, opaque 2x2 at (1,1)
+	pixels := make([]u8, 4 * 4 * 4)
+	defer delete(pixels)
+	for y in 1 ..= 2 {
+		for x in 1 ..= 2 {
+			i := (y * 4 + x) * 4
+			pixels[i + 3] = 255
+		}
+	}
+	x, y, w, h := opaque_bounds_rgba(pixels, 4, 4)
+	testing.expect_value(t, x, 1)
+	testing.expect_value(t, y, 1)
+	testing.expect_value(t, w, 2)
+	testing.expect_value(t, h, 2)
+}
+
+@(test)
+opaque_bounds_full :: proc(t: ^testing.T) {
+	pixels := make([]u8, 2 * 2 * 4)
+	defer delete(pixels)
+	for i := 3; i < len(pixels); i += 4 {
+		pixels[i] = 255
+	}
+	x, y, w, h := opaque_bounds_rgba(pixels, 2, 2)
+	testing.expect_value(t, x, 0)
+	testing.expect_value(t, y, 0)
+	testing.expect_value(t, w, 2)
+	testing.expect_value(t, h, 2)
+}
+
+@(test)
+opaque_bounds_empty :: proc(t: ^testing.T) {
+	pixels := make([]u8, 3 * 3 * 4)
+	defer delete(pixels)
+	x, y, w, h := opaque_bounds_rgba(pixels, 3, 3)
+	testing.expect_value(t, x, 0)
+	testing.expect_value(t, y, 0)
+	testing.expect_value(t, w, 1)
+	testing.expect_value(t, h, 1)
+}

assets_baked/characters/toad/toad.char.json

@@ -10,588 +10,572 @@
     "clips": {
         "walk": {
             "loop": true,
-            "fps": 10.00000000,
+            "fps": 15.00000000,
             "frames": [
                 {
                     "rect": [
-                        0,
-                        0,
-                        268,
-                        326
+                        1253,
+                        630,
+                        204,
+                        311
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        9,
+                        14
                     ]
                 },
                 {
                     "rect": [
-                        269,
+                        1256,
                         0,
-                        268,
-                        326
+                        218,
+                        314
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        9,
+                        10
                     ]
                 },
                 {
                     "rect": [
-                        538,
-                        0,
-                        268,
-                        326
+                        1458,
+                        630,
+                        231,
+                        310
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        9,
+                        8
                     ]
                 },
                 {
                     "rect": [
-                        807,
-                        0,
-                        268,
-                        326
+                        643,
+                        943,
+                        243,
+                        295
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        10,
+                        7
                     ]
                 },
                 {
                     "rect": [
-                        1076,
-                        0,
-                        268,
-                        326
+                        881,
+                        1245,
+                        254,
+                        278
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1345,
-                        0,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1614,
-                        0,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
+                        11,
+                        8
                     ]
                 },
                 {
                     "rect": [
                         0,
-                        327,
-                        268,
-                        326
+                        944,
+                        247,
+                        288
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        10,
+                        7
                     ]
                 },
                 {
                     "rect": [
-                        269,
-                        327,
-                        268,
-                        326
+                        1669,
+                        941,
+                        236,
+                        305
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        538,
-                        327,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        807,
-                        327,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1076,
-                        327,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1345,
-                        327,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1614,
-                        327,
-                        268,
-                        326
-                    ],
-                    "source_size": [
-                        268,
-                        326
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
+                        9,
+                        8
                     ]
                 },
                 {
                     "rect": [
                         0,
-                        654,
-                        268,
-                        326
+                        316,
+                        223,
+                        313
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        9,
+                        9
                     ]
                 },
                 {
                     "rect": [
-                        269,
-                        654,
-                        268,
-                        326
+                        1458,
+                        941,
+                        210,
+                        310
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        9,
+                        13
                     ]
                 },
                 {
                     "rect": [
-                        538,
-                        654,
-                        268,
-                        326
+                        224,
+                        316,
+                        211,
+                        313
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        11,
+                        11
                     ]
                 },
                 {
                     "rect": [
-                        807,
-                        654,
-                        268,
-                        326
+                        1032,
+                        630,
+                        220,
+                        311
                     ],
                     "source_size": [
                         268,
                         326
                     ],
                     "trim_offset": [
+                        13,
+                        7
+                    ]
+                },
+                {
+                    "rect": [
+                        1032,
+                        942,
+                        228,
+                        302
+                    ],
+                    "source_size": [
+                        268,
+                        326
+                    ],
+                    "trim_offset": [
+                        16,
+                        4
+                    ]
+                },
+                {
+                    "rect": [
                         0,
-                        0
+                        1233,
+                        237,
+                        286
+                    ],
+                    "source_size": [
+                        268,
+                        326
+                    ],
+                    "trim_offset": [
+                        18,
+                        2
+                    ]
+                },
+                {
+                    "rect": [
+                        643,
+                        1239,
+                        237,
+                        286
+                    ],
+                    "source_size": [
+                        268,
+                        326
+                    ],
+                    "trim_offset": [
+                        18,
+                        2
+                    ]
+                },
+                {
+                    "rect": [
+                        414,
+                        943,
+                        228,
+                        302
+                    ],
+                    "source_size": [
+                        268,
+                        326
+                    ],
+                    "trim_offset": [
+                        16,
+                        4
+                    ]
+                },
+                {
+                    "rect": [
+                        1690,
+                        630,
+                        220,
+                        310
+                    ],
+                    "source_size": [
+                        268,
+                        326
+                    ],
+                    "trim_offset": [
+                        13,
+                        7
+                    ]
+                },
+                {
+                    "rect": [
+                        436,
+                        316,
+                        210,
+                        313
+                    ],
+                    "source_size": [
+                        268,
+                        326
+                    ],
+                    "trim_offset": [
+                        11,
+                        11
                     ]
                 }
             ]
         },
         "idle": {
             "loop": true,
-            "fps": 10.00000000,
+            "fps": 15.00000000,
             "frames": [
                 {
                     "rect": [
-                        1883,
-                        0,
-                        213,
-                        319
+                        414,
+                        630,
+                        205,
+                        312
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        6,
+                        7
                     ]
                 },
                 {
                     "rect": [
-                        1883,
-                        320,
-                        213,
-                        319
+                        647,
+                        316,
+                        206,
+                        313
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        5,
+                        6
                     ]
                 },
                 {
                     "rect": [
-                        1883,
-                        640,
-                        213,
-                        319
+                        854,
+                        316,
+                        206,
+                        313
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        5,
+                        6
                     ]
                 },
                 {
                     "rect": [
-                        1076,
-                        654,
-                        213,
-                        319
+                        1684,
+                        0,
+                        207,
+                        314
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        4,
+                        5
                     ]
                 },
                 {
                     "rect": [
-                        1290,
-                        654,
-                        213,
-                        319
+                        1256,
+                        315,
+                        207,
+                        314
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        4,
+                        5
                     ]
                 },
                 {
                     "rect": [
-                        1504,
-                        654,
-                        213,
-                        319
+                        420,
+                        0,
+                        208,
+                        315
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        3,
+                        4
                     ]
                 },
                 {
                     "rect": [
-                        1718,
-                        960,
-                        213,
-                        319
+                        1475,
+                        0,
+                        208,
+                        314
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        3,
+                        4
                     ]
                 },
                 {
                     "rect": [
-                        1076,
-                        974,
-                        213,
-                        319
+                        629,
+                        0,
+                        208,
+                        315
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1290,
-                        974,
-                        213,
-                        319
-                    ],
-                    "source_size": [
-                        213,
-                        319
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "rect": [
-                        1504,
-                        974,
-                        213,
-                        319
-                    ],
-                    "source_size": [
-                        213,
-                        319
-                    ],
-                    "trim_offset": [
-                        0,
-                        0
+                        3,
+                        3
                     ]
                 },
                 {
                     "rect": [
                         0,
-                        981,
-                        213,
-                        319
+                        0,
+                        209,
+                        315
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        2,
+                        3
                     ]
                 },
                 {
                     "rect": [
-                        214,
-                        981,
-                        213,
-                        319
+                        210,
+                        0,
+                        209,
+                        315
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        2,
+                        3
                     ]
                 },
                 {
                     "rect": [
-                        428,
-                        981,
-                        213,
-                        319
+                        838,
+                        0,
+                        208,
+                        315
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        3,
+                        3
                     ]
                 },
                 {
                     "rect": [
-                        642,
-                        981,
-                        213,
-                        319
+                        1047,
+                        0,
+                        208,
+                        315
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        3,
+                        4
                     ]
                 },
                 {
                     "rect": [
-                        856,
-                        981,
-                        213,
-                        319
+                        1464,
+                        315,
+                        207,
+                        314
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        4,
+                        5
                     ]
                 },
                 {
                     "rect": [
-                        1718,
-                        1280,
-                        213,
-                        319
+                        1672,
+                        315,
+                        207,
+                        314
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        4,
+                        5
                     ]
                 },
                 {
                     "rect": [
-                        1070,
-                        1294,
-                        213,
-                        319
+                        0,
+                        630,
+                        206,
+                        313
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        5,
+                        6
                     ]
                 },
                 {
                     "rect": [
-                        1284,
-                        1294,
-                        213,
-                        319
+                        207,
+                        630,
+                        206,
+                        313
                     ],
                     "source_size": [
                         213,
                         319
                     ],
                     "trim_offset": [
-                        0,
-                        0
+                        5,
+                        6
+                    ]
+                },
+                {
+                    "rect": [
+                        620,
+                        630,
+                        205,
+                        312
+                    ],
+                    "source_size": [
+                        213,
+                        319
+                    ],
+                    "trim_offset": [
+                        6,
+                        7
+                    ]
+                },
+                {
+                    "rect": [
+                        826,
+                        630,
+                        205,
+                        312
+                    ],
+                    "source_size": [
+                        213,
+                        319
+                    ],
+                    "trim_offset": [
+                        6,
+                        7
                     ]
                 }
             ]

content/characters/toad/manifest.json

@@ -5,12 +5,12 @@
   "clips": {
     "idle": {
       "folder": "Idle",
-      "fps": 10,
+      "fps": 15,
       "loop": true
     },
     "walk": {
       "folder": "Walk",
-      "fps": 10,
+      "fps": 15,
       "loop": true
     }
   }

engine/animation_test.odin

@@ -0,0 +1,289 @@
+package engine
+
+import "core:testing"
+
+make_test_character :: proc(allocator := context.allocator) -> Character_Data {
+	data: Character_Data
+	data.def.clips = make(map[string]Clip_Def, allocator)
+
+	idle_frames := make([]Frame_Def, 3, allocator)
+	idle_frames[0] = {
+		rect = {0, 0, 10, 10},
+	}
+	idle_frames[1] = {
+		rect = {10, 0, 10, 10},
+	}
+	idle_frames[2] = {
+		rect = {20, 0, 10, 10},
+	}
+	data.def.clips["idle"] = Clip_Def {
+		loop   = true,
+		fps    = 10,
+		frames = idle_frames,
+	}
+
+	once_frames := make([]Frame_Def, 3, allocator)
+	once_frames[0] = {
+		rect = {0, 10, 10, 10},
+	}
+	once_frames[1] = {
+		rect = {10, 10, 10, 10},
+	}
+	once_frames[2] = {
+		rect = {20, 10, 10, 10},
+	}
+	data.def.clips["once"] = Clip_Def {
+		loop   = false,
+		fps    = 10,
+		frames = once_frames,
+	}
+
+	hold_frames := make([]Frame_Def, 2, allocator)
+	hold_frames[0] = {
+		rect = {0, 20, 10, 10},
+	}
+	hold_frames[1] = {
+		rect = {10, 20, 10, 10},
+	}
+	data.def.clips["hold"] = Clip_Def {
+		loop   = true,
+		fps    = 0,
+		frames = hold_frames,
+	}
+
+	return data
+}
+
+destroy_test_character :: proc(data: ^Character_Data) {
+	if data == nil do return
+	keys := make([dynamic]string, context.temp_allocator)
+	for key, clip in data.def.clips {
+		delete(clip.frames)
+		append(&keys, key)
+	}
+	for key in keys {
+		delete_key(&data.def.clips, key)
+	}
+	delete(data.def.clips)
+	data^ = {}
+}
+
+@(test)
+character_clip_found_and_missing :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	clip, ok := character_clip(&data, "idle")
+	testing.expect(t, ok, "character_clip should find idle")
+	testing.expect_value(t, len(clip.frames), 3)
+	testing.expect(t, clip.loop, "idle clip should loop")
+	testing.expect_value(t, clip.fps, f32(10))
+
+	_, ok = character_clip(&data, "missing")
+	testing.expect(t, !ok, "character_clip should miss unknown name")
+
+	data.def.clips["empty"] = Clip_Def {
+		loop   = true,
+		fps    = 10,
+		frames = nil,
+	}
+	_, ok = character_clip(&data, "empty")
+	testing.expect(t, !ok, "character_clip should reject empty frames")
+}
+
+@(test)
+set_sprite_clip_switch_and_guards :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	sprite := spawn_sprite(&data, {0, 0}, "idle", 0)
+	testing.expect_value(t, sprite.clip, "idle")
+
+	sprite.frame = 2
+	sprite.time = 0.05
+	set_sprite_clip(&sprite, "once")
+	testing.expect_value(t, sprite.clip, "once")
+	testing.expect_value(t, sprite.frame, 0)
+	testing.expect_value(t, sprite.time, f32(0))
+
+	sprite.frame = 1
+	sprite.time = 0.09
+	set_sprite_clip(&sprite, "once")
+	testing.expect_value(t, sprite.frame, 1)
+	testing.expect_value(t, sprite.time, f32(0.09))
+
+	set_sprite_clip(&sprite, "nope")
+	testing.expect_value(t, sprite.clip, "once")
+	testing.expect_value(t, sprite.frame, 1)
+	testing.expect_value(t, sprite.time, f32(0.09))
+}
+
+@(test)
+set_sprite_clip_caches_clip_def :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	sprite := spawn_sprite(&data, {}, "idle", 0)
+	testing.expect(t, sprite.has_clip, "spawn should cache a valid clip")
+	testing.expect_value(t, sprite.clip, "idle")
+	testing.expect(t, sprite.clip_def.loop, "idle clip loops")
+	testing.expect_value(t, sprite.clip_def.fps, f32(10))
+	testing.expect_value(t, len(sprite.clip_def.frames), 3)
+
+	set_sprite_clip(&sprite, "once")
+	testing.expect(t, sprite.has_clip, "switch should refresh cache")
+	testing.expect_value(t, sprite.clip, "once")
+	testing.expect(t, !sprite.clip_def.loop, "once clip does not loop")
+	testing.expect_value(t, sprite.clip_def.fps, f32(10))
+	testing.expect_value(t, len(sprite.clip_def.frames), 3)
+
+	set_sprite_clip(&sprite, "nope")
+	testing.expect(t, sprite.has_clip, "bad clip must leave cache intact")
+	testing.expect_value(t, sprite.clip, "once")
+	testing.expect(t, !sprite.clip_def.loop, "cached once clip preserved")
+	testing.expect_value(t, len(sprite.clip_def.frames), 3)
+}
+
+@(test)
+set_sprite_clip_def_applies_and_guards :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	sprite := spawn_sprite(&data, {}, "idle", 0)
+	sprite.frame = 2
+	sprite.time = 0.05
+
+	once := data.def.clips["once"]
+	set_sprite_clip_def(&sprite, "once", once)
+	testing.expect_value(t, sprite.clip, "once")
+	testing.expect(t, sprite.has_clip, "def apply should mark clip present")
+	testing.expect_value(t, sprite.frame, 0)
+	testing.expect_value(t, sprite.time, f32(0))
+	testing.expect(t, !sprite.clip_def.loop, "once clip does not loop")
+	testing.expect_value(t, len(sprite.clip_def.frames), 3)
+
+	sprite.frame = 1
+	sprite.time = 0.09
+	set_sprite_clip_def(&sprite, "once", once)
+	testing.expect_value(t, sprite.frame, 1)
+	testing.expect_value(t, sprite.time, f32(0.09))
+
+	set_sprite_clip_def(&sprite, "empty", Clip_Def{loop = true, fps = 10, frames = nil})
+	testing.expect_value(t, sprite.clip, "once")
+	testing.expect_value(t, sprite.frame, 1)
+
+	set_sprite_clip_def(nil, "once", once)
+}
+
+@(test)
+spawn_sprite_valid_and_invalid :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {1, 2}, "idle", 0)
+	testing.expect_value(t, s.clip, "idle")
+	testing.expect_value(t, s.frame, 0)
+	testing.expect_value(t, s.time, f32(0))
+	testing.expect_value(t, s.position, Vec2{1, 2})
+
+	s2 := spawn_sprite(&data, {}, "idle", 2)
+	testing.expect_value(t, s2.clip, "idle")
+	testing.expect_value(t, s2.frame, 2)
+
+	s3 := spawn_sprite(&data, {}, "idle", 99)
+	testing.expect_value(t, s3.frame, 2)
+
+	bad := spawn_sprite(&data, {}, "missing", 0)
+	testing.expect_value(t, bad.clip, "")
+	testing.expect_value(t, bad.frame, 0)
+	testing.expect_value(t, bad.time, f32(0))
+}
+
+@(test)
+update_sprite_advances_one_frame :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {}, "idle", 0)
+	update_sprite(&s, 0.1)
+	testing.expect_value(t, s.frame, 1)
+	testing.expect_value(t, s.time, f32(0))
+}
+
+@(test)
+update_sprite_advances_multiple_frames :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {}, "idle", 0)
+	update_sprite(&s, 0.25)
+	testing.expect_value(t, s.frame, 2)
+	testing.expect(t, s.time > 0.049 && s.time < 0.051, "leftover time after multi-frame advance should be ~0.05")
+}
+
+@(test)
+update_sprite_loops :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {}, "idle", 2)
+	update_sprite(&s, 0.1)
+	testing.expect_value(t, s.frame, 0)
+}
+
+@(test)
+update_sprite_non_loop_holds_last :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {}, "once", 2)
+	s.time = 0.05
+	update_sprite(&s, 0.1)
+	testing.expect_value(t, s.frame, 2)
+	testing.expect_value(t, s.time, f32(0))
+}
+
+@(test)
+update_sprite_fps_zero_holds :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {}, "hold", 0)
+	update_sprite(&s, 1.0)
+	testing.expect_value(t, s.frame, 0)
+}
+
+@(test)
+update_sprite_dt_non_positive_noop :: proc(t: ^testing.T) {
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := spawn_sprite(&data, {}, "idle", 0)
+	update_sprite(&s, 0)
+	update_sprite(&s, -0.1)
+	testing.expect_value(t, s.frame, 0)
+	testing.expect_value(t, s.time, f32(0))
+}
+
+@(test)
+update_sprite_nil_and_missing_clip_safe :: proc(t: ^testing.T) {
+	update_sprite(nil, 0.1)
+
+	data := make_test_character()
+	defer destroy_test_character(&data)
+
+	s := Sprite {
+		data  = &data,
+		clip  = "missing",
+		frame = 0,
+		time  = 0,
+	}
+	update_sprite(&s, 0.1)
+	testing.expect_value(t, s.frame, 0)
+
+	s2 := Sprite {
+		data = nil,
+		clip = "idle",
+	}
+	update_sprite(&s2, 0.1)
+}

engine/app.odin

@@ -1,6 +1,7 @@
 package engine
 
 import "core:fmt"
+import "core:mem"
 import "core:path/filepath"
 import sdl "vendor:sdl3"
 
@@ -10,7 +11,21 @@ Vertex :: struct {
 }
 
 SPRITE_VERT_COUNT :: 6
-VERTEX_BUFFER_SIZE :: SPRITE_VERT_COUNT * size_of(Vertex)
+MAX_SPRITES :: 128
+SPRITE_VERTS_SIZE :: SPRITE_VERT_COUNT * size_of(Vertex)
+VERTEX_BUFFER_SIZE :: MAX_SPRITES * SPRITE_VERTS_SIZE
+
+Queued_Sprite :: struct {
+	texture:     ^sdl.GPUTexture,
+	verts:       [SPRITE_VERT_COUNT]Vertex,
+	batch_group: u32, // 0 = strict order; nonzero = caller permits regrouping
+}
+
+Draw_Batch :: struct {
+	start:   int,
+	count:   int,
+	texture: ^sdl.GPUTexture,
+}
 
 App :: struct {
 	window:            ^sdl.Window,
@@ -25,6 +40,9 @@ App :: struct {
 	swapchain_h:       u32,
 	vertex_buffer:     ^sdl.GPUBuffer,
 	transfer_buffer:   ^sdl.GPUTransferBuffer,
+	draw_list:         [dynamic]Queued_Sprite,
+	clear_color:       sdl.FColor,
+	camera:            Camera,
 }
 
 Shader_Backend :: enum {
@@ -54,7 +72,7 @@ init :: proc(app: ^App, title: cstring, width, height: i32) -> bool {
 	}
 
 	requested: sdl.GPUShaderFormat = {.SPIRV, .DXIL, .MSL}
-	app.device = sdl.CreateGPUDevice(requested, true, nil)
+	app.device = sdl.CreateGPUDevice(requested, false, nil)
 	if app.device == nil {
 		fmt.eprintfln("CreateGPUDevice failed: %s", sdl.GetError())
 		return false
@@ -65,6 +83,23 @@ init :: proc(app: ^App, title: cstring, width, height: i32) -> bool {
 		return false
 	}
 
+	if !sdl.SetGPUAllowedFramesInFlight(app.device, 3) {
+		fmt.eprintfln("SetGPUAllowedFramesInFlight failed: %s", sdl.GetError())
+	}
+
+	// Prefer uncapped present for profiling; fall back if unsupported.
+	present := sdl.GPUPresentMode.VSYNC
+	if sdl.WindowSupportsGPUPresentMode(app.device, app.window, .IMMEDIATE) {
+		present = .IMMEDIATE
+	} else if sdl.WindowSupportsGPUPresentMode(app.device, app.window, .MAILBOX) {
+		present = .MAILBOX
+	}
+	if present != .VSYNC {
+		if !sdl.SetGPUSwapchainParameters(app.device, app.window, .SDR, present) {
+			fmt.eprintfln("SetGPUSwapchainParameters failed: %s", sdl.GetError())
+		}
+	}
+
 	ok: bool
 	app.shader, ok = choose_shader_runtime(app.device)
 	if !ok do return false
@@ -112,10 +147,16 @@ init :: proc(app: ^App, title: cstring, width, height: i32) -> bool {
 		return false
 	}
 
+	app.draw_list = make([dynamic]Queued_Sprite)
+
+	app.camera = camera_default()
+
 	return true
 }
 
 shutdown :: proc(app: ^App) {
+	delete(app.draw_list)
+
 	if app.device != nil {
 		ok := sdl.WaitForGPUIdle(app.device)
 		if !ok {
@@ -164,9 +205,13 @@ events :: proc() -> bool {
 	return true
 }
 
-begin_frame :: proc(app: ^App, clear: sdl.FColor = {0.12, 0.12, 0.16, 1}) {
-	app.cmd = sdl.AcquireGPUCommandBuffer(app.device)
+begin_frame :: proc(app: ^App, clear_color: sdl.FColor = {0.12, 0.12, 0.16, 1}) {
+	clear(&app.draw_list)
+	app.clear_color = clear_color
+	app.render_pass = nil
+	app.swapchain_texture = nil
 
+	app.cmd = sdl.AcquireGPUCommandBuffer(app.device)
 	if app.cmd == nil {
 		fmt.eprintfln("AcquireGPUCommandBuffer failed: %s", sdl.GetError())
 		return
@@ -181,36 +226,102 @@ begin_frame :: proc(app: ^App, clear: sdl.FColor = {0.12, 0.12, 0.16, 1}) {
 	)
 
 	if !ok || app.swapchain_texture == nil {
+		app.swapchain_texture = nil
 		return
 	}
+}
+
+end_frame :: proc(app: ^App) {
+	if app.cmd == nil {
+		clear(&app.draw_list)
+		return
+	}
+
+	cmd := app.cmd
+	defer {
+		app.render_pass = nil
+		app.swapchain_texture = nil
+		app.cmd = nil
+		clear(&app.draw_list)
+	}
+
+	if app.swapchain_texture == nil {
+		if !sdl.SubmitGPUCommandBuffer(cmd) {
+			fmt.eprintfln("SubmitGPUCommandBuffer failed")
+		}
+		return
+	}
+
+	n := len(app.draw_list)
+	batches: [dynamic]Draw_Batch
+	defer delete(batches)
+	if n > 0 {
+		prepare_draw_batches(app.draw_list[:], &batches)
+
+		map_ptr := sdl.MapGPUTransferBuffer(app.device, app.transfer_buffer, false)
+		if map_ptr == nil {
+			fmt.eprintfln("MapGPUTransferBuffer failed: %s", sdl.GetError())
+			if !sdl.SubmitGPUCommandBuffer(cmd) {
+				fmt.eprintfln("SubmitGPUCommandBuffer failed")
+			}
+			return
+		}
+
+		for i in 0 ..< n {
+			q := &app.draw_list[i]
+			offset := i * SPRITE_VERTS_SIZE
+			mem.copy(
+				rawptr(uintptr(map_ptr) + uintptr(offset)),
+				raw_data(q.verts[:]),
+				SPRITE_VERTS_SIZE,
+			)
+		}
+		sdl.UnmapGPUTransferBuffer(app.device, app.transfer_buffer)
+
+		copy_pass := sdl.BeginGPUCopyPass(cmd)
+		src := sdl.GPUTransferBufferLocation {
+			transfer_buffer = app.transfer_buffer,
+			offset          = 0,
+		}
+		dst := sdl.GPUBufferRegion {
+			buffer = app.vertex_buffer,
+			offset = 0,
+			size   = u32(n * SPRITE_VERTS_SIZE),
+		}
+		sdl.UploadToGPUBuffer(copy_pass, src, dst, false)
+		sdl.EndGPUCopyPass(copy_pass)
+	}
 
 	color_info := sdl.GPUColorTargetInfo {
 		texture     = app.swapchain_texture,
-		clear_color = clear,
+		clear_color = app.clear_color,
 		load_op     = .CLEAR,
 		store_op    = .STORE,
 	}
-
-	app.render_pass = sdl.BeginGPURenderPass(app.cmd, &color_info, 1, nil)
-
+	app.render_pass = sdl.BeginGPURenderPass(cmd, &color_info, 1, nil)
 	sdl.BindGPUGraphicsPipeline(app.render_pass, app.pipeline)
-}
 
-end_frame :: proc(app: ^App) {
-	if app.render_pass != nil {
-		sdl.EndGPURenderPass(app.render_pass)
-		app.render_pass = nil
-	}
-
-	if app.cmd != nil {
-		ok := sdl.SubmitGPUCommandBuffer(app.cmd)
-		if !ok {
-			fmt.eprintfln("SubmitGPUCommandBuffer failed")
+	for batch in batches {
+		sampler_binding := sdl.GPUTextureSamplerBinding {
+			texture = batch.texture,
+			sampler = app.sampler,
 		}
-		app.cmd = nil
-	}
+		sdl.BindGPUFragmentSamplers(app.render_pass, 0, &sampler_binding, 1)
 
-	app.swapchain_texture = nil
+		vb_binding := sdl.GPUBufferBinding {
+			buffer = app.vertex_buffer,
+			offset = u32(batch.start * SPRITE_VERTS_SIZE),
+		}
+		sdl.BindGPUVertexBuffers(app.render_pass, 0, &vb_binding, 1)
+
+		sdl.DrawGPUPrimitives(app.render_pass, u32(batch.count * SPRITE_VERT_COUNT), 1, 0, 0)
+	}
+	sdl.EndGPURenderPass(app.render_pass)
+	app.render_pass = nil
+
+	if !sdl.SubmitGPUCommandBuffer(cmd) {
+		fmt.eprintfln("SubmitGPUCommandBuffer failed")
+	}
 }
 
 load_gpu_shader :: proc(
@@ -338,3 +449,133 @@ create_sprite_pipeline :: proc(app: ^App) -> ^sdl.GPUGraphicsPipeline {
 
 	return pipeline
 }
+
+texture_run_len :: proc(list: []Queued_Sprite, start: int) -> int {
+	if start < 0 || start >= len(list) do return 0
+
+	tex := list[start].texture
+	n := 1
+
+	for i in start + 1 ..< len(list) {
+		if list[i].texture != tex do break
+		n += 1
+	}
+
+	return n
+}
+
+texture_run_count :: proc(list: []Queued_Sprite) -> int {
+	if len(list) == 0 do return 0
+	count := 0
+	i := 0
+	for i < len(list) {
+		run := texture_run_len(list, i)
+		count += 1
+		i += run
+	}
+	return count
+}
+
+prepare_draw_batches :: proc(list: []Queued_Sprite, batches: ^[dynamic]Draw_Batch) {
+	clear(batches)
+	group_texture_runs(list)
+	i := 0
+	for i < len(list) {
+		run := texture_run_len(list, i)
+		append(batches, Draw_Batch{start = i, count = run, texture = list[i].texture})
+		i += run
+	}
+}
+
+// Within each contiguous nonzero batch_group, stably sort by texture so
+// consecutive same-texture sprites become one draw. Group 0 and group
+// boundaries are never crossed.
+group_texture_runs :: proc(list: []Queued_Sprite) {
+	start := 0
+	for start < len(list) {
+		group := list[start].batch_group
+		if group == 0 {
+			start += 1
+			continue
+		}
+
+		end := start + 1
+		for end < len(list) && list[end].batch_group == group {
+			end += 1
+		}
+
+		stable_group_by_texture(list[start:end])
+		start = end
+	}
+}
+
+// Stably orders window by texture pointer. Fast path for 1–2 textures
+// (common); insertion sort for 3+.
+stable_group_by_texture :: proc(window: []Queued_Sprite) {
+	n := len(window)
+	if n <= 1 do return
+
+	already := true
+	for i in 1 ..< n {
+		if uintptr(window[i].texture) < uintptr(window[i - 1].texture) {
+			already = false
+			break
+		}
+	}
+	if already do return
+
+	first := uintptr(window[0].texture)
+	second: uintptr
+	has_second := false
+	third := false
+	for i in 1 ..< n {
+		t := uintptr(window[i].texture)
+		if t == first do continue
+		if !has_second {
+			second = t
+			has_second = true
+			continue
+		}
+		if t != second {
+			third = true
+			break
+		}
+	}
+
+	if !has_second do return
+
+	if third {
+		for i in 1 ..< n {
+			item := window[i]
+			j := i
+			for j > 0 {
+				if uintptr(window[j - 1].texture) <= uintptr(item.texture) {
+					break
+				}
+				window[j] = window[j - 1]
+				j -= 1
+			}
+			window[j] = item
+		}
+		return
+	}
+
+	lo, hi := first, second
+	if lo > hi do lo, hi = hi, lo
+
+	tmp: [MAX_SPRITES]Queued_Sprite
+	w := 0
+	for q in window {
+		if uintptr(q.texture) == lo {
+			tmp[w] = q
+			w += 1
+		}
+	}
+	for q in window {
+		if uintptr(q.texture) == hi {
+			tmp[w] = q
+			w += 1
+		}
+	}
+	copy(window, tmp[:w])
+}

engine/batching_test.odin

@@ -0,0 +1,429 @@
+package engine
+
+import "core:testing"
+import sdl "vendor:sdl3"
+
+fake_tex :: proc(id: uintptr) -> ^sdl.GPUTexture {
+	return cast(^sdl.GPUTexture)id
+}
+
+queued :: proc(tex_id: uintptr, group: u32, marker: f32) -> Queued_Sprite {
+	q: Queued_Sprite
+	q.texture = fake_tex(tex_id)
+	q.batch_group = group
+	q.verts[0].pos = {marker, 0}
+	return q
+}
+
+marker_of :: proc(q: Queued_Sprite) -> f32 {
+	return q.verts[0].pos.x
+}
+
+@(test)
+texture_run_len_empty_or_oob :: proc(t: ^testing.T) {
+	testing.expect_value(t, texture_run_len(nil, 0), 0)
+	list := []Queued_Sprite{}
+	testing.expect_value(t, texture_run_len(list, 0), 0)
+	list = make([]Queued_Sprite, 1)
+	defer delete(list)
+	list[0] = {texture = fake_tex(1)}
+	testing.expect_value(t, texture_run_len(list, -1), 0)
+	testing.expect_value(t, texture_run_len(list, 1), 0)
+}
+
+@(test)
+texture_run_len_single :: proc(t: ^testing.T) {
+	list := make([]Queued_Sprite, 1)
+	defer delete(list)
+	list[0] = {texture = fake_tex(1)}
+	testing.expect_value(t, texture_run_len(list, 0), 1)
+}
+
+@(test)
+texture_run_len_same_texture :: proc(t: ^testing.T) {
+	tex := fake_tex(1)
+	list := make([]Queued_Sprite, 3)
+	defer delete(list)
+	list[0] = {texture = tex}
+	list[1] = {texture = tex}
+	list[2] = {texture = tex}
+	testing.expect_value(t, texture_run_len(list, 0), 3)
+}
+
+@(test)
+texture_run_len_breaks_on_change :: proc(t: ^testing.T) {
+	a := fake_tex(1)
+	b := fake_tex(2)
+	list := make([]Queued_Sprite, 3)
+	defer delete(list)
+	list[0] = {texture = a}
+	list[1] = {texture = a}
+	list[2] = {texture = b}
+	testing.expect_value(t, texture_run_len(list, 0), 2)
+	testing.expect_value(t, texture_run_len(list, 2), 1)
+}
+
+@(test)
+texture_run_len_all_different :: proc(t: ^testing.T) {
+	list := make([]Queued_Sprite, 3)
+	defer delete(list)
+	list[0] = {texture = fake_tex(1)}
+	list[1] = {texture = fake_tex(2)}
+	list[2] = {texture = fake_tex(3)}
+	testing.expect_value(t, texture_run_len(list, 0), 1)
+	testing.expect_value(t, texture_run_len(list, 1), 1)
+	testing.expect_value(t, texture_run_len(list, 2), 1)
+}
+
+@(test)
+group_texture_runs_strict_order_unchanged :: proc(t: ^testing.T) {
+	// Group 0 alternates textures; sorting must not reorder (alpha order).
+	list := []Queued_Sprite {
+		queued(2, 0, 1),
+		queued(1, 0, 2),
+		queued(2, 0, 3),
+		queued(1, 0, 4),
+	}
+	before_runs := texture_run_count(list)
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), before_runs)
+	testing.expect_value(t, marker_of(list[0]), f32(1))
+	testing.expect_value(t, marker_of(list[1]), f32(2))
+	testing.expect_value(t, marker_of(list[2]), f32(3))
+	testing.expect_value(t, marker_of(list[3]), f32(4))
+}
+
+@(test)
+group_texture_runs_reduces_runs_inside_group :: proc(t: ^testing.T) {
+	list := []Queued_Sprite {
+		queued(2, 1, 1),
+		queued(1, 1, 2),
+		queued(2, 1, 3),
+		queued(1, 1, 4),
+	}
+	testing.expect_value(t, texture_run_count(list), 4)
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), 2)
+	testing.expect(t, list[0].texture == fake_tex(1), "lower texture pointer first")
+	testing.expect(t, list[1].texture == fake_tex(1), "same texture run")
+	testing.expect(t, list[2].texture == fake_tex(2), "second texture run")
+	testing.expect(t, list[3].texture == fake_tex(2), "second texture run cont")
+}
+
+@(test)
+group_texture_runs_stable_same_texture :: proc(t: ^testing.T) {
+	list := []Queued_Sprite {
+		queued(2, 1, 10),
+		queued(1, 1, 20),
+		queued(2, 1, 30),
+		queued(1, 1, 40),
+	}
+	group_texture_runs(list)
+	// Same-texture relative order preserved (stable sort).
+	testing.expect_value(t, marker_of(list[0]), f32(20))
+	testing.expect_value(t, marker_of(list[1]), f32(40))
+	testing.expect_value(t, marker_of(list[2]), f32(10))
+	testing.expect_value(t, marker_of(list[3]), f32(30))
+}
+
+@(test)
+group_texture_runs_respects_group_boundaries :: proc(t: ^testing.T) {
+	list := []Queued_Sprite {
+		queued(2, 1, 1),
+		queued(1, 1, 2),
+		queued(2, 0, 3), // strict barrier
+		queued(1, 2, 4),
+		queued(2, 2, 5),
+	}
+	group_texture_runs(list)
+	testing.expect_value(t, marker_of(list[2]), f32(3)) // barrier stays put
+	testing.expect(t, list[0].texture == fake_tex(1))
+	testing.expect(t, list[1].texture == fake_tex(2))
+	testing.expect(t, list[3].texture == fake_tex(1))
+	testing.expect(t, list[4].texture == fake_tex(2))
+	testing.expect_value(t, list[0].batch_group, u32(1))
+	testing.expect_value(t, list[1].batch_group, u32(1))
+	testing.expect_value(t, list[2].batch_group, u32(0))
+	testing.expect_value(t, list[3].batch_group, u32(2))
+	testing.expect_value(t, list[4].batch_group, u32(2))
+}
+
+@(test)
+group_texture_runs_does_not_merge_across_different_groups :: proc(t: ^testing.T) {
+	// Adjacent nonzero groups with different ids must not merge runs across.
+	list := []Queued_Sprite {
+		queued(1, 1, 1),
+		queued(2, 1, 2),
+		queued(1, 2, 3),
+		queued(2, 2, 4),
+	}
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), 4)
+	testing.expect_value(t, list[0].batch_group, u32(1))
+	testing.expect_value(t, list[1].batch_group, u32(1))
+	testing.expect_value(t, list[2].batch_group, u32(2))
+	testing.expect_value(t, list[3].batch_group, u32(2))
+}
+
+@(test)
+group_texture_runs_empty :: proc(t: ^testing.T) {
+	list := []Queued_Sprite{}
+	testing.expect_value(t, texture_run_count(list), 0)
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), 0)
+}
+
+@(test)
+group_texture_runs_already_optimal :: proc(t: ^testing.T) {
+	list := []Queued_Sprite {
+		queued(1, 1, 10),
+		queued(1, 1, 20),
+		queued(2, 1, 30),
+		queued(2, 1, 40),
+	}
+	testing.expect_value(t, texture_run_count(list), 2)
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), 2)
+	testing.expect_value(t, marker_of(list[0]), f32(10))
+	testing.expect_value(t, marker_of(list[1]), f32(20))
+	testing.expect_value(t, marker_of(list[2]), f32(30))
+	testing.expect_value(t, marker_of(list[3]), f32(40))
+}
+
+@(test)
+group_texture_runs_alternating_many_stable :: proc(t: ^testing.T) {
+	// Characterization: large alternating group must collapse to two runs
+	// while preserving same-texture submission order (markers).
+	N :: 64
+	list := make([]Queued_Sprite, N)
+	defer delete(list)
+	for i in 0 ..< N {
+		tex: uintptr = 2 if (i % 2) == 0 else 1
+		list[i] = queued(tex, 1, f32(i + 1))
+	}
+	testing.expect_value(t, texture_run_count(list), N)
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), 2)
+	testing.expect(t, list[0].texture == fake_tex(1))
+	testing.expect(t, list[N / 2 - 1].texture == fake_tex(1))
+	testing.expect(t, list[N / 2].texture == fake_tex(2))
+	testing.expect(t, list[N - 1].texture == fake_tex(2))
+	for i in 0 ..< N / 2 {
+		testing.expect_value(t, marker_of(list[i]), f32(2 * i + 2)) // odd markers: 2,4,...,N
+		testing.expect_value(t, marker_of(list[N / 2 + i]), f32(2 * i + 1)) // even markers: 1,3,...,N-1
+	}
+}
+
+@(test)
+group_texture_runs_three_textures_stable :: proc(t: ^testing.T) {
+	list := []Queued_Sprite {
+		queued(3, 1, 1),
+		queued(1, 1, 2),
+		queued(2, 1, 3),
+		queued(3, 1, 4),
+		queued(1, 1, 5),
+		queued(2, 1, 6),
+	}
+	testing.expect_value(t, texture_run_count(list), 6)
+	group_texture_runs(list)
+	testing.expect_value(t, texture_run_count(list), 3)
+	testing.expect_value(t, marker_of(list[0]), f32(2))
+	testing.expect_value(t, marker_of(list[1]), f32(5))
+	testing.expect_value(t, marker_of(list[2]), f32(3))
+	testing.expect_value(t, marker_of(list[3]), f32(6))
+	testing.expect_value(t, marker_of(list[4]), f32(1))
+	testing.expect_value(t, marker_of(list[5]), f32(4))
+}
+
+@(test)
+group_texture_runs_noncontiguous_same_group_id :: proc(t: ^testing.T) {
+	// Same nonzero id split by group 0: each window regroups alone.
+	list := []Queued_Sprite {
+		queued(2, 1, 1),
+		queued(1, 1, 2),
+		queued(2, 0, 3),
+		queued(2, 1, 4),
+		queued(1, 1, 5),
+	}
+	group_texture_runs(list)
+	testing.expect_value(t, marker_of(list[2]), f32(3))
+	testing.expect(t, list[0].texture == fake_tex(1))
+	testing.expect(t, list[1].texture == fake_tex(2))
+	testing.expect_value(t, list[2].batch_group, u32(0))
+	testing.expect(t, list[3].texture == fake_tex(1))
+	testing.expect(t, list[4].texture == fake_tex(2))
+	testing.expect_value(t, list[0].batch_group, u32(1))
+	testing.expect_value(t, list[1].batch_group, u32(1))
+	testing.expect_value(t, list[3].batch_group, u32(1))
+	testing.expect_value(t, list[4].batch_group, u32(1))
+}
+
+make_test_draw_app :: proc() -> App {
+	app: App
+	app.cmd = cast(^sdl.GPUCommandBuffer)uintptr(1)
+	app.swapchain_texture = fake_tex(99)
+	app.swapchain_w = 800
+	app.swapchain_h = 600
+	app.camera = camera_default()
+	app.draw_list = make([dynamic]Queued_Sprite)
+	return app
+}
+
+destroy_test_draw_app :: proc(app: ^App) {
+	if app == nil do return
+	delete(app.draw_list)
+	app^ = {}
+}
+
+make_test_draw_character :: proc() -> Character_Data {
+	data: Character_Data
+	data.texture = fake_tex(42)
+	data.width = 100
+	data.height = 100
+	data.def.pivot = {0.5, 1.0}
+	data.def.clips = make(map[string]Clip_Def)
+	frames := make([]Frame_Def, 1)
+	frames[0] = Frame_Def {
+		rect        = {0, 0, 10, 10},
+		source_size = {10, 10},
+		trim_offset = {0, 0},
+	}
+	data.def.clips["idle"] = Clip_Def {
+		loop   = true,
+		fps    = 10,
+		frames = frames,
+	}
+	return data
+}
+
+destroy_test_draw_character :: proc(data: ^Character_Data) {
+	if data == nil do return
+	keys := make([dynamic]string, context.temp_allocator)
+	for key, clip in data.def.clips {
+		delete(clip.frames)
+		append(&keys, key)
+	}
+	for key in keys {
+		delete_key(&data.def.clips, key)
+	}
+	delete(data.def.clips)
+	data^ = {}
+}
+
+@(test)
+draw_sprite_stamps_batch_group_zero :: proc(t: ^testing.T) {
+	app := make_test_draw_app()
+	defer destroy_test_draw_app(&app)
+	data := make_test_draw_character()
+	defer destroy_test_draw_character(&data)
+
+	sprite := spawn_sprite(&data, {100, 200}, "idle", 0)
+	draw_sprite(&app, &sprite)
+
+	testing.expect_value(t, len(app.draw_list), 1)
+	testing.expect_value(t, app.draw_list[0].batch_group, u32(0))
+	testing.expect(t, app.draw_list[0].texture == data.texture)
+}
+
+@(test)
+draw_sprite_at_max_sprites_does_not_append :: proc(t: ^testing.T) {
+	app := make_test_draw_app()
+	defer destroy_test_draw_app(&app)
+	data := make_test_draw_character()
+	defer destroy_test_draw_character(&data)
+
+	for _ in 0 ..< MAX_SPRITES {
+		append(&app.draw_list, Queued_Sprite{texture = data.texture})
+	}
+	testing.expect_value(t, len(app.draw_list), MAX_SPRITES)
+
+	sprite := spawn_sprite(&data, {100, 200}, "idle", 0)
+	draw_sprite(&app, &sprite)
+
+	testing.expect_value(t, len(app.draw_list), MAX_SPRITES)
+}
+
+@(test)
+draw_sprite_batched_stamps_batch_group :: proc(t: ^testing.T) {
+	app := make_test_draw_app()
+	defer destroy_test_draw_app(&app)
+	data := make_test_draw_character()
+	defer destroy_test_draw_character(&data)
+
+	sprite := spawn_sprite(&data, {100, 200}, "idle", 0)
+	draw_sprite_batched(&app, &sprite, 7)
+
+	testing.expect_value(t, len(app.draw_list), 1)
+	testing.expect_value(t, app.draw_list[0].batch_group, u32(7))
+	testing.expect(t, app.draw_list[0].texture == data.texture)
+}
+
+@(test)
+draw_sprite_batched_guards_leave_list_unchanged :: proc(t: ^testing.T) {
+	app := make_test_draw_app()
+	defer destroy_test_draw_app(&app)
+	data := make_test_draw_character()
+	defer destroy_test_draw_character(&data)
+	sprite := spawn_sprite(&data, {100, 200}, "idle", 0)
+
+	app.cmd = nil
+	draw_sprite_batched(&app, &sprite, 1)
+	testing.expect_value(t, len(app.draw_list), 0)
+	app.cmd = cast(^sdl.GPUCommandBuffer)uintptr(1)
+
+	app.swapchain_texture = nil
+	draw_sprite_batched(&app, &sprite, 1)
+	testing.expect_value(t, len(app.draw_list), 0)
+	app.swapchain_texture = fake_tex(99)
+
+	draw_sprite_batched(&app, nil, 1)
+	testing.expect_value(t, len(app.draw_list), 0)
+
+	no_data := sprite
+	no_data.data = nil
+	draw_sprite_batched(&app, &no_data, 1)
+	testing.expect_value(t, len(app.draw_list), 0)
+
+	no_tex := sprite
+	tex_data := data
+	tex_data.texture = nil
+	no_tex.data = &tex_data
+	draw_sprite_batched(&app, &no_tex, 1)
+	testing.expect_value(t, len(app.draw_list), 0)
+}
+
+@(test)
+prepare_draw_batches_regroups_then_plans_runs :: proc(t: ^testing.T) {
+	list := []Queued_Sprite {
+		queued(2, 1, 1),
+		queued(1, 1, 2),
+		queued(2, 1, 3),
+		queued(1, 1, 4),
+		queued(3, 0, 5),
+		queued(1, 0, 6),
+	}
+	batches := make([dynamic]Draw_Batch)
+	defer delete(batches)
+
+	prepare_draw_batches(list, &batches)
+
+	testing.expect_value(t, len(batches), 4)
+	testing.expect_value(t, batches[0].start, 0)
+	testing.expect_value(t, batches[0].count, 2)
+	testing.expect(t, batches[0].texture == fake_tex(1))
+	testing.expect_value(t, batches[1].start, 2)
+	testing.expect_value(t, batches[1].count, 2)
+	testing.expect(t, batches[1].texture == fake_tex(2))
+	testing.expect_value(t, batches[2].start, 4)
+	testing.expect_value(t, batches[2].count, 1)
+	testing.expect(t, batches[2].texture == fake_tex(3))
+	testing.expect_value(t, batches[3].start, 5)
+	testing.expect_value(t, batches[3].count, 1)
+	testing.expect(t, batches[3].texture == fake_tex(1))
+
+	// Group 0 submission order preserved.
+	testing.expect_value(t, marker_of(list[4]), f32(5))
+	testing.expect_value(t, marker_of(list[5]), f32(6))
+	testing.expect_value(t, list[4].batch_group, u32(0))
+	testing.expect_value(t, list[5].batch_group, u32(0))
+}

engine/camera.odin

@@ -0,0 +1,17 @@
+package engine
+
+Camera :: struct {
+	position: Vec2,
+	anchor:   Vec2,
+}
+
+camera_default :: proc() -> Camera {
+	return Camera{position = {0, 0}, anchor = {0.5, 0.5}}
+}
+
+world_to_screen :: proc(cam: Camera, world: Vec2, viewport: Vec2) -> Vec2 {
+	return {
+		world.x - cam.position.x + viewport.x * cam.anchor[0],
+		world.y - cam.position.y + viewport.y * cam.anchor[1],
+	}
+}

engine/camera_test.odin

@@ -0,0 +1,44 @@
+package engine
+
+import "core:testing"
+
+@(test)
+camera_default_values :: proc(t: ^testing.T) {
+	cam := camera_default()
+	testing.expect_value(t, cam.position, Vec2{0, 0})
+	testing.expect_value(t, cam.anchor, Vec2{0.5, 0.5})
+}
+
+@(test)
+world_to_screen_centered_identity :: proc(t: ^testing.T) {
+	cam := Camera {
+		position = {400, 500},
+		anchor   = {0.5, 0.5},
+	}
+	viewport := Vec2{800, 600}
+	screen := world_to_screen(cam, cam.position, viewport)
+	testing.expect_value(t, screen.x, f32(400))
+	testing.expect_value(t, screen.y, f32(300))
+}
+
+@(test)
+world_to_screen_origin_cam :: proc(t: ^testing.T) {
+	cam := Camera {
+		position = {0, 0},
+		anchor   = {0.5, 0.5},
+	}
+	screen := world_to_screen(cam, {10, 20}, {200, 100})
+	testing.expect_value(t, screen.x, f32(110))
+	testing.expect_value(t, screen.y, f32(70))
+}
+
+@(test)
+world_to_screen_top_left_anchor :: proc(t: ^testing.T) {
+	cam := Camera {
+		position = {5, 7},
+		anchor   = {0, 0},
+	}
+	screen := world_to_screen(cam, {15, 27}, {800, 600})
+	testing.expect_value(t, screen.x, f32(10))
+	testing.expect_value(t, screen.y, f32(20))
+}

engine/character_data.odin

@@ -170,7 +170,10 @@ load_character_data :: proc(app: ^App, character_json_path: string) -> (Characte
 	sdl.EndGPUCopyPass(copy_pass)
 	fence := sdl.SubmitGPUCommandBufferAndAcquireFence(cmd)
 	if fence == nil {
-		fmt.eprintfln("SubmitGPUCommandBufferAndAcquireFence (texture upload) failed: %s", sdl.GetError())
+		fmt.eprintfln(
+			"SubmitGPUCommandBufferAndAcquireFence (texture upload) failed: %s",
+			sdl.GetError(),
+		)
 		sdl.ReleaseGPUTransferBuffer(app.device, tbuf)
 		sdl.ReleaseGPUTexture(app.device, out.texture)
 		return {}, false
@@ -200,6 +203,29 @@ destroy_character_data :: proc(app: ^App, data: ^Character_Data) {
 	data^ = {}
 }
 
+character_clip :: proc(data: ^Character_Data, clip_name: string) -> (clip: Clip_Def, ok: bool) {
+	if data == nil do return {}, false
+	character, found := data.def.clips[clip_name]
+	if !found || len(character.frames) == 0 do return {}, false
+	return character, true
+}
+
+character_frame :: proc(
+	data: ^Character_Data,
+	clip_name: string,
+	frame_index: int,
+) -> (
+	frame: Frame_Def,
+	ok: bool,
+) {
+	if data == nil do return {}, false
+	clip, found := data.def.clips[clip_name]
+	if !found || frame_index < 0 || frame_index >= len(clip.frames) {
+		return {}, false
+	}
+	return clip.frames[frame_index], true
+}
+
 character_frame_rect :: proc(
 	data: ^Character_Data,
 	clip_name: string,
@@ -208,10 +234,7 @@ character_frame_rect :: proc(
 	rect: [4]int,
 	ok: bool,
 ) {
-	clip, found := data.def.clips[clip_name]
-	if !found || frame_index < 0 || frame_index >= len(clip.frames) {
-		return {}, false
-	}
-
-	return clip.frames[frame_index].rect, true
+	frame, found := character_frame(data, clip_name, frame_index)
+	if !found do return {}, false
+	return frame.rect, true
 }

engine/character_data_test.odin

@@ -11,7 +11,7 @@ parse_char_def_happy_path :: proc(t: ^testing.T) {
 	def, ok := parse_char_def(src)
 	defer destroy_char_def(&def)
 
-	testing.expect(t, ok)
+	testing.expect(t, ok, "parse_char_def should succeed on valid JSON")
 	testing.expect_value(t, def.id, "toad")
 	testing.expect_value(t, def.atlas, "toad.atlas.png")
 	testing.expect_value(t, def.version, 1)
@@ -20,8 +20,8 @@ parse_char_def_happy_path :: proc(t: ^testing.T) {
 	testing.expect_value(t, def.pivot[1], f32(1.0))
 
 	idle, found := def.clips["idle"]
-	testing.expect(t, found)
-	testing.expect(t, idle.loop)
+	testing.expect(t, found, "expected idle clip in parsed def")
+	testing.expect(t, idle.loop, "idle clip should loop")
 	testing.expect_value(t, idle.fps, f32(8.0))
 	testing.expect_value(t, len(idle.frames), 1)
 	testing.expect_value(t, idle.frames[0].rect, [4]int{1, 2, 3, 4})
@@ -30,7 +30,7 @@ parse_char_def_happy_path :: proc(t: ^testing.T) {
 @(test)
 parse_char_def_bad_json :: proc(t: ^testing.T) {
 	_, ok := parse_char_def(transmute([]u8)string("{ not json"))
-	testing.expect(t, !ok)
+	testing.expect(t, !ok, "parse_char_def should fail on invalid JSON")
 }
 
 @(test)
@@ -51,17 +51,66 @@ character_frame_rect_hit_and_miss :: proc(t: ^testing.T) {
 	}
 
 	rect, ok := character_frame_rect(&data, "idle", 1)
-	testing.expect(t, ok)
+	testing.expect(t, ok, "character_frame_rect should find idle frame 1")
 	testing.expect_value(t, rect, [4]int{50, 60, 70, 80})
 
 	_, ok = character_frame_rect(&data, "missing", 0)
-	testing.expect(t, !ok)
+	testing.expect(t, !ok, "character_frame_rect should miss unknown clip")
 
 	_, ok = character_frame_rect(&data, "idle", -1)
-	testing.expect(t, !ok)
+	testing.expect(t, !ok, "character_frame_rect should reject negative index")
 
 	_, ok = character_frame_rect(&data, "idle", 2)
-	testing.expect(t, !ok)
+	testing.expect(t, !ok, "character_frame_rect should reject out-of-range index")
+}
+
+@(test)
+character_frame_returns_full_def :: proc(t: ^testing.T) {
+	data: Character_Data
+	data.def.clips = make(map[string]Clip_Def)
+	defer delete(data.def.clips)
+
+	frames := make([]Frame_Def, 1)
+	frames[0] = Frame_Def {
+		rect        = {10, 20, 30, 40},
+		source_size = {100, 200},
+		trim_offset = {5, 7},
+	}
+	defer delete(frames)
+
+	data.def.clips["idle"] = Clip_Def {
+		loop   = true,
+		fps    = 10,
+		frames = frames,
+	}
+
+	frame, ok := character_frame(&data, "idle", 0)
+	testing.expect(t, ok, "character_frame should find idle frame 0")
+	testing.expect_value(t, frame.rect, [4]int{10, 20, 30, 40})
+	testing.expect_value(t, frame.source_size, [2]int{100, 200})
+	testing.expect_value(t, frame.trim_offset, [2]int{5, 7})
+}
+
+@(test)
+character_frame_nil_and_bad_index :: proc(t: ^testing.T) {
+	_, ok := character_frame(nil, "idle", 0)
+	testing.expect(t, !ok, "character_frame should fail on nil data")
+
+	data: Character_Data
+	data.def.clips = make(map[string]Clip_Def)
+	defer delete(data.def.clips)
+
+	frames := make([]Frame_Def, 1)
+	frames[0] = {rect = {1, 2, 3, 4}}
+	defer delete(frames)
+	data.def.clips["idle"] = Clip_Def{frames = frames}
+
+	_, ok = character_frame(&data, "idle", -1)
+	testing.expect(t, !ok, "character_frame should reject negative index")
+	_, ok = character_frame(&data, "idle", 1)
+	testing.expect(t, !ok, "character_frame should reject out-of-range index")
+	_, ok = character_frame(&data, "missing", 0)
+	testing.expect(t, !ok, "character_frame should miss unknown clip")
 }
 
 destroy_char_def :: proc(def: ^Char_Def) {

engine/input.odin

@@ -0,0 +1,43 @@
+package engine
+
+import sdl "vendor:sdl3"
+
+Key :: enum {
+	A,
+	D,
+	Left,
+	Right,
+	Up,
+	Down,
+	Space,
+	N1,
+	N2,
+}
+
+key_down :: proc(key: Key) -> bool {
+	keys := sdl.GetKeyboardState(nil)
+	if keys == nil do return false
+
+	scan_code: sdl.Scancode
+	switch key {
+	case .A:
+		scan_code = .A
+	case .D:
+		scan_code = .D
+	case .Left:
+		scan_code = .LEFT
+	case .Right:
+		scan_code = .RIGHT
+	case .Up:
+		scan_code = .UP
+	case .Down:
+		scan_code = .DOWN
+	case .Space:
+		scan_code = .SPACE
+	case .N1:
+		scan_code = ._1
+	case .N2:
+		scan_code = ._2
+	}
+	return keys[scan_code]
+}

engine/shader_backend_test.odin

@@ -21,16 +21,25 @@ shader_filenames_per_backend :: proc(t: ^testing.T) {
 @(test)
 choose_shader_runtime_prefers_msl :: proc(t: ^testing.T) {
 	rt, ok := choose_shader_runtime_from_formats({.MSL, .SPIRV, .DXIL})
-	testing.expect(t, ok)
+	testing.expect(t, ok, "should pick a runtime when MSL is available")
 	testing.expect_value(t, rt.backend, Shader_Backend.Metal_MSL)
 	testing.expect_value(t, rt.shader_dir, "shaders/metal")
 	testing.expect_value(t, rt.format, sdl.GPUShaderFormat{.MSL})
 }
 
+@(test)
+choose_shader_runtime_prefers_dxil_without_msl :: proc(t: ^testing.T) {
+	rt, ok := choose_shader_runtime_from_formats({.DXIL, .SPIRV})
+	testing.expect(t, ok, "should pick a runtime when DXIL is available")
+	testing.expect_value(t, rt.backend, Shader_Backend.DSD12_DXIL)
+	testing.expect_value(t, rt.shader_dir, "shaders/d3d12")
+	testing.expect_value(t, rt.format, sdl.GPUShaderFormat{.DXIL})
+}
+
 @(test)
 choose_shader_runtime_spirv_only :: proc(t: ^testing.T) {
 	rt, ok := choose_shader_runtime_from_formats({.SPIRV})
-	testing.expect(t, ok)
+	testing.expect(t, ok, "should pick SPIR-V when it is the only format")
 	testing.expect_value(t, rt.backend, Shader_Backend.Vulkan_SPIRV)
 	testing.expect_value(t, rt.shader_dir, "shaders/vulkan")
 	testing.expect_value(t, rt.format, sdl.GPUShaderFormat{.SPIRV})
@@ -39,5 +48,5 @@ choose_shader_runtime_spirv_only :: proc(t: ^testing.T) {
 @(test)
 choose_shader_runtime_empty_fails :: proc(t: ^testing.T) {
 	_, ok := choose_shader_runtime_from_formats({})
-	testing.expect(t, !ok)
+	testing.expect(t, !ok, "empty format set should fail")
 }

engine/sprite.odin

@@ -1,15 +1,18 @@
 package engine
 
-import "core:mem"
 import sdl "vendor:sdl3"
 
 Vec2 :: [2]f32
 
 Sprite :: struct {
-	data:     ^Character_Data,
-	position: Vec2,
-	clip:     string,
-	frame:    int,
+	data:      ^Character_Data,
+	position:  Vec2,
+	clip:      string,
+	clip_def:  Clip_Def,
+	has_clip:  bool,
+	frame:     int,
+	time:      f32,
+	flip_x:    bool,
 }
 
 spawn_sprite :: proc(
@@ -18,13 +21,58 @@ spawn_sprite :: proc(
 	clip: string = "idle",
 	frame: int = 0,
 ) -> Sprite {
-	return Sprite{data = data, position = position, clip = clip, frame = frame}
+	sprite := Sprite {
+		data     = data,
+		position = position,
+	}
+	set_sprite_clip(&sprite, clip)
+	if frame != 0 && sprite.has_clip {
+		c := sprite.clip_def
+		if frame < 0 {
+			sprite.frame = 0
+		} else if frame >= len(c.frames) {
+			sprite.frame = len(c.frames) - 1
+		} else {
+			sprite.frame = frame
+		}
+	}
+	return sprite
 }
 
-// stubbed for later
 update_sprite :: proc(sprite: ^Sprite, dt: f32) {
-	_ = sprite
-	_ = dt
+	if sprite == nil || sprite.data == nil do return
+	if dt <= 0 do return
+	if !sprite.has_clip do return
+
+	clip := sprite.clip_def
+
+	frame_count := len(clip.frames)
+	if frame_count <= 0 do return
+
+	if sprite.frame < 0 do sprite.frame = 0
+	if sprite.frame >= frame_count do sprite.frame = frame_count - 1
+
+	if clip.fps <= 0 do return
+
+	sprite.time += dt
+	frame_duration := 1.0 / clip.fps
+
+	for sprite.time >= frame_duration {
+		sprite.time -= frame_duration
+		next := sprite.frame + 1
+
+		if next >= frame_count {
+			if clip.loop {
+				sprite.frame = 0
+			} else {
+				sprite.frame = frame_count - 1
+				sprite.time = 0
+				break
+			}
+		} else {
+			sprite.frame = next
+		}
+	}
 }
 
 to_clip :: proc(px, py, sw, sh: f32) -> [2]f32 {
@@ -34,44 +82,81 @@ to_clip :: proc(px, py, sw, sh: f32) -> [2]f32 {
 	}
 }
 
+// Axis-aligned quad: two unique x and y values, so scale once and reuse.
+sprite_quad_to_clip :: proc(x0, y0, x1, y1, sw, sh: f32) -> [4]Vec2 {
+	sx := 2.0 / sw
+	sy := 2.0 / sh
+
+	left := x0 * sx - 1
+	right := x1 * sx - 1
+	top := 1 - y0 * sy
+	bottom := 1 - y1 * sy
+
+	return {
+		{left, top},
+		{right, top},
+		{right, bottom},
+		{left, bottom},
+	}
+}
+
 draw_sprite :: proc(app: ^App, sprite: ^Sprite) {
-	if app.render_pass == nil || app.cmd == nil || app.swapchain_texture == nil {
-		return // begin_frame may have skipped (minimized window, etc.)
+	draw_sprite_batched(app, sprite, 0)
+}
+
+// Nonzero batch_group lets end_frame regroup consecutive same-group sprites by
+// texture. Group 0 keeps exact submission order for correct alpha overlap.
+draw_sprite_batched :: proc(app: ^App, sprite: ^Sprite, batch_group: u32) {
+	if app.cmd == nil || app.swapchain_texture == nil {
+		return
 	}
 	if sprite == nil || sprite.data == nil || sprite.data.texture == nil {
 		return
 	}
-
-	rect, ok := character_frame_rect(sprite.data, sprite.clip, sprite.frame)
-	if !ok {
+	if len(app.draw_list) >= MAX_SPRITES {
+		return
+	}
+	if !sprite.has_clip do return
+	if sprite.frame < 0 || sprite.frame >= len(sprite.clip_def.frames) {
 		return
 	}
 
-	fw := f32(rect[2])
-	fh := f32(rect[3])
+	frame := sprite.clip_def.frames[sprite.frame]
 
-	// Feet-centered placement, same as renderer version
-	x0_px := sprite.position.x - fw * 0.5
-	y0_px := sprite.position.y - fh
-	x1_px := x0_px + fw
-	y1_px := y0_px + fh
+	src_w := f32(frame.source_size[0])
+	src_h := f32(frame.source_size[1])
+	if src_w <= 0 do src_w = f32(frame.rect[2])
+	if src_h <= 0 do src_h = f32(frame.rect[3])
+
+	fw := f32(frame.rect[2])
+	fh := f32(frame.rect[3])
+	trim_x := f32(frame.trim_offset[0])
+	trim_y := f32(frame.trim_offset[1])
+	pivot := sprite.data.def.pivot
+
+	viewport := Vec2{f32(app.swapchain_w), f32(app.swapchain_h)}
+	feet := world_to_screen(app.camera, sprite.position, viewport)
+
+	x0_px, y0_px, x1_px, y1_px := sprite_feet_quad(
+		feet,
+		src_w,
+		src_h,
+		{trim_x, trim_y},
+		{fw, fh},
+		pivot,
+		sprite.flip_x,
+	)
 
 	sw := f32(app.swapchain_w)
 	sh := f32(app.swapchain_h)
-	p0 := to_clip(x0_px, y0_px, sw, sh) // top-left
-	p1 := to_clip(x1_px, y0_px, sw, sh) // top-right
-	p2 := to_clip(x1_px, y1_px, sw, sh) // bottom-right
-	p3 := to_clip(x0_px, y1_px, sw, sh) // bottom-left
+	points := sprite_quad_to_clip(x0_px, y0_px, x1_px, y1_px, sw, sh)
+	p0, p1, p2, p3 := points[0], points[1], points[2], points[3]
 
 	tex_w := f32(sprite.data.width)
 	tex_h := f32(sprite.data.height)
-	u0 := f32(rect[0]) / tex_w
-	v0 := f32(rect[1]) / tex_h
-	u1 := f32(rect[0] + rect[2]) / tex_w
-	v1 := f32(rect[1] + rect[3]) / tex_h
+	u0, v0, u1, v1 := frame_uvs(frame.rect, tex_w, tex_h, sprite.flip_x)
 
-	// Two triangles: (0,1,2) and (0,2,3)
-	verts := [6]Vertex {
+	verts := [SPRITE_VERT_COUNT]Vertex {
 		{pos = p0, uv = {u0, v0}},
 		{pos = p1, uv = {u1, v0}},
 		{pos = p2, uv = {u1, v1}},
@@ -80,52 +165,81 @@ draw_sprite :: proc(app: ^App, sprite: ^Sprite) {
 		{pos = p3, uv = {u0, v1}},
 	}
 
-	map_ptr := sdl.MapGPUTransferBuffer(app.device, app.transfer_buffer, false)
-	if map_ptr == nil {
-		return
-	}
-	mem.copy(map_ptr, raw_data(verts[:]), size_of(verts))
-	sdl.UnmapGPUTransferBuffer(app.device, app.transfer_buffer)
-
-	// IMPORTANT: SDL does not allow beginning a copy pass while a render pass
-	// is active on the same command buffer. Upload on a separate command buffer.
-	copy_cmd := sdl.AcquireGPUCommandBuffer(app.device)
-	if copy_cmd == nil {
-		return
-	}
-	copy_pass := sdl.BeginGPUCopyPass(copy_cmd)
-
-	src := sdl.GPUTransferBufferLocation {
-		transfer_buffer = app.transfer_buffer,
-		offset          = 0,
-	}
-	dst := sdl.GPUBufferRegion {
-		buffer = app.vertex_buffer,
-		offset = 0,
-		size   = u32(size_of(verts)),
-	}
-	sdl.UploadToGPUBuffer(copy_pass, src, dst, false)
-	sdl.EndGPUCopyPass(copy_pass)
-	fence := sdl.SubmitGPUCommandBufferAndAcquireFence(copy_cmd)
-	if fence == nil {
-		return
-	}
-	defer sdl.ReleaseGPUFence(app.device, fence)
-	if !sdl.WaitForGPUFences(app.device, true, &fence, 1) {
-		return
-	}
-
-	sampler_binding := sdl.GPUTextureSamplerBinding {
-		texture = sprite.data.texture,
-		sampler = app.sampler,
-	}
-	sdl.BindGPUFragmentSamplers(app.render_pass, 0, &sampler_binding, 1)
-
-	vb_binding := sdl.GPUBufferBinding {
-		buffer = app.vertex_buffer,
-		offset = 0,
-	}
-	sdl.BindGPUVertexBuffers(app.render_pass, 0, &vb_binding, 1)
-
-	sdl.DrawGPUPrimitives(app.render_pass, 6, 1, 0, 0)
+	append(
+		&app.draw_list,
+		Queued_Sprite {
+			texture = sprite.data.texture,
+			verts = verts,
+			batch_group = batch_group,
+		},
+	)
+}
+
+set_sprite_clip :: proc(sprite: ^Sprite, clip: string) {
+	if sprite == nil || sprite.data == nil do return
+
+	if sprite.clip == clip && sprite.has_clip do return
+
+	def, ok := character_clip(sprite.data, clip)
+	if !ok do return
+
+	set_sprite_clip_def(sprite, clip, def)
+}
+
+// Applies a pre-resolved clip without looking up the character clip map.
+// Use when callers already hold Clip_Def (e.g. thrashing between known clips).
+set_sprite_clip_def :: proc(sprite: ^Sprite, clip: string, def: Clip_Def) {
+	if sprite == nil do return
+	if len(def.frames) == 0 do return
+
+	if sprite.clip == clip && sprite.has_clip do return
+
+	sprite.clip = clip
+	sprite.clip_def = def
+	sprite.has_clip = true
+	sprite.frame = 0
+	sprite.time = 0
+}
+
+sprite_quad_origin :: proc(position: Vec2, size: Vec2, pivot: [2]f32) -> Vec2 {
+	return {position.x - size.x * pivot[0], position.y - size.y * pivot[1]}
+}
+
+frame_uvs :: proc(rect: [4]int, tex_w, tex_h: f32, flip_x: bool) -> (u0, v0, u1, v1: f32) {
+	u0 = f32(rect[0]) / tex_w
+	v0 = f32(rect[1]) / tex_h
+	u1 = f32(rect[0] + rect[2]) / tex_w
+	v1 = f32(rect[1] + rect[3]) / tex_h
+	if flip_x do u0, u1 = u1, u0
+	return
+}
+
+sprite_feet_quad :: proc(
+	feet: Vec2,
+	src_w, src_h: f32,
+	trim: Vec2,
+	size: Vec2,
+	pivot: [2]f32,
+	flip_x: bool,
+) -> (
+	x0, y0, x1, y1: f32,
+) {
+	canvas_top := feet.y - src_h * pivot[1]
+	if flip_x {
+		canvas_left := feet.x - (1.0 - pivot[0]) * src_w
+		x0 = canvas_left + (src_w - trim.x - size.x)
+		y0 = canvas_top + trim.y
+	} else {
+		canvas_left := feet.x - src_w * pivot[0]
+		x0 = canvas_left + trim.x
+		y0 = canvas_top + trim.y
+	}
+	x1 = x0 + size.x
+	y1 = y0 + size.y
+	return
+}
+
+set_sprite_flip_x :: proc(sprite: ^Sprite, flip: bool) {
+	if sprite == nil do return
+	sprite.flip_x = flip
 }

engine/sprite_test.odin

@@ -19,3 +19,73 @@ to_clip_corners :: proc(t: ^testing.T) {
 	testing.expect_value(t, p[0], f32(0))
 	testing.expect_value(t, p[1], f32(0))
 }
+
+@(test)
+sprite_quad_origin_feet :: proc(t: ^testing.T) {
+	o := sprite_quad_origin({400, 500}, {100, 200}, {0.5, 1.0})
+	testing.expect_value(t, o.x, f32(350))
+	testing.expect_value(t, o.y, f32(300))
+}
+
+@(test)
+sprite_quad_origin_center :: proc(t: ^testing.T) {
+	o := sprite_quad_origin({400, 500}, {100, 200}, {0.5, 0.5})
+	testing.expect_value(t, o.x, f32(350))
+	testing.expect_value(t, o.y, f32(400))
+}
+
+@(test)
+frame_uvs_unflipped :: proc(t: ^testing.T) {
+	u0, v0, u1, v1 := frame_uvs({10, 20, 30, 40}, 100, 200, false)
+	testing.expect_value(t, u0, f32(0.1))
+	testing.expect_value(t, v0, f32(0.1))
+	testing.expect_value(t, u1, f32(0.4))
+	testing.expect_value(t, v1, f32(0.3))
+	testing.expect(t, u0 < u1, "unflipped UVs should have u0 < u1")
+}
+
+@(test)
+frame_uvs_flipped :: proc(t: ^testing.T) {
+	a0, _, a1, _ := frame_uvs({10, 20, 30, 40}, 100, 200, false)
+	b0, v0, b1, v1 := frame_uvs({10, 20, 30, 40}, 100, 200, true)
+	testing.expect_value(t, b0, a1)
+	testing.expect_value(t, b1, a0)
+	testing.expect_value(t, v0, f32(0.1))
+	testing.expect_value(t, v1, f32(0.3))
+}
+
+@(test)
+sprite_feet_quad_no_flip :: proc(t: ^testing.T) {
+	// feet (400,500), source 100x200, pivot feet, trim (10,20), packed 80x160
+	x0, y0, x1, y1 := sprite_feet_quad(
+		{400, 500},
+		100,
+		200,
+		{10, 20},
+		{80, 160},
+		{0.5, 1.0},
+		false,
+	)
+	testing.expect_value(t, x0, f32(360)) // 400 - 50 + 10
+	testing.expect_value(t, y0, f32(320)) // 500 - 200 + 20
+	testing.expect_value(t, x1, f32(440))
+	testing.expect_value(t, y1, f32(480))
+}
+
+@(test)
+sprite_feet_quad_flip_x :: proc(t: ^testing.T) {
+	x0, y0, x1, y1 := sprite_feet_quad(
+		{400, 500},
+		100,
+		200,
+		{5, 20},
+		{80, 160},
+		{0.5, 1.0},
+		true,
+	)
+	// canvas_left = 350; trim_x_draw = 100 - 5 - 80 = 15 → x0 = 365
+	testing.expect_value(t, x0, f32(365))
+	testing.expect_value(t, y0, f32(320))
+	testing.expect_value(t, x1, f32(445))
+	testing.expect_value(t, y1, f32(480))
+}

engine/time.odin

@@ -0,0 +1,8 @@
+package engine
+
+import sdl "vendor:sdl3"
+
+// now_seconds returns seconds since SDL init (monotonic for frame timing).
+now_seconds :: proc() -> f64 {
+	return f64(sdl.GetTicksNS()) / 1_000_000_000.0
+}

examples/camera_sandbox/main.odin

@@ -0,0 +1,58 @@
+package main
+
+import eng "pkg:engine"
+
+// Camera sandbox: toad stays put; arrows pan the camera. Space toggles follow mode.
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "camera sandbox", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	toad := eng.spawn_sprite(&data, {0, 0}, "idle", 0)
+	app.camera.position = {0, -100}
+
+	follow := false
+	space_was_down := false
+	CAM_SPEED :: f32(300)
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		space := eng.key_down(.Space)
+		if space && !space_was_down {
+			follow = !follow
+		}
+		space_was_down = space
+
+		if follow {
+			app.camera.position = toad.position - {0, 100}
+		} else {
+			if eng.key_down(.Left) || eng.key_down(.A) {
+				app.camera.position.x -= CAM_SPEED * dt
+			}
+			if eng.key_down(.Right) || eng.key_down(.D) {
+				app.camera.position.x += CAM_SPEED * dt
+			}
+			if eng.key_down(.Up) {
+				app.camera.position.y -= CAM_SPEED * dt
+			}
+			if eng.key_down(.Down) {
+				app.camera.position.y += CAM_SPEED * dt
+			}
+		}
+
+		eng.update_sprite(&toad, dt)
+
+		eng.begin_frame(&app)
+		eng.draw_sprite(&app, &toad)
+		eng.end_frame(&app)
+	}
+}

examples/clip_thrash/main.odin

@@ -0,0 +1,80 @@
+package main
+
+import "core:fmt"
+import eng "pkg:engine"
+
+// Clip thrash: flip every sprite between idle/walk each frame via set_sprite_clip_def.
+COUNT :: eng.MAX_SPRITES
+COLS :: 16
+FRAME_LOG_EVERY :: 60
+
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "clip_thrash", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	idle_def, idle_ok := eng.character_clip(&data, "idle")
+	walk_def, walk_ok := eng.character_clip(&data, "walk")
+	if !idle_ok || !walk_ok do return
+
+	sprites: [COUNT]eng.Sprite
+	for i in 0 ..< COUNT {
+		col := i % COLS
+		row := i / COLS
+		pos := eng.Vec2 {
+			f32(40 + col * 48),
+			f32(80 + row * 60),
+		}
+		sprites[i] = eng.spawn_sprite(&data, pos, "idle", i % 5)
+	}
+
+	app.camera.position = {400, 400}
+
+	last := eng.now_seconds()
+	frame_i := 0
+	sum_ms: f64
+	peak_ms: f64
+	use_walk := false
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+		frame_ms := f64(dt) * 1000.0
+		sum_ms += frame_ms
+		if frame_ms > peak_ms do peak_ms = frame_ms
+		frame_i += 1
+
+		if frame_i % FRAME_LOG_EVERY == 0 {
+			avg := sum_ms / f64(FRAME_LOG_EVERY)
+			fps := 1000.0 / avg if avg > 0 else 0
+			fmt.printfln(
+				"clip_thrash frame: avg=%.2f ms (%.1f FPS) peak=%.2f ms over %d frames",
+				avg,
+				fps,
+				peak_ms,
+				FRAME_LOG_EVERY,
+			)
+			sum_ms = 0
+			peak_ms = 0
+		}
+
+		clip := "walk" if use_walk else "idle"
+		def := walk_def if use_walk else idle_def
+		use_walk = !use_walk
+		for &s in sprites {
+			eng.set_sprite_clip_def(&s, clip, def)
+			eng.update_sprite(&s, dt)
+		}
+
+		eng.begin_frame(&app)
+		for &s in sprites {
+			eng.draw_sprite(&app, &s)
+		}
+		eng.end_frame(&app)
+	}
+}

examples/clips/main.odin

@@ -0,0 +1,38 @@
+package main
+
+import eng "pkg:engine"
+
+// Clip switcher: 1 = idle, 2 = walk. No movement — animation policy only.
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "clips", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	toad := eng.spawn_sprite(&data, {400, 500}, "idle", 0)
+	app.camera.position = toad.position - {0, 100}
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		if eng.key_down(.N1) {
+			eng.set_sprite_clip(&toad, "idle")
+		}
+		if eng.key_down(.N2) {
+			eng.set_sprite_clip(&toad, "walk")
+		}
+
+		eng.update_sprite(&toad, dt)
+
+		eng.begin_frame(&app)
+		eng.draw_sprite(&app, &toad)
+		eng.end_frame(&app)
+	}
+}

examples/crowd/main.odin

@@ -0,0 +1,72 @@
+package main
+
+import "core:fmt"
+import eng "pkg:engine"
+
+// Many sprites sharing one Character_Data (Flyweight) — good batching demo.
+COUNT :: eng.MAX_SPRITES
+COLS :: 16
+FRAME_LOG_EVERY :: 60
+
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "crowd", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	sprites: [COUNT]eng.Sprite
+	for i in 0 ..< COUNT {
+		col := i % COLS
+		row := i / COLS
+		pos := eng.Vec2 {
+			f32(40 + col * 48),
+			f32(80 + row * 60),
+		}
+		clip := "idle" if (i % 2) == 0 else "walk"
+		sprites[i] = eng.spawn_sprite(&data, pos, clip, i % 5)
+	}
+
+	app.camera.position = {400, 400}
+
+	last := eng.now_seconds()
+	frame_i := 0
+	sum_ms: f64
+	peak_ms: f64
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+		frame_ms := f64(dt) * 1000.0
+		sum_ms += frame_ms
+		if frame_ms > peak_ms do peak_ms = frame_ms
+		frame_i += 1
+
+		if frame_i % FRAME_LOG_EVERY == 0 {
+			avg := sum_ms / f64(FRAME_LOG_EVERY)
+			fps := 1000.0 / avg if avg > 0 else 0
+			fmt.printfln(
+				"crowd frame: avg=%.2f ms (%.1f FPS) peak=%.2f ms over %d frames",
+				avg,
+				fps,
+				peak_ms,
+				FRAME_LOG_EVERY,
+			)
+			sum_ms = 0
+			peak_ms = 0
+		}
+
+		for &s in sprites {
+			eng.update_sprite(&s, dt)
+		}
+
+		eng.begin_frame(&app)
+		for &s in sprites {
+			eng.draw_sprite(&app, &s)
+		}
+		eng.end_frame(&app)
+	}
+}

examples/crowd_batch/main.odin

@@ -0,0 +1,79 @@
+package main
+
+import "core:fmt"
+import eng "pkg:engine"
+
+// Multi-texture batching stress: two Character_Data (two GPU textures), alternating sprites.
+COUNT :: eng.MAX_SPRITES
+COLS :: 16
+FRAME_LOG_EVERY :: 60
+BATCH_GROUP :: u32(1)
+TOAD_JSON :: "assets_baked/characters/toad/toad.char.json"
+
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "crowd_batch", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data_a, ok_a := eng.load_character_data(&app, TOAD_JSON)
+	if !ok_a do return
+	defer eng.destroy_character_data(&app, &data_a)
+
+	data_b, ok_b := eng.load_character_data(&app, TOAD_JSON)
+	if !ok_b do return
+	defer eng.destroy_character_data(&app, &data_b)
+
+	sprites: [COUNT]eng.Sprite
+	for i in 0 ..< COUNT {
+		col := i % COLS
+		row := i / COLS
+		pos := eng.Vec2 {
+			f32(40 + col * 48),
+			f32(80 + row * 60),
+		}
+		clip := "idle" if (i % 2) == 0 else "walk"
+		data := &data_a if (i % 2) == 0 else &data_b
+		sprites[i] = eng.spawn_sprite(data, pos, clip, i % 5)
+	}
+
+	app.camera.position = {400, 400}
+
+	last := eng.now_seconds()
+	frame_i := 0
+	sum_ms: f64
+	peak_ms: f64
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+		frame_ms := f64(dt) * 1000.0
+		sum_ms += frame_ms
+		if frame_ms > peak_ms do peak_ms = frame_ms
+		frame_i += 1
+
+		if frame_i % FRAME_LOG_EVERY == 0 {
+			avg := sum_ms / f64(FRAME_LOG_EVERY)
+			fps := 1000.0 / avg if avg > 0 else 0
+			fmt.printfln(
+				"crowd_batch frame: avg=%.2f ms (%.1f FPS) peak=%.2f ms over %d frames",
+				avg,
+				fps,
+				peak_ms,
+				FRAME_LOG_EVERY,
+			)
+			sum_ms = 0
+			peak_ms = 0
+		}
+
+		for &s in sprites {
+			eng.update_sprite(&s, dt)
+		}
+
+		eng.begin_frame(&app)
+		for &s in sprites {
+			eng.draw_sprite_batched(&app, &s, BATCH_GROUP)
+		}
+		eng.end_frame(&app)
+	}
+}

examples/crowd_overdraw/main.odin

@@ -0,0 +1,70 @@
+package main
+
+import "core:fmt"
+import eng "pkg:engine"
+
+// GPU overdraw stress: MAX_SPRITES stacked near one world point.
+COUNT :: eng.MAX_SPRITES
+FRAME_LOG_EVERY :: 60
+
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "crowd_overdraw", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	center := eng.Vec2{400, 400}
+	sprites: [COUNT]eng.Sprite
+	for i in 0 ..< COUNT {
+		jitter := eng.Vec2 {
+			f32((i % 7) - 3),
+			f32((i % 5) - 2),
+		}
+		clip := "idle" if (i % 2) == 0 else "walk"
+		sprites[i] = eng.spawn_sprite(&data, center + jitter, clip, i % 5)
+	}
+
+	app.camera.position = {400, 400}
+
+	last := eng.now_seconds()
+	frame_i := 0
+	sum_ms: f64
+	peak_ms: f64
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+		frame_ms := f64(dt) * 1000.0
+		sum_ms += frame_ms
+		if frame_ms > peak_ms do peak_ms = frame_ms
+		frame_i += 1
+
+		if frame_i % FRAME_LOG_EVERY == 0 {
+			avg := sum_ms / f64(FRAME_LOG_EVERY)
+			fps := 1000.0 / avg if avg > 0 else 0
+			fmt.printfln(
+				"crowd_overdraw frame: avg=%.2f ms (%.1f FPS) peak=%.2f ms over %d frames",
+				avg,
+				fps,
+				peak_ms,
+				FRAME_LOG_EVERY,
+			)
+			sum_ms = 0
+			peak_ms = 0
+		}
+
+		for &s in sprites {
+			eng.update_sprite(&s, dt)
+		}
+
+		eng.begin_frame(&app)
+		for &s in sprites {
+			eng.draw_sprite(&app, &s)
+		}
+		eng.end_frame(&app)
+	}
+}

examples/hello_sprite/main.odin

@@ -0,0 +1,34 @@
+package main
+
+import eng "pkg:engine"
+
+// Minimal: load one baked character and draw idle. No input, no camera follow.
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "hello sprite", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	sprite := eng.spawn_sprite(&data, {400, 500}, "idle", 0)
+
+	// Screen-centered framing without gameplay camera follow:
+	// treat spawn position as world; look slightly above feet.
+	app.camera.position = sprite.position - {0, 100}
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		eng.update_sprite(&sprite, dt)
+
+		eng.begin_frame(&app)
+		eng.draw_sprite(&app, &sprite)
+		eng.end_frame(&app)
+	}
+}

examples/toad/main.odin

@@ -4,7 +4,7 @@ import eng "pkg:engine"
 
 main :: proc() {
 	app: eng.App
-	if !eng.init(&app, "toad", 800, 600) do return
+	if !eng.init(&app, "toad game", 800, 600) do return
 	defer eng.shutdown(&app)
 
 	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
@@ -14,10 +14,37 @@ main :: proc() {
 
 	toad := eng.spawn_sprite(&data, {400, 500}, "idle", 0)
 
+	last := eng.now_seconds()
+	SPEED :: f32(200)
+
 	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		left := eng.key_down(.A) || eng.key_down(.Left)
+		right := eng.key_down(.D) || eng.key_down(.Right)
+
+		if left || right {
+			eng.set_sprite_clip(&toad, "walk")
+			if left {
+				toad.position.x -= SPEED * dt
+				toad.flip_x = true
+			}
+
+			if right {
+				toad.position.x += SPEED * dt
+				toad.flip_x = false
+			}
+		} else {
+			eng.set_sprite_clip(&toad, "idle")
+		}
+
+		app.camera.position = toad.position - {0, 100}
+		eng.update_sprite(&toad, dt)
+
 		eng.begin_frame(&app)
 		eng.draw_sprite(&app, &toad)
 		eng.end_frame(&app)
 	}
 }
-

flame/crowd-20260803-003404-report.txt

@@ -0,0 +1,645 @@
+# To display the perf.data header info, please use --header/--header-only options.
+#
+#
+# Total Lost Samples: 0
+#
+# Samples: 499  of event 'cpu/cycles/Pu'
+# Event count (approx.): 2684910393
+#
+# Overhead  Command          Shared Object                  Symbol                                     
+# ........  ...............  .............................  ...........................................
+#
+     9.56%  crowd_perf       crowd_perf                     [.] engine::draw_sprite
+            |
+            ---engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     5.33%  crowd_perf       crowd_perf                     [.] engine::to_clip
+            |
+            ---engine::to_clip
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     3.98%  crowd_perf       crowd_perf                     [.] engine::sprite_feet_quad
+            |
+            ---engine::sprite_feet_quad
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     3.01%  crowd_perf       crowd_perf                     [.] engine::update_sprite
+            |
+            ---engine::update_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     2.56%  crowd_perf       crowd_perf                     [.] runtime::default_hasher
+            |
+            ---runtime::default_hasher
+               runtime::default_hasher_string
+               __$hasher$$string
+               |          
+               |--1.36%--engine::character_frame
+               |          engine::draw_sprite
+               |          main::main
+               |          main
+               |          0x7fe3b6c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --1.20%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fe3b6c27740
+                          __libc_start_main
+                          _start
+
+     2.49%  crowd_perf       libc.so.6                      [.] 0x000000000018a4c4
+            |
+            ---0x7fe3b6d8a4c4
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     2.47%  crowd_perf       crowd_perf                     [.] runtime::_append_elem
+            |
+            ---runtime::_append_elem
+               runtime::append_elem:proc(array:^[dynamic]engine::Queued_Sprite,arg:engine::Queued_Sprite,loc:runtime::Source_Code_Location)->(n:int,err:runtime::Allocator_Error)
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     1.97%  crowd_perf       crowd_perf                     [.] runtime::bounds_check_error
+            |
+            ---runtime::bounds_check_error
+               engine::character_frame
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     1.70%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_proxy_marshal_array_flags
+            |
+            ---wl_proxy_marshal_array_flags
+               wl_proxy_marshal_flags
+               |          
+                --0.87%--0x7fe396d97539
+                          0x7fe396d8a4f8
+                          0x7fe3b724ffc9
+                          engine::end_frame
+                          main::main
+                          main
+                          0x7fe3b6c27740
+                          __libc_start_main
+                          _start
+
+     1.61%  crowd_perf       crowd_perf                     [.] __$map_get$$map[string]engine::Clip_Def
+            |
+            ---__$map_get$$map[string]engine::Clip_Def
+               |          
+               |--1.00%--engine::character_frame
+               |          engine::draw_sprite
+               |          main::main
+               |          main
+               |          0x7fe3b6c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.61%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fe3b6c27740
+                          __libc_start_main
+                          _start
+
+     1.57%  wl_cursor_surfa  libc.so.6                      [.] 0x000000000009ca5c
+     1.50%  crowd_perf       crowd_perf                     [.] engine::world_to_screen
+            |
+            ---engine::world_to_screen
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     1.35%  crowd_perf       crowd_perf                     [.] runtime::memory_equal
+            |
+            ---runtime::memory_equal
+               runtime::string_eq
+               __$map_get$$map[string]engine::Clip_Def
+               |          
+                --1.06%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fe3b6c27740
+                          __libc_start_main
+                          _start
+
+     1.33%  crowd_perf       libc.so.6                      [.] pthread_mutex_lock
+            |
+            ---pthread_mutex_lock
+
+     1.31%  crowd_perf       crowd_perf                     [.] engine::character_frame
+            |
+            ---engine::character_frame
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     1.19%  crowd_perf       crowd_perf                     [.] runtime::string_eq
+            |
+            ---runtime::string_eq
+               __$map_get$$map[string]engine::Clip_Def
+               |          
+               |--0.62%--engine::character_frame
+               |          engine::draw_sprite
+               |          main::main
+               |          main
+               |          0x7fe3b6c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.57%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fe3b6c27740
+                          __libc_start_main
+                          _start
+
+     1.18%  crowd_perf       [unknown]                      [k] 0xffffffffab355a81
+            |
+            ---0xffffffffab355a81
+               0xffffffffa9e0012f
+               ioctl
+               drmIoctl
+               |          
+                --0.59%--drmSyncobjCreate
+                          0x7fe396d8c878
+                          0x7fe396d893c8
+                          0x7fe396d89241
+                          0x7fe3b72544bd
+                          0x7fe3b7069860
+                          engine::begin_frame
+                          main::main
+                          main
+                          0x7fe3b6c27740
+                          __libc_start_main
+                          _start
+
+     1.11%  crowd_perf       libc.so.6                      [.] clock_gettime
+            |
+            ---clock_gettime
+               |          
+                --0.68%--0x7fe396f7a09a
+
+     1.08%  crowd_perf       libc.so.6                      [.] 0x0000000000189c40
+            |
+            ---0x7fe3b6d89c40
+               0x7fe3b6e6ee65
+               wl_proxy_marshal_array_flags
+               wl_proxy_marshal_flags
+               0x7fe396d97614
+               0x7fe396d8a4f8
+               0x7fe3b724ffc9
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     1.03%  crowd_perf       crowd_perf                     [.] main::main
+            |
+            ---main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.94%  crowd_perf       libc.so.6                      [.] ioctl
+            |
+            ---ioctl
+               |          
+                --0.94%--drmIoctl
+
+     0.91%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000001428a1
+            |
+            ---0x7fe3b71428a1
+               0x7fe3b714928f
+               0x7fe3b7141b9a
+               0x7fe3b71426da
+
+     0.89%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000ac3a
+            |
+            ---0x7fe3b739bc3a
+               0x7fe3b739c855
+               0x7fe3b73a0f57
+               0x7fe3b73a2e00
+               0x7fe3b739eeda
+               _dl_catch_exception
+               0x7fe3b739e242
+               _dl_catch_exception
+               0x7fe3b739e7a9
+               0x7fe3b6c93bb3
+               _dl_catch_exception
+               0x7fe3b73935c8
+               0x7fe3b6c936a2
+               dlopen
+               0x7fe3b61b2c10
+               0x7fe3b61b7b4b
+
+     0.85%  crowd_perf       libc.so.6                      [.] 0x000000000018a4c0
+            |
+            ---0x7fe3b6d8a4c0
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.84%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000691d6
+            |
+            ---0x7fe3b70691d6
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.76%  crowd_perf       libc.so.6                      [.] pthread_rwlock_wrlock
+            |
+            ---pthread_rwlock_wrlock
+
+     0.74%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000142863
+            |
+            ---0x7fe3b7142863
+               0x7fe3b71429b4
+               0x7fe3b714921a
+               0x7fe3b7141b9a
+               0x7fe3b71426da
+
+     0.74%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000149304
+            |
+            ---0x7fe3b7149304
+               0x7fe3b7141b9a
+               0x7fe3b71426da
+
+     0.74%  crowd_perf       libc.so.6                      [.] 0x000000000018a0e8
+            |
+            ---0x7fe3b6d8a0e8
+               mem::copy
+               engine::load_character_data
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.74%  crowd_perf       libc.so.6                      [.] 0x000000000009ca5c
+            |
+            ---0x7fe3b6c9ca5c
+
+     0.73%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000143ffe
+            |
+            ---0x7fe3b7143ffe
+               0x7fe3b714a028
+               0x7fe3b7141b9a
+
+     0.72%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000143fe9
+            |
+            ---0x7fe3b7143fe9
+               0x7fe3b714a028
+               0x7fe3b7141b9a
+
+     0.71%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003263
+            |
+            ---0x7fe3b6e6d263
+               wl_proxy_marshal_flags
+               0x7fe396d97937
+               0x7fe396d8a4f8
+               0x7fe3b724ffc9
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.70%  crowd_perf       crowd_perf                     [.] runtime::default_hasher_string
+            |
+            ---runtime::default_hasher_string
+               __$hasher$$string
+
+     0.69%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjTimelineWait
+            |
+            ---drmSyncobjTimelineWait
+
+     0.68%  crowd_perf       libc.so.6                      [.] 0x00000000000a590c
+            |
+            ---0x7fe3b6ca590c
+               0x7fe396d827d6
+               0x7fe396d3cff4
+               0x7fe396ddcaf6
+               0x7fe396ddccd4
+               0x7fe396de6f2c
+               0x7fe3b724fec1
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.66%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024d030
+            |
+            ---0x7fe3b724d030
+               0x7fe3b724f5c0
+               0x7fe3b72545c5
+               0x7fe3b7069860
+               engine::begin_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.66%  crowd_perf       libc.so.6                      [.] 0x000000000018a547
+            |
+            ---0x7fe3b6d8a547
+
+     0.65%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d27b4
+            |
+            ---0x7fe396cd27b4
+               0x7fe396de6325
+               0x7fe3b72546f1
+               0x7fe3b7069860
+               engine::begin_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.64%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022d88
+            |
+            ---0x7fe396c22d88
+               0x7fe396cd2f6f
+               0x7fe396de6325
+
+     0.61%  crowd_perf       crowd_perf                     [.] engine::texture_run_len
+            |
+            ---engine::texture_run_len
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.55%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bbf60
+            |
+            ---0x7fe396cbbf60
+               0x7fe396cc6c98
+               0x7fe396cc985a
+               0x7fe396cd7932
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.54%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000022daad
+            |
+            ---0x7fe396e2daad
+               0x7fe396d15bcb
+               0x7fe396d162ff
+
+     0.53%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023af6a
+            |
+            ---0x7fe3b723af6a
+               0x7fe3b7249f38
+               engine::end_frame
+               main::main
+               main
+               0x7fe3b6c27740
+               __libc_start_main
+               _start
+
+     0.48%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_display_flush
+     0.48%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cf827
+     0.47%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000166ae
+     0.44%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022daa
+     0.43%  crowd_perf       libc.so.6                      [.] cfree
+     0.43%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2c23
+     0.41%  crowd_perf       libc.so.6                      [.] 0x00000000000a58f9
+     0.41%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d44f
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002b9b1
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e4771
+     0.40%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x00000000000055ca
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000116639
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d1196
+     0.39%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x000000000000315e
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d957
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000013d072
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cb17b
+     0.38%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000005485a
+     0.38%  crowd_perf       libc.so.6                      [.] malloc
+     0.38%  crowd_perf       libc.so.6                      [.] 0x0000000000180625
+     0.38%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033b85f
+     0.38%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ccd20
+     0.38%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c9899
+     0.38%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001deb23
+     0.38%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000284e5
+     0.38%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41b7
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000027cca
+     0.37%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002476b9
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41d6
+     0.37%  crowd_perf       libc.so.6                      [.] 0x000000000018a52e
+     0.37%  crowd_perf       crowd_perf                     [.] runtime::map_seed_from_map_data
+     0.36%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_rmutex_lock
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e2e46
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000022e017
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b7b5f
+     0.35%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_message_loader_queue_messages
+     0.35%  crowd_perf       libc.so.6                      [.] pthread_rwlock_rdlock
+     0.35%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000be015
+     0.35%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c49da
+     0.34%  crowd_perf       libc.so.6                      [.] 0x000000000018a507
+     0.34%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_display_dispatch_queue_pending
+     0.34%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000197523
+     0.34%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ec905
+     0.34%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c4a56
+     0.34%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cb864
+     0.34%  crowd_perf       libdrm.so.2.134.0              [.] drmIoctl
+     0.34%  crowd_perf       crowd_perf                     [.] engine::character_clip
+     0.34%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d8f7
+     0.33%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002f104
+     0.33%  crowd_perf       libc.so.6                      [.] pthread_mutex_unlock
+     0.33%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000f7a2c
+     0.33%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b92b8
+     0.33%  crowd_perf       crowd_perf                     [.] engine::begin_frame
+     0.33%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023b8f4
+     0.33%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c2207
+     0.33%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018c7d5
+     0.32%  wl_cursor_surfa  [unknown]                      [k] 0xffffffffa9e000ad
+     0.32%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024ab50
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022a03
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c9cd7
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000116770
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000182332
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ebd64
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3c19
+     0.31%  crowd_perf       libc.so.6                      [.] __errno_location
+     0.31%  crowd_perf       libc.so.6                      [.] 0x00000000000a57e4
+     0.31%  crowd_perf       libc.so.6                      [.] 0x000000000018a4b0
+     0.31%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_dispatch_queue_pending
+     0.30%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a7491
+     0.30%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001801f0
+     0.30%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x00000000000039f1
+     0.30%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023c110
+     0.30%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd301
+     0.30%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000176c9
+     0.30%  crowd_perf       libc.so.6                      [.] 0x0000000000189c53
+     0.30%  crowd_perf       libc.so.6                      [.] 0x0000000000180600
+     0.30%  crowd_perf       crowd_perf                     [.] __$hasher$$string
+     0.30%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c8b16
+     0.30%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd419
+     0.30%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000021b321
+     0.30%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023b39a
+     0.30%  crowd_perf       libc.so.6                      [.] 0x000000000018a4ea
+     0.30%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023be20
+     0.29%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000027f50
+     0.29%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022e83
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d178c
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d6734
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bb103
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b70b2
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cc0c4
+     0.26%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000017694
+     0.26%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017e9d4
+     0.26%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d64a8
+     0.26%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000335bd4
+     0.26%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000243e20
+     0.26%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x0000000000004951
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000189397
+     0.25%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003147
+     0.24%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000068d01a
+     0.24%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e379c
+     0.24%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjWait
+     0.23%  crowd_perf       [unknown]                      [k] 0xffffffffa9e000ca
+     0.23%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000028eca3
+     0.20%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d851
+     0.20%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a73ff
+     0.18%  crowd_perf       libxkbcommon.so.0.13.2         [.] xkb_keymap_key_get_syms_by_level
+     0.18%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dce94
+     0.10%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_connection_unlock
+     0.08%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6761
+     0.01%  crowd_perf       libc.so.6                      [.] 0x0000000000189d47
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094084
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x000000000018a507
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] pthread_mutex_lock
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000e922c9
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffab35a5c1
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd461
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f74
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001cd7b4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017ff33
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000af32
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_read_events
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d65a4
+     0.00%  crowd_perf       libc.so.6                      [.] vsnprintf
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000184dd2
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000193ec9
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x00000000000147f8
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345adb
+     0.00%  crowd_perf       libc.so.6                      [.] __ctype_init
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000064834
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345ad6
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ddb
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x0000000000005d0b
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345b18
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345bb0
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f76
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345ce7
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000616e
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000094040
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3362
+     0.00%  crowd_perf       libc.so.6                      [.] realloc
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345bb3
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000ac94
+     0.00%  crowd_perf       libc.so.6                      [.] pthread_setaffinity_np
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000097417
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000973bb
+     0.00%  crowd_perf       libdrm_amdgpu.so.1.134.0       [.] 0x00000000000078b0
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e01284
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000103a40
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001fcc4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ccb
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344cd4
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] ppoll
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094040
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000011bed0
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e01280
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094047
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094085
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000973a0
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000011bed7
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x0000000000002ede
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x0000000000006167
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000ac75
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000b7f3
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000b84a
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x0000000000019a7d
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x0000000000019a84
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001f103
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001fcc0
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000011bed2
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000011bed5
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjImportSyncFile
+     0.00%  crowd_perf       libdrm_amdgpu.so.1.134.0       [.] amdgpu_device_initialize
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd464
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd46a
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ce2
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ddd
+     0.00%  crowd_perf       libz.so.1.3.2                  [.] 0x0000000000003004
+     0.00%  crowd_perf       libz.so.1.3.2                  [.] 0x000000000000300f
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e01670
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] recvmsg
+
+
+#
+# (Tip: To change sampling frequency to 100 Hz: perf record -F 100)
+#

flame/crowd-20260803-134209-report.txt

@@ -0,0 +1,700 @@
+# To display the perf.data header info, please use --header/--header-only options.
+#
+#
+# Total Lost Samples: 0
+#
+# Samples: 469  of event 'cpu/cycles/Pu'
+# Event count (approx.): 2304609671
+#
+# Overhead  Command          Shared Object                  Symbol                                                                                                                                                                
+# ........  ...............  .............................  ......................................................................................................................................................................
+#
+    12.22%  crowd_perf       crowd_perf                     [.] engine::draw_sprite
+            |
+            ---engine::draw_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     5.51%  crowd_perf       crowd_perf                     [.] engine::to_clip
+            |
+            ---engine::to_clip
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     4.04%  crowd_perf       libc.so.6                      [.] pthread_mutex_lock
+            |
+            ---pthread_mutex_lock
+               |          
+               |--0.81%--0x7fe9b424f559
+               |          0x7fe9b42545c5
+               |          0x7fe9b4069860
+               |          engine::begin_frame
+               |          main::main
+               |          main
+               |          0x7fe9b3c27740
+               |          __libc_start_main
+               |          _start
+               |          
+               |--0.79%--wl_display_prepare_read_queue
+               |          wl_display_dispatch_queue_timeout
+               |          0x7fe9b228fead
+               |          0x7fe9b1d936f3
+               |          0x7fe9b1d97300
+               |          0x7fe9b1d8a4f8
+               |          0x7fe9b424ffc9
+               |          engine::end_frame
+               |          main::main
+               |          main
+               |          0x7fe9b3c27740
+               |          __libc_start_main
+               |          _start
+               |          
+               |--0.76%--0x7fe9b3e94a51
+               |          0x7fe9b4054fca
+               |          0x7fe9b4055bbd
+               |          engine::events
+               |          main::main
+               |          main
+               |          0x7fe9b3c27740
+               |          __libc_start_main
+               |          _start
+               |          
+               |--0.76%--wl_display_cancel_read
+               |          
+                --0.52%--0x7fe9b3eab81f
+                          0x7fe9b3e905f6
+                          dbus_connection_dispatch
+                          0x7fe9b4054fe2
+                          0x7fe9b4055bbd
+                          engine::events
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     3.30%  crowd_perf       crowd_perf                     [.] engine::sprite_feet_quad
+            |
+            ---engine::sprite_feet_quad
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     3.12%  crowd_perf       crowd_perf                     [.] main::main
+            |
+            ---main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     3.01%  crowd_perf       crowd_perf                     [.] engine::update_sprite
+            |
+            ---engine::update_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     2.34%  crowd_perf       crowd_perf                     [.] engine::world_to_screen
+            |
+            ---engine::world_to_screen
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     1.95%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41d6
+            |
+            ---0x7fe9b1df41d6
+               |          
+                --1.18%--0x7fe9b1df44e5
+                          0x7fe9b1c27d3c
+                          0x7fe9b1c28070
+                          0x7fe9b1c2d63c
+                          |          
+                           --0.87%--0x7fe9b1cd16b8
+                                     0x7fe9b1cd2520
+                                     0x7fe9b1cd2d0a
+                                     0x7fe9b1de6325
+                                     0x7fe9b42546f1
+                                     0x7fe9b4069860
+                                     engine::begin_frame
+                                     main::main
+                                     main
+                                     0x7fe9b3c27740
+                                     __libc_start_main
+                                     _start
+
+     1.95%  crowd_perf       crowd_perf                     [.] runtime::default_hasher
+            |
+            ---runtime::default_hasher
+               runtime::default_hasher_string
+               __$hasher$$string
+               |          
+               |--1.28%--engine::character_clip
+               |          engine::update_sprite
+               |          main::main
+               |          main
+               |          0x7fe9b3c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.66%--engine::character_frame
+                          engine::draw_sprite
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.60%  crowd_perf       libc.so.6                      [.] clock_gettime
+            |
+            ---clock_gettime
+               |          
+                --0.83%--wl_display_dispatch_queue_timeout
+                          0x7fe9b228fead
+                          0x7fe9b1d936f3
+                          0x7fe9b1d97300
+                          0x7fe9b1d8a4f8
+                          0x7fe9b424ffc9
+                          engine::end_frame
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.50%  crowd_perf       crowd_perf                     [.] __$map_get$$map[string]engine::Clip_Def
+            |
+            ---__$map_get$$map[string]engine::Clip_Def
+               |          
+               |--0.79%--engine::character_frame
+               |          engine::draw_sprite
+               |          main::main
+               |          main
+               |          0x7fe9b3c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.71%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.49%  wl_cursor_surfa  [unknown]                      [k] 0xffffffffab041cef
+            |
+            ---0xffffffffab041cef
+               0xffffffffab355aba
+               0xffffffffa9e0012f
+
+     1.41%  crowd_perf       crowd_perf                     [.] engine::character_frame
+            |
+            ---engine::character_frame
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     1.28%  crowd_perf       [unknown]                      [k] 0xffffffffab355a81
+            |
+            ---0xffffffffab355a81
+               0xffffffffa9e0012f
+               |          
+               |--0.77%--ioctl
+               |          drmIoctl
+               |          
+                --0.51%--0x7fe9b3c9fff2
+                          0x7fe9b3c9403b
+                          0x7fe9b3c94083
+                          __close
+                          0x7fe9b1d8cacd
+                          0x7fe9b1d893c8
+                          0x7fe9b1d89241
+                          0x7fe9b42544bd
+                          0x7fe9b4069860
+                          engine::begin_frame
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.26%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_read_events
+     1.25%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_proxy_marshal_array_flags
+            |
+            ---wl_proxy_marshal_array_flags
+               wl_proxy_marshal_flags
+               |          
+                --0.83%--0x7fe9b1d97614
+                          0x7fe9b1d8a4f8
+                          0x7fe9b424ffc9
+                          engine::end_frame
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.22%  crowd_perf       crowd_perf                     [.] runtime::string_eq
+            |
+            ---runtime::string_eq
+               __$map_get$$map[string]engine::Clip_Def
+               |          
+               |--0.72%--engine::character_clip
+               |          engine::update_sprite
+               |          main::main
+               |          main
+               |          0x7fe9b3c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.50%--engine::character_frame
+                          engine::draw_sprite
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.22%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ce007
+            |
+            ---0x7fe9b1cce007
+               0x7fe9b1dcae1a
+               0x7fe9b424437c
+               0x7fe9b406920d
+               engine::end_frame
+               main::main
+
+     1.17%  crowd_perf       crowd_perf                     [.] runtime::memory_equal
+            |
+            ---runtime::memory_equal
+               runtime::string_eq
+               __$map_get$$map[string]engine::Clip_Def
+               |          
+                --0.72%--engine::character_frame
+                          engine::draw_sprite
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     1.05%  crowd_perf       crowd_perf                     [.] engine::character_clip
+            |
+            ---engine::character_clip
+               engine::update_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.99%  crowd_perf       crowd_perf                     [.] runtime::bounds_check_error
+            |
+            ---runtime::bounds_check_error
+               |          
+                --0.54%--engine::texture_run_len
+                          engine::end_frame
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     0.95%  crowd_perf       libc.so.6                      [.] 0x000000000018a4c4
+            |
+            ---0x7fe9b3d8a4c4
+               |          
+                --0.52%--engine::draw_sprite
+                          main::main
+                          main
+                          0x7fe9b3c27740
+                          __libc_start_main
+                          _start
+
+     0.94%  crowd_perf       crowd_perf                     [.] engine::texture_run_len
+            |
+            ---engine::texture_run_len
+               engine::end_frame
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.93%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000001428e7
+            |
+            ---0x7fe9b41428e7
+
+     0.85%  crowd_perf       libc.so.6                      [.] 0x00000000000a44b7
+            |
+            ---0x7fe9b3ca44b7
+               0x7fe9b3ca6ed2
+
+     0.85%  crowd_perf       libc.so.6                      [.] 0x000000000009ca5c
+            |
+            ---0x7fe9b3c9ca5c
+
+     0.84%  crowd_perf       libzstd.so.1.5.7               [.] 0x0000000000092a16
+            |
+            ---0x7fe9b0567a16
+               ZSTD_decompressSequences (inlined)
+               ZSTD_decompressBlock_internal
+               ZSTD_decompressBlock_internal
+               0x7fe9b0562e85
+               ZSTD_decompress_usingDDict
+               ZSTD_decompress
+               0x7fe9b1f5f8cf
+               0x7fe9b1f380f5
+               0x7fe9b1f3978d
+               0x7fe9b1f37a86
+               0x7fe9b1e05d1b
+               0x7fe9b1d28dcd
+               0x7fe9b1e0583a
+               0x7fe9b1e05d49
+               0x7fe9b1d28abb
+               0x7fe9b1d292b4
+               0x7fe9b1d2ab09
+
+     0.83%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000143ffe
+            |
+            ---0x7fe9b4143ffe
+               0x7fe9b414a028
+               0x7fe9b4141b9a
+
+     0.83%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003263
+            |
+            ---0x7fe9b433a263
+               wl_proxy_marshal_flags
+               0x7fe9b1d97937
+               0x7fe9b1d8a4f8
+               0x7fe9b424ffc9
+               engine::end_frame
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.83%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033b851
+            |
+            ---0x7fe9b1f3b851
+               0x7fe9b1df41ce
+               0x7fe9b1df44e5
+               0x7fe9b1c27d3c
+               0x7fe9b1c28070
+               0x7fe9b1c2d63c
+
+     0.83%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000014400b
+            |
+            ---0x7fe9b414400b
+               0x7fe9b414a028
+               0x7fe9b4141b9a
+
+     0.82%  crowd_perf       crowd_perf                     [.] engine::frame_uvs
+            |
+            ---engine::frame_uvs
+               engine::draw_sprite
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.82%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000144008
+            |
+            ---0x7fe9b4144008
+               0x7fe9b414a028
+               0x7fe9b4141b9a
+
+     0.81%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2c2b
+            |
+            ---0x7fe9b1cd2c2b
+               0x7fe9b1de6325
+               0x7fe9b42546f1
+               0x7fe9b4069860
+               engine::begin_frame
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.79%  crowd_perf       libc.so.6                      [.] pthread_rwlock_rdlock
+            |
+            ---pthread_rwlock_rdlock
+
+     0.78%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000001428a1
+            |
+            ---0x7fe9b41428a1
+               0x7fe9b414921a
+               0x7fe9b4141b9a
+               0x7fe9b41426da
+
+     0.76%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a66e2
+     0.69%  crowd_perf       libc.so.6                      [.] 0x000000000018a547
+            |
+            ---0x7fe9b3d8a547
+               0x7fe9b1cd1554
+               0x7fe9b1de165e
+               0x7fe9b1ddee47
+               0x7fe9b1de35f1
+               0x7fe9b1de157e
+               0x7fe9b423be46
+               0x7fe9b4068a74
+               engine::end_frame
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.67%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000014288a
+            |
+            ---0x7fe9b414288a
+               0x7fe9b41429b4
+               0x7fe9b414921a
+               0x7fe9b4141b9a
+               0x7fe9b41426da
+
+     0.61%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000180ab2
+            |
+            ---0x7fe9b1d80ab2
+
+     0.58%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000114c26
+            |
+            ---0x7fe9b1d14c26
+               0x7fe9b1d15976
+               0x7fe9b1d162ff
+               0x7fe9b1d1692c
+               0x7fe9b1c2bd93
+               0x7fe9b1c2da03
+               0x7fe9b1c2e4ca
+               0x7fe9b1c2f277
+               0x7fe9b1de052c
+               0x7fe9b1de1521
+               0x7fe9b4247581
+               0x7fe9b4064bab
+               engine::end_frame
+               main::main
+
+     0.52%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022daa
+            |
+            ---0x7fe9b1c22daa
+               0x7fe9b1cd2f6f
+               0x7fe9b1de6325
+               0x7fe9b423bc48
+               0x7fe9b423beb3
+               0x7fe9b4068a74
+               engine::end_frame
+               main::main
+               main
+               0x7fe9b3c27740
+               __libc_start_main
+               _start
+
+     0.51%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6747
+     0.49%  crowd_perf       libc.so.6                      [.] 0x00000000001904ba
+     0.48%  crowd_perf       libc.so.6                      [.] 0x000000000018a52e
+     0.48%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d17cc
+     0.47%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3c6b
+     0.47%  crowd_perf       [vdso]                         [.] __vdso_clock_gettime
+     0.47%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d6365
+     0.46%  crowd_perf       libc.so.6                      [.] 0x000000000018a486
+     0.46%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e4c30
+     0.46%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3ff4
+     0.45%  crowd_perf       libdbus-1.so.3.38.3            [.] dbus_connection_get_dispatch_status
+     0.45%  crowd_perf       libc.so.6                      [.] 0x0000000000093fe4
+     0.44%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017e9d4
+     0.44%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000114197
+     0.43%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd46c
+     0.43%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ce927
+     0.43%  crowd_perf       crowd_perf                     [.] runtime::map_seed_from_map_data
+     0.43%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033cb4a
+     0.42%  crowd_perf       libc.so.6                      [.] 0x0000000000189c4b
+     0.42%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000018567
+     0.42%  crowd_perf       libc.so.6                      [.] 0x0000000000189cca
+     0.41%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001de7c1
+     0.41%  crowd_perf       libc.so.6                      [.] 0x000000000009ca21
+     0.41%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000176c6
+     0.41%  crowd_perf       crowd_perf                     [.] __$hasher$$string
+     0.41%  crowd_perf       libxkbcommon.so.0.13.2         [.] 0x0000000000005fe7
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2c23
+     0.40%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000185a0
+     0.40%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024f5ea
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000e662b
+     0.40%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000005555
+     0.40%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000541ae
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000e6624
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033e954
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001ded02
+     0.40%  crowd_perf       [unknown]                      [k] 0xffffffffa9e000ab
+     0.39%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000054314
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f34c7
+     0.39%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000064bba
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ebaa4
+     0.39%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b8cb1
+     0.38%  crowd_perf       libc.so.6                      [.] pthread_rwlock_wrlock
+     0.38%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f76
+     0.38%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x000000000000326a
+     0.38%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000064a44
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cf7ea
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c4a65
+     0.37%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002501f2
+     0.37%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024e78a
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000035f600
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41b7
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bdd41
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000013c80b
+     0.37%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e61b8
+     0.37%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023bc49
+     0.37%  crowd_perf       libc.so.6                      [.] 0x0000000000189cc4
+     0.36%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000247677
+     0.36%  wl_cursor_surfa  libc.so.6                      [.] pthread_mutex_lock
+     0.36%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x000000000003186f
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d19ec
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017ff7a
+     0.36%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000053d7e
+     0.36%  crowd_perf       libc.so.6                      [.] 0x000000000018a4ca
+     0.36%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000246f63
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e6473
+     0.35%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d6725
+     0.34%  crowd_perf       libc.so.6                      [.] pthread_mutex_unlock
+     0.32%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024fc98
+     0.32%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cf078
+     0.32%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000004dc1
+     0.31%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094047
+     0.31%  crowd_perf       crowd_perf                     [.] runtime::_append_elem
+     0.29%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022d80
+     0.28%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023b5cb
+     0.24%  crowd_perf       crowd_perf                     [.] runtime::append_elem:proc(array:^[dynamic]engine::Queued_Sprite,arg:engine::Queued_Sprite,loc:runtime::Source_Code_Location)->(n:int,err:runtime::Allocator_Error)
+     0.23%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_list_insert
+     0.23%  crowd_perf       libc.so.6                      [.] 0x00000000000a718d
+     0.19%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033b80b
+     0.17%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000ffcb
+     0.16%  crowd_perf       libc.so.6                      [.] 0x0000000000189c40
+     0.09%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000335bdd
+     0.02%  crowd_perf       libc.so.6                      [.] 0x00000000000a4451
+     0.02%  wl_cursor_surfa  [unknown]                      [k] 0xffffffffa9e000ad
+     0.02%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6ea4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000e5f87
+     0.00%  crowd_perf       libGLX_nvidia.so.610.43.03     [.] 0x00000000000ab456
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a6968
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e4d25
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000018325e
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x00000000000144d1
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d5e9
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_dispatch_queue_pending
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a44b7
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344db9
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a74c7
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000185195
+     0.00%  wl_cursor_surfa  [unknown]                      [k] 0xffffffffab041d04
+     0.00%  wl_cursor_surfa  libffi.so.8.4.1                [.] 0x0000000000002807
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjTimelineWait
+     0.00%  crowd_perf       libexpat.so.1.12.2             [.] 0x0000000000002ea9
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344c64
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a5735
+     0.00%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_string_equal_c_str
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_get_fd
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f2fa5
+     0.00%  crowd_p:disk$0   libc.so.6                      [.] 0x00000000000a590f
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6732
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000002647b
+     0.00%  crowd_perf       libc.so.6                      [.] realloc
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000534a3
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000649f8
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e4d24
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ccb
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a66c4
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000189cf7
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345b18
+     0.00%  crowd_perf       libc.so.6                      [.] strchrnul@plt
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000008b802
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffab355a39
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffab355a10
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] ppoll
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345ad6
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345adb
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345ce7
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x0000000000014464
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] recvmsg
+     0.00%  crowd_perf       libxcb.so.1.1.0                [.] 0x000000000000caad
+     0.00%  crowd_perf       libc.so.6                      [.] __ctype_init
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a713d
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e01690
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001cd7b1
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000097417
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000103a63
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd5e5
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjWait
+     0.00%  crowd_perf       libexpat.so.1.12.2             [.] 0x000000000000b5db
+     0.00%  crowd_perf       libc.so.6                      [.] __errno_location
+     0.00%  crowd_p:disk$0   libc.so.6                      [.] 0x000000000009404d
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001fce9
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ddd
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345bb3
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e01280
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344cd4
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094085
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000011bed0
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ddb
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094040
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmIoctl
+     0.00%  crowd_perf       crowd_perf                     [.] runtime::multi_pointer_slice_expr_error
+     0.00%  crowd_perf       libc.so.6                      [.] ioctl
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000973a0
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000103a40
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e01670
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094050
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094084
+     0.00%  crowd_p:disk$0   libc.so.6                      [.] 0x0000000000094047
+     0.00%  crowd_p:disk$0   libc.so.6                      [.] 0x0000000000094048
+     0.00%  crowd_p:disk$0   libc.so.6                      [.] 0x0000000000094049
+     0.00%  crowd_perf       crowd_perf                     [.] main
+     0.00%  crowd_perf       crowd_perf                     [.] memset@plt
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001f103
+     0.00%  crowd_perf       libc.so.6                      [.] __poll
+     0.00%  crowd_perf       libc.so.6                      [.] malloc
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000094047
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000009741b
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a710f
+     0.00%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x0000000000032197
+     0.00%  crowd_perf       libexpat.so.1.12.2             [.] 0x0000000000021792
+     0.00%  crowd_perf       libexpat.so.1.12.2             [.] 0x000000000002179b
+     0.00%  crowd_perf       libexpat.so.1.12.2             [.] 0x00000000000217aa
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd564
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd592
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd61c
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000003458a3
+     0.00%  crowd_perf       libxcb.so.1.1.0                [.] 0x000000000000c8db
+     0.00%  crowd_perf       libxcb.so.1.1.0                [.] 0x000000000000ce6f
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffffa9e015f0
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f74
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094048
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094049
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094097
+
+
+#
+# (Tip: To show IPC for sampling periods use perf record -e '{cycles,instructions}:S' and then browse context)
+#

flame/crowd-20260809-140133-report.txt

@@ -0,0 +1,783 @@
+# To display the perf.data header info, please use --header/--header-only options.
+#
+#
+# Total Lost Samples: 0
+#
+# Samples: 1K of event 'cpu/cycles/Pu'
+# Event count (approx.): 8251313686
+#
+# Overhead  Command          Shared Object                   Symbol                                                                                                                                                                
+# ........  ...............  ..............................  ......................................................................................................................................................................
+#
+    10.24%  crowd_perf       crowd_perf                      [.] engine::draw_sprite
+            |
+            ---engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     5.73%  crowd_perf       crowd_perf                      [.] engine::to_clip
+            |
+            ---engine::to_clip
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     2.74%  crowd_perf       crowd_perf                      [.] runtime::default_hasher
+            |
+            ---runtime::default_hasher
+               runtime::default_hasher_string
+               __$hasher$$string
+               |          
+               |--2.10%--engine::character_clip
+               |          engine::update_sprite
+               |          main::main
+               |          main
+               |          0x7fec32c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.64%--engine::character_frame
+                          engine::draw_sprite
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     2.48%  crowd_perf       crowd_perf                      [.] engine::sprite_feet_quad
+            |
+            ---engine::sprite_feet_quad
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     2.16%  crowd_perf       libc.so.6                       [.] pthread_mutex_lock
+            |
+            ---pthread_mutex_lock
+               |          
+                --0.60%--wl_proxy_marshal_array_flags
+                          wl_proxy_marshal_flags
+
+     2.09%  crowd_perf       crowd_perf                      [.] __$map_get$$map[string]engine::Clip_Def
+            |
+            ---__$map_get$$map[string]engine::Clip_Def
+               |          
+               |--1.49%--engine::character_clip
+               |          engine::update_sprite
+               |          main::main
+               |          main
+               |          0x7fec32c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.60%--engine::character_frame
+                          engine::draw_sprite
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     2.04%  crowd_perf       crowd_perf                      [.] engine::update_sprite
+            |
+            ---engine::update_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     1.91%  crowd_perf       crowd_perf                      [.] runtime::memory_equal
+            |
+            ---runtime::memory_equal
+               runtime::string_eq
+               __$map_get$$map[string]engine::Clip_Def
+               |          
+               |--1.32%--engine::character_frame
+               |          engine::draw_sprite
+               |          main::main
+               |          main
+               |          0x7fec32c27740
+               |          __libc_start_main
+               |          _start
+               |          
+                --0.58%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     1.90%  crowd_perf       crowd_perf                      [.] engine::character_clip
+            |
+            ---engine::character_clip
+               engine::update_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     1.85%  crowd_perf       crowd_perf                      [.] engine::world_to_screen
+            |
+            ---engine::world_to_screen
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     1.41%  crowd_perf       crowd_perf                      [.] runtime::_append_elem
+            |
+            ---runtime::_append_elem
+               runtime::append_elem:proc(array:^[dynamic]engine::Queued_Sprite,arg:engine::Queued_Sprite,loc:runtime::Source_Code_Location)->(n:int,err:runtime::Allocator_Error)
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     1.37%  crowd_perf       crowd_perf                      [.] engine::end_frame
+            |
+            ---engine::end_frame
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     1.15%  crowd_perf       libc.so.6                       [.] clock_gettime
+            |
+            ---clock_gettime
+
+     1.05%  crowd_perf       libdbus-1.so.3.38.3             [.] _dbus_atomic_dec
+            |
+            ---_dbus_atomic_dec
+               |          
+                --0.95%--_dbus_connection_unref_unlocked
+                          0x7fec32e8fbae
+                          0x7fec32e8fdad
+                          0x7fec32e94b31
+                          0x7fec33054fca
+                          0x7fec33055bbd
+                          engine::events
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     0.95%  crowd_perf       crowd_perf                      [.] main::main
+            |
+            ---main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     0.91%  crowd_perf       crowd_perf                      [.] runtime::append_elem:proc(array:^[dynamic]engine::Queued_Sprite,arg:engine::Queued_Sprite,loc:runtime::Source_Code_Location)->(n:int,err:runtime::Allocator_Error)
+            |
+            ---runtime::append_elem:proc(array:^[dynamic]engine::Queued_Sprite,arg:engine::Queued_Sprite,loc:runtime::Source_Code_Location)->(n:int,err:runtime::Allocator_Error)
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     0.91%  crowd_perf       libc.so.6                       [.] 0x000000000018a4c4
+            |
+            ---0x7fec32d8a4c4
+               |          
+                --0.82%--engine::draw_sprite
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     0.86%  crowd_perf       crowd_perf                      [.] runtime::string_eq
+            |
+            ---runtime::string_eq
+               __$map_get$$map[string]engine::Clip_Def
+               |          
+                --0.60%--engine::character_clip
+                          engine::update_sprite
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     0.84%  crowd_perf       crowd_perf                      [.] engine::character_frame
+            |
+            ---engine::character_frame
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     0.81%  crowd_perf       libwayland-client.so.0.25.0     [.] wl_proxy_marshal_array_flags
+            |
+            ---wl_proxy_marshal_array_flags
+               wl_proxy_marshal_flags
+
+     0.77%  crowd_perf       libc.so.6                       [.] 0x00000000000a7159
+            |
+            ---0x7fec32ca7159
+               |          
+                --0.61%--0x7fec12d80142
+                          0x7fec12d82613
+                          0x7fec12d3cff4
+                          0x7fec12ddcaf6
+                          0x7fec12ddccd4
+                          0x7fec12de6f2c
+                          0x7fec3324fec1
+                          engine::end_frame
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     0.74%  wl_cursor_surfa  libc.so.6                       [.] 0x0000000000093fff
+     0.73%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000143ffe
+            |
+            ---0x7fec33143ffe
+               0x7fec3314a028
+               0x7fec33141b9a
+
+     0.73%  crowd_perf       crowd_perf                      [.] runtime::bounds_check_error
+            |
+            ---runtime::bounds_check_error
+               |          
+                --0.53%--engine::character_frame
+                          engine::draw_sprite
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     0.71%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f41b7
+            |
+            ---0x7fec12df41b7
+               0x7fec12df44e5
+               |          
+                --0.59%--0x7fec12c2baf6
+                          0x7fec12c2da03
+                          0x7fec12c2e4ca
+                          0x7fec12c2f277
+                          0x7fec12de052c
+                          0x7fec12de1521
+                          0x7fec33247581
+                          0x7fec33064bab
+                          engine::end_frame
+                          main::main
+
+     0.70%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023af6a
+            |
+            ---0x7fec3323af6a
+               |          
+                --0.58%--0x7fec33249f38
+                          engine::end_frame
+                          main::main
+                          main
+                          0x7fec32c27740
+                          __libc_start_main
+                          _start
+
+     0.69%  crowd_perf       crowd_perf                      [.] engine::frame_uvs
+            |
+            ---engine::frame_uvs
+               engine::draw_sprite
+               main::main
+               main
+               0x7fec32c27740
+               __libc_start_main
+               _start
+
+     0.68%  crowd_perf       libc.so.6                       [.] 0x000000000009ca5c
+            |
+            ---0x7fec32c9ca5c
+
+     0.67%  crowd_perf       [vdso]                          [.] __vdso_clock_gettime
+            |
+            ---__vdso_clock_gettime
+               clock_gettime
+
+     0.58%  crowd_perf       libdrm.so.2.134.0               [.] drmIoctl
+     0.58%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033b80b
+            |
+            ---0x7fec12f3b80b
+               0x7fec12df41ce
+               0x7fec12df44e5
+
+     0.53%  crowd_perf       libc.so.6                       [.] cfree
+            |
+            ---cfree
+
+     0.51%  crowd_perf       [unknown]                       [k] 0xffffffff84e00080
+            |
+            ---0xffffffff84e00080
+
+     0.45%  crowd_perf       libc.so.6                       [.] pthread_mutex_unlock
+     0.44%  crowd_perf       libc.so.6                       [.] pthread_rwlock_rdlock
+     0.43%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d2c23
+     0.40%  crowd_perf       libc.so.6                       [.] 0x0000000000180625
+     0.39%  crowd_perf       libc.so.6                       [.] 0x000000000018a547
+     0.37%  crowd_perf       crowd_perf                      [.] runtime::default_hasher_string
+     0.36%  crowd_perf       libc.so.6                       [.] 0x000000000018a4c0
+     0.35%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000247484
+     0.33%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003147
+     0.33%  crowd_perf       libc.so.6                       [.] 0x0000000000189cc4
+     0.33%  crowd_perf       [unknown]                       [k] 0xffffffff84e00084
+     0.31%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a44b7
+     0.31%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000110d98
+     0.31%  wl_cursor_surfa  libc.so.6                       [.] 0x000000000018a4f3
+     0.30%  crowd_perf       libc.so.6                       [.] 0x000000000018a4e2
+     0.30%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000e6624
+     0.28%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033b84d
+     0.28%  crowd_perf       libc.so.6                       [.] 0x00000000000a4524
+     0.28%  crowd_perf       libc.so.6                       [.] malloc
+     0.27%  crowd_perf       crowd_perf                      [.] runtime::map_seed_from_map_data
+     0.27%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001822f7
+     0.26%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033c9d7
+     0.26%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000be362
+     0.26%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024cff0
+     0.26%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cd8a8
+     0.26%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018d44f
+     0.25%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001d131e
+     0.25%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000116255
+     0.25%  crowd_perf       libdbus-1.so.3.38.3             [.] _dbus_atomic_inc
+     0.25%  crowd_perf       crowd_perf                      [.] __$hasher$$string
+     0.25%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000062360
+     0.25%  crowd_perf       libdrm.so.2.134.0               [.] drmSyncobjTimelineWait
+     0.24%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022daa
+     0.24%  crowd_perf       libc.so.6                       [.] 0x000000000018a486
+     0.24%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000b7b5f
+     0.24%  crowd_perf       libdbus-1.so.3.38.3             [.] _dbus_message_loader_queue_messages
+     0.24%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000168f4
+     0.24%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000144008
+     0.24%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024cd09
+     0.23%  crowd_perf       libc.so.6                       [.] 0x00000000000a45c9
+     0.23%  crowd_perf       crowd_perf                      [.] engine::texture_run_len
+     0.23%  crowd_perf       [unknown]                       [k] 0xffffffff86355a81
+     0.23%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023af07
+     0.23%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024d030
+     0.23%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003140
+     0.23%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000166c5
+     0.22%  crowd_perf       libc.so.6                       [.] pthread_rwlock_unlock
+     0.22%  crowd_perf       libc.so.6                       [.] 0x000000000018a4ea
+     0.22%  crowd_perf       libc.so.6                       [.] 0x000000000018a4ca
+     0.22%  crowd_perf       libc.so.6                       [.] 0x000000000009ca36
+     0.22%  crowd_perf       crowd_perf                      [.] engine::begin_frame
+     0.22%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000002501f2
+     0.22%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x00000000000032b2
+     0.22%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cf9cf
+     0.22%  crowd_perf       libc.so.6                       [.] 0x00000000000a58f9
+     0.22%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e47ac
+     0.21%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003263
+     0.21%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e61b8
+     0.21%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x00000000000049dc
+     0.21%  wl_cursor_surfa  libSDL3.so.0.4.12               [.] 0x00000000001cd7b4
+     0.21%  crowd_perf       [unknown]                       [k] 0xffffffff85a7a084
+     0.20%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d2761
+     0.19%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003203
+     0.19%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002295c
+     0.19%  crowd_perf       libc.so.6                       [.] 0x0000000000190598
+     0.18%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d33ea
+     0.17%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000541ae
+     0.17%  crowd_perf       [unknown]                       [k] 0xffffffff855d7847
+     0.17%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000037a095
+     0.17%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c5b8f
+     0.17%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x0000000000016a5d
+     0.17%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002ca02
+     0.16%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000181459
+     0.16%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] wl_display_flush
+     0.16%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ebd77
+     0.16%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e35cb
+     0.16%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x0000000000031bdf
+     0.16%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000bbf75
+     0.16%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e4a6a
+     0.15%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e4d24
+     0.15%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000016610
+     0.15%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ed46e
+     0.15%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018d496
+     0.15%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000b8dea
+     0.15%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024fd04
+     0.14%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000249f10
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ba831
+     0.14%  crowd_perf       libc.so.6                       [.] 0x000000000018a55c
+     0.14%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003165
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000035f660
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000115185
+     0.14%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000018584
+     0.14%  crowd_perf       libc.so.6                       [.] 0x000000000009ffc4
+     0.14%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000657d0
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000028528
+     0.14%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000004cb4
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000021b325
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000013c5ff
+     0.14%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a7586
+     0.14%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000016675
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000035f6d0
+     0.14%  crowd_perf       [unknown]                       [k] 0xffffffff855e8fd6
+     0.14%  crowd_perf       libc.so.6                       [.] 0x00000000000a44b7
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018aae8
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022b11
+     0.14%  crowd_perf       libdbus-1.so.3.38.3             [.] dbus_connection_ref
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001d9f6f
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001814d7
+     0.14%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000035f634
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000181ee4
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033cb4a
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cb17f
+     0.13%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] wl_display_read_events
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018c7aa
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033b7e1
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c9cb4
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c5e16
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000017dbbb
+     0.13%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000f7a33
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000017ea01
+     0.13%  crowd_perf       libnvidia-glcore.so.610.43.03   [.] 0x0000000000fcd46c
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ccf75
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002c934
+     0.13%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000185a9
+     0.13%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003193
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000115378
+     0.13%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000062cee
+     0.13%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x00000000000039f1
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c5525
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001dbca4
+     0.13%  wl_cursor_surfa  libc.so.6                       [.] 0x0000000000094084
+     0.13%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a66c4
+     0.13%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000001c8cfd
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c5b0f
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000116284
+     0.13%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x000000000000320b
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000017d7c4
+     0.13%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023af40
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002cd72
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cd651
+     0.13%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000217945
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024e846
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000017ff51
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000186261
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000002440cf
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ebdf7
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f3ff0
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cb17b
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001deb23
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f2e1b
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f44d1
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001161e8
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d88e7
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001168fc
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cea95
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e4771
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000336cae
+     0.12%  crowd_perf       [unknown]                       [k] 0xffffffff84e00087
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cd7c4
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000b8712
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000010da71
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001dca18
+     0.12%  crowd_perf       libc.so.6                       [.] 0x00000000000a6ed3
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000bf533
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ceb86
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001166e5
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000068cca2
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000116312
+     0.12%  crowd_perf       libdbus-1.so.3.38.3             [.] _dbus_list_pop_first_link
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000180ab2
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002336f
+     0.12%  crowd_perf       crowd_perf                      [.] engine::now_seconds
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024fc98
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f3ff4
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000116118
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000181449
+     0.12%  crowd_perf       libdrm.so.2.134.0               [.] drmSyncobjWait
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000b707d
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000011621a
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023c102
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000002469b4
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001d8d26
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000bdcf2
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e4c57
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c2897
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023be6f
+     0.12%  crowd_perf       [unknown]                       [k] 0xffffffff84e015f4
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000025442a
+     0.12%  crowd_perf       libc.so.6                       [.] 0x00000000000a6403
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f3010
+     0.12%  wl_cursor_surfa  libSDL3.so.0.4.12               [.] 0x00000000001e3f78
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e61f1
+     0.12%  crowd_perf       [unknown]                       [k] 0xffffffff85a7a016
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018d4e4
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000f4af3
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001153f9
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cb4b9
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000283b6
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d2d0b
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e6d70
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000115a48
+     0.12%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024d110
+     0.12%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000017ff7a
+     0.11%  crowd_perf       libc.so.6                       [.] 0x00000000000a5735
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000011416b
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023aefa
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cd413
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000068cc64
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022d88
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000025478f
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000545e3
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018c87b
+     0.11%  crowd_perf       libc.so.6                       [.] 0x000000000005bcfd
+     0.11%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x00000000000032a4
+     0.11%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x000000000001aa7b
+     0.11%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a674c
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d6749
+     0.11%  crowd_perf       libffi.so.8.4.1                 [.] 0x0000000000002bf4
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000054e93
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000018567
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000189a35
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000182313
+     0.11%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x000000000003219d
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] SDL_UnmapGPUTransferBuffer
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000176c2
+     0.11%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] 0x0000000000003689
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022a03
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002f38d
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d2686
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000244358
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ce843
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f41d6
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000217e57
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cca9b
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000022d261
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ebc8d
+     0.11%  crowd_perf       libc.so.6                       [.] pthread_getspecific
+     0.11%  crowd_perf       libc.so.6                       [.] 0x00000000000a4520
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c0133
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000176d1
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000002475f1
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000035f6c7
+     0.11%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a661d
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000246fbc
+     0.11%  wl_cursor_surfa  libc.so.6                       [.] pthread_mutex_lock
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c4a78
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d227c
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cf034
+     0.11%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000016e32
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000b91fb
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e6228
+     0.11%  crowd_perf       libc.so.6                       [.] 0x0000000000189c5a
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000b7a68
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f2b1b
+     0.11%  crowd_perf       libc.so.6                       [.] __libc_calloc
+     0.11%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c5ba8
+     0.11%  crowd_perf       libc.so.6                       [.] 0x0000000000189c6e
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033c9cd
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000bc661
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022a90
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d2ed4
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cfbdd
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001158db
+     0.10%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x000000000000315e
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c5b36
+     0.10%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x000000000000326e
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000013c87e
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000062c29
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024e2b6
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000023be24
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000197523
+     0.10%  crowd_perf       libwayland-client.so.0.25.0     [.] wl_display_prepare_read_queue
+     0.10%  crowd_perf       libc.so.6                       [.] 0x00000000000a57e4
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000002441e6
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cd71c
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018c8b9
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001cfb14
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000067a27
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000022ddf5
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000254752
+     0.10%  crowd_perf       libc.so.6                       [.] 0x000000000009ca4f
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000189e7f
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f2d44
+     0.10%  crowd_perf       libc.so.6                       [.] 0x0000000000183444
+     0.10%  crowd_perf       libc.so.6                       [.] ioctl
+     0.10%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000001662f
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d3c1f
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ed479
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e4e14
+     0.10%  wl_cursor_surfa  libSDL3.so.0.4.12               [.] 0x00000000001e3f76
+     0.10%  crowd_perf       libwayland-client.so.0.25.0     [.] wl_list_empty
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d6c8b
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000193681
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001dd4e5
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018d452
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000028474
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000bc657
+     0.10%  crowd_perf       libdbus-1.so.3.38.3             [.] dbus_connection_get_dispatch_status
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000068fe91
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000017e9d8
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000fa720
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000013d041
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000033b851
+     0.10%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e3616
+     0.09%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024f5a2
+     0.09%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000025445f
+     0.09%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000cb359
+     0.09%  crowd_perf       libc.so.6                       [.] strchrnul@plt
+     0.09%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000d3493
+     0.09%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022b67
+     0.09%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000116982
+     0.09%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000035f664
+     0.09%  crowd_perf       libc.so.6                       [.] 0x0000000000189c47
+     0.08%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x00000000000031c3
+     0.08%  crowd_perf       libc.so.6                       [.] 0x00000000000a66c4
+     0.08%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ebd95
+     0.08%  crowd_perf       libc.so.6                       [.] 0x00000000000a5750
+     0.08%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ce980
+     0.08%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000115f93
+     0.08%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018d5e9
+     0.08%  wl_cursor_surfa  libc.so.6                       [.] 0x000000000009ca5c
+     0.07%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018aaf9
+     0.07%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000c4a6a
+     0.07%  wl_cursor_surfa  libSDL3.so.0.4.12               [.] 0x00000000001cd7b1
+     0.07%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e4e3e
+     0.06%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] wl_list_insert
+     0.06%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a6ed3
+     0.03%  crowd_perf       libxkbcommon.so.0.13.2          [.] 0x00000000000084b7
+     0.03%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a6f67
+     0.02%  crowd_perf       libc.so.6                       [.] 0x0000000000189d47
+     0.02%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e5074
+     0.02%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x000000000000ac3a
+     0.01%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000182d8f
+     0.00%  crowd_perf       libc.so.6                       [.] __cxa_finalize
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] pthread_cond_broadcast
+     0.00%  wl_cursor_surfa  [unknown]                       [k] 0xffffffff84e00080
+     0.00%  crowd_perf       libc.so.6                       [.] 0x00000000000a7681
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] 0x00000000000036ef
+     0.00%  crowd_p:disk$0   libc.so.6                       [.] pthread_cond_wait
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] 0x0000000000003621
+     0.00%  crowd_perf       libc.so.6                       [.] 0x00000000000534eb
+     0.00%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x0000000000037c44
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x000000000009ca21
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] ppoll
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000002d5ba
+     0.00%  crowd_perf       libSDL3.so.0.4.12               [.] 0x00000000000670f4
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000037a011
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000189cf7
+     0.00%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x0000000000015951
+     0.00%  crowd_perf       libSDL3.so.0.4.12               [.] 0x000000000024e620
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f2f92
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x00000000000a4463
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000001e56c
+     0.00%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x000000000001004a
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] 0x00000000000031c3
+     0.00%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x0000000000014887
+     0.00%  crowd_perf       libc.so.6                       [.] 0x000000000005b734
+     0.00%  crowd_perf       libc.so.6                       [.] 0x000000000005bd50
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001e3e38
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000064b99
+     0.00%  crowd_perf       libc.so.6                       [.] 0x000000000005a244
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345b18
+     0.00%  crowd_perf       libc.so.6                       [.] __ctype_init
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff86355a14
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff86355a10
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345ce7
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345adb
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x0000000000654f48
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12               [.] 0x00000000001e3f74
+     0.00%  crowd_perf       libc.so.6                       [.] __errno_location
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ca8f2
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x0000000001961f52
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345837
+     0.00%  crowd_perf       libc.so.6                       [.] pthread_self
+     0.00%  wl_cursor_surfa  [unknown]                       [k] 0xffffffff852a9115
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000103a63
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000018d575
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345cfe
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000097417
+     0.00%  crowd_perf       libc.so.6                       [.] 0x000000000009741b
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001166ae
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff84e015f0
+     0.00%  crowd_perf       libwayland-client.so.0.25.0     [.] wl_display_dispatch_queue_timeout
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000185400
+     0.00%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x0000000000008b5e
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022edc
+     0.00%  crowd_perf       libSDL3.so.0.4.12               [.] 0x0000000000018892
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000028ed39
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x0000000000094040
+     0.00%  crowd_perf       libc.so.6                       [.] sendmsg
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff84e01280
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000344ddb
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345bb3
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000344ddd
+     0.00%  crowd_perf       libc.so.6                       [.] 0x000000000011bed0
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000344cd4
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345ad6
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000094047
+     0.00%  crowd_perf       libc.so.6                       [.] 0x00000000000973a0
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000103a40
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x0000000000094047
+     0.00%  crowd_perf       libc.so.6                       [.] __poll
+     0.00%  crowd_perf       libc.so.6                       [.] 0x00000000000973a4
+     0.00%  crowd_perf       libdbus-1.so.3.38.3             [.] 0x0000000000032197
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff84e01630
+     0.00%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x000000000000932e
+     0.00%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x0000000000009339
+     0.00%  crowd_perf       ld-linux-x86-64.so.2            [.] 0x000000000001f103
+     0.00%  crowd_perf       libc.so.6                       [.] ppoll
+     0.00%  crowd_perf       libc.so.6                       [.] realloc
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000094040
+     0.00%  crowd_perf       libc.so.6                       [.] 0x0000000000094084
+     0.00%  crowd_perf       libc.so.6                       [.] 0x00000000000a78dc
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03   [.] 0x00000000009e786b
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x0000000000455dd3
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x000000000067d1b0
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x000000000067d1c2
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x0000000001956940
+     0.00%  crowd_perf       libnvidia-gpucomp.so.610.43.03  [.] 0x000000000195a141
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022e9e
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022ea7
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000022ebd
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000bafc5
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ca918
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000000ca91f
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000011666f
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001166a8
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f2dbf
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x00000000001f2dd0
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000028ece4
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000028ed0d
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x0000000000345bb0
+     0.00%  crowd_perf       libvulkan_radeon.so             [.] 0x000000000068d01a
+     0.00%  crowd_perf       libwayland-client.so.0.25.0     [.] 0x0000000000003aa8
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff84e01670
+     0.00%  crowd_perf       [unknown]                       [k] 0xffffffff84e01690
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x0000000000094050
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x0000000000094085
+     0.00%  wl_cursor_surfa  libc.so.6                       [.] 0x000000000009fff2
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0     [.] 0x0000000000004524
+     0.00%  wl_cursor_surfa  [unknown]                       [k] 0xffffffff84e01630
+
+
+#
+# (Tip: For tracepoint events, try: perf report -s trace_fields)
+#

flame/crowd-20260809-140317-report.txt

@@ -0,0 +1,730 @@
+# To display the perf.data header info, please use --header/--header-only options.
+#
+#
+# Total Lost Samples: 0
+#
+# Samples: 953  of event 'cpu/cycles/Pu'
+# Event count (approx.): 5763089468
+#
+# Overhead  Command          Shared Object                  Symbol                                                                                                                                                                                    
+# ........  ...............  .............................  ..........................................................................................................................................................................................
+#
+     4.03%  crowd_perf       libc.so.6                      [.] pthread_mutex_lock
+            |
+            ---pthread_mutex_lock
+               |          
+                --0.65%--0x7f80850501f1
+                          engine::end_frame (inlined)
+                          main::main
+                          main
+                          0x7f8084a27740
+                          __libc_start_main
+                          _start
+
+     3.19%  crowd_perf       crowd_perf                     [.] main::main
+            |          
+             --0.79%--runtime::default_hasher (inlined)
+                       runtime::default_hasher_string (inlined)
+                       |          
+                        --0.54%--engine::character_clip (inlined)
+                                  engine::update_sprite (inlined)
+                                  main::main
+                                  main
+                                  0x7f8084a27740
+                                  __libc_start_main
+                                  _start
+
+     2.85%  crowd_perf       libc.so.6                      [.] 0x00000000000a73e9
+            |
+            ---0x7f8084aa73e9
+               wl_proxy_marshal_array_flags
+               wl_proxy_marshal_flags
+               0x7f8082b97614
+               0x7f8082b8a4f8
+               0x7f808504ffc9
+               engine::end_frame (inlined)
+               main::main
+               main
+               0x7f8084a27740
+               __libc_start_main
+               _start
+
+     2.20%  crowd_perf       crowd_perf                     [.] __$map_get$$map[string]engine::Clip_Def
+            |
+            ---__$map_get$$map[string]engine::Clip_Def
+               |          
+                --1.91%--engine::character_clip (inlined)
+                          engine::update_sprite (inlined)
+                          main::main
+                          main
+                          0x7f8084a27740
+                          __libc_start_main
+                          _start
+
+     2.07%  crowd_perf       libc.so.6                      [.] 0x0000000000189c53
+            |
+            ---0x7f8084b89c53
+               runtime::_append_elem
+               runtime::append_elem:proc(array:^[dynamic]engine::Queued_Sprite,arg:engine::Queued_Sprite,loc:runtime::Source_Code_Location)->(n:int,err:runtime::Allocator_Error) (inlined)
+               engine::draw_sprite (inlined)
+               main::main
+               main
+               0x7f8084a27740
+               __libc_start_main
+               _start
+
+     1.83%  crowd_perf       libc.so.6                      [.] clock_gettime
+            |
+            ---clock_gettime
+               |          
+               |--0.53%--0x7f808502c819
+               |          
+                --0.52%--0x7f8082d7a09a
+                          0x7f8082d3de27
+                          |          
+                           --0.52%--0x7f8082b975b5
+                                     0x7f8082b8a4f8
+                                     0x7f808504ffc9
+                                     engine::end_frame (inlined)
+                                     main::main
+                                     main
+                                     0x7f8084a27740
+                                     __libc_start_main
+                                     _start
+
+     1.58%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_proxy_marshal_array_flags
+            |
+            ---wl_proxy_marshal_array_flags
+               wl_proxy_marshal_flags
+
+     1.55%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000031fb52
+            |
+            ---0x7f8082d1fb52
+               0x7f8082a2cc72
+               0x7f8082a2cf4e
+               0x7f8082a2e299
+               0x7f8082a2f277
+               0x7f8082be052c
+               0x7f8082be1521
+               0x7f8085047581
+               0x7f8084e64bab
+               engine::end_frame (inlined)
+               main::main
+               main
+               0x7f8084a27740
+               __libc_start_main
+               _start
+
+     1.34%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_list_insert
+     1.30%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a678f
+     1.18%  crowd_perf       [unknown]                      [k] 0xffffffff84e00080
+            |
+            ---0xffffffff84e00080
+               |          
+                --0.94%--ioctl
+                          |          
+                           --0.80%--drmIoctl
+
+     1.07%  crowd_perf       libc.so.6                      [.] ioctl
+            |
+            ---ioctl
+               |          
+                --1.07%--drmIoctl
+                          |          
+                           --0.61%--drmSyncobjTimelineWait
+                                     |          
+                                      --0.50%--0x7f8082b8d8ad
+                                                0x7f8082b93f45
+                                                0x7f8082b89296
+                                                0x7f8082b89241
+                                                0x7f80850544bd
+                                                0x7f8084e69860
+                                                engine::begin_frame (inlined)
+                                                main::main
+                                                main
+                                                0x7f8084a27740
+                                                __libc_start_main
+                                                _start
+
+     1.05%  crowd_perf       [vdso]                         [.] __vdso_clock_gettime
+            |
+            ---__vdso_clock_gettime
+               clock_gettime
+               |          
+                --0.50%--0x7f8082d7a09a
+
+     0.93%  crowd_perf       [unknown]                      [k] 0xffffffff86355a81
+            |
+            ---0xffffffff86355a81
+               0xffffffff84e0012f
+               |          
+                --0.81%--ioctl
+                          |          
+                           --0.69%--drmIoctl
+
+     0.92%  crowd_perf       libdrm.so.2.134.0              [.] drmIoctl
+            |
+            ---drmIoctl
+
+     0.85%  crowd_perf       libc.so.6                      [.] cfree
+            |
+            ---cfree
+
+     0.81%  crowd_perf       libc.so.6                      [.] 0x000000000009ca5c
+            |
+            ---0x7f8084a9ca5c
+
+     0.78%  crowd_perf       libc.so.6                      [.] 0x00000000000a6ed3
+            |
+            ---0x7f8084aa6ed3
+               |          
+                --0.55%--0x7f8084aa714d
+
+     0.70%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002501f2
+            |
+            ---0x7f80850501f2
+               engine::end_frame (inlined)
+               main::main
+               main
+               0x7f8084a27740
+               __libc_start_main
+               _start
+
+     0.65%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022d88
+            |
+            ---0x7f8082a22d88
+
+     0.62%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41b7
+            |
+            ---0x7f8082bf41b7
+               0x7f8082bf44e5
+
+     0.61%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2c23
+            |
+            ---0x7f8082ad2c23
+               0x7f8082be6325
+
+     0.60%  crowd_perf       libc.so.6                      [.] 0x000000000018a547
+            |
+            ---0x7f8084b8a547
+
+     0.56%  crowd_perf       libc.so.6                      [.] malloc
+            |
+            ---malloc
+
+     0.55%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000e6624
+            |
+            ---0x7f8082ae6624
+               0x7f8082be6325
+
+     0.53%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002475f1
+            |
+            ---0x7f80850475f1
+               0x7f8084e64bab
+               engine::end_frame (inlined)
+               main::main
+               main
+               0x7f8084a27740
+               __libc_start_main
+               _start
+
+     0.53%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e61b8
+            |
+            ---0x7f8082be61b8
+               0x7f808503b9d8
+               0x7f8085049f22
+               engine::end_frame (inlined)
+               main::main
+               main
+               0x7f8084a27740
+               __libc_start_main
+               _start
+
+     0.51%  crowd_perf       [unknown]                      [k] 0xffffffff855d7847
+            |
+            ---0xffffffff855d7847
+               0xffffffff86355aba
+               0xffffffff84e0012f
+               ioctl
+               drmIoctl
+
+     0.50%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033b80b
+            |
+            ---0x7f8082d3b80b
+               0x7f8082bf41ce
+
+     0.50%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023af6a
+     0.48%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001deb23
+     0.48%  crowd_perf       libc.so.6                      [.] pthread_rwlock_unlock
+     0.48%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033c9d7
+     0.47%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002ca18
+     0.46%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_flush
+     0.46%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b92b8
+     0.45%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001822f7
+     0.44%  crowd_perf       libc.so.6                      [.] pthread_rwlock_wrlock
+     0.41%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003203
+     0.41%  crowd_perf       libc.so.6                      [.] __errno_location
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000180ab2
+     0.40%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024d183
+     0.40%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2761
+     0.39%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000016900
+     0.39%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000243e0a
+     0.39%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6747
+     0.36%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d492
+     0.35%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001814c2
+     0.35%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b8fdd
+     0.35%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000e5edc
+     0.33%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f74
+     0.33%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000001493ed
+     0.32%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000005430
+     0.32%  crowd_perf       libc.so.6                      [.] 0x00000000000a7554
+     0.29%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e0534
+     0.29%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_proxy_marshal_flags
+     0.29%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000110d3b
+     0.29%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001defd2
+     0.29%  wl_cursor_surfa  libc.so.6                      [.] 0x000000000018a507
+     0.29%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003147
+     0.29%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x00000000000032a4
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d44f
+     0.28%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d866
+     0.28%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000168f4
+     0.27%  wl_cursor_surfa  libc.so.6                      [.] ppoll
+     0.27%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d227c
+     0.27%  crowd_perf       crowd_perf                     [.] runtime::_append_elem
+     0.27%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003943
+     0.27%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b91fd
+     0.26%  crowd_perf       libc.so.6                      [.] pthread_mutex_unlock
+     0.26%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41d6
+     0.26%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002441e6
+     0.26%  crowd_perf       libc.so.6                      [.] 0x00000000000a6ed7
+     0.26%  crowd_perf       libc.so.6                      [.] 0x00000000000a590c
+     0.26%  crowd_perf       [unknown]                      [k] 0xffffffff84e00084
+     0.26%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_read_events
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033cb4a
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f2f9e
+     0.25%  crowd_perf       libc.so.6                      [.] 0x0000000000180604
+     0.25%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000016904
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000181449
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000fabbd
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022daa
+     0.25%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b69b6
+     0.24%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ba831
+     0.24%  wl_cursor_surfa  libc.so.6                      [.] pthread_mutex_lock
+     0.24%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000068ccac
+     0.24%  crowd_perf       libc.so.6                      [.] 0x00000000000a7101
+     0.24%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001152d6
+     0.24%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bdd3d
+     0.24%  crowd_perf       libc.so.6                      [.] 0x000000000018a54e
+     0.24%  crowd_perf       [unknown]                      [k] 0xffffffff85a7a016
+     0.24%  wl_cursor_surfa  libc.so.6                      [.] recvmsg
+     0.23%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000035f607
+     0.23%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3ff4
+     0.23%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjWait
+     0.23%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x000000000000320b
+     0.22%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023434e
+     0.22%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024ff8e
+     0.22%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002504d8
+     0.21%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000093fe4
+     0.21%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f4165
+     0.20%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000018896
+     0.20%  crowd_perf       libc.so.6                      [.] 0x0000000000183444
+     0.19%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd91c
+     0.19%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000e6243
+     0.19%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd030
+     0.19%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000001663d
+     0.18%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000115378
+     0.18%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001da01c
+     0.18%  crowd_perf       libc.so.6                      [.] 0x00000000000a579b
+     0.18%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x0000000000004cb4
+     0.17%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ebd58
+     0.17%  crowd_perf       libc.so.6                      [.] 0x0000000000180625
+     0.17%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001df838
+     0.17%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cfab0
+     0.17%  crowd_perf       libc.so.6                      [.] 0x00000000000a678f
+     0.17%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cf034
+     0.16%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024cec9
+     0.16%  crowd_perf       [unknown]                      [k] 0xffffffff86355a14
+     0.16%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023af5d
+     0.16%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094085
+     0.16%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_atomic_inc
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000037a25e
+     0.16%  crowd_perf       libdbus-1.so.3.38.3            [.] dbus_connection_unref
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000181484
+     0.16%  crowd_perf       libwayland-client.so.0.25.0    [.] wl_list_remove
+     0.16%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000025445f
+     0.16%  crowd_perf       libc.so.6                      [.] 0x000000000009ca14
+     0.16%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_connection_lock
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000217ee9
+     0.16%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000254472
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd6f2
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000f4ad9
+     0.16%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd461
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018aaf2
+     0.16%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002caab
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e6434
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002ca15
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c5ba8
+     0.15%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003263
+     0.15%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000015f1c3
+     0.15%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x00000000000032dc
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3344
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d7063
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c4a41
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ec895
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000335bd4
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ebdc5
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3ff6
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ebe76
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ed816
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e61f1
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d5ef
+     0.15%  crowd_perf       libc.so.6                      [.] 0x000000000018062b
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d13c3
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d8386
+     0.15%  wl_cursor_surfa  libc.so.6                      [.] 0x000000000009ca5c
+     0.15%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000015f1a4
+     0.15%  crowd_perf       libc.so.6                      [.] 0x00000000000a5735
+     0.15%  crowd_perf       [unknown]                      [k] 0xffffffff84e00087
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022b88
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000217dba
+     0.15%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000001da04c
+     0.15%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000019371b
+     0.15%  crowd_perf       libc.so.6                      [.] 0x0000000000189c44
+     0.14%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x000000000001ab32
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000196829
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000017690
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d844
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bddf1
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000013ca2e
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000054e60
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000194631
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c9aeb
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017dbc1
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000197523
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001cf344
+     0.14%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x000000000001aa6d
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024ce11
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000055379
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024bb5e
+     0.14%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x0000000000031883
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d6418
+     0.14%  crowd_perf       libc.so.6                      [.] 0x000000000018a57d
+     0.14%  crowd_perf       libc.so.6                      [.] 0x0000000000189c93
+     0.14%  crowd_perf       libc.so.6                      [.] 0x000000000009ca4f
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000168f0
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000028474
+     0.14%  crowd_perf       libc.so.6                      [.] 0x00000000000a7477
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022a86
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d4ac
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000035f6c7
+     0.14%  crowd_perf       libc.so.6                      [.] 0x00000000000a66c4
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000002310fb
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000176c6
+     0.14%  crowd_perf       libc.so.6                      [.] 0x000000000009ca19
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023b2d1
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d8b8
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d9f47
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bbf60
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cea95
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000115ac7
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000115b65
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002470cf
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024d18e
+     0.14%  crowd_perf       libc.so.6                      [.] 0x000000000009ffc0
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cf4c5
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000244261
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d886
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001896c4
+     0.14%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x00000000000049dc
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c0ac8
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002ca2a
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d3493
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000001e62d
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000116118
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000053d7e
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c877c
+     0.14%  crowd_perf       libc.so.6                      [.] 0x000000000018a4f3
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000022d354
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022d55
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e5ebd
+     0.14%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000004c80
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f41a4
+     0.14%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003140
+     0.14%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e60b2
+     0.14%  crowd_perf       libc.so.6                      [.] 0x000000000009ca5a
+     0.14%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023c133
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024d1c6
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033ca1e
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000be09c
+     0.13%  crowd_perf       libc.so.6                      [.] 0x0000000000189cc4
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000185a0
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cc0cb
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b74ff
+     0.13%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_rmutex_lock
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bc373
+     0.13%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003193
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d148b
+     0.13%  crowd_perf       libc.so.6                      [.] 0x0000000000189d47
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023c3e7
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024b818
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000217eac
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000027f8e
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022aa5
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c9d9f
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002f38d
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024cf70
+     0.13%  crowd_perf       [unknown]                      [k] 0xffffffff855e8f44
+     0.13%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x00000000000032b2
+     0.13%  crowd_perf       libc.so.6                      [.] 0x000000000009ca31
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000005536a
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000013c684
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024fc98
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ed0ff
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c6ce6
+     0.13%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x000000000003187f
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001cfb65
+     0.13%  crowd_perf       libc.so.6                      [.] 0x0000000000180614
+     0.13%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_list_pop_first_link
+     0.13%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000005485
+     0.13%  crowd_perf       libc.so.6                      [.] __libc_calloc
+     0.13%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x000000000000320e
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001db541
+     0.13%  crowd_perf       libc.so.6                      [.] 0x000000000009408f
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f2f92
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c5bde
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d16a6
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001398b4
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024f60d
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d5e9
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d793a
+     0.13%  crowd_perf       libc.so.6                      [.] 0x000000000018a4c4
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001cf563
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ccf20
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000002310dc
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d7a3
+     0.13%  crowd_perf       libc.so.6                      [.] __close
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000035f634
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ed45b
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2d0b
+     0.13%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000f7a33
+     0.13%  crowd_perf       libc.so.6                      [.] 0x00000000000a7491
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000230ea5
+     0.13%  crowd_perf       libc.so.6                      [.] 0x00000000000a57a6
+     0.13%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000110d5e
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000068d087
+     0.12%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x0000000000031820
+     0.12%  crowd_perf       libc.so.6                      [.] 0x000000000009ca17
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024d030
+     0.12%  wl_cursor_surfa  libc.so.6                      [.] pthread_mutex_unlock
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024e291
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2ac1
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018c879
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022b1c
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f2c85
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e34fc
+     0.12%  crowd_perf       libc.so.6                      [.] ppoll
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bcb9e
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002334f
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022950
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d649e
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cfa60
+     0.12%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003912
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d1145
+     0.12%  crowd_perf       libdbus-1.so.3.38.3            [.] 0x00000000000318bf
+     0.12%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x00000000000049dc
+     0.12%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x0000000000003689
+     0.12%  crowd_perf       libc.so.6                      [.] 0x00000000000a6621
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002d844
+     0.12%  crowd_perf       [unknown]                      [k] 0xffffffff86355a41
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002bc13
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033cb5b
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002ce05
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000014f29b
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000025478f
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d462
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e6d9f
+     0.12%  crowd_perf       libc.so.6                      [.] 0x00000000000a6610
+     0.12%  crowd_perf       [unknown]                      [k] 0xffffffff850a84c5
+     0.12%  crowd_perf       libc.so.6                      [.] 0x0000000000180653
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033ca37
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000249e81
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dcabc
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000110ce8
+     0.12%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x000000000000328a
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024cef0
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd943
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c2584
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd7c1
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000022f3e
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d635
+     0.12%  crowd_perf       libc.so.6                      [.] 0x000000000009ca74
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cea42
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023b143
+     0.12%  wl_cursor_surfa  libc.so.6                      [.] 0x000000000018a4f3
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd71c
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d1865
+     0.12%  crowd_perf       libc.so.6                      [.] 0x000000000018a486
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e519a
+     0.12%  crowd_perf       libc.so.6                      [.] 0x00000000000a66e2
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000019678f
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e5134
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000002463df
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000054e93
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000068cf84
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000b6d7d
+     0.12%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000af32
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ed081
+     0.12%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000218046
+     0.12%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000541ae
+     0.12%  crowd_perf       libdbus-1.so.3.38.3            [.] _dbus_message_loader_queue_messages
+     0.12%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x000000000000546e
+     0.12%  crowd_perf       libwayland-client.so.0.25.0    [.] 0x0000000000003233
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000180ada
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000028174
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000657d0
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ce7ac
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000250239
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000068d014
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023ba94
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000013cae3
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000cd796
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024d1b9
+     0.11%  crowd_perf       libc.so.6                      [.] 0x000000000018a507
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f3465
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d452
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001e6363
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000021b281
+     0.11%  crowd_perf       libc.so.6                      [.] 0x00000000000a5904
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f401a
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000001c8c05
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d2d97
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000379fe4
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001529e1
+     0.11%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6732
+     0.11%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_prepare_read_queue
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024cddc
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000010da99
+     0.11%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x0000000000004961
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d62b5
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d874
+     0.11%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a66e2
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000182733
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000023598
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000054f23
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x00000000000176cf
+     0.11%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000024e2b6
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001f44c0
+     0.11%  crowd_perf       libc.so.6                      [.] 0x00000000000a6403
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d11b3
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d3c36
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033df64
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000d3a9c
+     0.11%  crowd_perf       libc.so.6                      [.] 0x00000000000a6603
+     0.11%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000283b6
+     0.11%  crowd_perf       libc.so.6                      [.] 0x00000000000a456a
+     0.11%  crowd_perf       libc.so.6                      [.] 0x0000000000189d0b
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000c5581
+     0.10%  crowd_perf       libc.so.6                      [.] 0x00000000000a5851
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000ce761
+     0.10%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023bdb8
+     0.10%  crowd_perf       [unknown]                      [k] 0xffffffff86355a45
+     0.10%  crowd_perf       libSDL3.so.0.4.12              [.] 0x000000000023b914
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000022d239
+     0.10%  crowd_perf       libc.so.6                      [.] 0x0000000000064888
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bdd81
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000231160
+     0.10%  crowd_perf       libc.so.6                      [.] 0x000000000018a4c0
+     0.10%  crowd_perf       libc.so.6                      [.] 0x000000000018a56f
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000022d386
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000280a5
+     0.10%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000002cd72
+     0.10%  crowd_perf       libSDL3.so.0.4.12              [.] 0x0000000000069865
+     0.09%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018a489
+     0.09%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000033b807
+     0.09%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000035f6d4
+     0.09%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000fa782
+     0.08%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000000bdfc3
+     0.03%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000fea2
+     0.01%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001d12c7
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a447d
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x0000000000004951
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a5701
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] wl_display_dispatch_queue_pending
+     0.00%  wl_cursor_surfa  libwayland-client.so.0.25.0    [.] 0x0000000000003193
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001dd35f
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000040242
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a7491
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a6ea4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000027f18
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffff8632ecd9
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000aed9
+     0.00%  crowd_perf       libc.so.6                      [.] getenv
+     0.00%  crowd_perf       libGLX_nvidia.so.610.43.03     [.] 0x000000000009e60a
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000094006
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x00000000001895fc
+     0.00%  crowd_perf       libc.so.6                      [.] __libc_secure_getenv
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x00000000000a6ea4
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x00000000000147ed
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffff850a7e70
+     0.00%  crowd_perf       libc.so.6                      [.] __ctype_init
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000064845
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000009741b
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345adb
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001cd7b4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345cfe
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f76
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000028ed0d
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345b18
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345ad6
+     0.00%  crowd_perf       libLLVM.so.22.1                [.] std::enable_if<llvm::hashing::detail::is_hashable_data<char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<char const>(char const*, char const*)
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000097417
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a5770
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001cd7b9
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000103a63
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd46c
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d572
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjExportSyncFile
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000deb7
+     0.00%  crowd_perf       libnvidia-glsi.so.610.43.03    [.] 0x00000000000460e4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000018d7de
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjTransfer
+     0.00%  crowd_perf       libdrm_amdgpu.so.1.134.0       [.] amdgpu_query_info
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001fce9
+     0.00%  wl_cursor_surfa  libSDL3.so.0.4.12              [.] 0x00000000001e3f78
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ddb
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344cd4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ccb
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000344ddd
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x0000000000345bb3
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffff84e01280
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094040
+     0.00%  crowd_perf       libc.so.6                      [.] 0x000000000011bed0
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000973a0
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094084
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000103a40
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000028ece4
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000028ed4d
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000dedf
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000f60f
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000000f611
+     0.00%  crowd_perf       ld-linux-x86-64.so.2           [.] 0x000000000001f103
+     0.00%  crowd_perf       libLLVM.so.22.1                [.] 0x000000000083a104
+     0.00%  crowd_perf       libLLVM.so.22.1                [.] 0x000000000083a146
+     0.00%  crowd_perf       libc.so.6                      [.] wait4
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000094040
+     0.00%  crowd_perf       libc.so.6                      [.] 0x0000000000094047
+     0.00%  crowd_perf       libc.so.6                      [.] 0x00000000000a58a9
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmCommandWrite
+     0.00%  crowd_perf       libdrm.so.2.134.0              [.] drmSyncobjTimelineWait
+     0.00%  crowd_perf       libnvidia-glcore.so.610.43.03  [.] 0x0000000000fcd46a
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017fa4b
+     0.00%  crowd_perf       libvulkan_radeon.so            [.] 0x000000000017fae8
+     0.00%  crowd_perf       [unknown]                      [k] 0xffffffff84e01670
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x0000000000094050
+     0.00%  wl_cursor_surfa  libc.so.6                      [.] 0x000000000009408f
+     0.00%  wl_cursor_surfa  [unknown]                      [k] 0xffffffff84e01630
+
+
+#
+# (Tip: For hierarchical output, try: perf report --hierarchy)
+#

scripts/bake_all.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT"
+
+CONTENT_ROOT="${CONTENT_ROOT:-content/characters}"
+OUT_ROOT="${OUT_ROOT:-assets_baked/characters}"
+
+if [[ ! -d "$CONTENT_ROOT" ]]; then
+	echo "missing content root: $CONTENT_ROOT" >&2
+	exit 1
+fi
+
+shopt -s nullglob
+manifests=("$CONTENT_ROOT"/*/manifest.json)
+if [[ ${#manifests[@]} -eq 0 ]]; then
+	echo "no character manifests under $CONTENT_ROOT" >&2
+	exit 1
+fi
+
+for manifest in "${manifests[@]}"; do
+	char_dir="$(dirname "$manifest")"
+	name="$(basename "$char_dir")"
+	out_dir="$OUT_ROOT/$name"
+	mkdir -p "$out_dir"
+	echo "baking $name -> $out_dir"
+	odin run assetbake -- "$char_dir" "$out_dir"
+done
+
+echo "baked ${#manifests[@]} character(s)"