Publish WeightProgramBench: 317 training games and 5 held-out MinAtar tasks

README.md

@@ -0,0 +1,183 @@
+---
+pretty_name: WeightProgramBench
+language:
+- en
+task_categories:
+- text-generation
+size_categories:
+- n<1K
+tags:
+- reinforcement-learning
+- weight-space-programming
+- games
+- benchmark
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train.jsonl
+  - split: test
+    path: data/test.jsonl
+---
+
+# WeightProgramBench
+
+Write the weights of a small game-playing neural network in one response,
+without tools. Each task provides the game rules, observation layout, game
+source, and network format. A CPU scorer reads numeric tensor assignments and
+plays the resulting policy; it never executes model-written code or trains the
+submitted network. Reinforcement learning can train the language model between
+submissions.
+
+This dataset preserves the expanded MinAtar Synth v4 corpus: **317 training
+games and five held-out original MinAtar games**. It contains task prompts,
+game implementations, the frozen scorer, and source attribution. It does not
+contain reference solutions, model weights, or model-generated trajectories.
+
+## Splits
+
+| Split | Games | Family |
+| --- | ---: | --- |
+| Train | 51 | Atari-style synthetic Python conversions |
+| Train | 266 | Crisp-inspired synthetic Python conversions |
+| Test | 5 | Original MinAtar: Asterix, Breakout, Freeway, Seaquest, Space Invaders |
+
+Training environments are compact Python adaptations, not Atari ROM emulation
+or native Crisp gameplay. All use `10 × 10 × 6` binary observations. The five
+original MinAtar games have their observation channels mapped into the same
+six-channel input. The split holds out game identities; it does not establish
+that every test mechanic is absent from training.
+
+## Load the tasks
+
+```python
+from datasets import load_dataset
+
+tasks = load_dataset("neilkale/WeightProgramBench")
+print(len(tasks["train"]), len(tasks["test"]))  # 317, 5
+task = tasks["test"][0]
+messages = [
+    {"role": "system", "content": task["system_prompt"]},
+    {"role": "user", "content": task["prompt"]},
+]
+```
+
+Each row preserves the original fields `name`, `split`, `game`, `source`,
+`prompt`, `system_prompt`, and `episodes`. Additional columns are:
+
+- `task_id`: zero-based index in the original 322-row task file. These IDs are
+  not renumbered within splits.
+- `family`: `atari_synthetic`, `crisp_synthetic`, or `minatar_original`.
+- `upstream_source_url` and `upstream_revision`: implementation provenance.
+- `native_source_url`: pinned native Crisp source, where applicable.
+
+For reproducible experiments, pin the same dataset commit using `revision=`
+when loading tasks and downloading runtime files.
+
+## Policy and scoring
+
+Every task uses a **600 → 32 → 32 → 6** network with **20,486 float32
+parameters**, two tanh hidden layers, and softmax-sampled actions. All parameters
+start at zero. The model supplies numeric tensor assignments in a fenced
+`edits` block, following the task's format. The scorer validates assignments
+with Python's AST and literal parser; it does not execute the response as Python.
+
+Each submitted policy plays **1,000 episodes**:
+
+- Environment seed: `1729 + episode_index`, covering `1729–2728`.
+- Independent action RNG seed: `7919 + episode_index`, covering `7919–8918`.
+- Sticky-action probability: `0.1`.
+- Episode limit: termination or **10,000 actions**.
+- Original MinAtar difficulty ramping: disabled.
+
+Seeds are fixed across games and submissions. The reward is
+`clip(mean_game_score, 0, game_score_cap) / game_score_cap`. Each synthetic game
+declares its own cap. Original MinAtar caps are 1,000, except Freeway's cap of
+100. These scales do not make games equally difficult. Invalid submissions
+receive zero. Keep raw scores alongside normalized rewards when comparing
+policies.
+
+The frozen runtime uses **NumPy 2.3.4** and **MinAtar 1.0.15**. Policy inference
+and replay run on CPU. One policy's 1,000 episodes are one language-model
+sample, not 1,000 independent model generations.
+
+## Score a saved response locally
+
+Install the replay dependencies; installing MinAtar without dependencies avoids
+adding optional visualization and training packages:
+
+```bash
+python -m pip install huggingface_hub 'numpy==2.3.4'
+python -m pip install --no-deps 'MinAtar==1.0.15'
+```
+
+Save the model's complete response, including its `edits` block, in `answer.txt`.
+Then evaluate it against the matching game:
+
+```python
+import json
+from pathlib import Path
+import sys
+from huggingface_hub import snapshot_download
+
+snapshot = Path(snapshot_download("neilkale/WeightProgramBench", repo_type="dataset"))
+runtime = snapshot / "runtime"
+sys.path.insert(0, str(runtime))
+from verify import apply_edits, evaluate, score_cap
+
+tasks = [json.loads(line) for line in (runtime / "tasks.jsonl").read_text().splitlines()]
+task = next(task for task in tasks if task["game"] == "breakout" and task["source"] == "original")
+answer = Path("answer.txt").read_text()
+weights, edit_count = apply_edits(answer)
+raw_score, mean_episode_length = evaluate(task["game"], task["source"], weights, task["episodes"])
+cap = score_cap(task["game"], task["source"])
+reward = min(max(raw_score, 0.0), cap) / cap
+print({"raw_score": raw_score, "reward": reward, "mean_episode_length": mean_episode_length})
+```
+
+This example raises on malformed responses so local debugging is explicit.
+For the benchmark's invalid-submission handling, use
+`verify.grade_answer(game, source, answer, episodes)`, which returns a reward
+and grading metadata. Full 1,000-episode replay can take several minutes,
+depending on the game and CPU.
+
+The Trajectory integration lives in the
+[WeightProgramBench cookbook PR](https://github.com/Trajectorylabs/trajectory-cookbook/pull/104).
+Model inference and training are separate from the local scorer.
+
+## Files and integrity
+
+- `data/train.jsonl`, `data/test.jsonl`: Hugging Face task splits with provenance
+  columns added.
+- `runtime/tasks.jsonl`: byte-identical frozen task records in their original
+  order, without added columns.
+- `runtime/minatar_synth/games/`: the 317 frozen Python training environments.
+- `runtime/verify.py`: frozen policy parser and CPU scorer.
+- `runtime/source.json`: SHA-256 digests for the original task file, scorer,
+  and all 317 game files.
+- `TASK_ORIGINS.json`: per-game source mappings, pinned revisions, and prompt
+  and implementation digests.
+- `THIRD_PARTY_NOTICES.md`, `runtime/NOTICE.txt`, and `runtime/LICENSE-*`:
+  credits and applicable upstream notices.
+
+Synthetic source revision: `4038830175c4201ca10e004ed4441985f2acddf2`.
+Frozen task-file SHA-256:
+`cc2d728fc3c820f217ecf43a4fdc0c9e2a5e292fcdd8b4afb0cb1d34774691e6`.
+
+## Credits and licensing
+
+The weight-space programming setup follows
+[Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab's experiments](https://rikiyat.github.io/blog/weight-space-programming/),
+particularly Experiment 5. The expanded training environments come from
+[Trajectory Labs, Jerry Chan, and contributors to MinAtar Synth](https://github.com/Trajectorylabs/minatar-synth/tree/4038830175c4201ca10e004ed4441985f2acddf2).
+Crisp game designs and sources are credited to **ABA Games** and contributors,
+and the portable SDL/C versions to **Joyrider3774** and contributors.
+Original **MinAtar** is by **Kenny Young and Tian Tian**.
+
+Licensing differs by component: original MinAtar source is GPL-3.0, the cited
+native Crisp source collections carry MIT notices, and the original experiment's
+prompt/log materials are attributed under CC BY 4.0. The pinned MinAtar Synth
+repository does not declare a license for its converted implementations. This
+dataset does not assert a blanket license for those files. See
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for the exact scopes and source
+links; the original MinAtar source embedded in prompts retains its GPL scope.

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,76 @@
+# Sources and credits
+
+WeightProgramBench packages the existing MinAtar Synth v4 task corpus without
+changing its game implementations, prompts, parser, or scoring contract. Its
+322 tasks comprise 51 Atari-style synthetic training games, 266 Crisp-inspired
+synthetic training games, and five original MinAtar held-out games. These are
+compact Python adaptations, not Atari ROM emulation or native Crisp gameplay.
+
+[`TASK_ORIGINS.json`](TASK_ORIGINS.json) records every task's family, source,
+revision or package version, source digest, and prompt digest. It also retains
+the exact pinned native-source link from each Crisp conversion's documentation.
+
+## MinAtar Synth implementations
+
+Credit Trajectory Labs, Jerry Chan, and the contributors to
+[MinAtar Synth](https://github.com/Trajectorylabs/minatar-synth/tree/4038830175c4201ca10e004ed4441985f2acddf2).
+The 317 Python training environments are pinned to commit
+`4038830175c4201ca10e004ed4441985f2acddf2`. The five original MinAtar environments
+are a separate dependency. The extra `pong.py` in the source repository is not
+part of this benchmark's task roster.
+
+The pinned MinAtar Synth repository does not declare a license. No blanket license
+is asserted for the converted implementations; the notices below describe the
+respective upstream components and do not supply that missing declaration.
+
+The 51 Atari-style conversions document mechanics and deliberate simplifications
+from historical Atari 2600 games and their manuals. Their documentation's
+historical-source notes are retained per task in `TASK_ORIGINS.json`. They use
+NumPy and the Python standard library, not Atari ROMs or the original MinAtar
+game modules. This describes their implementation and provenance, not a
+conclusion about the license of the converted code.
+
+## Crisp game designs and source
+
+Credit **ABA Games** and the authors and contributors to its Crisp games, and
+**Joyrider3774** and contributors for the portable SDL/C versions. The 266
+conversions cite three pinned source collections:
+
+| Source | Conversions | Pinned revision |
+| --- | ---: | --- |
+| [crisp-game-lib-games](https://github.com/abagames/crisp-game-lib-games) | 136 | `cfb39d2f988feb5918eb83697145b5a35adabf58` |
+| [crisp-game-lib-11-games](https://github.com/abagames/crisp-game-lib-11-games) | 8 | `6fea4eefe2deaa42706051d96a04ec9e36104696` |
+| [crisp-game-lib-portable-sdl](https://github.com/joyrider3774/crisp-game-lib-portable-sdl) | 122 | `04bc2c4cfc2853628eda25a46190bb7ac6fe216a` |
+
+These source collections carry MIT licenses, Copyright 2021 or 2022 ABA Games.
+Their exact license texts and source links are retained in
+[`LICENSE-Crisp`](runtime/LICENSE-Crisp). Keep the applicable copyright and permission
+notices with redistributed copies or substantial portions of those sources.
+These source licenses are distinct from the undeclared license of the converted
+MinAtar Synth implementation.
+
+## Original MinAtar games
+
+Credit **Kenny Young and Tian Tian**, authors of
+[MinAtar](https://github.com/kenjyoung/MinAtar). The five held-out tasks are
+`asterix`, `breakout`, `freeway`, `seaquest`, and `space_invaders`, using
+**MinAtar 1.0.15**. Their original source is included in their task prompts with
+its author headers. The package version, source-file paths, and source digests
+are recorded rather than asserting an unverified Git release commit.
+
+MinAtar is licensed under **GNU GPL version 3**. Its complete license text is
+included as [`LICENSE-MinAtar`](runtime/LICENSE-MinAtar); preserve the source notices and
+applicable GPL terms when distributing this material. This notice does not
+relicense MinAtar under the cookbook's license.
+
+## Weight-space programming experiment
+
+Credit **Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab** for the
+[weight-space programming experiments](https://rikiyat.github.io/blog/weight-space-programming/),
+especially [Experiment 5: writing policy weights from scratch](https://github.com/RikiyaT/lm_understand-logs/tree/4d09ba6d6a7e891dd8063974dfe81b3d78e3494f/exp5_write_from_scratch).
+The benchmark follows that one-response, no-tools weight-programming setup.
+The experiment's prompt/log materials are attributed under
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), separately from the
+GPL-licensed MinAtar source embedded in those prompts. The expanded game corpus
+and model-training experiments are subsequent adaptations, not results from
+the original experiment.

data/test.jsonl

@@ -0,0 +1,5 @@
+{"name": "space_invaders", "split": "test", "game": "space_invaders", "source": "original", "prompt": "Write from scratch the weights of a policy network that plays Space Invaders as well as possible.\n\nThere is no training, data, loss, gradients, fine-tuning, code execution, calculator, or environment feedback. This is one response. Briefly describe the strategy and hidden units, then provide the weights in the final `edits` code block.\n\nMove the cannon, shoot alien waves, and avoid aliens and enemy bullets.\n\nActions are sampled from softmax logits and have sticky-action probability 0.1.\n\nExact MinAtar 1.0.15 source (`minatar/environments/space_invaders.py`):\n```python\n################################################################################################################\n# Authors:                                                                                                     #\n# Kenny Young (kjyoung@ualberta.ca)                                                                            #\n# Tian Tian (ttian@ualberta.ca)                                                                                #\n################################################################################################################\nimport numpy as np\n\n\n#####################################################################################################################\n# Constants\n#\n#####################################################################################################################\nshot_cool_down = 5\nenemy_move_interval = 12\nenemy_shot_interval = 10\n\n\n#####################################################################################################################\n# Env\n#\n# The player controls a cannon at the bottom of the screen and can shoot bullets upward at a cluster of aliens above.\n# The aliens move across the screen until one of them hits the edge, at which point they all move down and switch\n# directions. The current alien direction is indicated by 2 channels (one for left and one for right) one of which is\n# active at the location of each alien. A reward of +1 is given each time an alien is shot, and that alien is also\n# removed. The aliens will also shoot bullets back at the player. When few aliens are left, alien speed will begin to\n# increase. When only one alien is left, it will move at one cell per frame. When a wave of aliens is fully cleared a\n# new one will spawn which moves at a slightly faster speed than the last. Termination occurs when an alien or bullet\n# hits the player.\n#\n#####################################################################################################################\nclass Env:\n    def __init__(self, ramping=True):\n        self.channels ={\n            'cannon':0,\n            'alien':1,\n            'alien_left':2,\n            'alien_right':3,\n            'friendly_bullet':4,\n            'enemy_bullet':5\n        }\n        self.action_map = ['n','l','u','r','d','f']\n        self.ramping = ramping\n        self.random = np.random.RandomState()\n        self.reset()\n\n    # Update environment according to agent action\n    def act(self, a):\n        r = 0\n        if(self.terminal):\n            return r, self.terminal\n\n        a = self.action_map[a]\n\n        # Resolve player action\n        if(a=='f' and self.shot_timer == 0):\n            self.f_bullet_map[9,self.pos]=1\n            self.shot_timer = shot_cool_down\n        elif(a=='l'):\n            self.pos = max(0, self.pos-1)\n        elif(a=='r'):\n            self.pos = min(9, self.pos+1)\n\n        # Update Friendly Bullets\n        self.f_bullet_map = np.roll(self.f_bullet_map, -1, axis=0)\n        self.f_bullet_map[9,:] = 0\n\n        # Update Enemy Bullets\n        self.e_bullet_map = np.roll(self.e_bullet_map, 1, axis=0)\n        self.e_bullet_map[0,:] = 0\n        if(self.e_bullet_map[9,self.pos]):\n            self.terminal = True\n\n        # Update aliens\n        if(self.alien_map[9,self.pos]):\n            self.terminal = True\n        if(self.alien_move_timer==0):\n            self.alien_move_timer = min(np.count_nonzero(self.alien_map),self.enemy_move_interval)\n            if((np.sum(self.alien_map[:,0])>0 and self.alien_dir<0) or (np.sum(self.alien_map[:,9])>0 and self.alien_dir>0)):\n                self.alien_dir = -self.alien_dir\n                if(np.sum(self.alien_map[9,:])>0):\n                    self.terminal = True\n                self.alien_map = np.roll(self.alien_map, 1, axis=0)\n            else:\n                self.alien_map = np.roll(self.alien_map, self.alien_dir, axis=1)\n            if(self.alien_map[9,self.pos]):\n                self.terminal = True\n        if(self.alien_shot_timer==0):\n            self.alien_shot_timer = enemy_shot_interval\n            nearest_alien = self._nearest_alien(self.pos)\n            self.e_bullet_map[nearest_alien[0], nearest_alien[1]] = 1\n\n        kill_locations = np.logical_and(self.alien_map,self.alien_map==self.f_bullet_map)\n\n        r+=np.sum(kill_locations)\n        self.alien_map[kill_locations] = self.f_bullet_map[kill_locations] = 0\n\n\n        # Update various timers\n        self.shot_timer -= self.shot_timer>0\n        self.alien_move_timer-=1\n        self.alien_shot_timer-=1\n        if(np.count_nonzero(self.alien_map)==0):\n            if(self.enemy_move_interval>6 and self.ramping):\n                self.enemy_move_interval-=1\n                self.ramp_index+=1\n            self.alien_map[0:4,2:8] = 1\n        return r, self.terminal\n\n    # Find the alien closest to player in manhattan distance, currently used to decide which alien shoots\n    def _nearest_alien(self, pos):\n        search_order = [i for i in range(10)]\n        search_order.sort(key=lambda x: abs(x-pos))\n        for i in search_order:\n            if(np.sum(self.alien_map[:,i])>0):\n                return [np.max(np.where(self.alien_map[:,i]==1)),i]\n        return None\n\n    # Query the current level of the difficulty ramp, could be used as additional input to agent for example\n    def difficulty_ramp(self):\n        return self.ramp_index\n\n    # Process the game-state into the 10x10xn state provided to the agent and return\n    def state(self):\n        state = np.zeros((10,10,len(self.channels)),dtype=bool)\n        state[9,self.pos,self.channels['cannon']] = 1\n        state[:,:, self.channels['alien']] = self.alien_map\n        if(self.alien_dir<0):\n            state[:,:, self.channels['alien_left']] = self.alien_map\n        else:\n            state[:,:, self.channels['alien_right']] = self.alien_map\n        state[:,:, self.channels['friendly_bullet']] = self.f_bullet_map\n        state[:,:, self.channels['enemy_bullet']] = self.e_bullet_map\n        return state\n\n    # Reset to start state for new episode\n    def reset(self):\n        self.pos = 5\n        self.f_bullet_map = np.zeros((10,10))\n        self.e_bullet_map = np.zeros((10,10))\n        self.alien_map = np.zeros((10,10))\n        self.alien_map[0:4,2:8] = 1\n        self.alien_dir = -1\n        self.enemy_move_interval = enemy_move_interval\n        self.alien_move_timer = self.enemy_move_interval\n        self.alien_shot_timer = enemy_shot_interval\n        self.ramp_index = 0\n        self.shot_timer = 0\n        self.terminal = False\n\n    # Dimensionality of the game-state (10x10xn)\n    def state_shape(self):\n        return [10,10,len(self.channels)]\n\n    # Subset of actions that actually have a unique impact in this environment\n    def minimal_action_set(self):\n        minimal_actions = ['n','l','r','f']\n        return [self.action_map.index(x) for x in minimal_actions]\n\n```\n\nInput: a row-major 10x10x6 binary grid. Index `(row * 10 + column) * 6 + channel`. Channels: player=cannon; danger=alien|enemy_bullet; reward=alien; projectile=friendly_bullet; trail=alien_left|alien_right; gauge=empty.\n\nNetwork: `h1=tanh(x@W1+b1)`, `h2=tanh(h1@W2+b2)`, `logits=h2@W3+b3`. Shapes are W1 600x32, b1 32, W2 32x32, b2 32, W3 32x6, b3 6. All 20,486 values start at zero.\n\nThe hidden evaluator runs 1,000 fixed-seed episodes, stopping each after 10,000 steps. It divides mean game score by the game's fixed cap and clips the result to [0, 1].\n\nThe final fenced block must start with `edits`. It may contain numeric assignments to indexed entries or slices of W1, b1, W2, b2, W3, and b3. Half-open Python slices and numeric lists are supported, as are `*=`, `+=`, and `-=`. Values must be finite and have absolute value at most 1e6. Example:\n```edits\nW1[12, 0] = 2.5\nb1[0:4] = -1\nW2[0:2, 0:3] = [[1, -1, 0.5], [0, 2, 0]]\nW3[:, 2] *= 2\n```\n", "system_prompt": "You directly program neural-network weights. Follow the task constraints exactly.", "episodes": 1000, "task_id": 185, "family": "minatar_original", "upstream_source_url": "https://pypi.org/project/MinAtar/1.0.15/", "upstream_revision": "MinAtar==1.0.15", "native_source_url": null}
+{"name": "breakout", "split": "test", "game": "breakout", "source": "original", "prompt": "Write from scratch the weights of a policy network that plays Breakout as well as possible.\n\nThere is no training, data, loss, gradients, fine-tuning, code execution, calculator, or environment feedback. This is one response. Briefly describe the strategy and hidden units, then provide the weights in the final `edits` code block.\n\nMove the bottom-row paddle left or right to bounce the diagonal ball and break bricks.\n\nActions are sampled from softmax logits and have sticky-action probability 0.1.\n\nExact MinAtar 1.0.15 source (`minatar/environments/breakout.py`):\n```python\n################################################################################################################\n# Authors:                                                                                                     #\n# Kenny Young (kjyoung@ualberta.ca)                                                                            #\n# Tian Tian (ttian@ualberta.ca)                                                                                #\n################################################################################################################\nimport numpy as np\n\n\n#####################################################################################################################\n# Env\n#\n# The player controls a paddle on the bottom of the screen and must bounce a ball tobreak 3 rows of bricks along the\n# top of the screen. A reward of +1 is given for each brick broken by the ball.  When all bricks are cleared another 3\n# rows are added. The ball travels only along diagonals, when it hits the paddle it is bounced either to the left or\n# right depending on the side of the paddle hit, when it hits a wall or brick it is reflected. Termination occurs when\n# the ball hits the bottom of the screen. The balls direction is indicated by a trail channel.\n#\n#####################################################################################################################\nclass Env:\n    def __init__(self, ramping=None):\n        self.channels ={\n            'paddle':0,\n            'ball':1,\n            'trail':2,\n            'brick':3,\n        }\n        self.action_map = ['n','l','u','r','d','f']\n        self.random = np.random.RandomState()\n        self.reset()\n\n    # Update environment according to agent action\n    def act(self, a):\n        r = 0\n        if(self.terminal):\n            return r, self.terminal\n\n        a = self.action_map[a]\n\n        # Resolve player action\n        if(a=='l'):\n            self.pos = max(0, self.pos-1)\n        elif(a=='r'):\n            self.pos = min(9,self.pos+1)\n\n        # Update ball position\n        self.last_x = self.ball_x\n        self.last_y = self.ball_y\n        if(self.ball_dir == 0):\n            new_x = self.ball_x-1\n            new_y = self.ball_y-1\n        elif(self.ball_dir == 1):\n            new_x = self.ball_x+1\n            new_y = self.ball_y-1\n        elif(self.ball_dir == 2):\n            new_x = self.ball_x+1\n            new_y = self.ball_y+1\n        elif(self.ball_dir == 3):\n            new_x = self.ball_x-1\n            new_y = self.ball_y+1\n\n        strike_toggle = False\n        if(new_x<0 or new_x>9):\n            if(new_x<0):\n                new_x = 0\n            if(new_x>9):\n                new_x=9\n            self.ball_dir=[1,0,3,2][self.ball_dir]\n        if(new_y<0):\n            new_y = 0\n            self.ball_dir=[3,2,1,0][self.ball_dir]\n        elif(self.brick_map[new_y,new_x]==1):\n            strike_toggle = True\n            if(not self.strike):\n                r+=1\n                self.strike = True\n                self.brick_map[new_y,new_x]=0\n                new_y = self.last_y\n                self.ball_dir=[3,2,1,0][self.ball_dir]\n        elif(new_y == 9):\n            if(np.count_nonzero(self.brick_map)==0):\n                self.brick_map[1:4,:] = 1\n            if(self.ball_x == self.pos):\n                self.ball_dir=[3,2,1,0][self.ball_dir]\n                new_y = self.last_y\n            elif(new_x == self.pos):\n                self.ball_dir=[2,3,0,1][self.ball_dir]\n                new_y = self.last_y\n            else:\n                self.terminal = True\n\n        if(not strike_toggle):\n            self.strike = False\n\n        self.ball_x = new_x\n        self.ball_y = new_y\n        return r, self.terminal\n\n    # Query the current level of the difficulty ramp, difficulty does not ramp in this game, so return None\n    def difficulty_ramp(self):\n        return None\n\n    # Process the game-state into the 10x10xn state provided to the agent and return\n    def state(self):\n        state = np.zeros((10,10,len(self.channels)),dtype=bool)\n        state[self.ball_y,self.ball_x,self.channels['ball']] = 1\n        state[9,self.pos, self.channels['paddle']] = 1\n        state[self.last_y,self.last_x,self.channels['trail']] = 1\n        state[:,:,self.channels['brick']] = self.brick_map\n        return state\n\n    # Reset to start state for new episode\n    def reset(self):\n        self.ball_y = 3\n        ball_start = self.random.randint(2)\n        self.ball_x, self.ball_dir = [(0,2),(9,3)][ball_start]\n        self.pos = 4\n        self.brick_map = np.zeros((10,10))\n        self.brick_map[1:4,:] = 1\n        self.strike = False\n        self.last_x = self.ball_x\n        self.last_y = self.ball_y\n        self.terminal = False\n\n    # Dimensionality of the game-state (10x10xn)\n    def state_shape(self):\n        return [10,10,len(self.channels)]\n\n    # Subset of actions that actually have a unique impact in this environment\n    def minimal_action_set(self):\n        minimal_actions = ['n','l','r']\n        return [self.action_map.index(x) for x in minimal_actions]\n\n```\n\nInput: a row-major 10x10x6 binary grid. Index `(row * 10 + column) * 6 + channel`. Channels: player=paddle; danger=empty; reward=brick; projectile=ball; trail=trail; gauge=empty.\n\nNetwork: `h1=tanh(x@W1+b1)`, `h2=tanh(h1@W2+b2)`, `logits=h2@W3+b3`. Shapes are W1 600x32, b1 32, W2 32x32, b2 32, W3 32x6, b3 6. All 20,486 values start at zero.\n\nThe hidden evaluator runs 1,000 fixed-seed episodes, stopping each after 10,000 steps. It divides mean game score by the game's fixed cap and clips the result to [0, 1].\n\nThe final fenced block must start with `edits`. It may contain numeric assignments to indexed entries or slices of W1, b1, W2, b2, W3, and b3. Half-open Python slices and numeric lists are supported, as are `*=`, `+=`, and `-=`. Values must be finite and have absolute value at most 1e6. Example:\n```edits\nW1[12, 0] = 2.5\nb1[0:4] = -1\nW2[0:2, 0:3] = [[1, -1, 0.5], [0, 2, 0]]\nW3[:, 2] *= 2\n```\n", "system_prompt": "You directly program neural-network weights. Follow the task constraints exactly.", "episodes": 1000, "task_id": 241, "family": "minatar_original", "upstream_source_url": "https://pypi.org/project/MinAtar/1.0.15/", "upstream_revision": "MinAtar==1.0.15", "native_source_url": null}
+{"name": "freeway", "split": "test", "game": "freeway", "source": "original", "prompt": "Write from scratch the weights of a policy network that plays Freeway as well as possible.\n\nThere is no training, data, loss, gradients, fine-tuning, code execution, calculator, or environment feedback. This is one response. Briefly describe the strategy and hidden units, then provide the weights in the final `edits` code block.\n\nMove the chicken upward through traffic and score each time it reaches the top.\n\nActions are sampled from softmax logits and have sticky-action probability 0.1.\n\nExact MinAtar 1.0.15 source (`minatar/environments/freeway.py`):\n```python\n################################################################################################################\n# Authors:                                                                                                     #\n# Kenny Young (kjyoung@ualberta.ca)                                                                            #\n# Tian Tian (ttian@ualberta.ca)                                                                                #\n################################################################################################################\nimport numpy as np\n\n\n#####################################################################################################################\n# Constants\n#\n#####################################################################################################################\nplayer_speed = 3\ntime_limit = 2500\n\n\n#####################################################################################################################\n# Env\n#\n# The player begins at the bottom of the screen and motion is restricted to traveling up and down. Player speed is\n# also restricted such that the player can only move every 3 frames. A reward of +1 is given when the player reaches\n# the top of the screen, at which point the player is returned to the bottom. Cars travel horizontally on the screen\n# and teleport to the other side when the edge is reached. When hit by a car, the player is returned to the bottom of\n# the screen. Car direction and speed is indicated by 5 trail channels, the location of the trail gives direction\n# while the specific channel indicates how frequently the car moves (from once every frame to once every 5 frames).\n# Each time the player successfully reaches the top of the screen, the car speeds are randomized. Termination occurs\n# after 2500 frames have elapsed.\n#\n#####################################################################################################################\nclass Env:\n    def __init__(self, ramping=None):\n        self.channels ={\n            'chicken':0,\n            'car':1,\n            'speed1':2,\n            'speed2':3,\n            'speed3':4,\n            'speed4':5,\n            'speed5':6,\n        }\n        self.action_map = ['n','l','u','r','d','f']\n        self.random = np.random.RandomState()\n        self.reset()\n\n    # Update environment according to agent action\n    def act(self, a):\n        r = 0\n        if(self.terminal):\n            return r, self.terminal\n\n        a = self.action_map[a]\n\n        if(a=='u' and self.move_timer==0):\n            self.move_timer = player_speed\n            self.pos = max(0, self.pos-1)\n        elif(a=='d' and self.move_timer==0):\n            self.move_timer = player_speed\n            self.pos = min(9, self.pos+1)\n\n        # Win condition\n        if(self.pos==0):\n            r+=1\n            self._randomize_cars(initialize=False)\n            self.pos = 9\n\n        # Update cars\n        for car in self.cars:\n            if(car[0:2]==[4,self.pos]):\n                self.pos = 9\n            if(car[2]==0):\n                car[2]=abs(car[3])\n                car[0]+=1 if car[3]>0 else -1\n                if(car[0]<0):\n                    car[0]=9\n                elif(car[0]>9):\n                    car[0]=0\n                if(car[0:2]==[4,self.pos]):\n                    self.pos = 9\n            else:\n                car[2]-=1\n\n        # Update various timers\n        self.move_timer-=self.move_timer>0\n        self.terminate_timer-=1\n        if(self.terminate_timer<0):\n            self.terminal = True\n        return r, self.terminal\n\n    # Query the current level of the difficulty ramp, difficulty does not ramp in this game, so return None\n    def difficulty_ramp(self):\n        return None\n\n    # Process the game-state into the 10x10xn state provided to the agent and return\n    def state(self):\n        state = np.zeros((10,10,len(self.channels)),dtype=bool)\n        state[self.pos,4,self.channels['chicken']] = 1\n        for car in self.cars:\n            state[car[1],car[0], self.channels['car']] = 1\n            back_x = car[0]-1 if car[3]>0 else car[0]+1\n            if(back_x<0):\n                back_x=9\n            elif(back_x>9):\n                back_x=0\n            if(abs(car[3])==1):\n                trail = self.channels['speed1']\n            elif(abs(car[3])==2):\n                trail = self.channels['speed2']\n            elif(abs(car[3])==3):\n                trail = self.channels['speed3']\n            elif(abs(car[3])==4):\n                trail = self.channels['speed4']\n            elif(abs(car[3])==5):\n                trail = self.channels['speed5']\n            state[car[1],back_x, trail] = 1\n        return state\n\n    # Randomize car speeds and directions, also reset their position if initialize=True\n    def _randomize_cars(self, initialize=False):\n        speeds = self.random.randint(1,6,8)\n        directions = np.sign(self.random.rand(8) - 0.5).astype(int)\n        speeds*=directions\n        if(initialize):\n            self.cars = []\n            for i in range(8):\n                self.cars+=[[0,i+1,abs(speeds[i]),speeds[i]]]\n        else:\n            for i in range(8):\n                self.cars[i][2:4]=[abs(speeds[i]),speeds[i]]\n\n    # Reset to start state for new episode\n    def reset(self):\n        self._randomize_cars(initialize=True)\n        self.pos = 9\n        self.move_timer = player_speed\n        self.terminate_timer = time_limit\n        self.terminal = False\n\n    # Dimensionality of the game-state (10x10xn)\n    def state_shape(self):\n        return [10,10,len(self.channels)]\n\n    # Subset of actions that actually have a unique impact in this environment\n    def minimal_action_set(self):\n        minimal_actions = ['n','u','d']\n        return [self.action_map.index(x) for x in minimal_actions]\n\n```\n\nInput: a row-major 10x10x6 binary grid. Index `(row * 10 + column) * 6 + channel`. Channels: player=chicken; danger=car; reward=empty; projectile=empty; trail=speed1|speed2|speed3|speed4|speed5; gauge=empty.\n\nNetwork: `h1=tanh(x@W1+b1)`, `h2=tanh(h1@W2+b2)`, `logits=h2@W3+b3`. Shapes are W1 600x32, b1 32, W2 32x32, b2 32, W3 32x6, b3 6. All 20,486 values start at zero.\n\nThe hidden evaluator runs 1,000 fixed-seed episodes, stopping each after 10,000 steps. It divides mean game score by the game's fixed cap and clips the result to [0, 1].\n\nThe final fenced block must start with `edits`. It may contain numeric assignments to indexed entries or slices of W1, b1, W2, b2, W3, and b3. Half-open Python slices and numeric lists are supported, as are `*=`, `+=`, and `-=`. Values must be finite and have absolute value at most 1e6. Example:\n```edits\nW1[12, 0] = 2.5\nb1[0:4] = -1\nW2[0:2, 0:3] = [[1, -1, 0.5], [0, 2, 0]]\nW3[:, 2] *= 2\n```\n", "system_prompt": "You directly program neural-network weights. Follow the task constraints exactly.", "episodes": 1000, "task_id": 251, "family": "minatar_original", "upstream_source_url": "https://pypi.org/project/MinAtar/1.0.15/", "upstream_revision": "MinAtar==1.0.15", "native_source_url": null}
+{"name": "seaquest", "split": "test", "game": "seaquest", "source": "original", "prompt": "Write from scratch the weights of a policy network that plays Seaquest as well as possible.\n\nThere is no training, data, loss, gradients, fine-tuning, code execution, calculator, or environment feedback. This is one response. Briefly describe the strategy and hidden units, then provide the weights in the final `edits` code block.\n\nControl the submarine, shoot enemies, rescue divers, surface with divers, and manage oxygen.\n\nActions are sampled from softmax logits and have sticky-action probability 0.1.\n\nExact MinAtar 1.0.15 source (`minatar/environments/seaquest.py`):\n```python\n################################################################################################################\n# Authors:                                                                                                     #\n# Kenny Young (kjyoung@ualberta.ca)                                                                            #\n# Tian Tian (ttian@ualberta.ca)                                                                                #\n################################################################################################################\nimport numpy as np\n\n\n#####################################################################################################################\n# Constants\n#\n#####################################################################################################################\nramp_interval = 100\nmax_oxygen = 200\ninit_spawn_speed = 20\ndiver_spawn_speed = 30\ninit_move_interval = 5\nshot_cool_down = 5\nenemy_shot_interval = 10\nenemy_move_interval = 5\ndiver_move_interval = 5\n\n\n#####################################################################################################################\n# Env\n#\n# The player controls a submarine consisting of two cells, front and back, to allow direction to be determined. The\n# player can also fire bullets from the front of the submarine. Enemies consist of submarines and fish, distinguished\n# by the fact that submarines shoot bullets and fish do not. A reward of +1 is given each time an enemy is struck by\n# one of the player's bullets, at which point the enemy is also removed. There are also divers which the player can\n# move onto to pick up, doing so increments a bar indicated by another channel along the bottom of the screen. The\n# player also has a limited supply of oxygen indicated by another bar in another channel. Oxygen degrades over time,\n# and is replenished whenever the player moves to the top of the screen as long as the player has at least one rescued\n# diver on board. The player can carry a maximum of 6 divers. When surfacing with less than 6, one diver is removed.\n# When surfacing with 6, all divers are removed and a reward is given for each active cell in the oxygen bar. Each\n# time the player surfaces the difficulty is increased by increasing the spawn rate and movement speed of enemies.\n# Termination occurs when the player is hit by an enemy fish, sub or bullet; or when oxygen reached 0; or when the\n# player attempts to surface with no rescued divers. Enemy and diver directions are indicated by a trail channel\n# active in their previous location to reduce partial observability.\n#\n#####################################################################################################################\nclass Env:\n    def __init__(self, ramping=True):\n        self.channels ={\n            'sub_front':0,\n            'sub_back':1,\n            'friendly_bullet':2,\n            'trail':3,\n            'enemy_bullet':4,\n            'enemy_fish':5,\n            'enemy_sub':6,\n            'oxygen_guage':7,\n            'diver_guage':8,\n            'diver':9\n        }\n        self.action_map = ['n','l','u','r','d','f']\n        self.ramping = ramping\n        self.random = np.random.RandomState()\n        self.reset()\n\n    # Update environment according to agent action\n    def act(self, a):\n        r = 0\n        if(self.terminal):\n            return r, self.terminal\n\n        a = self.action_map[a]\n\n        # Spawn enemy if timer is up\n        if(self.e_spawn_timer==0):\n            self._spawn_enemy()\n            self.e_spawn_timer = self.e_spawn_speed\n\n        if(self.d_spawn_timer==0):\n            self._spawn_diver()\n            self.d_spawn_timer = diver_spawn_speed\n\n        # Resolve player action\n        if(a=='f' and self.shot_timer == 0):\n            self.f_bullets+=[[self.sub_x, self.sub_y, self.sub_or]]\n            self.shot_timer = shot_cool_down\n        elif(a=='l'):\n            self.sub_x = max(0, self.sub_x-1)\n            self.sub_or = False\n        elif(a=='r'):\n            self.sub_x = min(9, self.sub_x+1)\n            self.sub_or = True\n        elif(a=='u'):\n            self.sub_y = max(0, self.sub_y-1)\n        elif(a=='d'):\n            self.sub_y = min(8, self.sub_y+1)\n\n        # Update friendly Bullets\n        for bullet in reversed(self.f_bullets):\n            bullet[0]+=1 if bullet[2] else -1\n            if(bullet[0]<0 or bullet[0]>9):\n                self.f_bullets.remove(bullet)\n            else:\n                removed = False\n                for x in self.e_fish:\n                    if(bullet[0:2]==x[0:2]):\n                        self.e_fish.remove(x)\n                        self.f_bullets.remove(bullet)\n                        r+=1\n                        removed = True\n                        break\n                if(not removed):\n                    for x in self.e_subs:\n                        if(bullet[0:2]==x[0:2]):\n                            self.e_subs.remove(x)\n                            self.f_bullets.remove(bullet)\n                            r+=1\n                            break\n\n        # Update divers\n        for diver in reversed(self.divers):\n            if(diver[0:2]==[self.sub_x,self.sub_y] and self.diver_count<6):\n                self.divers.remove(diver)\n                self.diver_count+=1\n            else:\n                if(diver[3]==0):\n                    diver[3]=diver_move_interval\n                    diver[0]+=1 if diver[2] else -1\n                    if(diver[0]<0 or diver[0]>9):\n                        self.divers.remove(diver)\n                    elif(diver[0:2]==[self.sub_x,self.sub_y] and self.diver_count<6):\n                        self.divers.remove(diver)\n                        self.diver_count+=1\n                else:\n                    diver[3]-=1\n\n        # Update enemy subs\n        for sub in reversed(self.e_subs):\n            if(sub[0:2]==[self.sub_x,self.sub_y]):\n                self.terminal = True\n            if(sub[3]==0):\n                sub[3]=self.move_speed\n                sub[0]+=1 if sub[2] else -1\n                if(sub[0]<0 or sub[0]>9):\n                    self.e_subs.remove(sub)\n                elif(sub[0:2]==[self.sub_x,self.sub_y]):\n                    self.terminal = True\n                else:\n                    for x in self.f_bullets:\n                        if(sub[0:2]==x[0:2]):\n                            self.e_subs.remove(sub)\n                            self.f_bullets.remove(x)\n                            r+=1\n                            break\n            else:\n                sub[3]-=1\n            if(sub[4]==0):\n                sub[4]=enemy_shot_interval\n                self.e_bullets+=[[sub[0] if sub[2] else sub[0], sub[1], sub[2]]]\n            else:\n                sub[4]-=1\n\n        # Update enemy bullets\n        for bullet in reversed(self.e_bullets):\n            if(bullet[0:2]==[self.sub_x,self.sub_y]):\n                self.terminal = True\n            bullet[0]+=1 if bullet[2] else -1\n            if(bullet[0]<0 or bullet[0]>9):\n                self.e_bullets.remove(bullet)\n            else:\n                if(bullet[0:2]==[self.sub_x,self.sub_y]):\n                    self.terminal = True\n\n        # Update enemy fish\n        for fish in reversed(self.e_fish):\n            if(fish[0:2]==[self.sub_x,self.sub_y]):\n                self.terminal = True\n            if(fish[3]==0):\n                fish[3]=self.move_speed\n                fish[0]+=1 if fish[2] else -1\n                if(fish[0]<0 or fish[0]>9):\n                    self.e_fish.remove(fish)\n                elif(fish[0:2]==[self.sub_x,self.sub_y]):\n                    self.terminal = True\n                else:\n                    for x in self.f_bullets:\n                        if(fish[0:2]==x[0:2]):\n                            self.e_fish.remove(fish)\n                            self.f_bullets.remove(x)\n                            r+=1\n                            break\n            else:\n                fish[3]-=1\n\n        # Update various timers\n        self.e_spawn_timer -= self.e_spawn_timer>0\n        self.d_spawn_timer -= self.d_spawn_timer>0\n        self.shot_timer -= self.shot_timer>0\n        if(self.oxygen<=0):\n            self.terminal = True\n        if(self.sub_y>0):\n            self.oxygen-=1\n            self.surface = False\n        else:\n            if(not self.surface):\n                if(self.diver_count == 0):\n                    self.terminal = True\n                else:\n                    r+=self._surface()\n        return r, self.terminal\n\n    # Called when player hits surface (top row) if they have no divers, this ends the game,\n    # if they have 6 divers this gives reward proportional to the remaining oxygen and restores full oxygen\n    # otherwise this reduces the number of divers and restores full oxygen\n    def _surface(self):\n        self.surface = True\n        if(self.diver_count == 6):\n            self.diver_count = 0\n            r = self.oxygen*10//max_oxygen\n        else:\n            r = 0\n        self.oxygen = max_oxygen\n        self.diver_count -= 1\n        if self.ramping and (self.e_spawn_speed>1 or self.move_speed>2):\n            if(self.move_speed>2 and self.ramp_index%2):\n                    self.move_speed-=1\n            if(self.e_spawn_speed>1):\n                    self.e_spawn_speed-=1\n            self.ramp_index+=1\n        return r\n\n    # Spawn an enemy fish or submarine in random row and random direction,\n    # if the resulting row and direction would lead to a collision, do nothing instead\n    def _spawn_enemy(self):\n        lr = self.random.rand() < 1/2\n        is_sub = self.random.rand() < 1/3\n        x = 0 if lr else 9\n        y = self.random.randint(low=1, high=9)\n\n        # Do not spawn in same row an opposite direction as existing\n        if(any([z[1]==y and z[2]!=lr for z in self.e_subs+self.e_fish])):\n            return\n        if(is_sub):\n            self.e_subs+=[[x,y,lr,self.move_speed,enemy_shot_interval]]\n        else:\n            self.e_fish+=[[x,y,lr,self.move_speed]]\n\n    # Spawn a diver in random row with random direction\n    def _spawn_diver(self):\n        lr = self.random.rand() < 1/2\n        x = 0 if lr else 9\n        y = self.random.randint(low=1, high=9)\n        self.divers+=[[x,y,lr,diver_move_interval]]\n\n    # Query the current level of the difficulty ramp, could be used as additional input to agent for example\n    def difficulty_ramp(self):\n        return self.ramp_index\n\n    # Process the game-state into the 10x10xn state provided to the agent and return\n    def state(self):\n        state = np.zeros((10,10,len(self.channels)),dtype=bool)\n        state[self.sub_y,self.sub_x,self.channels['sub_front']] = 1\n        back_x = self.sub_x-1 if self.sub_or else self.sub_x+1\n        state[self.sub_y,back_x,self.channels['sub_back']] = 1\n        state[9,0:max(0,self.oxygen)*10//max_oxygen, self.channels['oxygen_guage']] = 1\n        state[9,9-self.diver_count:9, self.channels['diver_guage']] = 1\n        for bullet in self.f_bullets:\n            state[bullet[1],bullet[0], self.channels['friendly_bullet']] = 1\n        for bullet in self.e_bullets:\n            state[bullet[1],bullet[0], self.channels['enemy_bullet']] = 1\n        for fish in self.e_fish:\n            state[fish[1],fish[0], self.channels['enemy_fish']] = 1\n            back_x = fish[0]-1 if fish[2] else fish[0]+1\n            if(back_x>=0 and back_x<=9):\n                state[fish[1],back_x, self.channels['trail']] = 1\n        for sub in self.e_subs:\n            state[sub[1],sub[0], self.channels['enemy_sub']] = 1\n            back_x = sub[0]-1 if sub[2] else sub[0]+1\n            if(back_x>=0 and back_x<=9):\n                state[sub[1],back_x, self.channels['trail']] = 1\n        for diver in self.divers:\n            state[diver[1],diver[0], self.channels['diver']] = 1\n            back_x = diver[0]-1 if diver[2] else diver[0]+1\n            if(back_x>=0 and back_x<=9):\n                state[diver[1],back_x, self.channels['trail']] = 1\n\n        return state\n\n    # Reset to start state for new episode\n    def reset(self):\n        self.oxygen = max_oxygen\n        self.diver_count = 0\n        self.sub_x = 5\n        self.sub_y = 0\n        # 0=left, 1=right\n        self.sub_or = False\n        self.f_bullets = []\n        self.e_bullets = []\n        self.e_fish = []\n        self.e_subs = []\n        self.divers = []\n        self.e_spawn_speed = init_spawn_speed\n        self.e_spawn_timer = self.e_spawn_speed\n        self.d_spawn_timer = diver_spawn_speed\n        self.move_speed = init_move_interval\n        self.ramp_index = 0\n        self.shot_timer = 0\n        self.surface = True\n        self.terminal = False\n\n    # Dimensionality of the game-state (10x10xn)\n    def state_shape(self):\n        return [10,10,len(self.channels)]\n\n    # Subset of actions that actually have a unique impact in this environment\n    def minimal_action_set(self):\n        minimal_actions = ['n','l','u','r','d','f']\n        return [self.action_map.index(x) for x in minimal_actions]\n\n```\n\nInput: a row-major 10x10x6 binary grid. Index `(row * 10 + column) * 6 + channel`. Channels: player=sub_front|sub_back; danger=enemy_fish|enemy_sub|enemy_bullet; reward=enemy_fish|enemy_sub|diver; projectile=friendly_bullet; trail=trail|sub_back; gauge=oxygen_guage|diver_guage.\n\nNetwork: `h1=tanh(x@W1+b1)`, `h2=tanh(h1@W2+b2)`, `logits=h2@W3+b3`. Shapes are W1 600x32, b1 32, W2 32x32, b2 32, W3 32x6, b3 6. All 20,486 values start at zero.\n\nThe hidden evaluator runs 1,000 fixed-seed episodes, stopping each after 10,000 steps. It divides mean game score by the game's fixed cap and clips the result to [0, 1].\n\nThe final fenced block must start with `edits`. It may contain numeric assignments to indexed entries or slices of W1, b1, W2, b2, W3, and b3. Half-open Python slices and numeric lists are supported, as are `*=`, `+=`, and `-=`. Values must be finite and have absolute value at most 1e6. Example:\n```edits\nW1[12, 0] = 2.5\nb1[0:4] = -1\nW2[0:2, 0:3] = [[1, -1, 0.5], [0, 2, 0]]\nW3[:, 2] *= 2\n```\n", "system_prompt": "You directly program neural-network weights. Follow the task constraints exactly.", "episodes": 1000, "task_id": 270, "family": "minatar_original", "upstream_source_url": "https://pypi.org/project/MinAtar/1.0.15/", "upstream_revision": "MinAtar==1.0.15", "native_source_url": null}
+{"name": "asterix", "split": "test", "game": "asterix", "source": "original", "prompt": "Write from scratch the weights of a policy network that plays Asterix as well as possible.\n\nThere is no training, data, loss, gradients, fine-tuning, code execution, calculator, or environment feedback. This is one response. Briefly describe the strategy and hidden units, then provide the weights in the final `edits` code block.\n\nMove in four directions to collect treasure while avoiding horizontally moving enemies.\n\nActions are sampled from softmax logits and have sticky-action probability 0.1.\n\nExact MinAtar 1.0.15 source (`minatar/environments/asterix.py`):\n```python\n################################################################################################################\n# Authors:                                                                                                     #\n# Kenny Young (kjyoung@ualberta.ca)                                                                            #\n# Tian Tian (ttian@ualberta.ca)                                                                                #\n################################################################################################################\nimport numpy as np\n\n\n#####################################################################################################################\n# Constants\n#\n#####################################################################################################################\nramp_interval = 100\ninit_spawn_speed = 10\ninit_move_interval = 5\nshot_cool_down = 5\n\n\n#####################################################################################################################\n# Env\n#\n# The player can move freely along the 4 cardinal directions. Enemies and treasure spawn from the sides. A reward of\n# +1 is given for picking up treasure. Termination occurs if the player makes contact with an enemy. Enemy and\n# treasure direction are indicated by a trail channel. Difficulty is periodically increased by increasing the speed\n# and spawn rate of enemies and treasure.\n#\n#####################################################################################################################\nclass Env:\n    def __init__(self, ramping=True):\n        self.channels ={\n            'player':0,\n            'enemy':1,\n            'trail':2,\n            'gold':3\n        }\n        self.action_map = ['n','l','u','r','d','f']\n        self.ramping = ramping\n        self.random = np.random.RandomState()\n        self.reset()\n\n    # Update environment according to agent action\n    def act(self, a):\n        r = 0\n        if(self.terminal):\n            return r, self.terminal\n\n        a = self.action_map[a]\n\n        # Spawn enemy if timer is up\n        if(self.spawn_timer==0):\n            self._spawn_entity()\n            self.spawn_timer = self.spawn_speed\n\n        # Resolve player action\n        if(a=='l'):\n            self.player_x = max(0, self.player_x-1)\n        elif(a=='r'):\n            self.player_x = min(9, self.player_x+1)\n        elif(a=='u'):\n            self.player_y = max(1, self.player_y-1)\n        elif(a=='d'):\n            self.player_y = min(8, self.player_y+1)\n\n        # Update entities\n        for i in range(len(self.entities)):\n            x = self.entities[i]\n            if(x is not None):\n                if(x[0:2]==[self.player_x,self.player_y]):\n                    if(self.entities[i][3]):\n                        self.entities[i] = None\n                        r+=1\n                    else:\n                        self.terminal = True\n        if(self.move_timer==0):\n            self.move_timer = self.move_speed\n            for i in range(len(self.entities)):\n                x = self.entities[i]\n                if(x is not None):\n                    x[0]+=1 if x[2] else -1\n                    if(x[0]<0 or x[0]>9):\n                        self.entities[i] = None\n                    if(x[0:2]==[self.player_x,self.player_y]):\n                        if(self.entities[i][3]):\n                            self.entities[i] = None\n                            r+=1\n                        else:\n                            self.terminal = True\n\n        # Update various timers\n        self.spawn_timer -= 1\n        self.move_timer -= 1\n\n\n        #Ramp difficulty if interval has elapsed\n        if self.ramping and (self.spawn_speed>1 or self.move_speed>1):\n            if(self.ramp_timer>=0):\n                self.ramp_timer-=1\n            else:\n                if(self.move_speed>1 and self.ramp_index%2):\n                    self.move_speed-=1\n                if(self.spawn_speed>1):\n                    self.spawn_speed-=1\n                self.ramp_index+=1\n                self.ramp_timer=ramp_interval\n        return r, self.terminal\n\n    # Spawn a new enemy or treasure at a random location with random direction (if all rows are filled do nothing)\n    def _spawn_entity(self):\n        lr = self.random.rand() < 1/2\n        is_gold = self.random.rand() < 1/3\n        x = 0 if lr else 9\n        slot_options = [i for i in range(len(self.entities)) if self.entities[i]==None]\n        if(not slot_options):\n            return\n        slot = slot_options[self.random.randint(len(slot_options))]\n        self.entities[slot] = [x,slot+1,lr,is_gold]\n\n    # Query the current level of the difficulty ramp, could be used as additional input to agent for example\n    def difficulty_ramp(self):\n        return self.ramp_index\n\n    # Process the game-state into the 10x10xn state provided to the agent and return\n    def state(self):\n        state = np.zeros((10,10,len(self.channels)),dtype=bool)\n        state[self.player_y,self.player_x,self.channels['player']] = 1\n        for x in self.entities:\n            if(x is not None):\n                c = self.channels['gold'] if x[3] else self.channels['enemy']\n                state[x[1], x[0],c] = 1\n                back_x = x[0]-1 if x[2] else x[0]+1\n                if(back_x>=0 and back_x<=9):\n                    state[x[1], back_x, self.channels['trail']] = 1\n        return state\n\n    # Reset to start state for new episode\n    def reset(self):\n        self.player_x = 5\n        self.player_y = 5\n        self.entities = [None]*8\n        self.shot_timer = 0\n        self.spawn_speed = init_spawn_speed\n        self.spawn_timer = self.spawn_speed\n        self.move_speed = init_move_interval\n        self.move_timer = self.move_speed\n        self.ramp_timer = ramp_interval\n        self.ramp_index = 0\n        self.terminal = False\n\n    # Dimensionality of the game-state (10x10xn)\n    def state_shape(self):\n        return [10,10,len(self.channels)]\n\n    # Subset of actions that actually have a unique impact in this environment\n    def minimal_action_set(self):\n        minimal_actions = ['n','l','u','r','d']\n        return [self.action_map.index(x) for x in minimal_actions]\n\n```\n\nInput: a row-major 10x10x6 binary grid. Index `(row * 10 + column) * 6 + channel`. Channels: player=player; danger=enemy; reward=gold; projectile=empty; trail=trail; gauge=empty.\n\nNetwork: `h1=tanh(x@W1+b1)`, `h2=tanh(h1@W2+b2)`, `logits=h2@W3+b3`. Shapes are W1 600x32, b1 32, W2 32x32, b2 32, W3 32x6, b3 6. All 20,486 values start at zero.\n\nThe hidden evaluator runs 1,000 fixed-seed episodes, stopping each after 10,000 steps. It divides mean game score by the game's fixed cap and clips the result to [0, 1].\n\nThe final fenced block must start with `edits`. It may contain numeric assignments to indexed entries or slices of W1, b1, W2, b2, W3, and b3. Half-open Python slices and numeric lists are supported, as are `*=`, `+=`, and `-=`. Values must be finite and have absolute value at most 1e6. Example:\n```edits\nW1[12, 0] = 2.5\nb1[0:4] = -1\nW2[0:2, 0:3] = [[1, -1, 0.5], [0, 2, 0]]\nW3[:, 2] *= 2\n```\n", "system_prompt": "You directly program neural-network weights. Follow the task constraints exactly.", "episodes": 1000, "task_id": 278, "family": "minatar_original", "upstream_source_url": "https://pypi.org/project/MinAtar/1.0.15/", "upstream_revision": "MinAtar==1.0.15", "native_source_url": null}

runtime/LICENSE-Crisp

@@ -0,0 +1,54 @@
+Crisp source notices
+===================
+
+The following 2021 MIT notice is reproduced verbatim from:
+https://github.com/abagames/crisp-game-lib-games/blob/cfb39d2f988feb5918eb83697145b5a35adabf58/LICENSE.txt
+
+MIT License
+
+Copyright (c) 2021 ABA Games
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The following 2022 MIT notice is reproduced verbatim. Both pinned sources
+below carry this same notice:
+https://github.com/abagames/crisp-game-lib-11-games/blob/6fea4eefe2deaa42706051d96a04ec9e36104696/LICENSE.txt
+https://github.com/joyrider3774/crisp-game-lib-portable-sdl/blob/04bc2c4cfc2853628eda25a46190bb7ac6fe216a/LICENSE.txt
+
+MIT License
+
+Copyright (c) 2022 ABA Games
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

runtime/LICENSE-MinAtar

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

runtime/NOTICE.txt

@@ -0,0 +1,28 @@
+WeightProgramBench source notices
+
+The 317 synthetic game implementations come from Trajectory Labs, Jerry Chan,
+and contributors to https://github.com/Trajectorylabs/minatar-synth at commit
+4038830175c4201ca10e004ed4441985f2acddf2. That pinned repository does not declare a
+license for the converted implementations; this notice grants none.
+
+266 games adapt designs and source credited to ABA Games, with portable SDL/C
+versions credited to Joyrider3774 and contributors. The original collections
+are https://github.com/abagames/crisp-game-lib-games,
+https://github.com/abagames/crisp-game-lib-11-games, and
+https://github.com/joyrider3774/crisp-game-lib-portable-sdl. Their applicable MIT
+copyright and permission notices are preserved in LICENSE-Crisp.
+
+The five original MinAtar games use MinAtar 1.0.15, by Kenny Young and Tian Tian:
+https://github.com/kenjyoung/MinAtar. GPL-3.0 MinAtar source is embedded in the
+original-game prompts as well as installed as a dependency. LICENSE-MinAtar
+contains the full GPL text. This material is not relicensed by the cookbook.
+
+The weight-space programming experiment is credited to Rikiya Takehi,
+Jayden Teoh, Alex Zhang, and Omar Khattab:
+https://rikiyat.github.io/blog/weight-space-programming/
+Experiment prompt/log materials are attributed under CC BY 4.0:
+https://creativecommons.org/licenses/by/4.0/
+The expanded corpus and subsequent model training are separate adaptations.
+
+The example's THIRD_PARTY_NOTICES.md and TASK_ORIGINS.json provide the complete
+source mapping, pinned revisions, and prompt and implementation digests.

runtime/minatar_synth/games/accel_b.py

@@ -0,0 +1,133 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+MIN_SPAWN_STEPS = 4
+MAX_MULTIPLIER = 64
+PLAYER_ROW = 4
+
+
+@dataclass
+class Target:
+  row: int
+  column: int
+  fire_in: int = 0
+
+
+@dataclass
+class HomingShot:
+  row: int
+  column: int
+  target: Target
+  age: int = 0
+
+
+class AccelBEnvironment:
+  score_cap = (HORIZON // MIN_SPAWN_STEPS) * 2 * MAX_MULTIPLIER
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = self.throttle = 0
+    self.spawn_in = MIN_SPAWN_STEPS
+    self.multiplier = 1
+    self.enemies: list[Target] = []
+    self.hostile: list[Target] = []
+    self.shots: list[HomingShot] = []
+    self.blasts: list[tuple[int, int, int]] = []
+    self.terminal = False
+
+  @property
+  def column(self) -> int:
+    return 1 + self.throttle // 2
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.steps += 1
+    pressed = action == 5 and self.last_action != 5
+    self.last_action = action
+    self.throttle = min(6, self.throttle + 1) if action == 5 else max(0, self.throttle - 1)
+    if pressed and not (self.shots or self.blasts):
+      self.multiplier = 1
+      self.shots = [HomingShot(PLAYER_ROW, self.column, target)
+                    for target in (*self.enemies, *self.hostile)]
+    self._advance_targets()
+    self._advance_salvo()
+    reward = 0
+    for targets in (self.enemies, self.hostile):
+      remaining = []
+      for target in targets:
+        if any(abs(target.row - row) <= 1 and abs(target.column - column) <= 1
+               for row, column, _ in self.blasts):
+          reward += self.multiplier
+          self.multiplier = min(MAX_MULTIPLIER, 2 * self.multiplier)
+        elif target.column >= 0:
+          remaining.append(target)
+      targets[:] = remaining
+    self.terminal = any((missile.row, missile.column) == (PLAYER_ROW, self.column)
+                        for missile in self.hostile) or self.steps >= self.horizon
+    self.spawn_in -= 1
+    if self.spawn_in == 0 and not self.terminal:
+      self.enemies.append(Target(int(self.random.choice((1, 2, 3, 5, 6, 7, 8))), 9, 3))
+      self.spawn_in = max(MIN_SPAWN_STEPS, 10 - self.throttle)
+    return float(reward), self.terminal
+
+  def _advance_targets(self) -> None:
+    for enemy in self.enemies:
+      if self.throttle >= 3 or self.steps % 3 == 0:
+        enemy.column -= 1
+      enemy.fire_in -= 1
+      if enemy.fire_in == 0 and enemy.column >= 0:
+        self.hostile.append(Target(enemy.row, enemy.column))
+    for missile in self.hostile:
+      missile.column -= 1
+      if self.steps % 2 == 0:
+        missile.row += int(np.sign(PLAYER_ROW - missile.row))
+
+  def _advance_salvo(self) -> None:
+    self.blasts = [(row, column, timer - 1)
+                   for row, column, timer in self.blasts if timer > 1]
+    remaining = []
+    for shot in self.shots:
+      shot.age += 1
+      shot.column += 1 if shot.age == 1 else int(np.sign(shot.target.column - shot.column))
+      if shot.age > 1:
+        shot.row += int(np.sign(shot.target.row - shot.row))
+      distance = max(abs(shot.row - shot.target.row), abs(shot.column - shot.target.column))
+      if distance <= 1 or shot.age >= 12:
+        self.blasts.append((shot.row, max(0, min(9, shot.column)), 3))
+      else:
+        remaining.append(shot)
+    self.shots = remaining
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[PLAYER_ROW, self.column, 0] = True
+    for channel, targets in ((1, self.hostile), (2, self.enemies), (3, self.shots)):
+      for target in targets:
+        if 0 <= target.column < 10:
+          state[target.row, target.column, channel] = True
+    for row, column, _ in self.blasts:
+      state[max(0, row - 1):row + 2, max(0, column - 1):column + 2, 4] = True
+    values = (self.steps, self.throttle, self.spawn_in, self.multiplier,
+              int(self.last_action == 5), int(not (self.shots or self.blasts)))
+    for row, value in enumerate(values):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/adventure.py

@@ -0,0 +1,199 @@
+import numpy as np
+
+
+class AdventureEnvironment:
+  """Compact Adventure: rooms, keys, carried objects, dragon, bat, and chalice return."""
+
+  score_cap = 1.0
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_000):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.room = 0
+    self.player = [8, 5]
+    self.held = None
+    self.items = {
+      "gold_key": [0, 5, 7], "black_key": [2, 7, 7], "white_key": [4, 2, 2],
+      "sword": [1, 7, 2], "chalice": [5, 2, 7], "bridge": [3, 6, 2],
+      "magnet": [5, 7, 2],
+    }
+    self.dragons = [[2, 5, 5], [3, 3, 7], [5, 6, 6]]
+    self.previous_dragons = [dragon.copy() for dragon in self.dragons]
+    self.bat = [1, 2, 8]
+    self.previous_bat = self.bat.copy()
+    self.castles = {
+      0: {"key": "gold_key", "open": False},
+      2: {"key": "black_key", "open": False},
+      4: {"key": "white_key", "open": False},
+    }
+    self.dragon_alive = [True, True, True]
+    self.last_action = 0
+    self.steps = 0
+    self.terminal = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    dropped = False
+    if action in (1, 2, 3, 4):
+      dy, dx = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}[action]
+      target = [min(9, max(0, self.player[0] + dy)), min(9, max(0, self.player[1] + dx))]
+      if self._can_move(target):
+        self.player = target
+        self._change_room()
+    elif action == 5 and self.held is not None:
+      self.items[self.held] = [self.room, *self.player]
+      self.held = None
+      dropped = True
+
+    if not dropped:
+      self._collect_item()
+    self._use_magnet()
+    self.previous_dragons = [dragon.copy() for dragon in self.dragons]
+    self.previous_bat = self.bat.copy()
+    self._move_dragons()
+    self._move_bat()
+    castle = self.castles.get(self.room)
+    if castle and self.player[0] <= 1 and self.held == castle["key"]:
+      castle["open"] = True
+    if self.room == 0 and self.player[0] <= 1 and self.held == "chalice" and self.castles[0]["open"]:
+      self.terminal = True
+      return 1.0, True
+    self.steps += 1
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return 0.0, self.terminal
+
+  def _can_move(self, target: list[int]) -> bool:
+    if self.room != 3 or {self.player[0], target[0]} != {4, 5}:
+      return True
+    bridge = self.items.get("bridge")
+    bridge_column = bridge[2] if bridge is not None and bridge[0] == 3 else None
+    return self.held == "bridge" or bridge_column == target[1]
+
+  def _change_room(self) -> None:
+    if self.player[1] == 0 and self.room % 2 == 1:
+      self.room -= 1
+      self.player[1] = 9
+    elif self.player[1] == 9 and self.room % 2 == 0:
+      self.room += 1
+      self.player[1] = 0
+    elif self.player[0] == 0 and self.room >= 2:
+      self.room -= 2
+      self.player[0] = 9
+    elif self.player[0] == 9 and self.room < 4:
+      self.room += 2
+      self.player[0] = 0
+
+  def _collect_item(self) -> None:
+    for name, location in list(self.items.items()):
+      if location == [self.room, *self.player] and self.held is None:
+        self.held = name
+        del self.items[name]
+    castle = self.castles.get(self.room)
+    if castle and self.held == castle["key"] and self.player[0] <= 1:
+      castle["open"] = True
+
+  def _move_dragons(self) -> None:
+    for index, dragon in enumerate(self.dragons):
+      if not self.dragon_alive[index] or dragon[0] != self.room:
+        continue
+      _, row, column = dragon
+      row += int(np.sign(self.player[0] - row))
+      column += int(np.sign(self.player[1] - column))
+      dragon[1:] = [row, column]
+      if [row, column] == self.player:
+        if self.held == "sword":
+          self.dragon_alive[index] = False
+        else:
+          self.terminal = True
+
+  def _use_magnet(self) -> None:
+    if self.held != "magnet":
+      return
+    candidates = [(name, location) for name, location in self.items.items() if location[0] == self.room]
+    if not candidates:
+      return
+    _, location = min(candidates, key=lambda item: abs(item[1][1] - self.player[0]) + abs(item[1][2] - self.player[1]))
+    location[1] += int(np.sign(self.player[0] - location[1]))
+    location[2] += int(np.sign(self.player[1] - location[2]))
+
+  def _move_bat(self) -> None:
+    if self.random.rand() >= 0.15:
+      return
+    self.bat[0] = int(self.random.randint(6))
+    self.bat[1] = int(self.random.randint(10))
+    self.bat[2] = int(self.random.randint(10))
+    if self.bat == [self.room, *self.player] and self.held is not None:
+      name = self.held
+      self.held = None
+      self.items[name] = self.bat.copy()
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for name, (room, row, column) in self.items.items():
+      if room == self.room:
+        if name == "chalice":
+          state[row, column, 2] = True
+        else:
+          state[row, column, 3] = True
+          marker = {
+            "gold_key": 0,
+            "black_key": 1,
+            "white_key": 2,
+            "sword": 3,
+            "bridge": 4,
+            "magnet": 5,
+          }[name]
+          state[row, marker, 5] = True
+    for alive, dragon in zip(self.dragon_alive, self.dragons, strict=True):
+      if alive and dragon[0] == self.room:
+        state[dragon[1], dragon[2], 1] = True
+    for previous, alive in zip(self.previous_dragons, self.dragon_alive, strict=True):
+      if alive and previous[0] == self.room:
+        state[previous[1], previous[2], 4] = True
+    if self.bat[0] == self.room:
+      state[self.bat[1], self.bat[2], 1] = True
+    if self.previous_bat[0] == self.room:
+      state[self.previous_bat[1], self.previous_bat[2], 4] = True
+    if self.room == 3:
+      state[4, :, 1] = True
+      bridge = self.items.get("bridge")
+      if self.held == "bridge":
+        state[4, self.player[1], 1] = False
+      elif bridge is not None and bridge[0] == 3:
+        state[4, bridge[2], 1] = False
+    if self.room in self.castles:
+      state[0, 4:7, 1] = not self.castles[self.room]["open"]
+    if self.held is not None:
+      held_marker = {
+        "gold_key": 0,
+        "black_key": 1,
+        "white_key": 2,
+        "sword": 3,
+        "chalice": 4,
+        "bridge": 5,
+        "magnet": 6,
+      }[self.held]
+      state[8, held_marker, 5] = True
+    state[9, self.room, 5] = True
+    for castle_room, castle in self.castles.items():
+      if castle["open"]:
+        state[7, castle_room, 5] = True
+    return state

runtime/minatar_synth/games/aerial_bar.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from math import cos, pi, sin
+
+import numpy as np
+
+
+HORIZON = 400
+UNIT = 8
+WATER = 72
+PERIOD = 32
+
+
+@dataclass
+class Bar:
+  anchor: int
+  length: int
+  phase: int
+  used: bool = False
+
+  def tip(self, ceiling: int) -> tuple[int, int]:
+    angle = 0.85 * sin(self.phase * 2 * pi / PERIOD)
+    return self.anchor + round(self.length * sin(angle)), ceiling + round(self.length * cos(angle))
+
+
+class AerialBarEnvironment:
+  score_cap = HORIZON
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = self.flight = 0
+    self.ceiling = 8
+    self.attached: Bar | None = Bar(32, 38, 0, True)
+    self.bars = [self.attached, Bar(66, int(self.random.integers(25, 34)), 0)]
+    self.x, self.y = self.attached.tip(self.ceiling)
+    self.vx = self.vy = 0
+    self.bounced = False
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    pressed = action == 5 and self.last_action != 5
+    self.last_action = action
+    self.steps += 1
+    scroll = int(self.steps % 8 == 0) + max(0, (self.x - 40) // 8)
+    self.x -= scroll
+    for bar in self.bars:
+      bar.anchor -= scroll
+      bar.phase = (bar.phase + 1) % PERIOD
+    if self.bars[-1].anchor < 55:
+      self.bars.append(Bar(self.bars[-1].anchor + int(self.random.integers(26, 42)),
+                           int(self.random.integers(18, 39)), int(self.random.integers(PERIOD))))
+
+    reward = 0
+    if self.attached is not None:
+      bar = self.attached
+      self.x, self.y = bar.tip(self.ceiling)
+      if pressed:
+        future = Bar(bar.anchor, bar.length, (bar.phase + 1) % PERIOD)
+        next_x, next_y = future.tip(self.ceiling)
+        self.vx, self.vy = next_x - self.x, next_y - self.y - 1
+        self.attached = None
+        self.flight = 0
+        self.bounced = False
+    else:
+      self.flight += 1
+      self.x += self.vx
+      self.y += self.vy
+      if action != 5 or self.steps % 5 == 0:
+        self.vy += 1
+      if action != 5 and self.steps % 4 == 0:
+        self.vx -= int(np.sign(self.vx))
+      if self.y >= WATER:
+        self.y = WATER - 1
+        self.vy = -max(1, self.vy * 3 // 2)
+        self.ceiling += 8
+        self.bounced = True
+        for bar in self.bars:
+          bar.used = False
+      if self.y <= self.ceiling:
+        self.y = self.ceiling
+        self.vy = max(0, -self.vy // 2)
+      for bar in self.bars:
+        x, y = bar.tip(self.ceiling)
+        if not bar.used and abs(self.x - x) <= 5 and abs(self.y - y) <= 5:
+          self.attached = bar
+          bar.used = True
+          reward = 0 if self.bounced else self.flight
+          self.ceiling = max(8, self.ceiling - 4)
+          self.x, self.y = bar.tip(self.ceiling)
+          break
+    self.bars = [bar for bar in self.bars if bar.anchor >= -24 or bar is self.attached]
+    self.terminal = (
+      (self.attached.anchor < 0 if self.attached is not None else self.x < 0)
+      or any(bar.tip(self.ceiling)[1] >= WATER for bar in self.bars)
+      or self.steps >= self.horizon
+    )
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[min(9, self.y // UNIT), max(0, min(9, self.x // UNIT)), 0] = True
+    state[WATER // UNIT:, :, 1] = True
+    for bar in self.bars:
+      x, y = bar.tip(self.ceiling)
+      if 0 <= x < 80 and 0 <= y < 80:
+        state[y // UNIT, x // UNIT, 3 if bar.used else 2] = True
+    state[:min(10, self.ceiling // UNIT), :, 4] = True
+    values = (self.steps, self.flight, self.ceiling, self.x + 32, self.y,
+              self.vx + 16, self.vy + 64, int(self.attached is not None),
+              int(self.bounced), int(self.last_action == 5))
+    for row, value in enumerate(values):
+      for bit in range(10):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/alien.py

@@ -0,0 +1,116 @@
+import numpy as np
+
+
+MAZE = np.array([
+  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+  [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+  [1, 0, 1, 0, 1, 0, 1, 1, 0, 1],
+  [1, 0, 1, 0, 0, 0, 0, 1, 0, 1],
+  [1, 0, 1, 1, 1, 1, 0, 1, 0, 1],
+  [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+  [1, 1, 0, 1, 1, 0, 1, 1, 0, 1],
+  [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+  [1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
+  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+], dtype=bool)
+
+
+class AlienEnvironment:
+  """Maze pursuit with eggs, pulsars, and three vulnerable Alien enemies."""
+
+  score_cap = 35.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.player = [8, 5]
+    self.previous_player = self.player.copy()
+    self.aliens = [[1, 1], [1, 8], [7, 1]]
+    self.previous_aliens = [position.copy() for position in self.aliens]
+    passages = [tuple(position) for position in np.argwhere(~MAZE)]
+    reserved = {tuple(self.player), *(tuple(position) for position in self.aliens)}
+    self.pulsars = {(3, 3), (5, 8), (8, 1)}
+    self.eggs = {position for position in passages if position not in reserved | self.pulsars}
+    self.eggs = set(sorted(self.eggs)[:20])
+    self.power_timer = 0
+    self.last_action = 0
+    self.steps = 0
+    self.terminal = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.previous_player = self.player.copy()
+    delta = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}.get(action, (0, 0))
+    target = [self.player[0] + delta[0], self.player[1] + delta[1]]
+    if not MAZE[*target]:
+      self.player = target
+
+    reward = 0.0
+    position = tuple(self.player)
+    if position in self.eggs:
+      self.eggs.remove(position)
+      reward += 1.0
+    if position in self.pulsars:
+      self.pulsars.remove(position)
+      self.power_timer = 30
+
+    self.previous_aliens = [alien.copy() for alien in self.aliens]
+    for alien in self.aliens:
+      self._move_alien(alien)
+    defeated = []
+    for alien in self.aliens:
+      if alien == self.player:
+        if self.power_timer > 0:
+          reward += 5.0
+          defeated.append(alien)
+        else:
+          self.terminal = True
+    for alien in defeated:
+      self.aliens.remove(alien)
+    self.power_timer = max(0, self.power_timer - 1)
+    self.steps += 1
+    if not self.eggs:
+      self.terminal = True
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_alien(self, alien: list[int]) -> None:
+    candidates = []
+    for row_delta, column_delta in ((0, -1), (-1, 0), (0, 1), (1, 0)):
+      candidate = [alien[0] + row_delta, alien[1] + column_delta]
+      if not MAZE[*candidate]:
+        distance = abs(candidate[0] - self.player[0]) + abs(candidate[1] - self.player[1])
+        candidates.append((distance, self.random.rand(), candidate))
+    if candidates:
+      alien[:] = min(candidates)[2]
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for alien in self.aliens:
+      state[*alien, 1] = True
+    for egg in self.eggs:
+      state[*egg, 2] = True
+    for pulsar in self.pulsars:
+      state[*pulsar, 3] = True
+    for previous in self.previous_aliens:
+      state[*previous, 4] = True
+    state[9, : min(10, (self.power_timer + 2) // 3), 5] = True
+    return state

runtime/minatar_synth/games/amidar.py

@@ -0,0 +1,133 @@
+import numpy as np
+
+
+ACTIONS = {
+  1: (0, -1),
+  2: (-1, 0),
+  3: (0, 1),
+  4: (1, 0),
+}
+
+
+class AmidarEnvironment:
+  """Trace a rectilinear maze while avoiding deterministic patrol enemies."""
+
+  score_cap = 9.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 600):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.player = [9, 0]
+    self.previous_player = self.player.copy()
+    self.enemies = [[0, 0], [0, 9], [9, 9]]
+    self.previous_enemies = [position.copy() for position in self.enemies]
+    self.enemy_directions = [4, 1, 2]
+    self.painted_edges: set[tuple[tuple[int, int], tuple[int, int]]] = set()
+    self.completed_boxes: set[tuple[int, int]] = set()
+    self.shadow_timer = 0
+    self.shadow_uses = 3
+    self.last_action = 0
+    self.steps = 0
+    self.terminal = False
+
+  @staticmethod
+  def _on_path(position: list[int] | tuple[int, int]) -> bool:
+    row, column = position
+    return 0 <= row < 10 and 0 <= column < 10 and (row % 3 == 0 or column % 3 == 0)
+
+  @staticmethod
+  def _edge(first: list[int], second: list[int]) -> tuple[tuple[int, int], tuple[int, int]]:
+    return tuple(sorted((tuple(first), tuple(second))))
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.previous_player = self.player.copy()
+    if action == 5 and self.shadow_uses > 0 and self.shadow_timer == 0:
+      self.shadow_uses -= 1
+      self.shadow_timer = 12
+    elif action in ACTIONS:
+      row_delta, column_delta = ACTIONS[action]
+      target = [self.player[0] + row_delta, self.player[1] + column_delta]
+      if self._on_path(target):
+        self.player = target
+        if self.player != self.previous_player:
+          self.painted_edges.add(self._edge(self.previous_player, self.player))
+
+    reward = self._complete_boxes()
+    self.previous_enemies = [position.copy() for position in self.enemies]
+    if self.shadow_timer == 0:
+      for index in range(len(self.enemies)):
+        self._move_enemy(index)
+    if self.shadow_timer == 0 and any(enemy == self.player for enemy in self.enemies):
+      self.terminal = True
+    self.shadow_timer = max(0, self.shadow_timer - 1)
+    self.steps += 1
+    if len(self.completed_boxes) == 9 or self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_enemy(self, index: int) -> None:
+    direction = self.enemy_directions[index]
+    preferences = (direction, {1: 2, 2: 3, 3: 4, 4: 1}[direction], {1: 4, 2: 1, 3: 2, 4: 3}[direction])
+    for candidate_direction in preferences:
+      row_delta, column_delta = ACTIONS[candidate_direction]
+      target = [self.enemies[index][0] + row_delta, self.enemies[index][1] + column_delta]
+      if self._on_path(target):
+        self.enemies[index] = target
+        self.enemy_directions[index] = candidate_direction
+        return
+
+  def _complete_boxes(self) -> float:
+    reward = 0.0
+    for box_row in range(3):
+      for box_column in range(3):
+        box = (box_row, box_column)
+        if box in self.completed_boxes:
+          continue
+        top = box_row * 3
+        left = box_column * 3
+        required = set()
+        for offset in range(3):
+          required.add(self._edge([top, left + offset], [top, left + offset + 1]))
+          required.add(self._edge([top + 3, left + offset], [top + 3, left + offset + 1]))
+          required.add(self._edge([top + offset, left], [top + offset + 1, left]))
+          required.add(self._edge([top + offset, left + 3], [top + offset + 1, left + 3]))
+        if required <= self.painted_edges:
+          self.completed_boxes.add(box)
+          reward += 1.0
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for enemy in self.enemies:
+      channel = 3 if self.shadow_timer > 0 else 1
+      state[*enemy, channel] = True
+    for box_row in range(3):
+      for box_column in range(3):
+        center = (min(9, box_row * 3 + 1), min(9, box_column * 3 + 1))
+        if (box_row, box_column) not in self.completed_boxes:
+          state[*center, 2] = True
+    for first, second in self.painted_edges:
+      state[*first, 4] = True
+      state[*second, 4] = True
+    state[9, : self.shadow_uses, 5] = True
+    if self.shadow_timer > 0:
+      state[8, : min(10, self.shadow_timer), 5] = True
+    return state

runtime/minatar_synth/games/ant_lion.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+from math import cos, pi, sin
+
+import numpy as np
+
+
+HORIZON = 400
+ANGLES = 32
+
+
+@dataclass
+class EscapeBar:
+  angle: int
+  inner: int
+  outer: int
+  speed: int = 2
+
+
+class AntLionEnvironment:
+  score_cap = HORIZON * (HORIZON + 1)
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.angle, self.radius = 8, 32
+    self.steps = self.last_action = self.velocity = self.multiplier = 0
+    self.spawn_in = 1
+    self.bars: list[EscapeBar] = []
+    self.attached: EscapeBar | None = None
+    self.offset = 0
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    if self.attached is None:
+      self.velocity = max(-2, min(2, self.velocity + (1 if action == 5 else -1)))
+      self.angle = (self.angle + self.velocity) % ANGLES
+      self.radius -= 2 if self.radius > 40 else 1
+    if self.radius <= 3:
+      self.terminal = True
+      return 0.0, True
+    self.spawn_in -= 1
+    if not self.spawn_in:
+      self.bars.append(EscapeBar(int(self.random.integers(ANGLES)), 42,
+                                 42 + int(self.random.integers(8, 17))))
+      self.spawn_in = max(8, int(self.random.integers(14, 20)) - self.steps // 80)
+    remaining = []
+    for bar in self.bars:
+      if self.steps % 4 == 0:
+        bar.angle = (bar.angle - 1) % ANGLES
+      movement = bar.speed + int(bar.inner > 40)
+      bar.inner = max(0, bar.inner - movement)
+      bar.outer -= movement
+      if bar.outer >= 0:
+        remaining.append(bar)
+      else:
+        self.multiplier = max(1, self.multiplier - 1) if self.multiplier else 0
+        if self.attached is bar:
+          self.attached = None
+    self.bars = remaining
+    if self.attached is not None:
+      bar = self.attached
+      self.offset += 3
+      if self.steps % 5 == 0:
+        bar.speed = min(3, bar.speed + 1)
+      self.angle, self.radius = bar.angle, bar.inner + self.offset
+      if self.radius > bar.outer + 3:
+        self.attached = None
+    reward = 0
+    if self.attached is None and self.radius > 3:
+      for bar in self.bars:
+        separation = (self.angle - bar.angle) % ANGLES
+        if min(separation, ANGLES - separation) <= 1 and bar.inner <= self.radius <= bar.outer:
+          self.attached = bar
+          self.offset = self.radius - bar.inner
+          self.multiplier += 2
+          reward = self.multiplier
+          break
+    self.terminal = self.radius <= 3 or self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  @staticmethod
+  def _cell(angle: int, radius: int) -> tuple[int, int]:
+    radians = angle * 2 * pi / ANGLES
+    return round(4.5 + sin(radians) * radius / 9), round(4.5 + cos(radians) * radius / 9)
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row, column = self._cell(self.angle, self.radius)
+    state[max(0, min(9, row)), max(0, min(9, column)), 0] = True
+    state[4:6, 4:6, 1] = True
+    for bar in self.bars:
+      for radius in range(bar.inner, bar.outer + 1):
+        row, column = self._cell(bar.angle, radius)
+        if 0 <= row < 10 and 0 <= column < 10:
+          state[row, column, 3 if bar is self.attached else 2] = True
+    values = (self.angle, self.radius, self.velocity + 2, self.offset,
+              self.multiplier, self.steps, self.spawn_in, self.last_action)
+    for row, value in enumerate(values):
+      for bit in range(10):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/arcfire.py

@@ -0,0 +1,122 @@
+from math import atan2, cos, hypot, pi, sin, sqrt
+
+import numpy as np
+
+
+HORIZON = 400
+SECTORS = 24
+MAX_CHARGE = 12
+SPAWN_INTERVAL = 6
+CENTER = (5, 5)
+MAX_ENEMIES = (HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL
+
+
+class ArcfireEnvironment:
+  score_cap = MAX_ENEMIES * (MAX_ENEMIES + 1) // 2
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.player = CENTER
+    self.steps = self.last_action = self.aim = self.charge = self.arc_start = 0
+    self.multiplier = 1
+    self.spawn_index = int(self.random.integers(36))
+    self.enemies: list[tuple[int, int]] = []
+    self.shot: tuple[int, int, int, int] | None = None
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  @staticmethod
+  def _range(width: int) -> int:
+    return max(3, round(9 / sqrt(width)))
+
+  def _in_arc(self, cell: tuple[int, int], start: int, width: int, radius: int) -> bool:
+    dy, dx = cell[0] - self.player[0], cell[1] - self.player[1]
+    direction = atan2(dy, dx) * SECTORS / (2 * pi)
+    return (direction - start) % SECTORS <= width and abs(hypot(dx, dy) - radius) <= 0.75
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.steps += 1
+    self.aim = (self.aim + 1) % SECTORS
+    if action == 5 and self.last_action != 5:
+      self.charge, self.arc_start, self.multiplier = 1, self.aim, 1
+    elif action == 5 and self.charge:
+      self.charge += 1
+      if self.charge > MAX_CHARGE:
+        self.charge = 0
+    elif self.charge:
+      width = self.charge
+      reach = self._range(width)
+      if self.shot is None:
+        self.shot = (self.arc_start, width, reach, 1)
+      angle = (self.arc_start + width / 2) * 2 * pi / SECTORS
+      stride = reach / 2
+      row, column = self.player
+      self.player = (max(1, min(8, row + round(stride * sin(angle)))),
+                     max(1, min(8, column + round(stride * cos(angle)))))
+      self.charge = 0
+    self.last_action = action
+
+    if self.steps % SPAWN_INTERVAL == 1:
+      if self.random.random() < 0.1:
+        self.spawn_index = int(self.random.integers(36))
+      else:
+        self.spawn_index = (self.spawn_index + int(self.random.integers(-1, 2))) % 36
+      side, offset = divmod(self.spawn_index, 9)
+      self.enemies.append(((0, offset), (offset, 9), (9, 9 - offset), (9 - offset, 0))[side])
+    if self.steps % 3 == 0:
+      self.enemies = [(row + int(np.sign(CENTER[0] - row)), column + int(np.sign(CENTER[1] - column)))
+                      for row, column in self.enemies]
+
+    reward = 0
+    if self.shot is not None:
+      start, width, reach, radius = self.shot
+      survivors = []
+      for cell in self.enemies:
+        if self._in_arc(cell, start, width, radius):
+          reward += self.multiplier
+          self.multiplier += 1
+        else:
+          survivors.append(cell)
+      self.enemies = survivors
+      self.shot = (start, width, reach, radius + 1) if radius < reach else None
+    self.terminal = any(cell in (CENTER, self.player) for cell in self.enemies)
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for cell in self.enemies:
+      state[*cell, 1] = True
+    state[*CENTER, 2] = True
+    for row in range(10):
+      for column in range(10):
+        cell = row, column
+        if self.shot is not None:
+          start, width, _, radius = self.shot
+          state[row, column, 3] = self._in_arc(cell, start, width, radius)
+        if self.charge:
+          state[row, column, 4] = self._in_arc(cell, self.arc_start, self.charge, self._range(self.charge))
+    values = (self.steps, self.aim, self.charge, self.arc_start, self.multiplier,
+              self.spawn_index, int(self.last_action == 5), *(self.shot or (0, 0, 0, 0)))
+    offset = 0
+    for value, width in zip(values, (9, 5, 4, 5, 7, 6, 1, 5, 4, 4, 4), strict=True):
+      for bit in range(width):
+        state[offset // 10, offset % 10, 5] = bool(value & (1 << bit))
+        offset += 1
+    return state

runtime/minatar_synth/games/assault.py

@@ -0,0 +1,190 @@
+import numpy as np
+
+
+class AssaultEnvironment:
+  """Fixed-cannon wave defense with vertical/lateral fire and weapon heat."""
+
+  score_cap = 75.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.player_column = 5
+    self.facing = 1
+    self.mothership_column = 0
+    self.mothership_direction = 1
+    self.aliens: list[dict[str, int | bool]] = []
+    self.friendly_shots: list[list[int]] = []
+    self.hostile_shots: list[list[int]] = []
+    self.fireballs: list[list[int]] = []
+    self.previous_aliens: list[list[int]] = []
+    self.previous_hostiles: list[list[int]] = []
+    self.wave = 0
+    self.spawned = 0
+    self.lives = 3
+    self.heat = 0
+    self.steps = 0
+    self.last_action = 0
+    self.terminal = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    fired = False
+    if action == 1:
+      self.player_column = max(0, self.player_column - 1)
+      self.facing = -1
+    elif action == 3:
+      self.player_column = min(9, self.player_column + 1)
+      self.facing = 1
+    elif action == 2 and self.heat < 9:
+      self.friendly_shots.append([8, self.player_column, -1, 0])
+      fired = True
+    elif action == 5 and self.heat < 9:
+      self.friendly_shots.append([9, self.player_column, 0, self.facing])
+      fired = True
+    self.heat = min(10, self.heat + 2) if fired else max(0, self.heat - 1)
+    if self.heat >= 10:
+      self._lose_life()
+
+    self._move_mothership()
+    self._spawn_alien()
+    self.previous_aliens = [[int(alien["row"]), int(alien["column"])] for alien in self.aliens]
+    self.previous_hostiles = [shot[:2] for shot in self.hostile_shots + self.fireballs]
+    self._move_aliens()
+    self._move_projectiles()
+    reward = self._resolve_friendly_hits()
+    self._resolve_hostile_hits()
+    self._launch_hostile_weapon()
+    self.steps += 1
+    if self.spawned == 10 and not self.aliens:
+      self.wave += 1
+      if self.wave == 5:
+        self.terminal = True
+      else:
+        self.spawned = 0
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_mothership(self) -> None:
+    self.mothership_column += self.mothership_direction
+    if self.mothership_column in (0, 9):
+      self.mothership_direction *= -1
+
+  def _spawn_alien(self) -> None:
+    if self.spawned >= 10 or self.steps % 4 != 0:
+      return
+    self.aliens.append({
+      "row": 1,
+      "column": self.mothership_column,
+      "direction": self.mothership_direction,
+      "split": self.spawned % 2 == 1,
+    })
+    self.spawned += 1
+
+  def _move_aliens(self) -> None:
+    for alien in self.aliens:
+      direction = int(alien["direction"])
+      column = int(alien["column"]) + direction
+      if column < 0 or column > 9:
+        direction *= -1
+        column = min(9, max(0, column))
+      alien["column"] = column
+      alien["direction"] = direction
+      if self.wave % 3 == 1 and self.steps % 3 == 0:
+        alien["row"] = min(7, int(alien["row"]) + 1)
+      elif self.wave % 3 == 2 and self.random.rand() < 0.2:
+        alien["row"] = int(self.random.randint(1, 7))
+        alien["column"] = int(self.random.randint(10))
+
+  def _move_projectiles(self) -> None:
+    for shot in self.friendly_shots:
+      shot[0] += shot[2]
+      shot[1] += shot[3]
+    self.friendly_shots = [shot for shot in self.friendly_shots if 0 <= shot[0] < 10 and 0 <= shot[1] < 10]
+    for shot in self.hostile_shots:
+      shot[0] += 1
+    reached_base = [shot for shot in self.hostile_shots if shot[0] >= 9]
+    self.hostile_shots = [shot for shot in self.hostile_shots if shot[0] < 9]
+    for shot in reached_base:
+      direction = int(np.sign(self.player_column - shot[1])) or 1
+      self.fireballs.append([9, shot[1], 0, direction])
+    for fireball in self.fireballs:
+      fireball[1] += fireball[3]
+    self.fireballs = [shot for shot in self.fireballs if 0 <= shot[1] < 10]
+
+  def _resolve_friendly_hits(self) -> float:
+    reward = 0.0
+    remaining_shots = []
+    for shot in self.friendly_shots:
+      hit_fireball = next((fireball for fireball in self.fireballs if fireball[:2] == shot[:2]), None)
+      if hit_fireball is not None:
+        self.fireballs.remove(hit_fireball)
+        continue
+      hit = next((alien for alien in self.aliens if [alien["row"], alien["column"]] == shot[:2]), None)
+      if hit is None:
+        remaining_shots.append(shot)
+        continue
+      self.aliens.remove(hit)
+      if bool(hit["split"]):
+        column = int(hit["column"])
+        row = int(hit["row"])
+        for direction in (-1, 1):
+          self.aliens.append({"row": row, "column": column, "direction": direction, "split": False})
+      else:
+        reward += 1.0
+    self.friendly_shots = remaining_shots
+    return reward
+
+  def _resolve_hostile_hits(self) -> None:
+    if any(shot[:2] == [9, self.player_column] for shot in self.fireballs):
+      self.fireballs = [shot for shot in self.fireballs if shot[:2] != [9, self.player_column]]
+      self._lose_life()
+
+  def _launch_hostile_weapon(self) -> None:
+    if self.steps % 12 != 0 or not self.aliens:
+      return
+    lowest = max(self.aliens, key=lambda alien: int(alien["row"]))
+    self.hostile_shots.append([int(lowest["row"]) + 1, int(lowest["column"])])
+
+  def _lose_life(self) -> None:
+    self.lives -= 1
+    self.heat = 0
+    self.friendly_shots.clear()
+    self.hostile_shots.clear()
+    self.fireballs.clear()
+    if self.lives <= 0:
+      self.terminal = True
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[9, self.player_column, 0] = True
+    state[0, self.mothership_column, 1] = True
+    for shot in self.hostile_shots + self.fireballs:
+      state[shot[0], shot[1], 1] = True
+    for alien in self.aliens:
+      state[int(alien["row"]), int(alien["column"]), 2] = True
+    for shot in self.friendly_shots:
+      state[shot[0], shot[1], 3] = True
+    for row, column in self.previous_aliens + self.previous_hostiles:
+      state[row, column, 4] = True
+    state[9, : self.heat, 5] = True
+    state[8, : self.lives, 5] = True
+    state[7, : self.wave + 1, 5] = True
+    return state

runtime/minatar_synth/games/asteroids.py

@@ -0,0 +1,167 @@
+import numpy as np
+
+
+DIRECTIONS = (
+  (-1, 0),
+  (-1, 1),
+  (0, 1),
+  (1, 1),
+  (1, 0),
+  (1, -1),
+  (0, -1),
+  (-1, -1),
+)
+POINTS = {3: 20.0, 2: 50.0, 1: 100.0}
+
+
+class AsteroidsEnvironment:
+  """Momentum, wraparound, fragmentation, and risky hyperspace on a torus."""
+
+  score_cap = 6_240.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.ship = [5, 5]
+    self.previous_ship = self.ship.copy()
+    self.velocity = [0, 0]
+    self.direction = 0
+    self.shots: list[list[int]] = []
+    self.wave = 0
+    self.lives = 4
+    self.steps = 0
+    self.last_action = 0
+    self.terminal = False
+    self._start_wave()
+
+  def _start_wave(self) -> None:
+    starts = ((0, 0, 1, 1), (0, 9, 1, -1), (9, 0, -1, 1), (9, 9, -1, -1))
+    self.asteroids = [
+      {"row": row, "column": column, "dr": dr, "dc": dc, "size": 3}
+      for row, column, dr, dc in starts
+    ]
+    self.previous_asteroids = [[int(asteroid["row"]), int(asteroid["column"])] for asteroid in self.asteroids]
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.previous_ship = self.ship.copy()
+    if action == 1:
+      self.direction = (self.direction - 1) % 8
+    elif action == 3:
+      self.direction = (self.direction + 1) % 8
+    elif action == 2:
+      thrust = DIRECTIONS[self.direction]
+      self.velocity[0] = int(np.clip(self.velocity[0] + thrust[0], -1, 1))
+      self.velocity[1] = int(np.clip(self.velocity[1] + thrust[1], -1, 1))
+    elif action == 4:
+      self.ship = [int(self.random.randint(10)), int(self.random.randint(10))]
+      self.velocity = [0, 0]
+    elif action == 5:
+      dr, dc = DIRECTIONS[self.direction]
+      self.shots.append([self.ship[0], self.ship[1], dr, dc, 12])
+
+    if action != 4:
+      self.ship[0] = (self.ship[0] + self.velocity[0]) % 10
+      self.ship[1] = (self.ship[1] + self.velocity[1]) % 10
+    self.previous_asteroids = [[int(asteroid["row"]), int(asteroid["column"])] for asteroid in self.asteroids]
+    self._move_asteroids()
+    self._move_shots()
+    reward = self._resolve_shots()
+    if any([asteroid["row"], asteroid["column"]] == self.ship for asteroid in self.asteroids):
+      self._lose_ship()
+    self.steps += 1
+    if not self.asteroids:
+      self.wave += 1
+      if self.wave == 3:
+        self.terminal = True
+      else:
+        self._start_wave()
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_asteroids(self) -> None:
+    for asteroid in self.asteroids:
+      asteroid["row"] = (int(asteroid["row"]) + int(asteroid["dr"])) % 10
+      asteroid["column"] = (int(asteroid["column"]) + int(asteroid["dc"])) % 10
+
+  def _move_shots(self) -> None:
+    for shot in self.shots:
+      shot[0] = (shot[0] + shot[2]) % 10
+      shot[1] = (shot[1] + shot[3]) % 10
+      shot[4] -= 1
+    self.shots = [shot for shot in self.shots if shot[4] > 0]
+
+  def _resolve_shots(self) -> float:
+    reward = 0.0
+    remaining_shots = []
+    for shot in self.shots:
+      hit = next(
+        (asteroid for asteroid in self.asteroids if [asteroid["row"], asteroid["column"]] == shot[:2]),
+        None,
+      )
+      if hit is None:
+        remaining_shots.append(shot)
+        continue
+      self.asteroids.remove(hit)
+      size = int(hit["size"])
+      reward += POINTS[size]
+      if size > 1:
+        for turn in (-1, 1):
+          direction = DIRECTIONS.index((int(hit["dr"]), int(hit["dc"])))
+          dr, dc = DIRECTIONS[(direction + turn) % 8]
+          self.asteroids.append({
+            "row": int(hit["row"]),
+            "column": int(hit["column"]),
+            "dr": dr,
+            "dc": dc,
+            "size": size - 1,
+          })
+    self.shots = remaining_shots
+    return reward
+
+  def _lose_ship(self) -> None:
+    self.lives -= 1
+    self.ship = [5, 5]
+    self.previous_ship = self.ship.copy()
+    self.velocity = [0, 0]
+    self.shots.clear()
+    if self.lives <= 0:
+      self.terminal = True
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.ship, 0] = True
+    for asteroid in self.asteroids:
+      row, column = int(asteroid["row"]), int(asteroid["column"])
+      state[row, column, 1] = True
+      state[row, column, 2] = True
+      size = int(asteroid["size"])
+      state[row, (column + size - 1) % 10, 5] = True
+    for shot in self.shots:
+      state[shot[0], shot[1], 3] = True
+    for row, column in self.previous_asteroids:
+      state[row, column, 4] = True
+    state[*self.previous_ship, 4] = True
+    state[9, : self.lives, 5] = True
+    state[8, : self.wave + 1, 5] = True
+    velocity_marker = (self.velocity[0] + 1) * 3 + self.velocity[1] + 1
+    state[7, velocity_marker, 5] = True
+    state[6, self.direction, 5] = True
+    return state

runtime/minatar_synth/games/atlantis.py

@@ -0,0 +1,158 @@
+import numpy as np
+
+
+class AtlantisEnvironment:
+  """Three fixed defense posts protect seven installations from descending formations."""
+
+  score_cap = 35_500.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.installations = [True] * 7
+    self.shots: list[list[int | str]] = []
+    self.wave = 0
+    self.wave_step = 0
+    self.steps = 0
+    self.total_score = 0.0
+    self.restorations_used = 0
+    self.last_action = 0
+    self.terminal = False
+    self.escaped = False
+    self._start_wave()
+
+  def _start_wave(self) -> None:
+    self.enemies = [
+      {"row": index // 5, "column": (index * 2) % 10, "direction": 1, "bandit": index == 8}
+      for index in range(9)
+    ]
+    self.previous_enemies = [[int(enemy["row"]), int(enemy["column"])] for enemy in self.enemies]
+    self.wave_step = 0
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    if action == 1:
+      self.shots.append([8, 1, -1, 1, "sentry"])
+    elif action == 3:
+      self.shots.append([8, 8, -1, -1, "sentry"])
+    elif action == 5 and self.installations[0]:
+      self.shots.append([8, 5, -1, 0, "command"])
+
+    self.previous_enemies = [[int(enemy["row"]), int(enemy["column"])] for enemy in self.enemies]
+    self._move_enemies()
+    self._move_shots()
+    reward = self._resolve_hits()
+    self._resolve_deathrays()
+    self.wave_step += 1
+    self.steps += 1
+    if not any(self.installations):
+      self.escaped = True
+      self.terminal = True
+    elif not self.enemies:
+      bonus = 500.0 * sum(self.installations)
+      reward += bonus
+      self.total_score += bonus
+      self._restore_installations()
+      self.wave += 1
+      if self.wave == 5:
+        self.terminal = True
+      else:
+        self._start_wave()
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_enemies(self) -> None:
+    if self.wave_step % max(1, 4 - min(self.wave, 2)) != 0:
+      return
+    for enemy in self.enemies:
+      column = int(enemy["column"]) + int(enemy["direction"])
+      if column < 0 or column > 9:
+        enemy["direction"] = -int(enemy["direction"])
+        enemy["row"] = int(enemy["row"]) + 1
+        column = min(9, max(0, column))
+      enemy["column"] = column
+
+  def _move_shots(self) -> None:
+    for shot in self.shots:
+      shot[0] = int(shot[0]) + int(shot[2])
+      shot[1] = int(shot[1]) + int(shot[3])
+    self.shots = [shot for shot in self.shots if 0 <= int(shot[0]) < 10 and 0 <= int(shot[1]) < 10]
+
+  def _resolve_hits(self) -> float:
+    reward = 0.0
+    remaining_shots = []
+    for shot in self.shots:
+      hit = next(
+        (enemy for enemy in self.enemies if [enemy["row"], enemy["column"]] == shot[:2]),
+        None,
+      )
+      if hit is None:
+        remaining_shots.append(shot)
+        continue
+      sentry = shot[4] == "sentry"
+      if bool(hit["bandit"]):
+        reward += 2_000.0 if sentry else 1_000.0
+        self.enemies.clear()
+        remaining_shots = []
+        break
+      reward += 200.0 if sentry else 100.0
+      self.enemies.remove(hit)
+    self.shots = remaining_shots
+    self.total_score += reward
+    return reward
+
+  def _resolve_deathrays(self) -> None:
+    attackers = [enemy for enemy in self.enemies if int(enemy["row"]) >= 8]
+    for enemy in attackers:
+      live = [index for index, intact in enumerate(self.installations) if intact]
+      if live:
+        target = 0 if self.installations[0] else live[int(self.random.randint(len(live)))]
+        self.installations[target] = False
+      self.enemies.remove(enemy)
+
+  def _restore_installations(self) -> None:
+    available = int(self.total_score // 10_000) - self.restorations_used
+    while available > 0 and not all(self.installations):
+      target = next(index for index, intact in enumerate(self.installations) if not intact)
+      self.installations[target] = True
+      self.restorations_used += 1
+      available -= 1
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[9, 0, 0] = True
+    state[9, 9, 0] = True
+    if self.installations[0]:
+      state[9, 5, 0] = True
+    for enemy in self.enemies:
+      row, column = int(enemy["row"]), int(enemy["column"])
+      state[row, column, 1] = True
+      state[row, column, 2] = True
+      if bool(enemy["bandit"]):
+        state[row, column, 5] = True
+    for shot in self.shots:
+      state[int(shot[0]), int(shot[1]), 3] = True
+    for row, column in self.previous_enemies:
+      if 0 <= row < 10 and 0 <= column < 10:
+        state[row, column, 4] = True
+    for index, intact in enumerate(self.installations):
+      state[9, index + 1, 5] = intact
+    state[8, : self.wave + 1, 5] = True
+    return state

runtime/minatar_synth/games/attack_chain.py

@@ -0,0 +1,118 @@
+from math import sqrt
+
+import numpy as np
+
+
+HORIZON = 400
+CARDS = 6
+CHAINS_PER_DEAL = 7
+RED, GREEN, BLUE = range(3)
+PRESSURE_LIMIT = 300
+
+
+class AttackChainEnvironment:
+  # One chain per two steps at most, and no card reaches 200 damage.
+  score_cap = (HORIZON // 2) * (99 + 250) * (1 + HORIZON // 2)
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.pressure = self.total = self.turn = self.chains = 0
+    self.cooldown = self.pending = 0
+    self.last_type = -1
+    self.last_action = 0
+    self.multiplier = 1
+    self.terminal = False
+    self._deal()
+
+  def _deal(self) -> None:
+    green_left = 2
+    self.types = []
+    for _ in range(CARDS):
+      if green_left and self.random.random() < 0.2:
+        self.types.append(GREEN)
+        green_left -= 1
+      else:
+        self.types.append(int(self.random.choice((RED, BLUE))))
+    scale = 4 + sqrt(min(20, self.multiplier))
+    self.values = [int(value * scale) for value in self.random.integers(3, 7, size=CARDS)]
+    self.available = [True] * CARDS
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    self.pressure += 1
+    reward = 0
+    if self.cooldown:
+      self.cooldown = 0
+      self.total += self.pending
+      self.pending = 0
+      if self.total >= 100 or not any(self.available):
+        reward = self._settle()
+    elif self.pressure >= PRESSURE_LIMIT:
+      self.terminal = True
+    elif self.available[action]:
+      self.pressure += 4
+      self.available[action] = False
+      value, color = self.values[action], self.types[action]
+      if color == RED and self.turn == 0:
+        value = value * 5 // 4
+      elif color == GREEN:
+        value = min(value, 99 - self.total)
+      self.pending = value
+      self.cooldown = 1
+      self.last_type = color
+      self.turn += 1
+      self.values[action] = self.values[action] * 11 // 10 + 10
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _settle(self) -> int:
+    reward = self.total * self.multiplier
+    excess = max(0, self.total - 115)
+    self.pressure = max(0, self.pressure - int(excess * sqrt(excess / self.multiplier)))
+    returns = sum(self.total >= threshold for threshold in (100, 150, 200))
+    unavailable = [index for index, ready in enumerate(self.available) if not ready]
+    if returns and unavailable and self.last_type == BLUE:
+      best = max(unavailable, key=self.values.__getitem__)
+      self.available[best] = True
+      unavailable.remove(best)
+      returns -= 1
+    for index in self.random.permutation(unavailable)[:returns]:
+      self.available[index] = True
+    self.chains += 1
+    if not any(self.available) or self.chains == CHAINS_PER_DEAL:
+      self.chains = 0
+      self.multiplier += 1
+      self._deal()
+    self.total = self.turn = 0
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    for index, (color, value, ready) in enumerate(zip(self.types, self.values, self.available, strict=True)):
+      state[9, index, color] = True
+      state[9, index, 3] = ready
+      for bit in range(8):
+        state[bit, index, 4] = bool(value & (1 << bit))
+    values = (self.pressure, self.total, self.turn, self.chains, self.multiplier,
+              self.pending, self.cooldown, self.last_type + 1, self.steps, self.last_action)
+    for row, value in enumerate(values):
+      for bit in range(10):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/b_blast.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 300
+RED_INTERVAL = 12
+ORDINARY_INTERVAL = 4
+MAX_RED = (HORIZON + RED_INTERVAL - 1) // RED_INTERVAL
+MAX_BALLS = HORIZON // ORDINARY_INTERVAL + 10 * MAX_RED
+MOVES = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}
+
+
+@dataclass
+class Ball:
+  row: int
+  column: int
+  red: bool = False
+
+
+class BBlastEnvironment:
+  score_cap = MAX_BALLS * (MAX_BALLS + 1) // 2 + 10 * MAX_RED
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.cursor = (5, 5)
+    self.center = self.cursor
+    self.steps = self.last_action = self.charge = self.cooldown = 0
+    self.balls: list[Ball] = []
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.steps += 1
+    self.cooldown = max(0, self.cooldown - 1)
+    reward = 0
+    if action == 5:
+      if not self.charge:
+        self.center = self.cursor
+        self.charge = 1
+      elif not self.cooldown or self.steps % 3 == 0:
+        self.charge = min(12, self.charge + 1)
+    else:
+      if self.charge:
+        reward += self._blast()
+      if action in MOVES:
+        dr, dc = MOVES[action]
+        row, column = self.cursor
+        self.cursor = max(0, min(9, row + dr)), max(0, min(9, column + dc))
+    self.last_action = action
+    if self.steps % RED_INTERVAL == 1:
+      self.balls.append(Ball(1, int(self.random.integers(2, 8)), True))
+    if self.steps % ORDINARY_INTERVAL == 0:
+      self.balls.append(Ball(int(self.random.integers(2, 8)), int(self.random.integers(1, 9))))
+    if self.steps % 2 == 0:
+      reward += self._settle()
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _blast(self) -> int:
+    row, column = self.center
+    hit = [ball for ball in self.balls
+           if (ball.row - row) ** 2 + (ball.column - column) ** 2 <= (self.charge / 2 + 0.5) ** 2]
+    removed = {id(ball) for ball in hit}
+    self.balls = [ball for ball in self.balls if id(ball) not in removed]
+    for ball in hit:
+      if ball.red:
+        self.balls.extend(Ball(max(0, min(9, ball.row + dr)), max(0, min(9, ball.column + dc)))
+                          for dr in (-1, 0, 1) for dc in (-1, 0, 1))
+    self.charge = 0
+    self.cooldown = 6
+    return len(hit) * (len(hit) + 1) // 2
+
+  def _settle(self) -> int:
+    reward = 0
+    occupied: set[tuple[int, int]] = set()
+    for ball in sorted(self.balls, key=lambda item: -item.row):
+      options = [(ball.row + 1, ball.column), (ball.row, ball.column),
+                 (ball.row, ball.column - 1), (ball.row, ball.column + 1),
+                 (ball.row - 1, ball.column)]
+      for row, column in options:
+        if 0 <= row < 10 and 0 <= column < 10 and (row, column) not in occupied:
+          ball.row, ball.column = row, column
+          occupied.add((row, column))
+          break
+      if ball.red and ball.row == 9:
+        reward += 10
+        ball.red = False
+      if ball.row == 0:
+        self.terminal = True
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.cursor, 0] = True
+    for ball in self.balls:
+      state[ball.row, ball.column, 1 if ball.red else 2] = True
+    if self.charge:
+      state[*self.center, 3] = True
+      rows, columns = np.ogrid[:10, :10]
+      state[:, :, 4] = ((rows - self.center[0]) ** 2 + (columns - self.center[1]) ** 2
+                       <= (self.charge / 2 + 0.5) ** 2)
+    for row, value in enumerate((self.steps, self.charge, self.cooldown, self.last_action)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/b_cannon.py

@@ -0,0 +1,159 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+WAVE_DELAY = 8
+MAX_WAVE = 4
+PERIMETER = (
+  tuple((9, x) for x in range(10))
+  + tuple((y, 9) for y in range(8, -1, -1))
+  + tuple((0, x) for x in range(8, -1, -1))
+  + tuple((y, 0) for y in range(1, 9))
+)
+
+
+@dataclass
+class Ball:
+  row: int
+  column: int
+  dy: int
+  dx: int
+  size: int = 3
+  immunity: int = 0
+
+
+class BCannonEnvironment:
+  score_cap = HORIZON // WAVE_DELAY * MAX_WAVE * 8 * 99
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = self.held = self.wave_size = self.ball_index = 0
+    self.perimeter_index, self.direction = 5, 1
+    self.wave_max, self.ball_period, self.wave_wait = 2, 3, WAVE_DELAY
+    self.balls: list[Ball] = []
+    self.rope: list[tuple[int, int]] = []
+    self.rope_length = 0
+    self.terminal = False
+
+  @property
+  def player(self) -> tuple[int, int]:
+    return PERIMETER[self.perimeter_index]
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def _aim(self) -> tuple[int, int] | None:
+    if not self.balls:
+      return None
+    row, column = self.player
+    ball = min(self.balls, key=lambda item: (item.row - row) ** 2 + (item.column - column) ** 2)
+    return max(1, min(8, ball.row + ball.dy)), max(1, min(8, ball.column + ball.dx))
+
+  def _fire(self, target: tuple[int, int]) -> None:
+    row, column = self.player
+    dy, dx = target[0] - row, target[1] - column
+    scale = max(abs(dy), abs(dx))
+    self.rope = []
+    for distance in range(1, 11):
+      cell = row + round(dy * distance / scale), column + round(dx * distance / scale)
+      if not all(0 < coordinate < 9 for coordinate in cell):
+        break
+      self.rope.append(cell)
+    self.rope_length = 1
+
+  def _spawn_wave(self) -> None:
+    self.wave_size += 1
+    if self.wave_size > self.wave_max:
+      self.wave_size = 1
+      self.wave_max = min(MAX_WAVE, self.wave_max + 1)
+      self.ball_period = max(1, self.ball_period - 1)
+    start = int(self.random.integers(1, 3))
+    self.balls = [Ball(3, start + 2 * index, 1, 0) for index in range(self.wave_size)]
+    self.ball_index = (self.ball_index + self.wave_size) % 100
+    self.wave_wait = WAVE_DELAY
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    if action == 5 and self.last_action != 5:
+      self.direction *= -1
+    self.last_action = action
+    self.steps += 1
+    if action == 5:
+      if self.balls:
+        self.held += 1
+        target = self._aim()
+        if self.held == 3 and target is not None:
+          self._fire(target)
+    else:
+      self.held = 0
+      self.perimeter_index = (self.perimeter_index + self.direction) % len(PERIMETER)
+    reward = self._advance_balls()
+    if self.rope:
+      self.rope_length += 1
+      if self.rope_length > len(self.rope) + 1:
+        self.rope.clear()
+        self.rope_length = 0
+    if not self.balls:
+      self.wave_wait -= 1
+      if self.wave_wait == 0:
+        self._spawn_wave()
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_balls(self) -> int:
+    reward = 0
+    remaining = []
+    rope = set(self.rope[:self.rope_length])
+    for ball in self.balls:
+      if self.steps % self.ball_period == 0:
+        if not 0 <= ball.row + ball.dy < 10:
+          ball.dy *= -1
+        if not 0 <= ball.column + ball.dx < 10:
+          ball.dx *= -1
+        ball.row += ball.dy
+        ball.column += ball.dx
+      ball.immunity = max(0, ball.immunity - 1)
+      cell = ball.row, ball.column
+      if cell in rope and not ball.immunity:
+        if ball.size == 0:
+          reward += self.ball_index
+        else:
+          remaining.extend(Ball(*cell, -ball.dy or 1, dx, ball.size - 1, 3) for dx in (-1, 1))
+          self.ball_index = (self.ball_index + 2) % 100
+      else:
+        self.terminal |= cell == self.player
+        remaining.append(ball)
+    self.balls = remaining
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for ball in self.balls:
+      state[ball.row, ball.column, 1] = True
+      state[ball.row, ball.column, 2] |= ball.immunity > 0
+    for cell in self.rope[:self.rope_length]:
+      state[*cell, 3] = True
+    target = self._aim()
+    if target is not None:
+      state[*target, 4] = True
+    values = (self.steps, self.held, self.wave_size, self.wave_max, self.wave_wait,
+              self.ball_period, self.ball_index, int(self.direction > 0), int(self.last_action == 5))
+    for row, value in enumerate(values):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/b_math.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+
+HORIZON = 400
+FULL_TIME = 60
+FEEDBACK_STEPS = 3
+MAX_ANSWERS = (HORIZON + FEEDBACK_STEPS) // (FEEDBACK_STEPS + 1)
+
+
+class BMathEnvironment:
+  score_cap = 57 * MAX_ANSWERS * (MAX_ANSWERS + 1) // 2
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.questions = self.feedback = self.last_action = 0
+    self.time = FULL_TIME
+    self.multiplier = 1
+    self.correct = False
+    self.selected = 0
+    self.terminal = False
+    self._question()
+
+  def _question(self) -> None:
+    self.operation = int(self.random.integers(min(4, 1 + self.questions // 5)))
+    if self.operation < 2:
+      total = int(self.random.integers(10, 100))
+      part = int(self.random.integers(1, total))
+      self.left, self.right, self.answer = (
+        (part, total - part, total) if self.operation == 0 else (total, part, total - part)
+      )
+    else:
+      factor = int(self.random.integers(2, 10))
+      quotient = int(self.random.integers(2, 99 // factor + 1))
+      product = factor * quotient
+      self.left, self.right, self.answer = (
+        (quotient, factor, product) if self.operation == 2 else (product, factor, quotient)
+      )
+    distractors = [value for value in range(max(1, self.answer - 7), min(99, self.answer + 7) + 1)
+                   if value != self.answer]
+    choices = self.random.choice(distractors, size=4, replace=False)
+    self.options = self.random.permutation([self.answer, *choices]).tolist()
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    reward = 0
+    if self.feedback:
+      self.feedback -= 1
+      if not self.feedback:
+        self._question()
+    elif 1 <= action <= 5:
+      reward = (57 * self.time * self.multiplier + FULL_TIME - 1) // FULL_TIME
+      self.correct = self.options[action - 1] == self.answer
+      self.selected = action
+      if self.correct:
+        self.time += 30
+        if self.time >= FULL_TIME:
+          self.multiplier += 1
+      else:
+        self.time -= 15
+        self.multiplier = max(1, self.multiplier - 1)
+      self.time = min(FULL_TIME, self.time)
+      self.feedback = FEEDBACK_STEPS
+      self.questions += 1
+    self.time = max(0, self.time - 1)
+    self.terminal = self.time == 0 or self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[self.operation, 0, 0] = True
+    for row, value in enumerate((self.left, self.right, *self.options)):
+      for bit in range(8):
+        state[row, bit, 1] = bool(value & (1 << bit))
+    if self.feedback:
+      state[0, self.selected, 2] = True
+      state[int(self.correct), 0, 3] = True
+    for row, value in enumerate((self.time, self.multiplier, self.questions,
+                                 self.feedback, self.steps, self.last_action)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/b_walls.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+COLUMN = 5
+PLAYER_ROW = 9
+PHASE_LENGTH = 6
+
+
+@dataclass
+class Wall:
+  row: int
+  phase: int
+  width: int
+  period: int
+  direction: int
+
+  def blocks(self, column: int) -> bool:
+    return (column - self.phase) % self.period < self.width
+
+
+class BWallsEnvironment:
+  score_cap = HORIZON * 2 ** (PLAYER_ROW - 1)
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.wall_clock = self.last_action = self.travel = 0
+    self.multiplier = 1
+    self.shot: int | None = None
+    self.terminal = False
+    self.walls: list[Wall] = []
+    self._spawn(3)
+    self._spawn(0)
+
+  def _spawn(self, row: int) -> None:
+    width = int(self.random.integers(1, 3))
+    period = width + int(self.random.integers(2, 5))
+    self.walls.append(Wall(row, int(self.random.integers(period)), width, period,
+                           int(self.random.choice((-1, 1)))))
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  @property
+  def stopped(self) -> bool:
+    return self.wall_clock // PHASE_LENGTH % 2 == 1
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    if action == 5 and self.last_action != 5 and self.shot is None:
+      self.shot = PLAYER_ROW
+      self.multiplier = 1
+    self.last_action = action
+    self.steps += 1
+    moving = not self.stopped
+    if moving:
+      for wall in self.walls:
+        wall.phase = (wall.phase + wall.direction) % wall.period
+
+    near_launch = self.shot is not None and self.shot >= 7
+    if near_launch or self.steps % (5 if self.steps < 200 else 4) == 0:
+      self.travel += 1
+      for wall in self.walls:
+        wall.row += 1
+      if self.travel % 3 == 0:
+        self._spawn(0)
+
+    reward = 0
+    if self.shot is not None:
+      self.shot -= 1
+      if self.shot < 0 or any(wall.row == self.shot and wall.blocks(COLUMN) for wall in self.walls):
+        self.shot = None
+      else:
+        for wall in self.walls:
+          if wall.row - 1 == self.shot:
+            reward = self.multiplier
+            self.multiplier *= 2
+            self.walls.remove(wall)
+            break
+        if moving and self.shot < max((wall.row for wall in self.walls), default=-2) + 1:
+          self.shot = None
+    if self.shot is None:
+      self.wall_clock += 1
+    self.terminal = any(wall.row == PLAYER_ROW and wall.blocks(COLUMN) for wall in self.walls)
+    self.walls = [wall for wall in self.walls if wall.row <= PLAYER_ROW]
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[PLAYER_ROW, COLUMN, 0] = True
+    if self.shot is not None:
+      state[self.shot, COLUMN, 3] = True
+    for wall in self.walls:
+      for column in range(10):
+        state[wall.row, column, 1] = wall.blocks(column)
+        state[wall.row, column, 4] = (column - wall.phase - wall.direction) % wall.period < wall.width
+      if wall.row > 0:
+        state[wall.row - 1, COLUMN, 2] = True
+    for row, value in enumerate((self.steps, self.wall_clock % (2 * PHASE_LENGTH),
+                                 self.travel % 3, self.multiplier, self.last_action)):
+      for bit in range(10):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/balance.py

@@ -0,0 +1,111 @@
+from math import ceil, cos, sin
+
+import numpy as np
+
+
+HORIZON = 400
+SPAWN_INTERVAL = 6
+FLOOR = 9
+MIN_LENGTH = 20
+MAX_LENGTH = 64
+
+
+class BalanceEnvironment:
+  score_cap = ((HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL) * 3 * MAX_LENGTH
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = 0
+    self.base = self.cursor = 4.5
+    self.velocity = self.angle = self.angular_velocity = self.wind = 0.0
+    self.length = MIN_LENGTH
+    self.coin_column = float(self.random.choice((2, 7)))
+    self.coins: list[tuple[float, float, float]] = []
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  @property
+  def tip(self) -> tuple[float, float]:
+    return FLOOR - cos(self.angle) * self.length / 8, self.base + sin(self.angle) * self.length / 8
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    self.cursor = max(0.0, min(9.0, self.cursor + (1 if action == 3 else -1 if action == 1 else 0)))
+    self.wind = 0.94 * (self.wind + float(self.random.uniform(-0.025, 0.025)))
+    self.velocity = 0.90 * (self.velocity + 0.08 * (self.cursor - self.base) - self.wind)
+    self.base += self.velocity
+    self.angular_velocity = 0.88 * (self.angular_velocity - 0.16 * self.velocity
+                                    + self.angle * self.length / 800)
+    self.angle += self.angular_velocity
+    row, column = self.tip
+    shift = (4.5 - column) * 0.18
+    self.base += shift
+    self.cursor = max(0.0, min(9.0, self.cursor + shift))
+    if row >= FLOOR - 0.25:
+      self.length /= 2
+      self.angular_velocity *= -0.5
+      if self.length < MIN_LENGTH:
+        self.terminal = True
+        return 0.0, True
+      self.angle /= 2
+    if self.steps % SPAWN_INTERVAL == 1:
+      self.coins.append((0.0, self.coin_column, float(self.random.uniform(-0.15, 0.15))))
+      self.coin_column = (self.coin_column + shift + float(self.random.uniform(-0.6, 0.6))) % 10
+
+    row, column = self.tip
+    reward = 0
+    remaining = []
+    for y, x, drift in self.coins:
+      y += 0.5
+      drift = 0.96 * (drift + self.wind / 2)
+      x += drift + shift
+      tip_hit = abs(y - row) <= 0.45 and abs(x - column) <= 0.55
+      fraction = (FLOOR - y) / max(0.01, FLOOR - row)
+      shaft_x = self.base + (column - self.base) * fraction
+      if tip_hit or (0 <= fraction <= 1 and abs(x - shaft_x) <= 0.45):
+        for _ in range(3 if tip_hit else 1):
+          reward += ceil(self.length)
+          self.length = min(MAX_LENGTH, self.length + 1)
+      elif y < FLOOR:
+        remaining.append((y, x, drift))
+    self.coins = remaining
+    self.terminal = self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row, column = self.tip
+    state[min(9, max(0, round(row))), min(9, max(0, round(column))), 0] = True
+    state[FLOOR, :, 1] = True
+    for y, x, _ in self.coins:
+      if 0 <= round(x) < 10:
+        state[round(y), round(x), 2] = True
+    for fraction in np.linspace(0, 1, 16):
+      x = round(self.base + fraction * (column - self.base))
+      y = round(FLOOR + fraction * (row - FLOOR))
+      if 0 <= x < 10 and 0 <= y < 10:
+        state[y, x, 3] = True
+    state[FLOOR, round(self.cursor), 4] = True
+    values = (self.steps, round(self.length * 4), round(self.angle * 64) + 256,
+              round(self.angular_velocity * 128) + 256, round(self.velocity * 32) + 256,
+              round(self.wind * 512) + 256, self.last_action)
+    for row, value in enumerate(values):
+      for bit in range(10):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/ball_tour.py

@@ -0,0 +1,108 @@
+import numpy as np
+
+
+ORBIT = (5, 6, 7, 8, 8, 8, 7, 6, 5, 4, 3, 2, 2, 2, 3, 4)
+HORIZON = 500
+
+
+class BallTourEnvironment:
+  # A ball is spawned no more often than every three columns of travel.
+  score_cap = 999 * ((HORIZON + 2) // 3)
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.distance = self.scroll_fraction = self.last_action = 0
+    self.next_spike = 1
+    self.next_ball = 2
+    self.multiplier = 100
+    self.spikes: list[tuple[int, int, int]] = []
+    self.balls: list[tuple[int, int]] = []
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  @property
+  def row(self) -> int:
+    return ORBIT[self.steps % len(ORBIT)]
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    self.scroll_fraction += 10 if action == 5 else 1
+    advance, self.scroll_fraction = divmod(self.scroll_fraction, 10)
+    self.distance += advance
+    moved_spikes = []
+    for row, column, velocity in self.spikes:
+      column += advance
+      if column > 9:
+        continue
+      if velocity and self.steps % 4 == 0:
+        if not 1 <= row + velocity <= 8:
+          velocity = -velocity
+        row += velocity
+      moved_spikes.append((row, column, velocity))
+    self.spikes = moved_spikes
+    if self.distance == self.next_spike:
+      row = int(self.random.integers(1, 9))
+      velocity = int(self.random.choice((-1, 1))) if self.random.random() < 0.2 else 0
+      self.spikes.append((row, 0, velocity))
+      self.next_spike += int(self.random.integers(1, 6))
+    self.terminal = any(column == 9 and row == self.row - 1 for row, column, _ in self.spikes)
+    if self.terminal:
+      return 0.0, True
+    reward = 0
+    remaining = []
+    for row, column in self.balls:
+      column += advance
+      if column == 9 and row in (self.row - 1, self.row):
+        reward += self.multiplier // 100
+        self.multiplier = min(99_900, self.multiplier + 1_000)
+      elif column <= 9:
+        remaining.append((row, column))
+    self.balls = remaining
+    if self.distance == self.next_ball:
+      row = int(self.random.integers(2, 8))
+      if any(spike_row == row and column == 0 for spike_row, column, _ in self.spikes):
+        self.next_ball += 1
+      else:
+        self.balls.append((row, 0))
+        self.next_ball += int(self.random.integers(3, 8))
+    self.multiplier = max(100, self.multiplier - 2)
+    self.terminal = self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[self.row, 9, 0] = True
+    state[self.row - 1, 9, 3] = True
+    state[ORBIT[(self.steps + 1) % len(ORBIT)], 9, 4] = True
+    for row, column in self.balls:
+      state[row, column, 2] = True
+    for row, column, velocity in self.spikes:
+      state[row, column, 1] = True
+      state[row, column, 4] = velocity == 1
+      state[row, column, 5] = velocity == -1
+    gauges = ((self.steps, 9), (self.scroll_fraction, 4), (self.multiplier, 17),
+              (self.next_spike - self.distance, 3), (self.next_ball - self.distance, 3),
+              (int(self.last_action == 5), 1))
+    offset = 0
+    for value, width in gauges:
+      for bit in range(width):
+        index = offset + bit
+        state[index // 9, index % 9, 3] = bool(value & (1 << bit))
+      offset += width
+    return state

runtime/minatar_synth/games/balloon.py

@@ -0,0 +1,124 @@
+from dataclasses import dataclass
+from math import hypot
+
+import numpy as np
+
+
+HORIZON = 400
+BONUS_INTERVAL = 8
+BALLOON_INTERVAL = 28
+MAX_BONUSES = (HORIZON + BONUS_INTERVAL - 1) // BONUS_INTERVAL
+MOVES = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}
+
+
+@dataclass
+class Balloon:
+  row: float
+  column: float
+  drift: float
+  rise: float = -0.24
+  radius: float = 1.8
+
+
+@dataclass
+class Bonus:
+  row: float
+  column: float
+  balloon: Balloon | None = None
+
+
+class BalloonEnvironment:
+  score_cap = MAX_BONUSES * (MAX_BONUSES + 1) // 2
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = 0
+    self.cursor = (5, 5)
+    self.wind = (0.0, 0.0)
+    self.balloons: list[Balloon] = []
+    self.bonuses: list[Bonus] = []
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    row, column = self.cursor
+    dr, dc = MOVES.get(action, (0, 0))
+    self.cursor = max(0, min(9, row + dr)), max(0, min(9, column + dc))
+    self.wind = (0.5 * self.wind[0] + 0.25 * (self.cursor[0] - row),
+                 0.5 * self.wind[1] + 0.25 * (self.cursor[1] - column))
+    if self.steps % BALLOON_INTERVAL == 1:
+      self.balloons.append(Balloon(9.5, float(self.random.uniform(2, 7)),
+                                   float(self.random.uniform(-0.12, 0.12))))
+    if self.steps % BONUS_INTERVAL == 1:
+      self.bonuses.append(Bonus(0.0, float(self.random.uniform(1, 8))))
+    for balloon in self.balloons:
+      if hypot(balloon.row - self.cursor[0], balloon.column - self.cursor[1]) < balloon.radius:
+        balloon.rise += self.wind[0]
+        balloon.drift += self.wind[1]
+      balloon.row += balloon.rise
+      balloon.column += balloon.drift
+      if not balloon.radius <= balloon.column <= 9 - balloon.radius:
+        balloon.column = max(balloon.radius, min(9 - balloon.radius, balloon.column))
+        balloon.drift *= -0.7
+      if balloon.row > 10 - balloon.radius and balloon.rise > 0:
+        balloon.rise *= -0.7
+      balloon.drift *= 0.9
+      balloon.rise += 0.15 * (-0.24 - balloon.rise)
+      balloon.radius -= 0.015 * hypot(balloon.drift, balloon.rise)
+    self.balloons = [balloon for balloon in self.balloons
+                     if balloon.row >= balloon.radius and balloon.radius >= 0.8]
+    alive = {id(balloon) for balloon in self.balloons}
+    collected = 0
+    remaining = []
+    for bonus in self.bonuses:
+      if bonus.balloon is None:
+        bonus.row += 0.22
+        for balloon in self.balloons:
+          if hypot(balloon.row - bonus.row, balloon.column - bonus.column) < 1.3 * balloon.radius:
+            bonus.balloon = balloon
+            break
+        if bonus.balloon is None and bonus.row >= 10:
+          self.terminal = True
+      if bonus.balloon is not None:
+        if id(bonus.balloon) not in alive:
+          collected += 1
+          continue
+        bonus.row, bonus.column = bonus.balloon.row, bonus.balloon.column
+      remaining.append(bonus)
+    self.bonuses = remaining
+    self.terminal |= self.steps >= self.horizon
+    return float(collected * (collected + 1) // 2), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.cursor, 0] = True
+    rows, columns = np.ogrid[:10, :10]
+    for balloon in self.balloons:
+      state[:, :, 1] |= (rows - balloon.row) ** 2 + (columns - balloon.column) ** 2 <= balloon.radius ** 2
+      state[max(0, min(9, round(balloon.row + balloon.rise))),
+            max(0, min(9, round(balloon.column + balloon.drift))), 4] = True
+    for bonus in self.bonuses:
+      state[max(0, min(9, round(bonus.row))), round(bonus.column), 3 if bonus.balloon else 2] = True
+    values = (self.steps, round(self.wind[0] * 64) + 32,
+              round(self.wind[1] * 64) + 32, self.last_action)
+    for row, value in enumerate(values):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/balls_bombs.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+GROUND = 32
+UNIT = 4
+SPAWN_INTERVAL = 5
+MAX_BALLS = (HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL
+
+
+@dataclass
+class Ball:
+  x: int
+  y: int
+  vx: int
+  vy: int = 0
+
+
+class BallsBombsEnvironment:
+  score_cap = MAX_BALLS * (MAX_BALLS + 1) // 2
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = self.scroll = 0
+    self.player = 2
+    self.next_bomb = 6
+    self.bomb: int | None = None
+    self.armed = False
+    self.blast: tuple[int, int] | None = None
+    self.multiplier = 1
+    self.balls: list[Ball] = []
+    self.terminal = False
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    if action == 5:
+      self.player += 1
+    self.scroll = max(0, self.player - 4)
+    if not self.armed and self.bomb is None and self.player >= self.next_bomb:
+      self.bomb = self.scroll + 9
+    if self.bomb == self.player:
+      self.armed = True
+      self.bomb = None
+      self.next_bomb = self.player + int(self.random.integers(9, 13))
+    if self.blast is not None:
+      center, radius = self.blast
+      self.blast = (center, radius + 1) if radius < 6 else None
+      if self.blast is None:
+        self.multiplier = 1
+    if self.steps % SPAWN_INTERVAL == 1:
+      from_left = self.random.random() < 0.1
+      self.balls.append(Ball(self.scroll + (0 if from_left else 9),
+                             int(self.random.integers(5, 17)), 1 if from_left else -1))
+    reward = 0
+    survivors = []
+    for ball in self.balls:
+      ball.vy += 1
+      ball.y += ball.vy
+      if ball.y >= GROUND:
+        ball.y = GROUND
+        ball.vy = -ball.vy
+      if self.steps % 2 == 0:
+        ball.x += ball.vx
+      if ball.x <= self.scroll and ball.vx < 0:
+        ball.vx = 2
+      elif ball.x >= self.scroll + 9 and ball.vx > 0:
+        ball.vx = -1
+      if self._in_blast(ball.y // UNIT, ball.x):
+        reward += self.multiplier
+        self.multiplier += 1
+      elif ball.x == self.player and ball.y // UNIT == GROUND // UNIT:
+        if self.armed:
+          self.armed = False
+          self.blast = self.player, 1
+        else:
+          self.terminal = True
+      elif ball.x >= self.scroll - 2:
+        survivors.append(ball)
+    self.balls = survivors
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _in_blast(self, row: int, x: int) -> bool:
+    if self.blast is None:
+      return False
+    center, radius = self.blast
+    distance_squared = (x - center) ** 2 + (GROUND // UNIT - row) ** 2
+    return (radius - 0.75) ** 2 <= distance_squared <= (radius + 0.75) ** 2
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[GROUND // UNIT, self.player - self.scroll, 0] = True
+    for ball in self.balls:
+      column = ball.x - self.scroll
+      if 0 <= column < 10:
+        row = max(0, ball.y // UNIT)
+        state[row, column, 1] = True
+        state[row, column, 4] |= ball.vy < 0
+    if self.bomb is not None and 0 <= self.bomb - self.scroll < 10:
+      state[GROUND // UNIT, self.bomb - self.scroll, 2] = True
+    if self.blast is not None:
+      for row in range(9):
+        for column in range(10):
+          state[row, column, 3] = self._in_blast(row, column + self.scroll)
+    values = (self.steps, self.multiplier, int(self.armed), self.player,
+              self.next_bomb, self.last_action, 0 if self.blast is None else self.blast[1])
+    for row, value in enumerate(values):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/bamboo.py

@@ -0,0 +1,108 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+MIN_SPAWN_INTERVAL = 70
+MAX_HARVEST = 100
+TRACK_WIDTH = 200
+
+
+@dataclass
+class Stalk:
+  x: int
+  height: float = 0
+  speed: float = 1
+
+
+class BambooEnvironment:
+  score_cap = math.ceil(HORIZON * FRAMES_PER_STEP / MIN_SPAWN_INTERVAL) * MAX_HARVEST
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.spawn_timer = 0
+    self.pressed = self.terminal = False
+    self.x = 190.0
+    self.direction = 1
+    self.boost = 0.0
+    self.stalks: list[Stalk] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    if pressed and not self.pressed:
+      self.direction *= -1
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self) -> int:
+    self.x = (self.x + self.direction * (1 + self.boost)) % TRACK_WIDTH
+    self.boost *= 0.9
+    if self.spawn_timer == 0:
+      self.stalks.append(Stalk(int(self.random.integers(5, 195))))
+      self.spawn_timer = int(self.random.integers(MIN_SPAWN_INTERVAL, 101))
+    self.spawn_timer -= 1
+
+    reward = 0
+    survivors = []
+    for stalk in self.stalks:
+      stalk.height += 0.14 * stalk.speed
+      distance = abs(self.x - stalk.x)
+      if not self.pressed and min(distance, TRACK_WIDTH - distance) <= 6:
+        if 5 <= stalk.height <= 25:
+          grade = math.ceil((stalk.height - 5) / 3)
+          reward += MAX_HARVEST if grade == 7 else grade**2
+          continue
+        if stalk.height > 25:
+          stalk.height *= 0.7
+          stalk.speed *= 0.6
+          self.direction *= -1
+          self.boost = min(5, self.boost + 1)
+          if stalk.height <= 25:
+            continue
+      if stalk.height > 50:
+        stalk.speed *= 0.997
+      if stalk.height >= 89:
+        self.terminal = True
+      survivors.append(stalk)
+    self.stalks = survivors
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    column = int(self.x) // 20
+    state[8, column, 0] = True
+    state[8, column, 1] = self.direction < 0
+    for stalk in self.stalks:
+      column = stalk.x // 20
+      height = max(1, math.ceil(stalk.height / 10))
+      state[9 - height:9, column, 2] = True
+      state[9 - height, column, 3] |= 5 <= stalk.height <= 25
+      state[9 - height, column, 4] |= 23 < stalk.height <= 25
+    state[9, 0, 5] = self.pressed
+    for bit in range(9):
+      state[9, bit + 1, 5] = bool(self.steps & (1 << bit))
+    return state

runtime/minatar_synth/games/bank_heist.py

@@ -0,0 +1,197 @@
+import numpy as np
+
+
+ROADS = np.array([
+  [1, 1, 1, 0, 0, 0, 1, 1, 1, 1],
+  [1, 0, 1, 1, 1, 1, 1, 0, 1, 0],
+  [1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+  [1, 1, 1, 0, 1, 1, 1, 1, 1, 1],
+  [0, 0, 1, 0, 0, 0, 1, 0, 1, 0],
+  [1, 1, 1, 1, 1, 0, 1, 0, 1, 0],
+  [1, 0, 0, 0, 1, 0, 1, 1, 1, 0],
+  [1, 1, 1, 1, 1, 1, 1, 0, 1, 1],
+  [1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
+  [1, 1, 1, 1, 1, 1, 1, 0, 1, 0],
+], dtype=bool)
+BANK_LOCATIONS = ((1, 2), (1, 6), (3, 4), (3, 8), (5, 2), (5, 6), (7, 4), (7, 8), (9, 2))
+TOWN_BONUSES = (93.0, 186.0, 279.0, 372.0)
+DELTAS = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}
+
+
+class BankHeistEnvironment:
+  """Four-town robbery route with fuel, pursuing cops, and tailpipe dynamite."""
+
+  score_cap = 4_530.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.town = 0
+    self.cars = 5
+    self.steps = 0
+    self.last_action = 0
+    self.terminal = False
+    self._start_town(full_fuel=True)
+
+  def _start_town(self, full_fuel: bool) -> None:
+    previous_fuel = getattr(self, "fuel", 100)
+    self.fuel = 100 if full_fuel else max(previous_fuel, 50)
+    self.player = [9, 0]
+    self.previous_player = self.player.copy()
+    self.direction = 3
+    self.cops: list[dict[str, object]] = []
+    self.previous_cops: list[list[int]] = []
+    self.dynamite: list[dict[str, int]] = []
+    self.robbed = 0
+    self.spawned_banks = 3
+    self.banks = set(BANK_LOCATIONS[:3])
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.previous_player = self.player.copy()
+    if action in DELTAS:
+      self.direction = action
+      self._move_player(action)
+    elif action == 5 and self.fuel > 5:
+      row_delta, column_delta = DELTAS[self.direction]
+      self.dynamite.append({
+        "row": (self.player[0] - row_delta) % 10,
+        "column": (self.player[1] - column_delta) % 10,
+        "timer": 2,
+      })
+      self.fuel -= 5
+
+    reward = self._rob_bank()
+    self.previous_cops = [list(cop["position"]) for cop in self.cops]
+    self._move_cops()
+    reward += self._detonate_dynamite()
+    if any(list(cop["position"]) == self.player for cop in self.cops):
+      self._lose_car()
+    self.fuel -= 1
+    if self.fuel <= 0:
+      self._lose_car()
+    if self.player == [0, 9]:
+      reward += self._leave_town()
+    self.steps += 1
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_player(self, action: int) -> None:
+    row_delta, column_delta = DELTAS[action]
+    target = [self.player[0] + row_delta, self.player[1] + column_delta]
+    if self.player[0] in (3, 7) and target[1] < 0:
+      target[1] = 9
+    elif self.player[0] in (3, 7) and target[1] > 9:
+      target[1] = 0
+    if 0 <= target[0] < 10 and 0 <= target[1] < 10 and ROADS[*target]:
+      self.player = target
+
+  def _rob_bank(self) -> float:
+    position = tuple(self.player)
+    if position not in self.banks:
+      return 0.0
+    self.banks.remove(position)
+    self.robbed += 1
+    if len(self.cops) < 3:
+      self.cops.append({"position": [*position], "previous": [*position]})
+    return float(self.robbed * 10)
+
+  def _move_cops(self) -> None:
+    for cop in self.cops:
+      position = list(cop["position"])
+      previous = list(cop["previous"])
+      candidates = []
+      for action in DELTAS:
+        row_delta, column_delta = DELTAS[action]
+        target = [position[0] + row_delta, position[1] + column_delta]
+        if position[0] in (3, 7) and target[1] < 0:
+          target[1] = 9
+        elif position[0] in (3, 7) and target[1] > 9:
+          target[1] = 0
+        if 0 <= target[0] < 10 and 0 <= target[1] < 10 and ROADS[*target] and target != previous:
+          distance = abs(target[0] - self.player[0]) + abs(target[1] - self.player[1])
+          candidates.append((distance, action, target))
+      if candidates:
+        cop["previous"] = position
+        cop["position"] = min(candidates)[2]
+
+  def _detonate_dynamite(self) -> float:
+    reward = 0.0
+    remaining = []
+    for stick in self.dynamite:
+      stick["timer"] -= 1
+      if stick["timer"] > 0:
+        remaining.append(stick)
+        continue
+      blast = [stick["row"], stick["column"]]
+      if blast == self.player:
+        self._lose_car()
+      pursuit_count = len(self.cops)
+      value = {1: 10.0, 2: 30.0, 3: 50.0}.get(pursuit_count, 0.0)
+      destroyed = [cop for cop in self.cops if list(cop["position"]) == blast]
+      for cop in destroyed:
+        self.cops.remove(cop)
+        reward += value
+        if self.spawned_banks < 9:
+          self.banks.add(BANK_LOCATIONS[self.spawned_banks])
+          self.spawned_banks += 1
+    self.dynamite = remaining
+    return reward
+
+  def _lose_car(self) -> None:
+    self.cars -= 1
+    self.player = [9, 0]
+    self.previous_player = self.player.copy()
+    self.fuel = 100
+    self.cops.clear()
+    self.dynamite.clear()
+    if self.cars <= 0:
+      self.terminal = True
+
+  def _leave_town(self) -> float:
+    reward = TOWN_BONUSES[self.town] if self.robbed >= 9 else 0.0
+    full_fuel = self.robbed >= 9
+    if full_fuel:
+      self.cars += 1
+    self.town += 1
+    if self.town == 4:
+      self.terminal = True
+    else:
+      self._start_town(full_fuel=full_fuel)
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for cop in self.cops:
+      state[*list(cop["position"]), 1] = True
+    for bank in self.banks:
+      state[*bank, 2] = True
+    state[0, 9, 2] = True
+    for stick in self.dynamite:
+      state[stick["row"], stick["column"], 3] = True
+    state[*self.previous_player, 4] = True
+    for position in self.previous_cops:
+      state[*position, 4] = True
+    state[9, : min(10, (self.fuel + 9) // 10), 5] = True
+    state[8, : min(10, self.cars), 5] = True
+    state[7, : self.town + 1, 5] = True
+    state[6, : min(9, self.robbed), 5] = True
+    return state

runtime/minatar_synth/games/barge_hop.py

@@ -0,0 +1,161 @@
+from dataclasses import dataclass
+from itertools import combinations
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+TIME_LIMIT = 1000
+FRAMES_PER_STEP = 4
+
+
+@dataclass
+class Barge:
+  x: float
+  width: float
+  velocity: float
+  phase: float
+  frequency: float
+  amplitude: float
+  top: float = 65
+
+
+class BargeHopEnvironment:
+  score_cap = 1000
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.frame = self.level = 0
+    self.pressed = self.terminal = False
+    self.remaining = float(TIME_LIMIT)
+    self._setup_round()
+
+  def _setup_round(self) -> None:
+    speed = 0.175 * (1 + math.sqrt(self.level * 0.3))
+    self.barges = [
+      Barge(
+        center + self.random.uniform(-4, 4),
+        float(self.random.integers(20, 29)),
+        float(self.random.choice((-1, 1))) * speed * self.random.uniform(0.9, 1.5),
+        self.random.uniform(0, math.tau),
+        self.random.uniform(0.02, 0.05),
+        self.random.uniform(1, 2),
+      )
+      for center in (32, 75, 118)
+    ]
+    self._return_to_dock()
+
+  def _return_to_dock(self) -> None:
+    self.x, self.feet = 8.0, 63.0
+    self.vx = self.vy = 0.0
+    self.grounded = True
+    self.support: Barge | None = None
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    jump = pressed and not self.pressed
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for frame in range(FRAMES_PER_STEP):
+      reward += self._advance_frame(jump and frame == 0)
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _move_barges(self) -> None:
+    for barge in self.barges:
+      barge.x += barge.velocity
+      barge.top = 65 - barge.amplitude * (
+        1 - math.sin(self.frame * barge.frequency + barge.phase)
+      )
+      low, high = 15 + barge.width / 2, 135 - barge.width / 2
+      if barge.x <= low:
+        barge.x, barge.velocity = low, abs(barge.velocity)
+      elif barge.x >= high:
+        barge.x, barge.velocity = high, -abs(barge.velocity)
+    for first, second in combinations(self.barges, 2):
+      gap = (first.width + second.width) / 2 - (second.x - first.x)
+      if gap <= 0:
+        continue
+      first.x -= gap / 2
+      second.x += gap / 2
+      if first.velocity > 0:
+        first.velocity *= -1
+      if second.velocity < 0:
+        second.velocity *= -1
+
+  def _advance_frame(self, jump: bool) -> int:
+    difficulty = 1 + self.level / 5
+    self.frame += 1
+    self.remaining -= math.sqrt(difficulty)
+    if self.remaining <= 0:
+      self.terminal = True
+      return 0
+    old_support_x = self.support.x if self.support is not None else 0
+    self._move_barges()
+    if self.grounded:
+      if self.support is not None:
+        self.x += self.support.x - old_support_x
+        self.feet = self.support.top
+      if not jump:
+        return 0
+      self.grounded = False
+      self.support = None
+      self.vx = 0.7 * math.sqrt(difficulty)
+      self.vy = -2.1 * math.sqrt(difficulty)
+    previous_feet = self.feet
+    self.vy += 0.15 * (0.5 if self.pressed else 1.5) * difficulty
+    self.x += self.vx
+    self.feet += self.vy
+    if self.vy < 0:
+      return 0
+    if self.x >= 133 and previous_feet <= 63 <= self.feet:
+      reward = int(120 * self.remaining / TIME_LIMIT)
+      self.level += 1
+      self.remaining = min(TIME_LIMIT, self.remaining + TIME_LIMIT / 2)
+      self._setup_round()
+      return reward
+    for barge in self.barges:
+      if abs(self.x - barge.x) <= barge.width / 2 + 3 and previous_feet <= barge.top <= self.feet:
+        self.support = barge
+        self.grounded = True
+        self.feet = barge.top
+        self.vx = self.vy = 0
+        return 1
+    if self.feet >= 71:
+      self._return_to_dock()
+    return 0
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    column = min(9, int(self.x / 15))
+    row = int((self.feet - 4) / 10)
+    state[row, column, 0] = True
+    state[row, column, 4] = self.grounded
+    state[6, (0, 9), 1] = True
+    state[7:9, :, 2] = True
+    for barge in self.barges:
+      left = max(0, int((barge.x - barge.width / 2) / 15))
+      right = min(9, int((barge.x + barge.width / 2) / 15))
+      state[int(barge.top / 10), left:right + 1, 3] = True
+      state[int(barge.top / 10), left:right + 1, 5] |= barge.velocity < 0
+    state[9, :math.ceil(max(0, self.remaining) / 100), 5] = True
+    state[8, 0, 5] = self.pressed
+    return state

runtime/minatar_synth/games/baroll.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+GROUND = 86
+
+
+@dataclass
+class Barrel:
+  x: float
+  y: float = -5
+  velocity: float = 0
+  rolling: bool = False
+
+
+class BarollEnvironment:
+  score_cap = HORIZON * FRAMES_PER_STEP
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.spawn_timer = 0
+    self.pressed = self.terminal = self.jumping = False
+    self.y = float(GROUND)
+    self.velocity = 0.0
+    self.barrels: list[Barrel] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    tap = pressed and not self.pressed
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for frame in range(FRAMES_PER_STEP):
+      self._advance_frame(tap and frame == 0)
+      reward += int(not pressed)
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self, tap: bool) -> None:
+    if self.spawn_timer == 0:
+      start = 100 if self.jumping else 10
+      self.barrels.append(Barrel(self.random.uniform(start, 200)))
+      self.spawn_timer = int(self.random.integers(30, 90))
+    self.spawn_timer -= 1
+    for barrel in self.barrels:
+      if barrel.rolling:
+        barrel.x -= 1
+      else:
+        barrel.velocity = (barrel.velocity + 0.2) * 0.92
+        barrel.y += barrel.velocity
+        if barrel.y > 85:
+          barrel.y = GROUND
+          barrel.rolling = True
+      barrel.x -= 1 if self.pressed else 2
+    self.barrels = [barrel for barrel in self.barrels if barrel.x > -5]
+
+    if self.jumping:
+      self.y += self.velocity
+      self.velocity += 0.1 if self.pressed else 0.2
+      if self.y > 85:
+        self.y = GROUND
+        self.jumping = self.pressed
+        self.velocity = -3 if self.pressed else 0
+    elif tap:
+      self.jumping = True
+      self.velocity = -3.6
+    self.terminal = any(
+      abs(barrel.x - 9) < 5 and abs(barrel.y - self.y) < 6
+      for barrel in self.barrels
+    )
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row = int(self.y) // 10
+    state[row, 0, 0] = True
+    state[row, 0, 4] = self.jumping and self.velocity < 0
+    for barrel in self.barrels:
+      if barrel.x >= 0 and barrel.y >= 0:
+        state[int(barrel.y) // 10, int(barrel.x) // 20, 2 if barrel.rolling else 1] = True
+    state[9, :, 3] = True
+    state[9, 0, 5] = self.pressed
+    for bit in range(9):
+      state[9, bit + 1, 5] = bool(self.steps & (1 << bit))
+    return state

runtime/minatar_synth/games/baserunner_dash.py

@@ -0,0 +1,113 @@
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 8
+BASES = ((50, 90), (90, 50), (50, 10), (10, 50))
+LEG_LENGTH = math.dist(BASES[0], BASES[1])
+RUNNER_SPEED = 0.6
+BALL_SPEED = 0.3
+
+
+class BaserunnerDashEnvironment:
+  score_cap = HORIZON * FRAMES_PER_STEP // math.ceil(LEG_LENGTH / RUNNER_SPEED)
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = 0
+    self.pressed = self.terminal = False
+    self.runner_base = 1
+    self.progress = 0.0
+    self.ball = BASES[0]
+    self.ball_base = 0
+    self.ball_target = 2
+    self.thrown = True
+
+  @property
+  def runner_target(self) -> int:
+    return (self.runner_base + 1) % len(BASES)
+
+  @property
+  def runner_position(self) -> tuple[float, float]:
+    x, y = BASES[self.runner_base]
+    target_x, target_y = BASES[self.runner_target]
+    fraction = self.progress / LEG_LENGTH
+    return x + (target_x - x) * fraction, y + (target_y - y) * fraction
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() >= self.sticky_action_prob:
+      self.pressed = action == 5
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_runner()
+      self._advance_ball()
+      runner_x, runner_y = self.runner_position
+      ball_x, ball_y = self.ball
+      if self.progress > 0 and not self.thrown and abs(runner_x - ball_x) < 6 and abs(runner_y - ball_y) < 6:
+        self.terminal = True
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_runner(self) -> int:
+    if not self.pressed:
+      self.progress = max(0, self.progress - RUNNER_SPEED)
+      return 0
+    self.progress += RUNNER_SPEED
+    if self.progress < LEG_LENGTH:
+      return 0
+    self.runner_base = self.runner_target
+    self.progress = 0.0
+    return 1
+
+  def _advance_ball(self) -> None:
+    x, y = self.ball
+    target = BASES[self.ball_target]
+    dx, dy = target[0] - x, target[1] - y
+    distance = math.hypot(dx, dy)
+    speed = BALL_SPEED * (3 if self.thrown else 1)
+    if distance <= speed:
+      self.ball = target
+      self.ball_base = self.ball_target
+      self.thrown = False
+      self.ball_target = self.runner_target if self.ball_base == self.runner_base else self.runner_base
+      return
+    self.ball = x + dx * speed / distance, y + dy * speed / distance
+    if not self.thrown and self.random.random() < 0.05:
+      self.thrown = True
+      if self.ball_base not in (self.runner_base, self.runner_target):
+        self.ball_target = self.runner_target
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    for x, y in BASES:
+      state[y // 10, x // 10, 0] = True
+    runner_x, runner_y = self.runner_position
+    state[int(runner_y) // 10, int(runner_x) // 10, 1] = True
+    ball_x, ball_y = self.ball
+    state[int(ball_y) // 10, int(ball_x) // 10, 2 if self.thrown else 3] = True
+    target_x, target_y = BASES[self.ball_target]
+    state[target_y // 10, target_x // 10, 4] = True
+    for index, channel in ((self.runner_base, 4), (self.runner_target, 5)):
+      state[0, index, channel] = True
+    for bit in range(9):
+      state[9, bit, 5] = bool(self.steps & (1 << bit))
+    state[9, 9, 5] = self.pressed
+    return state

runtime/minatar_synth/games/battle_zone.py

@@ -0,0 +1,223 @@
+import numpy as np
+
+
+DIRECTIONS = (
+  (-1, 0),
+  (-1, 1),
+  (0, 1),
+  (1, 1),
+  (1, 0),
+  (1, -1),
+  (0, -1),
+  (-1, -1),
+)
+POINTS = {"tank": 1_000.0, "fighter": 2_000.0, "supertank": 3_000.0, "saucer": 5_000.0}
+WAVES = (
+  ("tank", "tank", "tank", "fighter", "saucer"),
+  ("tank", "tank", "fighter", "fighter", "saucer"),
+  ("tank", "tank", "fighter", "supertank", "saucer"),
+  ("tank", "fighter", "fighter", "supertank", "saucer"),
+  ("tank", "fighter", "supertank", "supertank", "saucer"),
+)
+OBSTACLES = {(2, 2), (2, 7), (5, 1), (5, 8), (7, 3), (7, 6)}
+SPAWNS = ((0, 1), (0, 5), (0, 9), (4, 0), (4, 9))
+
+
+class BattleZoneEnvironment:
+  """Radar combat with oriented movement, cover, shell dodging, and four target classes."""
+
+  score_cap = 60_000.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.player = [9, 5]
+    self.previous_player = self.player.copy()
+    self.direction = 0
+    self.lives = 5
+    self.wave = 0
+    self.steps = 0
+    self.total_score = 0.0
+    self.bonus_awarded = False
+    self.player_shell: list[int] | None = None
+    self.enemy_shells: list[list[int]] = []
+    self.last_action = 0
+    self.terminal = False
+    self._start_wave()
+
+  def _start_wave(self) -> None:
+    self.enemies = [
+      {"kind": kind, "position": [*SPAWNS[index]], "previous": [*SPAWNS[index]]}
+      for index, kind in enumerate(WAVES[self.wave])
+    ]
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.previous_player = self.player.copy()
+    if action == 1:
+      self.direction = (self.direction - 1) % 8
+    elif action == 3:
+      self.direction = (self.direction + 1) % 8
+    elif action in (2, 4):
+      multiplier = 1 if action == 2 else -1
+      row_delta, column_delta = DIRECTIONS[self.direction]
+      target = [self.player[0] + multiplier * row_delta, self.player[1] + multiplier * column_delta]
+      if self._open(target):
+        self.player = target
+    elif action == 5 and self.player_shell is None:
+      row_delta, column_delta = DIRECTIONS[self.direction]
+      self.player_shell = [self.player[0], self.player[1], row_delta, column_delta, 9]
+
+    self._move_enemies()
+    self._move_shells()
+    reward = self._resolve_player_shell()
+    self._resolve_enemy_shells()
+    self._enemy_fire()
+    self.steps += 1
+    if self.total_score >= 50_000 and not self.bonus_awarded:
+      self.lives += 1
+      self.bonus_awarded = True
+    if not self.enemies:
+      self.wave += 1
+      if self.wave == len(WAVES):
+        self.terminal = True
+      else:
+        self._start_wave()
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  @staticmethod
+  def _open(position: list[int]) -> bool:
+    return 0 <= position[0] < 10 and 0 <= position[1] < 10 and tuple(position) not in OBSTACLES
+
+  def _move_enemies(self) -> None:
+    for enemy in self.enemies:
+      enemy["previous"] = list(enemy["position"])
+      kind = str(enemy["kind"])
+      if kind == "saucer":
+        enemy["position"][1] = (enemy["position"][1] + 1) % 10
+        continue
+      interval = {"tank": 3, "fighter": 2, "supertank": 1}[kind]
+      if self.steps % interval != 0:
+        continue
+      position = list(enemy["position"])
+      row_delta = int(np.sign(self.player[0] - position[0]))
+      column_delta = int(np.sign(self.player[1] - position[1]))
+      if kind == "fighter" and self.steps % 4 < 2:
+        column_delta = -column_delta or 1
+      candidates = ([position[0] + row_delta, position[1] + column_delta], [position[0] + row_delta, position[1]])
+      for target in candidates:
+        if self._open(target) and target != self.player:
+          enemy["position"] = target
+          break
+
+  def _move_shells(self) -> None:
+    if self.player_shell is not None:
+      self.player_shell[0] += self.player_shell[2]
+      self.player_shell[1] += self.player_shell[3]
+      self.player_shell[4] -= 1
+      if not self._open(self.player_shell[:2]) or self.player_shell[4] <= 0:
+        self.player_shell = None
+    remaining = []
+    for shell in self.enemy_shells:
+      shell[0] += shell[2]
+      shell[1] += shell[3]
+      shell[4] -= 1
+      if self._open(shell[:2]) and shell[4] > 0:
+        remaining.append(shell)
+    self.enemy_shells = remaining
+
+  def _resolve_player_shell(self) -> float:
+    if self.player_shell is None:
+      return 0.0
+    hit = next((enemy for enemy in self.enemies if enemy["position"] == self.player_shell[:2]), None)
+    if hit is None:
+      return 0.0
+    self.enemies.remove(hit)
+    self.player_shell = None
+    reward = POINTS[str(hit["kind"])]
+    self.total_score += reward
+    return reward
+
+  def _resolve_enemy_shells(self) -> None:
+    remaining = []
+    for shell in self.enemy_shells:
+      friendly_hit = next((enemy for enemy in self.enemies if enemy["position"] == shell[:2]), None)
+      if friendly_hit is not None:
+        self.enemies.remove(friendly_hit)
+      elif shell[:2] == self.player:
+        self._lose_tank()
+      else:
+        remaining.append(shell)
+    self.enemy_shells = remaining
+
+  def _enemy_fire(self) -> None:
+    for enemy in self.enemies:
+      kind = str(enemy["kind"])
+      if kind == "saucer":
+        continue
+      interval = {"tank": 12, "fighter": 9, "supertank": 7}[kind]
+      if self.steps % interval != 0:
+        continue
+      position = list(enemy["position"])
+      row_delta = int(np.sign(self.player[0] - position[0]))
+      column_delta = int(np.sign(self.player[1] - position[1]))
+      self.enemy_shells.append([position[0], position[1], row_delta, column_delta, 10])
+
+  def _lose_tank(self) -> None:
+    self.lives -= 1
+    self.player = [9, 5]
+    self.previous_player = self.player.copy()
+    self.direction = 0
+    self.player_shell = None
+    self.enemy_shells.clear()
+    if self.lives <= 0:
+      self.terminal = True
+
+  def _in_view(self, position: list[int]) -> bool:
+    row_delta = int(np.sign(position[0] - self.player[0]))
+    column_delta = int(np.sign(position[1] - self.player[1]))
+    if (row_delta, column_delta) == (0, 0):
+      return True
+    target_direction = DIRECTIONS.index((row_delta, column_delta))
+    return min((target_direction - self.direction) % 8, (self.direction - target_direction) % 8) <= 1
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for enemy in self.enemies:
+      position = list(enemy["position"])
+      state[*position, 1] = True
+      if self._in_view(position):
+        state[*position, 2] = True
+      type_marker = {"tank": 0, "fighter": 1, "supertank": 2, "saucer": 3}[str(enemy["kind"])]
+      state[position[0], type_marker, 5] = True
+      state[*list(enemy["previous"]), 4] = True
+    for shell in self.enemy_shells:
+      state[shell[0], shell[1], 1] = True
+    if self.player_shell is not None:
+      state[self.player_shell[0], self.player_shell[1], 3] = True
+    state[*self.previous_player, 4] = True
+    for obstacle in OBSTACLES:
+      state[*obstacle, 5] = True
+    state[9, : min(10, self.lives), 5] = True
+    state[8, : self.wave + 1, 5] = True
+    state[7, self.direction, 5] = True
+    return state

runtime/minatar_synth/games/beam_rider.py

@@ -0,0 +1,215 @@
+import numpy as np
+
+
+BEAM_COLUMNS = (1, 3, 5, 7, 9)
+SECTORS = (1, 2, 4, 6)
+
+
+class BeamRiderEnvironment:
+  """Five-beam sector defense with short lasers, scarce torpedoes, and rejuvenators."""
+
+  score_cap = 34_200.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 2_000):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.lane = 2
+    self.lives = 3
+    self.sector_index = 0
+    self.steps = 0
+    self.last_action = 0
+    self.terminal = False
+    self._start_sector()
+
+  @property
+  def sector(self) -> int:
+    return SECTORS[self.sector_index]
+
+  def _start_sector(self) -> None:
+    self.torpedoes = 3
+    self.saucers_destroyed = 0
+    self.saucers_spawned = 0
+    self.objects: list[dict[str, int | str | bool]] = []
+    self.shots: list[dict[str, int | str]] = []
+    self.previous_objects: list[list[int]] = []
+    self.sector_step = 0
+    self.sentinel: dict[str, int | str | bool] | None = None
+    self.rejuvenator_spawned = False
+    self.chirpers_spawned = 0
+    self.hazard_spawned = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    if action == 1:
+      self.lane = max(0, self.lane - 1)
+    elif action == 3:
+      self.lane = min(4, self.lane + 1)
+    elif action == 5:
+      self.shots.append({"row": 8, "lane": self.lane, "kind": "laser", "ttl": 4})
+    elif action == 2 and self.torpedoes > 0:
+      self.torpedoes -= 1
+      self.shots.append({"row": 8, "lane": self.lane, "kind": "torpedo", "ttl": 10})
+
+    self._spawn_objects()
+    self.previous_objects = [[int(obj["row"]), int(obj["lane"])] for obj in self.objects]
+    self._move_objects()
+    self._move_shots()
+    reward = self._resolve_shots()
+    self._resolve_player_contacts()
+    reward += self._move_sentinel()
+    self.sector_step += 1
+    self.steps += 1
+    if self.saucers_destroyed == 15 and self.sentinel is None:
+      self.sentinel = {"row": 0, "column": 0, "kind": "sentinel", "active": True}
+    if self.sentinel is not None and not bool(self.sentinel["active"]):
+      self.sector_index += 1
+      if self.sector_index == len(SECTORS):
+        self.terminal = True
+      else:
+        self._start_sector()
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _spawn_objects(self) -> None:
+    if self.saucers_spawned < 15 and self.sector_step % 5 == 0:
+      self.objects.append({"row": 0, "lane": int(self.random.randint(5)), "kind": "saucer", "red": False})
+      self.saucers_spawned += 1
+    if not self.rejuvenator_spawned and self.sector_step == 20:
+      self.objects.append({"row": 0, "lane": int(self.random.randint(5)), "kind": "rejuvenator", "red": False})
+      self.rejuvenator_spawned = True
+    if self.sector >= 4 and self.chirpers_spawned < 3 and self.sector_step in (12, 30, 48):
+      self.objects.append({"row": 0, "lane": int(self.random.randint(5)), "kind": "chirper", "red": False})
+      self.chirpers_spawned += 1
+    if self.sector >= 2 and not self.hazard_spawned and self.sector_step == 10:
+      kind = "debris" if self.sector < 6 else "blocker"
+      self.objects.append({"row": 0, "lane": int(self.random.randint(5)), "kind": kind, "red": False})
+      self.hazard_spawned = True
+
+  def _move_objects(self) -> None:
+    for obj in self.objects:
+      obj["row"] = int(obj["row"]) + 1
+      if obj["kind"] == "chirper" and int(obj["row"]) % 2 == 0:
+        obj["lane"] = int(np.clip(int(obj["lane"]) + self.random.choice((-1, 1)), 0, 4))
+    for obj in self.objects:
+      if obj["kind"] == "saucer" and int(obj["row"]) > 9:
+        obj["row"] = 0
+        obj["lane"] = int(self.random.randint(5))
+    self.objects = [obj for obj in self.objects if int(obj["row"]) <= 9 or obj["kind"] == "saucer"]
+
+  def _move_shots(self) -> None:
+    for shot in self.shots:
+      shot["row"] = int(shot["row"]) - 1
+      shot["ttl"] = int(shot["ttl"]) - 1
+    self.shots = [shot for shot in self.shots if int(shot["row"]) >= 0 and int(shot["ttl"]) > 0]
+
+  def _resolve_shots(self) -> float:
+    reward = 0.0
+    remaining = []
+    for shot in self.shots:
+      hit = next(
+        (obj for obj in self.objects if int(obj["row"]) == int(shot["row"]) and int(obj["lane"]) == int(shot["lane"])),
+        None,
+      )
+      if hit is None:
+        remaining.append(shot)
+        continue
+      kind = str(hit["kind"])
+      torpedo = shot["kind"] == "torpedo"
+      laser_vulnerable = kind in ("saucer", "chirper")
+      if kind == "rejuvenator" and not bool(hit["red"]):
+        hit["red"] = True
+        continue
+      if torpedo or laser_vulnerable:
+        self.objects.remove(hit)
+        if kind == "saucer":
+          self.saucers_destroyed += 1
+          reward += 100.0 * self.sector
+        elif kind == "chirper":
+          reward += 200.0 * self.sector
+      else:
+        remaining.append(shot)
+    self.shots = remaining
+    return reward
+
+  def _resolve_player_contacts(self) -> None:
+    contacts = [obj for obj in self.objects if int(obj["row"]) == 9 and int(obj["lane"]) == self.lane]
+    for obj in contacts:
+      self.objects.remove(obj)
+      if obj["kind"] == "rejuvenator" and not bool(obj["red"]):
+        self.lives += 1
+      else:
+        self._lose_ship()
+
+  def _move_sentinel(self) -> float:
+    if self.sentinel is None or not bool(self.sentinel["active"]):
+      return 0.0
+    self.sentinel["column"] = int(self.sentinel["column"]) + 1
+    hit = next(
+      (
+        shot
+        for shot in self.shots
+        if shot["kind"] == "torpedo"
+        and int(shot["row"]) == 0
+        and BEAM_COLUMNS[int(shot["lane"])] == int(self.sentinel["column"])
+      ),
+      None,
+    )
+    if hit is not None:
+      self.shots.remove(hit)
+      self.sentinel["active"] = False
+      return 500.0 * self.sector + 100.0 * self.lives
+    elif int(self.sentinel["column"]) > 9:
+      self.sentinel["active"] = False
+    return 0.0
+
+  def _lose_ship(self) -> None:
+    self.lives -= 1
+    self.lane = 2
+    self.shots.clear()
+    if self.lives <= 0:
+      self.terminal = True
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[9, BEAM_COLUMNS[self.lane], 0] = True
+    for obj in self.objects:
+      row, column = int(obj["row"]), BEAM_COLUMNS[int(obj["lane"])]
+      dangerous = obj["kind"] != "rejuvenator" or bool(obj["red"])
+      if dangerous:
+        state[row, column, 1] = True
+      if obj["kind"] in ("saucer", "chirper") or (obj["kind"] == "rejuvenator" and not bool(obj["red"])):
+        state[row, column, 2] = True
+      marker = {"saucer": 0, "chirper": 1, "debris": 2, "blocker": 3, "rejuvenator": 4}[str(obj["kind"])]
+      state[row, marker, 5] = True
+    if self.sentinel is not None and bool(self.sentinel["active"]):
+      state[0, min(9, int(self.sentinel["column"])), 2] = True
+    for shot in self.shots:
+      row, column = int(shot["row"]), BEAM_COLUMNS[int(shot["lane"])]
+      state[row, column, 3] = True
+      if shot["kind"] == "torpedo":
+        state[row, column, 5] = True
+    for row, lane in self.previous_objects:
+      if 0 <= row < 10:
+        state[row, BEAM_COLUMNS[lane], 4] = True
+    state[9, : min(10, self.lives), 5] = True
+    state[8, : self.torpedoes, 5] = True
+    state[7, : self.sector_index + 1, 5] = True
+    state[6, : min(10, (15 - self.saucers_destroyed + 1) // 2), 5] = True
+    return state

runtime/minatar_synth/games/berzerk.py

@@ -0,0 +1,246 @@
+import numpy as np
+
+
+DELTAS = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}
+OPENINGS = {(0, 5), (9, 5), (5, 0), (5, 9)}
+BASE_INTERIOR = {(2, 2), (2, 3), (2, 4), (4, 7), (5, 7), (6, 7), (7, 2), (7, 3)}
+SPAWN_CANDIDATES = ((1, 1), (1, 8), (4, 4), (7, 7), (8, 1), (3, 8), (6, 2))
+
+
+def room_walls(room: int) -> set[tuple[int, int]]:
+  boundary = {
+    (row, column)
+    for row in range(10)
+    for column in range(10)
+    if row in (0, 9) or column in (0, 9)
+  } - OPENINGS
+  interior = BASE_INTERIOR
+  for _ in range(room):
+    interior = {(column, 9 - row) for row, column in interior}
+  return boundary | interior
+
+
+class BerzerkEnvironment:
+  """Four electrified mazes with robot crossfire and invincible Evil Otto pressure."""
+
+  score_cap = 1_200.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_000):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.room = 0
+    self.lives = 3
+    self.steps = 0
+    self.last_action = 0
+    self.death_this_step = False
+    self.terminal = False
+    self._start_room([9, 5])
+
+  def _start_room(self, entry: list[int]) -> None:
+    self.walls = room_walls(self.room)
+    self.player = entry.copy()
+    self.previous_player = self.player.copy()
+    self.aim = 2
+    available = [position for position in SPAWN_CANDIDATES if position not in self.walls and list(position) != self.player]
+    self.robots = [list(position) for position in available[:5]]
+    self.previous_robots = [robot.copy() for robot in self.robots]
+    self.player_shot: list[int] | None = None
+    self.robot_shots: list[list[int]] = []
+    self.otto: list[int] | None = None
+    self.room_steps = 0
+    self.clear_bonus_awarded = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.death_this_step = False
+    self.previous_player = self.player.copy()
+    if action in DELTAS:
+      self.aim = action
+      if self._move_player(action):
+        self.steps += 1
+        return 0.0, self.terminal
+    elif action == 5 and self.player_shot is None:
+      row_delta, column_delta = DELTAS[self.aim]
+      self.player_shot = [self.player[0], self.player[1], row_delta, column_delta, 8]
+
+    self.previous_robots = [robot.copy() for robot in self.robots]
+    reward = self._move_robots()
+    self._move_shots()
+    reward += self._resolve_player_shot()
+    reward += self._resolve_robot_shots()
+    self._spawn_and_move_otto()
+    reward += self._resolve_otto()
+    if not self.robots and not self.clear_bonus_awarded:
+      reward += 50.0
+      self.clear_bonus_awarded = True
+    self.room_steps += 1
+    self.steps += 1
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return reward, self.terminal
+
+  def _move_player(self, action: int) -> bool:
+    row_delta, column_delta = DELTAS[action]
+    target = [self.player[0] + row_delta, self.player[1] + column_delta]
+    if not (0 <= target[0] < 10 and 0 <= target[1] < 10):
+      if tuple(self.player) in OPENINGS:
+        self.room += 1
+        if self.room == 4:
+          self.terminal = True
+        else:
+          opposite = {1: [5, 9], 2: [9, 5], 3: [5, 0], 4: [0, 5]}[action]
+          self._start_room(opposite)
+        return True
+      return False
+    if tuple(target) in self.walls:
+      self._lose_life()
+    elif target in self.robots or target == self.otto:
+      self._lose_life()
+    else:
+      self.player = target
+    return False
+
+  def _move_robots(self) -> float:
+    if self.room_steps % 2 != 0:
+      return 0.0
+    reward = 0.0
+    for robot in self.robots.copy():
+      row_delta = int(np.sign(self.player[0] - robot[0]))
+      column_delta = int(np.sign(self.player[1] - robot[1]))
+      target = [robot[0] + row_delta, robot[1] + column_delta]
+      if tuple(target) in self.walls:
+        if robot in self.robots:
+          self.robots.remove(robot)
+          reward += 50.0
+      elif target in self.robots:
+        if robot in self.robots:
+          self.robots.remove(robot)
+          reward += 50.0
+        if target in self.robots:
+          self.robots.remove(target)
+          reward += 50.0
+      elif target == self.player:
+        self._lose_life()
+      elif robot in self.robots:
+        robot[:] = target
+    if self.room_steps % 8 == 0:
+      for robot in self.robots:
+        row_delta = int(np.sign(self.player[0] - robot[0]))
+        column_delta = int(np.sign(self.player[1] - robot[1]))
+        self.robot_shots.append([robot[0], robot[1], row_delta, column_delta, 8])
+    return reward
+
+  def _move_shots(self) -> None:
+    if self.player_shot is not None:
+      self.player_shot[0] += self.player_shot[2]
+      self.player_shot[1] += self.player_shot[3]
+      self.player_shot[4] -= 1
+      if (
+        self.player_shot[4] <= 0
+        or not (0 <= self.player_shot[0] < 10 and 0 <= self.player_shot[1] < 10)
+        or tuple(self.player_shot[:2]) in self.walls
+      ):
+        self.player_shot = None
+    remaining = []
+    for shot in self.robot_shots:
+      shot[0] += shot[2]
+      shot[1] += shot[3]
+      shot[4] -= 1
+      if shot[4] > 0 and 0 <= shot[0] < 10 and 0 <= shot[1] < 10 and tuple(shot[:2]) not in self.walls:
+        remaining.append(shot)
+    self.robot_shots = remaining
+
+  def _resolve_player_shot(self) -> float:
+    if self.player_shot is None:
+      return 0.0
+    hit = next((robot for robot in self.robots if robot == self.player_shot[:2]), None)
+    if hit is None:
+      return 0.0
+    self.robots.remove(hit)
+    self.player_shot = None
+    return 50.0
+
+  def _resolve_robot_shots(self) -> float:
+    reward = 0.0
+    remaining = []
+    for shot in self.robot_shots:
+      hit = next((robot for robot in self.robots if robot == shot[:2]), None)
+      if hit is not None:
+        self.robots.remove(hit)
+        reward += 50.0
+      elif shot[:2] == self.player:
+        self._lose_life()
+      else:
+        remaining.append(shot)
+    self.robot_shots = remaining
+    return reward
+
+  def _spawn_and_move_otto(self) -> None:
+    if self.otto is None and self.room_steps >= 40:
+      self.otto = [9, 5]
+    if self.otto is None or self.room_steps % 2 != 0:
+      return
+    self.otto[0] += int(np.sign(self.player[0] - self.otto[0]))
+    self.otto[1] += int(np.sign(self.player[1] - self.otto[1]))
+
+  def _resolve_otto(self) -> float:
+    if self.otto is None:
+      return 0.0
+    reward = 0.0
+    hit = next((robot for robot in self.robots if robot == self.otto), None)
+    if hit is not None:
+      self.robots.remove(hit)
+      reward += 50.0
+    if self.otto == self.player:
+      self._lose_life()
+    return reward
+
+  def _lose_life(self) -> None:
+    if self.death_this_step:
+      return
+    self.death_this_step = True
+    self.lives -= 1
+    self.player = [9, 5]
+    self.previous_player = self.player.copy()
+    self.player_shot = None
+    self.robot_shots.clear()
+    if self.lives <= 0:
+      self.terminal = True
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    for robot in self.robots:
+      state[*robot, 1] = True
+      state[*robot, 2] = True
+    for shot in self.robot_shots:
+      state[shot[0], shot[1], 1] = True
+    if self.otto is not None:
+      state[*self.otto, 1] = True
+    if self.player_shot is not None:
+      state[self.player_shot[0], self.player_shot[1], 3] = True
+    state[*self.previous_player, 4] = True
+    for robot in self.previous_robots:
+      state[*robot, 4] = True
+    for wall in self.walls:
+      state[*wall, 5] = True
+    state[9, : self.lives, 5] = True
+    state[8, : self.room + 1, 5] = True
+    state[7, self.aim, 5] = True
+    return state

runtime/minatar_synth/games/blade_dancer.py

@@ -0,0 +1,130 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+PLAYER_X = 35
+GROUND = 80
+JUMP_DURATION = 30
+
+
+@dataclass
+class Enemy:
+  x: float
+  y: float
+  size: float
+
+
+class BladeDancerEnvironment:
+  score_cap = 100
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = 0
+    self.pressed = self.terminal = False
+    self.jump_ticks = 0.0
+    self.y = float(GROUND)
+    self.angle = math.pi / 2
+    self.length = 10.0
+    self.multiplier = 1
+    self.enemies: list[Enemy] = []
+    self.platforms = [(0.0, 200.0)]
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    if pressed and not self.pressed and not self.jump_ticks:
+      self.jump_ticks = JUMP_DURATION
+      self.multiplier = 1
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _sword_vector(self) -> tuple[float, float]:
+    return self.length * math.cos(self.angle), self.length * math.sin(self.angle)
+
+  def _advance_frame(self) -> int:
+    if self.jump_ticks:
+      self.jump_ticks = max(0, self.jump_ticks - (0.5 if self.pressed else 1))
+      progress = self.jump_ticks / JUMP_DURATION
+      self.y = GROUND - math.sin(progress * math.pi) * 30
+      self.angle = self.angle - 0.3 if self.jump_ticks else math.pi / 2
+      self.length = 8 + (1 - progress) * 22 if self.jump_ticks else 10
+
+    if not self.enemies or self.random.random() < 0.04:
+      if len(self.enemies) == 32:
+        self.enemies.pop(0)
+      self.enemies.append(Enemy(205, self.random.uniform(30, 75), self.random.uniform(3, 6)))
+    reward = 0
+    survivors = []
+    sword_x, sword_y = self._sword_vector()
+    sword_radius = 2.5 if self.jump_ticks else 1
+    for enemy in self.enemies:
+      enemy.x -= 1
+      dx, dy = enemy.x - PLAYER_X, enemy.y - (self.y - 4)
+      fraction = min(1, max(0, (dx * sword_x + dy * sword_y) / self.length**2))
+      distance = math.hypot(dx - fraction * sword_x, dy - fraction * sword_y)
+      radius = enemy.size / 2
+      if distance <= radius + sword_radius:
+        reward += self.multiplier
+        self.multiplier += 1
+        continue
+      if abs(dx) < 2 + radius and abs(enemy.y - self.y) < 4 + radius:
+        self.terminal = True
+      if enemy.x >= -10:
+        survivors.append(enemy)
+    self.enemies = survivors
+
+    self.platforms = [(left - 1, right - 1) for left, right in self.platforms if right >= 1]
+    end = self.platforms[-1][1]
+    if end < 200:
+      gap = self.random.uniform(15, 30) if self.random.random() < 0.32 else 0
+      length = self.random.uniform(30, 100) if gap else self.random.uniform(50, 150)
+      self.platforms.append((end + gap, end + gap + length))
+    if not self.jump_ticks and not any(left <= PLAYER_X <= right for left, right in self.platforms):
+      self.terminal = True
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row, column = int(self.y) // 10, PLAYER_X // 20
+    state[row, column, 0] = True
+    state[row, column, 4] = self.jump_ticks > 0
+    sword_x, sword_y = self._sword_vector()
+    for fraction in np.linspace(0, 1, 12):
+      y = int(self.y - 4 + fraction * sword_y) // 10
+      x = int(PLAYER_X + fraction * sword_x) // 20
+      state[y, x, 1] = True
+    for enemy in self.enemies:
+      if 0 <= enemy.x < 200:
+        state[int(enemy.y) // 10, int(enemy.x) // 20, 2] = True
+    for column in range(10):
+      x = 20 * column + PLAYER_X % 20
+      state[8, column, 3] = any(left <= x <= right for left, right in self.platforms)
+    state[9, 0, 5] = self.pressed
+    for row, value in enumerate((int(self.jump_ticks * 2), self.multiplier, self.steps)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/blast_buoy.py

@@ -0,0 +1,155 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+BLAST_RADIUS = 25
+
+
+@dataclass
+class Submarine:
+  x: float
+  y: float
+  vx: float
+  fire_timer: int
+
+
+@dataclass
+class Bullet:
+  x: float
+  y: float
+  vx: float
+
+
+class BlastBuoyEnvironment:
+  score_cap = 500
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.spawn_timer = self.combo_timer = self.shield = self.freeze = 0
+    self.combo = 1
+    self.pressed = self.terminal = False
+    self.x, self.y = 30.0, 40.0
+    self.vx = self.vy = 0.0
+    self.submarines: list[Submarine] = []
+    self.bullets: list[Bullet] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() >= self.sticky_action_prob:
+      self.pressed = action == 5
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self) -> int:
+    if self.freeze:
+      self.freeze -= 1
+      return 0
+    self.vy = min(1.1, max(-1.1, self.vy + (0.06 if self.pressed else -0.05)))
+    self.vx *= 0.95
+    self.x = min(95, max(5, self.x + self.vx))
+    self.y = min(87, max(13, self.y + self.vy))
+    if self.y in (13, 87):
+      self.vy = 0
+
+    self.shield = max(0, self.shield - 1)
+    if self.combo_timer:
+      self.combo_timer -= 1
+    else:
+      self.combo = 1
+
+    if not self.spawn_timer:
+      direction = int(self.random.choice((-1, 1)))
+      self.submarines.append(Submarine(
+        -8 if direction > 0 else 108,
+        self.random.uniform(13, 87),
+        direction * self.random.uniform(0.2, 0.45),
+        int(self.random.integers(60, 121)),
+      ))
+      self.spawn_timer = int(self.random.integers(50, 91))
+    self.spawn_timer -= 1
+
+    contact = None
+    for sub in self.submarines:
+      sub.x += sub.vx
+      sub.fire_timer -= 1
+      if sub.fire_timer < 0 and 0 < sub.x < 100 and abs(sub.y - self.y) < 10:
+        if math.hypot(sub.x - self.x, sub.y - self.y) > 36:
+          direction = 1 if self.x > sub.x else -1
+          self.bullets.append(Bullet(sub.x + direction * 6, sub.y, direction * 0.95))
+        sub.fire_timer = int(self.random.integers(90, 151))
+      if contact is None and not self.shield and abs(sub.x - self.x) < 7.5 and abs(sub.y - self.y) < 5:
+        contact = sub
+
+    self.submarines = [sub for sub in self.submarines if -12 <= sub.x <= 112]
+    reward = self._blast(contact) if contact is not None else 0
+
+    survivors = []
+    for bullet in self.bullets:
+      bullet.x += bullet.vx
+      if abs(bullet.x - self.x) < 5.5 and abs(bullet.y - self.y) < 4:
+        self.terminal |= not self.shield
+      elif -5 <= bullet.x <= 105:
+        survivors.append(bullet)
+    self.bullets = survivors
+    return reward
+
+  def _blast(self, center: Submarine) -> int:
+    self.submarines.remove(center)
+    remaining = [
+      sub for sub in self.submarines
+      if math.hypot(sub.x - center.x, sub.y - center.y) >= BLAST_RADIUS
+    ]
+    extras = len(self.submarines) - len(remaining)
+    self.submarines = remaining
+    self.bullets = [
+      bullet for bullet in self.bullets
+      if math.hypot(bullet.x - center.x, bullet.y - center.y) >= BLAST_RADIUS
+    ]
+    reward = (5 + 8 * extras) * self.combo
+    self.combo += 1
+    self.combo_timer = 120
+    angle = math.atan2(self.y - center.y, self.x - center.x)
+    self.vx, self.vy = 2.2 * math.cos(angle), 2.2 * math.sin(angle)
+    self.shield = 40
+    self.freeze = min(8, 3 + extras)
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row, column = int(self.y) // 10, int(self.x) // 10
+    state[row, column, 0] = True
+    state[row, column, 4] = self.shield > 0
+    for sub in self.submarines:
+      if 0 <= sub.x < 100:
+        state[int(sub.y) // 10, int(sub.x) // 10, 1 if sub.vx > 0 else 2] = True
+    for bullet in self.bullets:
+      if 0 <= bullet.x < 100:
+        state[int(bullet.y) // 10, int(bullet.x) // 10, 3] = True
+    for row, value in enumerate((self.steps, self.combo, self.combo_timer, self.shield, self.freeze)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    state[9, :2, 5] = self.pressed, self.vy > 0
+    return state

runtime/minatar_synth/games/blaze_thrust.py

@@ -0,0 +1,131 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+
+
+@dataclass
+class Bubble:
+  x: float
+  y: float
+  size: float
+
+
+class BlazeThrustEnvironment:
+  score_cap = 250
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.hold_time = 0
+    self.pressed = self.terminal = False
+    self.x, self.y = 50.0, 90.0
+    self.vx = self.vy = 0.0
+    self.size = 9.0
+    self.multiplier = 1
+    self.next_bubble = self.random.uniform(10, 40)
+    self.winds = [(0.0, self.random.uniform(20, 40))]
+    self.bubbles: list[Bubble] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() >= self.sticky_action_prob:
+      self.pressed = action == 5
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _wind_left(self, y: float) -> bool:
+    return any(top <= y <= bottom for top, bottom in self.winds)
+
+  def _advance_frame(self) -> int:
+    self.vy += -0.1 if self.pressed else 0.1
+    self.hold_time = self.hold_time + 1 if self.pressed else max(0, self.hold_time - 3)
+    scroll = max(0, (60 - self.y) * 0.1)
+    self.x += self.vx
+    self.y += self.vy + scroll
+    self.vx *= 0.95
+    self.vy *= 0.95
+    if self.x < 5:
+      self.x, self.vx = 10, abs(self.vx) * 0.5
+    elif self.x > 95:
+      self.x, self.vx = 90, -abs(self.vx) * 0.5
+    if self.y > 95:
+      self.y, self.vy = 90, -abs(self.vy) * 0.3
+
+    if scroll:
+      self.winds = [(top + scroll, bottom + scroll) for top, bottom in self.winds if top + scroll < 120]
+      top = self.winds[0][0]
+      if top >= 0:
+        bottom = top - self.random.uniform(20, 40)
+        self.winds.insert(0, (bottom - self.random.uniform(20, 40), bottom))
+    self.vx += self.size * (-0.02 if self._wind_left(self.y) else 0.02)
+    self.size *= 1 - 0.0016 * (1 + self.hold_time * 0.01)
+    if self.size <= 2:
+      self.terminal = True
+      return 0
+
+    reward = self._advance_bubbles(scroll)
+    if scroll and len(self.bubbles) < 15:
+      self.next_bubble -= scroll
+      if self.next_bubble <= 0:
+        size = self.random.uniform(3, 9)
+        self.bubbles.append(Bubble(self.random.uniform(10, 90), -size, size))
+        self.next_bubble = self.random.uniform(5, 55)
+    return reward
+
+  def _advance_bubbles(self, scroll: float) -> int:
+    reward = 0
+    remaining = []
+    for bubble in self.bubbles:
+      bubble.y += scroll + 0.3 - (bubble.size - 3) * 0.015
+      bubble.x += bubble.size * (-0.02 if self._wind_left(bubble.y) else 0.02)
+      bubble.x = min(95, max(5, bubble.x))
+      if math.hypot(bubble.x - self.x, bubble.y - self.y) <= bubble.size + self.size:
+        reward += self.multiplier
+        self.multiplier = min(16, self.multiplier + 1)
+        self.size = min(25, self.size + bubble.size * 0.2)
+      elif bubble.y > 120:
+        self.multiplier = 1
+      else:
+        remaining.append(bubble)
+    self.bubbles = remaining
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row, column = int(self.y) // 10, int(self.x) // 10
+    state[row, column, 0] = True
+    state[row, column, 4] = self.vy < 0
+    for row in range(10):
+      state[row, :, 1 if self._wind_left(10 * row + 5) else 2] = True
+    for bubble in self.bubbles:
+      if 0 <= bubble.y < 100:
+        state[int(bubble.y) // 10, int(bubble.x) // 10, 3] = True
+    for row, value in enumerate((round(self.size * 10), self.multiplier, self.hold_time, self.steps)):
+      for bit in range(10):
+        state[row, bit, 5] = bool(value & (1 << bit))
+      state[row + 4, 0, 5] = bool(value & 1024)
+    state[9, 0, 5] = self.pressed
+    return state

runtime/minatar_synth/games/block_stacker.py

@@ -0,0 +1,123 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+
+
+@dataclass
+class Block:
+  x: float
+  y: float
+  width: float
+
+
+class BlockStackerEnvironment:
+  score_cap = 50
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.stacked = 0
+    self.pressed = self.falling = self.terminal = False
+    self.angle = self.vx = self.vy = self.drift = 0.0
+    self.current = Block(50, 25, self.random.uniform(10, 30))
+    self.tower = [Block(50, 99, 99)]
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    tap = pressed and not self.pressed
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for frame in range(FRAMES_PER_STEP):
+      reward += self._advance_frame(tap and frame == 0)
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self, tap: bool) -> int:
+    difficulty = 1 + self.stacked / 50
+    self.angle += 0.05 * difficulty
+    previous_y = self.current.y
+    if self.falling:
+      self.current.x += self.vx * difficulty
+      self.current.y += self.vy * difficulty
+      self.vy += 0.1
+    else:
+      swing = math.sin(self.angle)
+      self.current.x = 50 - 20 * math.sin(swing)
+      self.current.y = 5 + 20 * math.cos(swing)
+      if tap:
+        self.falling = True
+        self.vx, self.vy = -math.cos(self.angle), 0.0
+
+    for block in self.tower:
+      block.x = (block.x + self.drift) % 100
+    top = min(block.y for block in self.tower)
+    reward = 0
+    if self.falling:
+      for block in sorted(self.tower, key=lambda block: block.y):
+        distance = abs((self.current.x - block.x + 50) % 100 - 50)
+        if previous_y <= block.y - 10 <= self.current.y and distance < (self.current.width + block.width) / 2:
+          self.current.y = block.y - 10
+          self.tower.append(self.current)
+          self.current = Block(50, 25, self.random.uniform(10, 30))
+          self.falling = False
+          self.stacked += 1
+          self.drift = self.random.uniform(-1, 1) * self.stacked / 50
+          reward = 1
+          break
+      else:
+        self.terminal = self.current.y > 105
+    scroll = difficulty * 0.01 + max(0, 70 - top) * 0.1
+    for block in self.tower:
+      block.y += scroll
+    self.tower = [block for block in self.tower if block.y <= 106]
+    self.terminal |= not self.tower
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    for block in self.tower:
+      self._draw_block(state, block, 0, wraps=True)
+    self._draw_block(state, self.current, 2 if self.falling else 1, wraps=False)
+    if not self.falling:
+      for fraction in np.linspace(0, 1, 8):
+        x = 50 + (self.current.x - 50) * fraction
+        y = (self.current.y - 5) * fraction
+        state[int(y) // 10, int(x) // 10, 3] = True
+    if self.drift < 0:
+      state[:, :, 4] = state[:, :, 0]
+    state[9, 0, 5] = self.pressed
+    for row, value in enumerate((self.steps, self.stacked)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    state[9, 1, 5] = (self.vx < 0 if self.falling else math.cos(self.angle) > 0)
+    return state
+
+  @staticmethod
+  def _draw_block(state: np.ndarray, block: Block, channel: int, wraps: bool) -> None:
+    for row in range(10):
+      if row * 10 < block.y + 5 and (row + 1) * 10 > block.y - 5:
+        for column in range(10):
+          dx = column * 10 + 5 - block.x
+          distance = abs((dx + 50) % 100 - 50) if wraps else abs(dx)
+          state[row, column, channel] |= distance < block.width / 2 + 5

runtime/minatar_synth/games/boarding.py

@@ -0,0 +1,150 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+
+
+@dataclass
+class Board:
+  x: float
+  y: float
+  slope: int
+
+
+@dataclass
+class Passenger:
+  x: float
+  y: float
+  kind: int
+  vx: float = 0
+  vy: float = 0
+  bounces: int = 0
+
+
+class BoardingEnvironment:
+  score_cap = 250
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.cooldown = 0
+    self.pressed = self.ready = self.terminal = False
+    self.x, self.direction, self.kind = 50.0, -1, -1
+    self.gate = self.gate_target = 91.0
+    self.board_credit = 0
+    self.boards: list[Board] = []
+    self.passengers: list[Passenger] = []
+    for y in range(47, 88, 2):
+      self._add_board(y)
+
+  def _add_board(self, y: float) -> None:
+    x = self.random.uniform(9, 90)
+    if all(math.hypot(board.x - x, board.y - y) >= 16 for board in self.boards):
+      self.boards.append(Board(x, y, int(self.random.choice((-1, 1)))))
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    released = self.pressed and not pressed
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for frame in range(FRAMES_PER_STEP):
+      reward += self._advance_frame(released and frame == 0)
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self, released: bool) -> int:
+    for board in self.boards:
+      board.y -= 0.1
+    self.boards = [board for board in self.boards if 15 < board.y < self.gate]
+    self.gate_target = max(11, self.gate_target - 0.1)
+    self.gate += (self.gate_target - self.gate) * 0.1
+    if self.gate <= 12:
+      self.terminal = True
+      return 0
+    if self.board_credit >= 2:
+      self._add_board(self.gate - 3)
+      self.board_credit -= 2
+
+    self.cooldown = max(0, self.cooldown - 1)
+    boarding = self.pressed and self.ready
+    if boarding and not self.cooldown:
+      self.passengers.append(Passenger(self.x, 9, self.kind))
+      self.cooldown = 10
+    self.x += self.direction * (0.1 if boarding else 1)
+    if self.x < 10 or self.x > 90:
+      self.direction = 1 if self.x < 10 else -1
+    if released:
+      if self.ready:
+        self.kind *= -1
+      self.ready = True
+
+    reward = 0
+    survivors = []
+    for passenger in self.passengers:
+      self._move_passenger(passenger)
+      if passenger.y <= self.gate:
+        survivors.append(passenger)
+      elif (passenger.x - 50) * passenger.kind > 0:
+        reward += passenger.bounces
+        self.gate_target = min(91, self.gate_target + 2 * passenger.bounces)
+        self.board_credit += passenger.bounces
+      else:
+        reward -= 1 + passenger.bounces
+        self.gate_target -= min(20, math.sqrt(1 + passenger.bounces))
+    self.passengers = survivors
+    return reward
+
+  def _move_passenger(self, passenger: Passenger) -> None:
+    old_x, old_y = passenger.x, passenger.y
+    passenger.vx *= 0.9
+    passenger.vy = (passenger.vy + 0.2) * 0.9
+    passenger.x += passenger.vx
+    passenger.y += passenger.vy
+    for board in self.boards:
+      previous = old_y - board.y - board.slope * (old_x - board.x)
+      current = passenger.y - board.y - board.slope * (passenger.x - board.x)
+      if previous > 0 or current < 0 or current == previous:
+        continue
+      crossing_x = old_x + (passenger.x - old_x) * (-previous / (current - previous))
+      if abs(crossing_x - board.x) <= 4:
+        impulse = math.hypot(passenger.vx, passenger.vy) * math.sqrt(2)
+        passenger.vx += board.slope * impulse
+        passenger.vy += impulse
+        passenger.x += 2 * passenger.vx
+        passenger.y += 2 * passenger.vy
+        passenger.bounces += 1
+        break
+    if passenger.x < 0 or passenger.x > 99:
+      passenger.x = min(99, max(0, passenger.x))
+      passenger.vx *= -1
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[0, int(self.x) // 10, 0] = True
+    state[int(self.gate) // 10, :, 1] = True
+    for board in self.boards:
+      state[int(board.y) // 10, int(board.x) // 10, 2 if board.slope < 0 else 3] = True
+    for passenger in self.passengers:
+      state[int(passenger.y) // 10, int(passenger.x) // 10, 4 if passenger.kind < 0 else 5] = True
+    state[0, :4, 1] = self.kind > 0, self.direction > 0, self.ready, self.pressed
+    return state

runtime/minatar_synth/games/bola_thread.py

@@ -0,0 +1,138 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+SCROLL = 0.55
+ROTATION = 0.022
+
+
+@dataclass
+class Wall:
+  x: float
+  gap_y: float
+  height: float
+  nub: bool
+  passed: bool = False
+
+  def blocked(self, y: float, margin: float = 0) -> bool:
+    return (
+      abs(y - self.gap_y) + margin > self.height / 2
+      or self.nub and abs(y - 50) < 4 + margin
+    )
+
+
+@dataclass
+class Beacon:
+  x: float
+  y: float
+
+
+class BolaThreadEnvironment:
+  score_cap = 150
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.freeze = 0
+    self.pressed = self.terminal = False
+    self.angle, self.radius = 0.0, 20.0
+    self.next_wall, self.next_beacon = 60.0, 100
+    self.walls: list[Wall] = []
+    self.beacons: list[Beacon] = []
+
+  @property
+  def balls(self) -> tuple[tuple[float, float], tuple[float, float]]:
+    dx = math.cos(self.angle) * self.radius
+    dy = math.sin(self.angle) * self.radius
+    return (30 + dx, 50 + dy), (30 - dx, 50 - dy)
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() >= self.sticky_action_prob:
+      self.pressed = action == 5
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self) -> int:
+    if self.freeze:
+      self.freeze -= 1
+      return 0
+    self.radius = max(6, self.radius - 0.6) if self.pressed else min(26, self.radius + 0.45)
+    self.angle = (self.angle + ROTATION) % math.tau
+    self.next_wall -= SCROLL
+    self.next_beacon -= 1
+    if self.next_wall < 0:
+      arrival_angle = self.angle + ROTATION * (108 - 30) / SCROLL
+      nub = self.random.random() < 0.36 and abs(math.sin(arrival_angle)) > 0.8
+      gap_y = self.random.uniform(42, 58)
+      height = self.random.uniform(42, 54) if nub else self.random.uniform(25, 40)
+      self.walls.append(Wall(108, gap_y, height, nub))
+      self.next_wall = self.random.uniform(65, 90)
+    if self.next_beacon < 0:
+      self.beacons.append(Beacon(108, self.random.uniform(20, 80)))
+      self.next_beacon = int(self.random.integers(90, 151))
+
+    reward = 0
+    balls = self.balls
+    for wall in self.walls:
+      wall.x -= SCROLL
+      if any(abs(x - wall.x) < 4 and wall.blocked(y, margin=2) for x, y in balls):
+        self.terminal = True
+        return reward
+      if not wall.passed and wall.x < 30:
+        wall.passed = True
+        bonus = max(1, int((self.radius - 6) // 3))
+        reward += bonus
+        self.freeze = 2 + 2 * (bonus >= 3) + 2 * (bonus >= 5)
+    self.walls = [wall for wall in self.walls if wall.x >= -5]
+    survivors = []
+    for beacon in self.beacons:
+      beacon.x -= SCROLL
+      if any(abs(x - beacon.x) < 4.5 and abs(y - beacon.y) < 4.5 for x, y in balls):
+        reward += 8
+      elif beacon.x >= -5:
+        survivors.append(beacon)
+    self.beacons = survivors
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[5, 3, 0] = True
+    for x, y in self.balls:
+      state[int(y) // 10, int(x) // 10, 1] = True
+    for wall in self.walls:
+      if 0 <= wall.x < 100:
+        column = int(wall.x) // 10
+        for row in range(10):
+          state[row, column, 2] |= abs(10 * row + 5 - wall.gap_y) > wall.height / 2
+        state[4:6, column, 3] |= wall.nub
+    for beacon in self.beacons:
+      if 0 <= beacon.x < 100:
+        state[int(beacon.y) // 10, int(beacon.x) // 10, 4] = True
+    for row, value in enumerate((self.steps, round(self.radius * 10), round(self.angle * 80), self.freeze)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    state[9, 0, 5] = self.pressed
+    return state

runtime/minatar_synth/games/bomb_up.py

@@ -0,0 +1,165 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+
+
+@dataclass
+class Body:
+  x: float
+  y: float
+  vx: float = 0
+  vy: float = 0
+
+
+@dataclass
+class Blast:
+  x: float
+  y: float
+  age: int = 0
+
+  @property
+  def radius(self) -> float:
+    return 25 * math.sin(self.age * 0.15)
+
+  def hits(self, x: float, y: float, tolerance: float) -> bool:
+    return abs(math.hypot(x - self.x, y - self.y) - self.radius) <= tolerance
+
+
+class BombUpEnvironment:
+  score_cap = 250
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.spawn_timer = 0
+    self.multiplier = 1
+    self.pressed = self.terminal = False
+    self.player = Body(50, 50)
+    self.spawner = Body(80, 0)
+    self.bomb: Body | None = None
+    self.blast: Blast | None = None
+    self.rocks: list[Body] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    tap = pressed and not self.pressed
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for frame in range(FRAMES_PER_STEP):
+      reward += self._advance_frame(tap and frame == 0)
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  @staticmethod
+  def _bounce(body: Body) -> None:
+    if (body.x < 7 and body.vx < 0) or (body.x > 93 and body.vx > 0):
+      body.x = min(93, max(7, body.x))
+      body.vx *= -0.7
+
+  def _tap(self) -> None:
+    player = self.player
+    if self.bomb is None:
+      direction = -1 if player.vx < 0 else 1
+      self.bomb = Body(player.x + 2 * direction, player.y, player.vx + 0.5 * direction, player.vy)
+      self.multiplier = 1
+      return
+    self.blast = Blast(self.bomb.x, self.bomb.y)
+    dx, dy = player.x - self.bomb.x, player.y - self.bomb.y
+    distance_squared = max(1, dx * dx + dy * dy)
+    player.vx += 20 * dx / distance_squared
+    player.vy += 20 * dy / distance_squared
+    self.bomb = None
+
+  def _advance_frame(self, tap: bool) -> int:
+    player = self.player
+    scroll = (40 - player.y) * 0.3 if player.y < 40 else min(0, (60 - player.y) * 0.2)
+    self._bounce(player)
+    player.vx *= 0.99
+    player.vy = (player.vy + 0.02) * 0.99
+    player.x += player.vx
+    player.y += player.vy + scroll
+    if tap:
+      self._tap()
+    if self.bomb is not None:
+      bomb = self.bomb
+      self._bounce(bomb)
+      bomb.vx *= 0.98
+      bomb.vy = (bomb.vy + 0.15) * 0.98
+      bomb.x += bomb.vx
+      bomb.y += bomb.vy + scroll
+      if bomb.y > 103:
+        self.bomb = None
+    if self.blast is not None:
+      self.blast.age += 1
+      if self.blast.radius < 0:
+        self.blast = None
+
+    self.spawner.vx = (self.spawner.vx + self.random.uniform(-0.1, 0.1)) * 0.99
+    self.spawner.x += self.spawner.vx
+    self._bounce(self.spawner)
+    if self.spawn_timer == 0:
+      bottom = self.random.random() > (0.05 if player.y > 30 else 0.9)
+      y = 103 if bottom else -3
+      vy = -self.random.uniform(0.5, 1) if bottom else player.vy / 2
+      self.rocks.append(Body(self.spawner.x, y, vy=vy))
+      self.spawn_timer = int(self.random.integers(8, 11))
+    self.spawn_timer -= 1
+
+    reward = 0
+    remaining = []
+    for rock in self.rocks:
+      rock.y += rock.vy
+      rock.vy = (rock.vy + 0.01) * 0.99
+      rock.y += rock.vy + scroll
+      if self.blast is not None and self.blast.hits(rock.x, rock.y, 3.5):
+        reward += self.multiplier
+        self.multiplier += 1
+        continue
+      if abs(rock.x - player.x) < 5.5 and abs(rock.y - player.y) < 5.5:
+        self.terminal = True
+      if -50 <= rock.y <= 150:
+        remaining.append(rock)
+    self.rocks = remaining
+    return reward
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row = min(9, max(0, int(self.player.y) // 10))
+    column = min(9, max(0, int(self.player.x) // 10))
+    state[row, column, 0] = True
+    state[row, column, 4] = self.player.vy < 0
+    if self.bomb is not None and 0 <= self.bomb.x < 100 and 0 <= self.bomb.y < 100:
+      state[int(self.bomb.y) // 10, int(self.bomb.x) // 10, 1] = True
+    for rock in self.rocks:
+      if 0 <= rock.y < 100:
+        state[int(rock.y) // 10, int(rock.x) // 10, 2] = True
+    if self.blast is not None:
+      for y in range(10):
+        for x in range(10):
+          state[y, x, 3] = self.blast.hits(x * 10 + 5, y * 10 + 5, 7)
+    for row, value in enumerate((self.steps, self.multiplier)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    state[9, :3, 5] = self.pressed, self.bomb is not None, self.player.vx < 0
+    return state

runtime/minatar_synth/games/bore_comet.py

@@ -0,0 +1,150 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+PLAYER_X = 35
+SCROLL = 0.6
+
+
+@dataclass
+class Rock:
+  x: float
+  y: float
+  width: float
+  height: float
+  bore: int = 0
+
+  @property
+  def threshold(self) -> int:
+    return round(math.sqrt(self.width * self.height) / (SCROLL / 0.5))
+
+  def contains(self, y: float) -> bool:
+    return abs(self.x - PLAYER_X) < self.width / 2 + 2 and abs(self.y - y) < self.height / 2 + 2
+
+
+@dataclass
+class Enemy:
+  x: float
+  y: float
+  vx: float
+
+
+class BoreCometEnvironment:
+  score_cap = 500
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.freeze = 0
+    self.pressed = self.terminal = self.was_in_rock = False
+    self.y, self.vy = 30.0, 0.0
+    self.next_rock, self.next_enemy = 20.0, 60
+    self.rocks: list[Rock] = []
+    self.enemies: list[Enemy] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() >= self.sticky_action_prob:
+      self.pressed = action == 5
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self) -> int:
+    if self.freeze:
+      self.freeze -= 1
+      return 0
+    rock = next((rock for rock in reversed(self.rocks) if rock.contains(self.y)), None)
+    if rock is not None and not self.pressed:
+      self.terminal = True
+      return 0
+
+    reward = 0
+    if self.pressed:
+      self.vy -= 0.06 if rock is not None else 0.11
+      if rock is not None:
+        rock.bore += 1
+        reward += 1
+        if rock.bore >= rock.threshold:
+          reward += rock.threshold + self._blast(15 + (rock.width + rock.height) / 4, 3)
+          self.rocks.remove(rock)
+          rock = None
+    self.vy = min(1.8, max(-1.5, self.vy + 0.05))
+    self.y += self.vy * (0.45 if rock is not None else 1)
+    if self.y < 10:
+      self.y, self.vy = 10, 0
+    if self.was_in_rock and rock is None and self.pressed:
+      reward += self._blast(22, 2)
+    self.was_in_rock = rock is not None
+
+    self._spawn()
+    for obstacle in self.rocks:
+      obstacle.x -= SCROLL
+    self.rocks = [obstacle for obstacle in self.rocks if obstacle.x >= -20]
+    for enemy in self.enemies:
+      enemy.x += enemy.vx
+      if rock is None and math.hypot(enemy.x - PLAYER_X, enemy.y - self.y) < 5:
+        self.terminal = True
+    self.enemies = [enemy for enemy in self.enemies if enemy.x >= -8]
+    self.terminal |= self.y > 91
+    return reward
+
+  def _blast(self, radius: float, freeze: int) -> int:
+    survivors = [enemy for enemy in self.enemies if math.hypot(enemy.x - PLAYER_X, enemy.y - self.y) >= radius]
+    kills = len(self.enemies) - len(survivors)
+    self.enemies = survivors
+    if kills or freeze == 3:
+      self.freeze = max(self.freeze, min(8, freeze + kills))
+    return 3 * kills**2
+
+  def _spawn(self) -> None:
+    self.next_rock -= SCROLL
+    if self.next_rock < 0:
+      self.rocks.append(Rock(112, self.random.uniform(25, 75), self.random.uniform(14, 30), self.random.uniform(10, 22)))
+      self.next_rock = self.random.uniform(30, 55)
+    self.next_enemy -= 1
+    if self.next_enemy < 0:
+      self.enemies.append(Enemy(105, self.random.uniform(8, 84), -SCROLL - self.random.uniform(0.2, 0.5)))
+      self.next_enemy = int(self.random.integers(50, 91))
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row = int(self.y) // 10
+    state[row, 3, 0] = True
+    state[row, 3, 4] = self.pressed
+    state[9, :, 3] = True
+    for rock in self.rocks:
+      for row in range(10):
+        if abs(row * 10 + 5 - rock.y) < rock.height / 2 + 5:
+          for column in range(10):
+            state[row, column, 1] |= abs(column * 10 + 5 - rock.x) < rock.width / 2 + 5
+    for enemy in self.enemies:
+      if 0 <= enemy.x < 100:
+        state[int(enemy.y) // 10, int(enemy.x) // 10, 2] = True
+    active_rock = next((rock for rock in reversed(self.rocks) if rock.contains(self.y)), None)
+    for row, value in enumerate((self.steps, self.freeze, active_rock.bore if active_rock else 0)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    state[9, :2, 5] = self.vy < 0, self.was_in_rock
+    return state

runtime/minatar_synth/games/bottop.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+
+
+@dataclass
+class Spike:
+  x: float
+  y: float
+
+
+class BottopEnvironment:
+  score_cap = HORIZON * FRAMES_PER_STEP / 10
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = 0
+    self.spawn_distance = self.height = self.velocity = 0.0
+    self.jumping = self.pressed = self.terminal = False
+    self.spikes: list[Spike] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() >= self.sticky_action_prob:
+      self.pressed = action == 5
+    self.steps += 1
+    frames = 0
+    for _ in range(FRAMES_PER_STEP):
+      self._advance_frame()
+      frames += 1
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return frames / 10, self.terminal
+
+  def _advance_frame(self) -> None:
+    self.spawn_distance -= 1
+    if self.spawn_distance < 0:
+      if self.random.random() < 0.33:
+        y = float(self.random.choice((8, 92)))
+      else:
+        y = self.random.uniform(8, 92)
+      self.spikes.append(Spike(103, y))
+      self.spawn_distance += self.random.uniform(30, 60)
+    for spike in self.spikes:
+      spike.x -= 1
+    self.spikes = [spike for spike in self.spikes if spike.x > -3]
+
+    if not self.jumping and self.pressed:
+      self.jumping = True
+      self.velocity = 3
+    if self.jumping:
+      self.velocity -= 0.1 if self.pressed else 0.3
+      self.height += self.velocity
+      if self.height < 0:
+        self.height = self.velocity = 0
+        self.jumping = False
+    top, bottom = 8 + self.height, 92 - self.height
+    self.terminal = any(
+      abs(spike.x - 9) < 6 and min(abs(spike.y - top), abs(spike.y - bottom)) < 6
+      for spike in self.spikes
+    )
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[int(8 + self.height) // 10, 0, 0] = True
+    state[int(92 - self.height) // 10, 0, 1] = True
+    for spike in self.spikes:
+      if 0 <= spike.x < 100:
+        state[int(spike.y) // 10, int(spike.x) // 10, 2] = True
+    state[(0, 9), :, 3] = True
+    state[0, :3, 4] = self.pressed, self.jumping, self.velocity > 0
+    for bit in range(9):
+      state[9, bit, 5] = bool(self.steps & (1 << bit))
+    return state

runtime/minatar_synth/games/bowling.py

@@ -0,0 +1,164 @@
+import numpy as np
+
+
+PIN_POSITIONS = ((4, 6), (3, 7), (5, 7), (2, 8), (4, 8), (6, 8), (1, 9), (3, 9), (5, 9), (7, 9))
+
+
+class BowlingEnvironment:
+  """Ten-frame steerable bowling with standard strike, spare, and tenth-frame scoring."""
+
+  score_cap = 300.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 500):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = horizon
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.bowler_row = 4
+    self.ball: list[int] | None = None
+    self.previous_ball: list[int] | None = None
+    self.hook = 0
+    self.standing = set(range(10))
+    self.frames: list[list[int]] = [[] for _ in range(10)]
+    self.frame = 0
+    self.confirmed_score = 0
+    self.steps = 0
+    self.last_action = 0
+    self.terminal = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    if self.ball is None:
+      if action == 2:
+        self.bowler_row = max(1, self.bowler_row - 1)
+      elif action == 4:
+        self.bowler_row = min(7, self.bowler_row + 1)
+      elif action == 5:
+        self.ball = [self.bowler_row, 0]
+        self.previous_ball = self.ball.copy()
+        self.hook = 0
+    else:
+      self.previous_ball = self.ball.copy()
+      if action == 2:
+        self.ball[0] = max(1, self.ball[0] - 1)
+        self.hook = max(-1, self.hook - 1)
+      elif action == 4:
+        self.ball[0] = min(7, self.ball[0] + 1)
+        self.hook = min(1, self.hook + 1)
+      self.ball[1] += 1
+      if self.ball[1] >= 9:
+        previous_score = self.confirmed_score
+        self._finish_roll()
+        self.confirmed_score = self._score_available()
+        reward = float(self.confirmed_score - previous_score)
+        self.steps += 1
+        return reward, self.terminal
+    self.steps += 1
+    if self.steps >= self.horizon:
+      self.terminal = True
+    return 0.0, self.terminal
+
+  def _finish_roll(self) -> None:
+    knocked = self._knocked_pins()
+    self.standing -= knocked
+    pinfall = len(knocked)
+    frame_rolls = self.frames[self.frame]
+    frame_rolls.append(pinfall)
+    self.ball = None
+    self.previous_ball = None
+    self.hook = 0
+    if self.frame < 9:
+      if pinfall == 10 or len(frame_rolls) == 2:
+        self.frame += 1
+        self.standing = set(range(10))
+      return
+    if len(frame_rolls) == 1:
+      if pinfall == 10:
+        self.standing = set(range(10))
+    elif len(frame_rolls) == 2:
+      if frame_rolls[0] == 10:
+        if pinfall == 10:
+          self.standing = set(range(10))
+      elif sum(frame_rolls) == 10:
+        self.standing = set(range(10))
+      else:
+        self.terminal = True
+    else:
+      self.terminal = True
+
+  def _knocked_pins(self) -> set[int]:
+    if not self.standing or self.ball is None:
+      return set()
+    entry_row = self.ball[0]
+    if self.standing == set(range(10)) and entry_row == 4 and self.hook != 0:
+      return self.standing.copy()
+    knocked = {
+      index
+      for index in self.standing
+      if abs(PIN_POSITIONS[index][0] - entry_row) <= 1
+    }
+    if self.hook < 0:
+      knocked |= {index for index in self.standing if PIN_POSITIONS[index][0] < entry_row and abs(PIN_POSITIONS[index][0] - entry_row) <= 2}
+    elif self.hook > 0:
+      knocked |= {index for index in self.standing if PIN_POSITIONS[index][0] > entry_row and abs(PIN_POSITIONS[index][0] - entry_row) <= 2}
+    return knocked
+
+  def _score_available(self) -> int:
+    flattened = [roll for frame in self.frames for roll in frame]
+    score = 0
+    cursor = 0
+    for frame_index in range(9):
+      frame = self.frames[frame_index]
+      if not frame:
+        break
+      if frame[0] == 10:
+        if cursor + 2 >= len(flattened):
+          break
+        score += 10 + flattened[cursor + 1] + flattened[cursor + 2]
+        cursor += 1
+      elif len(frame) == 2 and sum(frame) == 10:
+        if cursor + 2 >= len(flattened):
+          break
+        score += 10 + flattened[cursor + 2]
+        cursor += 2
+      elif len(frame) == 2:
+        score += sum(frame)
+        cursor += 2
+      else:
+        break
+    tenth = self.frames[9]
+    if self.frame == 9 or self.terminal:
+      score += sum(tenth)
+    return score
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[self.bowler_row, 0, 0] = True
+    state[0, :, 1] = True
+    state[9, :, 1] = True
+    for index in self.standing:
+      state[*PIN_POSITIONS[index], 2] = True
+    if self.ball is not None:
+      state[*self.ball, 3] = True
+    if self.previous_ball is not None:
+      state[*self.previous_ball, 4] = True
+    state[9, : self.frame + 1, 5] = True
+    state[8, : min(10, len(self.frames[self.frame]) + 1), 5] = True
+    score_bucket = min(9, self.confirmed_score // 30)
+    state[7, : score_bucket + 1, 5] = True
+    state[6, self.hook + 1, 5] = True
+    return state

runtime/minatar_synth/games/boxing.py

@@ -0,0 +1,147 @@
+import numpy as np
+
+
+DELTAS = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}
+
+
+class BoxingEnvironment:
+  """Two-minute top-down bout with guarded jabs, power punches, and counter windows."""
+
+  score_cap = 100.0
+
+  def __init__(self, sticky_action_prob: float = 0.1, round_steps: int = 120):
+    self.sticky_action_prob = sticky_action_prob
+    self.round_steps = round_steps
+    self.random = np.random.RandomState()
+    self.seed(0)
+    self.reset()
+
+  @classmethod
+  def normalize_score(cls, raw_score: float) -> float:
+    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
+
+  def seed(self, seed: int) -> None:
+    self.random.seed(seed)
+
+  def reset(self) -> None:
+    self.player = [5, 2]
+    self.opponent = [5, 7]
+    self.previous_player = self.player.copy()
+    self.previous_opponent = self.opponent.copy()
+    self.player_score = 0
+    self.opponent_score = 0
+    self.player_recovery = 0
+    self.opponent_recovery = 0
+    self.player_punch: list[int] | None = None
+    self.opponent_punch: list[int] | None = None
+    self.steps = 0
+    self.last_action = 0
+    self.terminal = False
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.rand() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.previous_player = self.player.copy()
+    self.previous_opponent = self.opponent.copy()
+    self.player_punch = None
+    self.opponent_punch = None
+    reward = 0.0
+    if action in DELTAS:
+      self._move(self.player, self.opponent, action)
+    elif action == 5 and self.player_recovery == 0:
+      scored = self._punch(self.player, self.opponent, defender_is_player=False)
+      reward = float(min(scored, 100 - self.player_score))
+      self.player_score += int(reward)
+      self.player_recovery = 2
+    if self.player_score >= 100:
+      self.player_score = 100
+      self.terminal = True
+      return reward, True
+
+    if self.steps < 60 or self.steps % 2 == 0:
+      self._opponent_action()
+    self.player_recovery = max(0, self.player_recovery - 1)
+    self.opponent_recovery = max(0, self.opponent_recovery - 1)
+    self.steps += 1
+    if self.opponent_score >= 100 or self.steps >= self.round_steps:
+      self.opponent_score = min(100, self.opponent_score)
+      self.terminal = True
+    return reward, self.terminal
+
+  @staticmethod
+  def _move(boxer: list[int], other: list[int], action: int) -> None:
+    row_delta, column_delta = DELTAS[action]
+    target = [boxer[0] + row_delta, boxer[1] + column_delta]
+    if 1 <= target[0] <= 8 and 1 <= target[1] <= 8 and target != other:
+      boxer[:] = target
+
+  def _punch(self, attacker: list[int], defender: list[int], defender_is_player: bool) -> int:
+    row_distance = abs(attacker[0] - defender[0])
+    column_distance = abs(attacker[1] - defender[1])
+    distance = max(row_distance, column_distance)
+    if distance > 2:
+      return 0
+    recovery = self.player_recovery if defender_is_player else self.opponent_recovery
+    angled = row_distance > 0 and column_distance > 0
+    if not angled and recovery == 0:
+      return 0
+    points = 2 if distance == 1 else 1
+    punch_cell = [
+      attacker[0] + int(np.sign(defender[0] - attacker[0])),
+      attacker[1] + int(np.sign(defender[1] - attacker[1])),
+    ]
+    if defender_is_player:
+      self.opponent_punch = punch_cell
+    else:
+      self.player_punch = punch_cell
+    self._push(attacker, defender)
+    return points
+
+  @staticmethod
+  def _push(attacker: list[int], defender: list[int]) -> None:
+    row_delta = int(np.sign(defender[0] - attacker[0]))
+    column_delta = int(np.sign(defender[1] - attacker[1]))
+    target = [
+      int(np.clip(defender[0] + row_delta, 1, 8)),
+      int(np.clip(defender[1] + column_delta, 1, 8)),
+    ]
+    if target != attacker:
+      defender[:] = target
+
+  def _opponent_action(self) -> None:
+    row_distance = abs(self.opponent[0] - self.player[0])
+    column_distance = abs(self.opponent[1] - self.player[1])
+    if max(row_distance, column_distance) <= 2 and self.opponent_recovery == 0:
+      self.opponent_score += self._punch(self.opponent, self.player, defender_is_player=True)
+      self.opponent_recovery = 2
+      return
+    candidates = []
+    for action in DELTAS:
+      row_delta, column_delta = DELTAS[action]
+      target = [self.opponent[0] + row_delta, self.opponent[1] + column_delta]
+      if not (1 <= target[0] <= 8 and 1 <= target[1] <= 8) or target == self.player:
+        continue
+      distance = max(abs(target[0] - self.player[0]), abs(target[1] - self.player[1]))
+      angled_bonus = -1 if target[0] != self.player[0] and target[1] != self.player[1] else 0
+      candidates.append((distance + angled_bonus, self.random.rand(), action))
+    if candidates:
+      self._move(self.opponent, self.player, min(candidates)[2])
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[*self.player, 0] = True
+    state[*self.opponent, 1] = True
+    state[*self.opponent, 2] = True
+    if self.player_punch is not None:
+      state[*self.player_punch, 3] = True
+    state[*self.previous_player, 4] = True
+    state[*self.previous_opponent, 4] = True
+    state[9, : min(10, (self.player_score + 9) // 10), 5] = True
+    state[8, : min(10, (self.opponent_score + 9) // 10), 5] = True
+    remaining = max(0, self.round_steps - self.steps)
+    state[7, : min(10, (remaining + 11) // 12), 5] = True
+    state[6, : self.player_recovery, 5] = True
+    return state

runtime/minatar_synth/games/breed_c.py

@@ -0,0 +1,138 @@
+import numpy as np
+
+
+SIZE = 9
+CENTER = SIZE // 2
+EMPTY = -1
+HORIZON = 400
+GROWTH_INTERVAL = 30
+SETTLE_DELAY = 15
+DIRECTIONS = ((0, -1), (-1, 0), (1, 0), (0, 1))
+
+
+class BreedCEnvironment:
+  score_cap = 250
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = self.growth_count = self.settle = self.clears = 0
+    self.multiplier = 1
+    self.timer = GROWTH_INTERVAL
+    self.terminal = False
+    self.cursor = CENTER, CENTER
+    self.grid = np.full((SIZE, SIZE), EMPTY, dtype=np.int8)
+    self.grid[CENTER, CENTER] = self.random.integers(4)
+    self._grow()
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    select = action == 5 and self.last_action != 5
+    self.last_action = action
+    self.steps += 1
+    reward = 0
+    if 1 <= action <= 4:
+      dy, dx = DIRECTIONS[action - 1]
+      y, x = self.cursor
+      self.cursor = min(SIZE - 1, max(0, y + dy)), min(SIZE - 1, max(0, x + dx))
+    if self.settle:
+      self.settle -= 1
+      if not self.settle:
+        self._compact()
+        self.clears += 1
+        self.timer = GROWTH_INTERVAL
+    else:
+      if self.grid[CENTER, CENTER] == EMPTY:
+        self.grid[CENTER, CENTER] = self.random.integers(4)
+      if select:
+        reward = self._erase()
+      if not self.settle:
+        self.timer -= 1
+        if self.timer <= 0:
+          self._grow()
+    self.terminal = self.steps >= self.horizon or bool(np.all(self.grid != EMPTY))
+    return float(reward), self.terminal
+
+  def _erase(self) -> int:
+    color = self.grid[self.cursor]
+    group = set()
+    if color != EMPTY:
+      group.add(self.cursor)
+      pending = [self.cursor]
+      while pending:
+        y, x = pending.pop()
+        for dy, dx in DIRECTIONS:
+          ny, nx = y + dy, x + dx
+          neighbor = ny, nx
+          if 0 <= ny < SIZE and 0 <= nx < SIZE and neighbor not in group and self.grid[neighbor] == color:
+            group.add(neighbor)
+            pending.append(neighbor)
+    size = len(group)
+    if size < 4:
+      self._grow()
+      self._grow()
+      return -size
+    for cell in group:
+      self.grid[cell] = EMPTY
+    reward = size * self.multiplier
+    self.multiplier += 1
+    self.settle = SETTLE_DELAY
+    return reward
+
+  def _grow(self) -> None:
+    lines = self.grid if self.growth_count % 2 == 0 else self.grid.T
+    old = lines.copy()
+    lines[:, :CENTER - 1] = old[:, 1:CENTER]
+    lines[:, CENTER + 2:] = old[:, CENTER + 1:-1]
+    for line in lines:
+      color = int(line[CENTER])
+      if color != EMPTY:
+        direction = int(self.random.choice((-1, 1)))
+        new_color = (color + int(self.random.integers(3))) % 4
+        line[CENTER - direction] = color
+        line[CENTER] = line[CENTER + direction] = new_color
+    self.growth_count += 1
+    self.multiplier = 1
+    self.timer = GROWTH_INTERVAL
+
+  def _compact(self) -> None:
+    axes = (self.grid, self.grid.T)
+    if self.clears % 2:
+      axes = axes[::-1]
+    moved = True
+    while moved:
+      moved = False
+      for lines in axes:
+        for line in lines:
+          for start, stop, step in ((CENTER, 0, -1), (CENTER, SIZE - 1, 1)):
+            for index in range(start, stop, step):
+              source = index + step
+              if line[index] == EMPTY and line[source] != EMPTY:
+                line[index], line[source] = line[source], EMPTY
+                moved = True
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    for color in range(4):
+      state[:SIZE, :SIZE, color] = self.grid == color
+    state[*self.cursor, 4] = True
+    for row, value in enumerate((self.steps, self.timer, self.settle, self.multiplier)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    state[9, 0, 5] = self.last_action == 5
+    state[9, 1, 5] = self.growth_count % 2 == 1
+    return state

runtime/minatar_synth/games/bridge_cross.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+BRIGADE_LEFT = 10
+BRIGADE_RIGHT = 40
+BRIDGE_TOP = 32
+GROUND = 37
+
+
+@dataclass
+class Bridge:
+  x: float
+  length: float
+
+  def overlaps_brigade(self) -> bool:
+    return self.x <= BRIGADE_RIGHT and self.x + self.length >= BRIGADE_LEFT
+
+
+class BridgeCrossEnvironment:
+  score_cap = 500
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.score_timer = 0
+    self.spawn_timer = 0.0
+    self.multiplier = 1
+    self.y, self.vy = float(GROUND), 0.0
+    self.pressed = self.jumping = self.falling = self.on_bridge = self.terminal = False
+    self.bridges: list[Bridge] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
+    tap = pressed and not self.pressed
+    self.pressed = pressed
+    self.steps += 1
+    reward = 0
+    for frame in range(FRAMES_PER_STEP):
+      reward += self._advance_frame(tap and frame == 0)
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self, tap: bool) -> int:
+    if self.spawn_timer <= 0:
+      self.bridges.append(Bridge(153, self.random.uniform(20, 40)))
+      self.spawn_timer = self.random.uniform(50, 100)
+    self.spawn_timer -= 1
+    for bridge in self.bridges:
+      bridge.x -= 1
+    self.bridges = [bridge for bridge in self.bridges if bridge.x + bridge.length > 0]
+    above_bridge = any(bridge.overlaps_brigade() for bridge in self.bridges)
+
+    if self.y < 35 and not above_bridge:
+      self.falling, self.on_bridge = True, False
+    if self.jumping or self.falling:
+      self.y += self.vy
+      self.vy += 0.1 if self.pressed else 0.2
+      surface = BRIDGE_TOP if above_bridge else GROUND
+      if self.y > surface and self.vy > 0:
+        self.y, self.vy = float(surface), 0.0
+        self.jumping = self.falling = False
+        self.on_bridge = above_bridge
+
+    if tap and not self.jumping:
+      self.jumping, self.on_bridge = True, False
+      self.vy = -2
+      self.multiplier = math.ceil(self.multiplier / 2)
+    if not self.jumping and self.y > BRIDGE_TOP and above_bridge:
+      self.terminal = True
+
+    if self.on_bridge:
+      self.score_timer -= 1
+      if self.score_timer < 0:
+        reward = self.multiplier
+        self.multiplier += 1
+        self.score_timer = 10
+        return reward
+    return 0
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    row = int(self.y) // 5
+    state[row, :3, 0] = True
+    state[row, :3, 3] = self.on_bridge
+    state[8:, :, 2] = True
+    for bridge in self.bridges:
+      for column in range(10):
+        state[7, column, 1] |= column * 15 < bridge.x + bridge.length and (column + 1) * 15 > bridge.x
+    state[0, :3, 4] = self.pressed, self.jumping, self.vy < 0
+    for row, value in enumerate((self.steps, self.multiplier, self.score_timer)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/bs_fish.py

@@ -0,0 +1,111 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+HORIZON = 400
+SPAWN_INTERVAL = 8
+MAX_FISH = (HORIZON // SPAWN_INTERVAL) * 13
+BIRD_ROW = 2
+NORMAL, BIG, FAKE, EYE = range(4)
+FLIGHT = (8, 7, 6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+FRAGMENTS = ((0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3),
+             (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 5))
+
+
+@dataclass
+class Fish:
+  column: int
+  kind: int = NORMAL
+  age: int = 0
+  row_offset: int = 0
+
+  @property
+  def row(self) -> int:
+    return max(0, min(9, FLIGHT[self.age] + self.row_offset))
+
+
+class BSFishEnvironment:
+  score_cap = MAX_FISH * (1 + 5 * (MAX_FISH - 1))
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = self.speed = 0
+    self.multiplier = 1
+    self.special_in = 3
+    self.fish: list[Fish] = []
+    self.terminal = False
+
+  @property
+  def bird_column(self) -> int:
+    return 1 + self.speed // 2
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    self.last_action = action
+    self.steps += 1
+    self.speed = min(6, self.speed + 1) if action == 5 else max(0, self.speed - 1)
+    if self.steps % SPAWN_INTERVAL == 1:
+      if self.special_in == 0:
+        kind = int(self.random.choice((BIG, FAKE)))
+        self.special_in = int(self.random.integers(3, 9))
+      else:
+        kind = NORMAL
+        self.special_in -= 1
+      self.fish.append(Fish(int(self.random.integers(7, 10)), kind))
+    reward = 0
+    remaining = []
+    for fish in self.fish:
+      fish.age += 1
+      if self.speed >= 4 or self.steps % 3 == 0:
+        fish.column -= 1
+      if fish.age == len(FLIGHT) or fish.column < -1:
+        if fish.kind != BIG:
+          self.multiplier = max(1, self.multiplier - 1)
+        continue
+      if fish.kind == FAKE and fish.row <= 5:
+        remaining.extend(Fish(fish.column + column - 2, EYE if (row, column) == (1, 2) else NORMAL,
+                              fish.age, row - 1) for row, column in FRAGMENTS)
+      elif fish.kind == BIG:
+        if abs(fish.row - BIRD_ROW) <= 1 and abs(fish.column - self.bird_column) <= 1:
+          self.terminal = True
+        remaining.append(fish)
+      elif fish.row == BIRD_ROW and fish.column == self.bird_column:
+        reward += self.multiplier
+        self.multiplier += 10 if fish.kind == EYE else 1
+      else:
+        remaining.append(fish)
+    self.fish = remaining
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    state[BIRD_ROW, self.bird_column, 0] = True
+    for fish in self.fish:
+      if 0 <= fish.column < 10:
+        channel = (2, 1, 1, 3)[fish.kind]
+        state[fish.row, fish.column, channel] = True
+        next_row = FLIGHT[min(fish.age + 1, len(FLIGHT) - 1)] + fish.row_offset
+        if 0 <= next_row < 10:
+          state[next_row, fish.column, 4] = True
+    for row, value in enumerate((self.steps, self.speed, self.multiplier, self.special_in, self.last_action)):
+      for bit in range(13):
+        index = row * 13 + bit
+        state[index // 10, index % 10, 5] = bool(value & (1 << bit))
+    return state

runtime/minatar_synth/games/c_nodes.py

@@ -0,0 +1,165 @@
+from dataclasses import dataclass
+import math
+
+import numpy as np
+
+
+HORIZON = 400
+FRAMES_PER_STEP = 4
+DIRECTIONS = ((0, -1), (-1, 0), (1, 0), (0, 1))
+
+
+@dataclass(eq=False)
+class Node:
+  x: float
+  y: float
+  vx: float = 0
+  vy: float = 0
+  anchored: bool = True
+  tethered: bool = False
+
+
+@dataclass
+class Link:
+  a: Node
+  b: Node
+  length: float
+
+  def near(self, x: float, y: float) -> bool:
+    dx, dy = self.b.x - self.a.x, self.b.y - self.a.y
+    px, py = x - self.a.x, y - self.a.y
+    squared = dx * dx + dy * dy
+    fraction = min(1, max(0, (px * dx + py * dy) / squared)) if squared else 0
+    return math.hypot(px - fraction * dx, py - fraction * dy) <= 5
+
+
+class CNodesEnvironment:
+  score_cap = 500
+
+  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
+    self.sticky_action_prob = sticky_action_prob
+    self.horizon = min(horizon, HORIZON)
+    self.seed(0)
+    self.reset()
+
+  def seed(self, seed: int) -> None:
+    self.random = np.random.default_rng(seed)
+
+  def reset(self) -> None:
+    self.steps = self.last_action = 0
+    self.multiplier = 1
+    self.next_node = self.boost = 0.0
+    self.cursor = (3, 5)
+    self.terminal = False
+    self.nodes: list[Node] = []
+    self.links: list[Link] = []
+
+  @classmethod
+  def normalize_score(cls, score: float) -> float:
+    return min(max(score, 0), cls.score_cap) / cls.score_cap
+
+  def act(self, action: int) -> tuple[float, bool]:
+    if self.terminal:
+      return 0.0, True
+    if self.random.random() < self.sticky_action_prob:
+      action = self.last_action
+    if 1 <= action <= 4:
+      dy, dx = DIRECTIONS[action - 1]
+      row, col = self.cursor
+      self.cursor = min(9, max(2, row + dy)), min(9, max(0, col + dx))
+    if action == 5 and self.last_action != 5:
+      row, col = self.cursor
+      self.links = [link for link in self.links if not link.near(col * 10 + 5, row * 10 + 5)]
+      self.multiplier = 1
+      self.boost = 1
+    self.last_action = action
+    self.steps += 1
+    reward = 0
+    for _ in range(FRAMES_PER_STEP):
+      reward += self._advance_frame()
+      if self.terminal:
+        break
+    self.terminal |= self.steps >= self.horizon
+    return float(reward), self.terminal
+
+  def _advance_frame(self) -> int:
+    lowest = max((node.y for node in self.nodes), default=0)
+    scroll = 0.03 + self.boost + max(0, 29 - lowest) * 0.1
+    self.boost *= 0.7
+    self.next_node -= scroll
+    if self.next_node < 0:
+      new = Node(self.random.uniform(10, 90), 0)
+      for node in self.nodes:
+        if node.anchored and abs(new.x - node.x) / 2 + abs(node.y) < 30 and self.random.random() < 0.7:
+          self.links.append(Link(new, node, math.hypot(new.x - node.x, node.y)))
+      self.nodes.append(new)
+      self.next_node = 4
+    for link in self.links:
+      dx, dy = link.b.x - link.a.x, link.b.y - link.a.y
+      distance = math.hypot(dx, dy)
+      if distance:
+        force = (distance - link.length) * 0.02 / distance
+        link.a.vx += force * dx
+        link.a.vy += force * dy
+        link.b.vx -= force * dx
+        link.b.vy -= force * dy
+    for node in self.nodes:
+      node.y += scroll
+      node.anchored &= node.y <= 20
+      if node.anchored:
+        node.vx = node.vy = 0
+      else:
+        node.x += node.vx
+        node.y += node.vy
+        node.vx *= 0.95
+        node.vy = (node.vy + 0.03) * 0.95
+    self.links = [link for link in self.links if min(link.a.y, link.b.y) <= 100]
+    self._update_tethers()
+    reward = 0
+    survivors = []
+    for node in self.nodes:
+      if node.tethered and node.y > 100:
+        self.terminal = True
+      if node.y > 140:
+        reward += self.multiplier
+        self.multiplier = min(64, self.multiplier * 2)
+      else:
+        survivors.append(node)
+    self.nodes = survivors
+    alive = set(survivors)
+    self.links = [link for link in self.links if link.a in alive and link.b in alive]
+    return reward
+
+  def _update_tethers(self) -> None:
+    connected = {node: [] for node in self.nodes}
+    for link in self.links:
+      connected[link.a].append(link.b)
+      connected[link.b].append(link.a)
+    pending = [node for node in self.nodes if node.anchored]
+    reached = set(pending)
+    while pending:
+      for neighbor in connected[pending.pop()]:
+        if neighbor not in reached:
+          reached.add(neighbor)
+          pending.append(neighbor)
+    for node in self.nodes:
+      node.tethered = node in reached and not node.anchored
+
+  def state(self) -> np.ndarray:
+    state = np.zeros((10, 10, 6), dtype=bool)
+    for node in self.nodes:
+      if 0 <= node.x < 100 and 0 <= node.y < 100:
+        channel = 0 if node.anchored else 1 if node.tethered else 2
+        state[int(node.y) // 10, int(node.x) // 10, channel] = True
+    for link in self.links:
+      for fraction in np.linspace(0, 1, 12):
+        x = link.a.x + (link.b.x - link.a.x) * fraction
+        y = link.a.y + (link.b.y - link.a.y) * fraction
+        if 0 <= x < 100 and 0 <= y < 100:
+          state[int(y) // 10, int(x) // 10, 3] = True
+    row, col = self.cursor
+    state[row, col, 4] = True
+    for row, value in enumerate((self.steps, self.multiplier, self.last_action)):
+      for bit in range(9):
+        state[row, bit, 5] = bool(value & (1 << bit))
+    return state