Pith. sign in

REVIEW 4 major objections 5 minor 16 references

The paper introduces Octax, a GPU-vectorized CHIP-8 emulator that claims 350,000 environment steps per second with 8,192 parallel games, and shows PPO agents learning across 16 arcade games.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-04 12:48 UTC pith:5GJRCNDG

load-bearing objection A genuinely useful JAX/GPU CHIP-8 arcade suite with credible throughput, but the fidelity and LLM-gradient claims need dialing back. the 4 major comments →

arxiv 2510.01764 v3 pith:5GJRCNDG submitted 2025-10-02 cs.LG

Octax: Accelerated CHIP-8 Arcade Environments for Reinforcement Learning in JAX

Waris Radji , Thomas Michel , Hector Piteau This is my paper
classification cs.LG
keywords CHIP-8 emulationJAXreinforcement learningGPU-accelerated environmentsarcade game benchmarksPPOLLM-generated environmentsparallel RL environments
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Octax is a JAX-based emulator for CHIP-8, a 1970s virtual machine whose simple instruction set and 4KB memory footprint let thousands of game instances run in parallel on a GPU. The paper argues this gives reinforcement learning a much-needed end-to-end GPU alternative to Atari-style arcade benchmarks, reaching about 350,000 environment steps per second (1.4 million frames) on consumer hardware—a 14x throughput advantage over a CPU-hosted arcade environment. The authors show PPO agents learn across 16 games with 12 seeds each, producing distinct learning profiles, and demonstrate an LLM pipeline that generates new CHIP-8 games with controlled difficulty. The payoff, if the claims hold, is that many-seed experiments and sweeps that once took weeks can run in hours on a single GPU.

Core claim

The core claim is that CHIP-8's constrained architecture—64x32 graphics, 35 instructions, deterministic execution—can be vectorized in JAX to create authentic image-based RL environments at massive scale, without losing the original game mechanics. Octax wraps ROMs with per-game score functions, termination predicates, action sets, and startup instruction sequences, then runs a vectorized fetch-decode-execute loop on GPU. On an RTX 3090 it sustains 350,000 environment steps per second across 8,192 parallel instances, scaling near-linearly, and PPO training over 5 million timesteps produces meaningful learning curves across the suite. The authors also show that LLMs can generate complete CHIP

What carries the argument

The engine is a JAX-vectorized CHIP-8 emulator. Each of the 35 opcodes becomes a pure function over an immutable emulator state, dispatched via a switch so that thousands of instances advance together on the GPU. Game-specific RL semantics live in four small components: score_fn reads the register or memory location that encodes score (for example, BCD-encoded player advantage in Pong's V14), terminated_fn reads game-over registers or compound conditions, action_set restricts the 16-key pad to the relevant keys, and startup_instructions auto-play menu screens. The LLM generation pipeline works by imposing the same register-mapping contract on generated assembly, so score and termination are

Load-bearing premise

The load-bearing premise is that each game's score function, termination predicate, action set, and startup sequence correctly encode the original game's objective, and that 4-frame-skip emulation at a fixed 700 Hz instruction rate preserves authentic mechanics; for several games the reward and termination logic came from LLM analysis of decompiled assembly rather than verification against a reference interpreter.

What would settle it

Run the same CHIP-8 ROMs on a reference interpreter and Octax side by side, comparing register values, memory, and framebuffer after fixed instruction counts for every opcode and game; any divergence would refute the fidelity claim. Alternatively, if replacing a hand-written score_fn with one that reads a different register yields better PPO returns, or if reverting to variable instruction timing changes the learning curves, the environment dynamics are not faithfully the original games.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

Share X Bluesky LinkedIn Reddit HN

If this is right

  • Many-seed, large-scale RL experiments on arcade-like image environments become practical on a single consumer GPU; the paper's 16-game, 12-seed PPO study ran as 24 concurrent sessions on one A100.
  • Near-linear scaling to 8,192 environments means hyperparameter sweeps and ablations that would be prohibitive with CPU emulators are feasible at 350,000 steps per second.
  • Because Octax executes real .ch8 ROMs rather than simplified reimplementations, the same games can be used as a fast CHIP-8-compatible environment layer if the fidelity claim holds.
  • The suite spans puzzle, action, strategy, exploration, and shooter genres with dense and sparse rewards, giving researchers a diverse, unified benchmark for comparing learning dynamics.
  • LLM-generated games with fixed register conventions yield reproducible difficulty gradients, opening a concrete path to curriculum and open-ended environment generation.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • An editorial extension: the register-mapping contract used for LLM generation could be turned into a formal specification, allowing automated verification of score and termination functions against a reference interpreter—something the paper leaves open.
  • An editorial extension: because the paper does not differential-test against a reference CHIP-8 interpreter, the most direct stress test is to compare register and framebuffer states after fixed instruction counts; if timing artifacts matter, learning curves could shift under authentic variable instruction timing.
  • An editorial extension: the same vectorized emulation approach could be carried to CHIP-8 successors such as Super-CHIP-8 and XO-CHIP for color and higher-resolution games, but that would require rebalancing the fixed 700 Hz timing assumption.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The manuscript introduces OCTAX, a JAX-based vectorized CHIP-8 emulator packaged as an RL environment suite for 21 classic arcade games. The central claims are: (i) throughput of about 350,000 environment steps per second (1.4 million frames per second) with 8,192 parallel environments on an RTX 3090, corresponding to a 14x speedup over EnvPool; (ii) PPO agents display varied learning behavior across 16 games, evaluated with IQM and confidence intervals over 12 seeds; and (iii) an LLM-assisted pipeline can generate new CHIP-8 games with a progressive difficulty gradient. The paper also releases code and data.

Significance. If the fidelity and reward-extraction concerns are resolved, this is a valuable infrastructure contribution. The throughput measurements are carefully executed (50 repetitions, multiple parallelization levels), the learning evaluation is above the field's usual practice (12 seeds, IQM, confidence intervals), and the open-source release plus LLM-based environment generation are concrete strengths. However, the abstract's 'perfect fidelity to the original game mechanics' is currently asserted rather than demonstrated, and the reward/termination functions underlying the learning curves are not independently validated. Because those functions support the paper's main 'meaningful RL learning' claim, the contribution is not yet fully established.

major comments (4)
  1. [Abstract; Section 3.2] The abstract and Section 5 claim 'perfect fidelity to the original game mechanics', but no differential test against a reference CHIP-8 interpreter or original hardware is reported. The fixed 700 Hz instruction rate, 4-frame skip, and startup_instructions are emulation choices that can alter input timing, collisions, and menu behavior. Moreover, Appendix B.2.4 states that Cavern is 'modified for leftward exploration', so not all environments are stock ROMs. Please add a validation protocol: run the same ROMs in a reference interpreter under scripted action sequences and compare framebuffer and score/termination traces, and clearly disclose which environments are modified. Without this, the fidelity claim is not supported.
  2. [Section 3.3; Section 4.3] The learning curves in Figure 3 rest on score_fn and terminated_fn correctly encoding each game's objective. Section 4.3 acknowledges that for several games the reward and termination logic 'proved difficult to extract through manual analysis' and that LLMs were used on decompiled assembly. The Pong formula `score = (V[14] // 10) - (V[14] % 10)` is a non-obvious encoding, and no independent verification is provided. If a score register or termination flag is misidentified, the curves reflect reward misspecification rather than agent competence. Please provide per-game validation (e.g., human-play score traces, instrumentation of a reference interpreter, or known ROM invariants) and list which games used LLM extraction. This is load-bearing for the central RL claim.
  3. [Section 4.2] The throughput result is benchmarked on Pong only, yet the text states that 'since all environments execute identical CHIP-8 computational cycles, these performance measurements apply uniformly across the entire game suite.' This is not accurate: instruction mixes vary by game, and Section 5 itself notes the cost depends on the slowest instruction among CHIP-8's 35 operations. The 14x speedup versus EnvPool is therefore demonstrated only for Pong. Please report throughput on a representative set of games or explicitly scope the claim as Pong-specific.
  4. [Section 4.1; Figure 3] To support the interpretation of 'meaningful RL learning' and 'cognitive diversity', the learning curves need a random-policy baseline and, where possible, human/reference scores. Several games show very small absolute returns (e.g., Tetris at 0.00-0.02, Worm at 0-1 in Figure 3), so without a baseline it is hard to tell whether 'rapid plateau' reflects genuine task mastery or a trivial reward signal. Random-policy returns are inexpensive to collect in OCTAX and would materially strengthen the claim.
minor comments (5)
  1. [Section 4.3; Figure 6] The 'meaningful difficulty gradient' is partly built into the LLM prompts: Level 2 is specified as time-limited and Level 3 as moving plus time-limited. The RL results confirm this ordering, but the claim should be phrased as a proof-of-concept that LLM-generated descriptions translate into performance differences, not as evidence of a general difficulty-calibration mechanism.
  2. [Section 3.2] The default frame-skip value is never stated numerically. Please specify the exact number of frames per step and how it interacts with the 60 Hz timer rate.
  3. [Introduction] Typos: 'First, we present the our end-to-end' should be 'we present our'; '1,4M frames' should be '1.4M'; the reference to 'Appendix 4' should be 'Appendix C'.
  4. [Section 2; Section 4.2] The related work cites EnvPool achieving up to 1M Atari frames per second, while the benchmark shows EnvPool plateauing around 25,000 steps per second. Please clarify whether the comparison uses the same frame-skip definition and whether the 25k value refers to steps or frames, so readers can reconcile the numbers.
  5. [Appendix B.1] The score-detection methodology is described qualitatively. Please provide the number of games extracted by static analysis vs. dynamic monitoring vs. LLM assistance, and any manual verification performed.

Circularity Check

1 steps flagged

Central throughput and PPO learnability claims are externally anchored; only the LLM 'difficulty gradient' conclusion largely restates the prompt-specified difficulty order.

specific steps
  1. renaming known result [Section 4.3, Target Shooter case study / Figure 6; pipeline Step 7 (same section)]
    "The inverse relationship between difficulty level and both final performance and sample efficiency indicates that our LLM-generated environments successfully create a meaningful difficulty gradient. [Pipeline Step 7:] the game description is augmented to increase difficulty or introduce new challenges."

    The difficulty levels being 'validated' are not discovered; their ordering is an input to the generation pipeline. Step 7 says the description is augmented to increase difficulty, and the case study fixes Level 1 as static, Level 2 as time-limited, Level 3 as moving+time-limited. The reward and termination signals come from registers V[2]/V[3] that the generated game was explicitly instructed to maintain, so the observed PPO ordering (returns 10.0 > 9.0 > 8.0) re-detects the prompt-specified difficulty order through the game's own score. No independent difficulty metric (e.g., human play, external validation) is used to establish 'meaningful.' The conclusion is therefore largely a restatement of the designed task order rather than an independent first-principles result.

full rationale

The paper's main throughput claim (350,000 steps/s versus EnvPool's ~25,000 steps/s, a 14x improvement) is an external benchmark measured on a consumer GPU against a standard baseline, so it is not circular. The PPO learning curves across 16 games are empirical training results, and the manual/LLM-derived score and termination functions are unvalidated but not fitted-to-prediction circularities. There is no load-bearing self-citation, uniqueness-theorem import, or ansatz smuggled via citation. The sole partial circularity is in Section 4.3: the 'meaningful difficulty gradient' is presented as a property of LLM-generated environments, but the difficulty ordering was specified in the prompts and the reward/termination registers were generated by the same process, so the Figure 6 stratification mostly confirms the designed order. This is a peripheral interpretive claim rather than a reduction of the central benchmark or learnability claims, hence the modest score of 3.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 0 invented entities

Octax is an engineering paper, so the ledger is dominated by engineering choices rather than theoretical postulates. No invented entities. The implicit debts: (1) 'perfect fidelity' is assumed without a conformance test; (2) per-game reward/termination encodings are assumed correct despite the paper's own admission that several were hard to extract; (3) the throughput comparison assumes EnvPool/ALE is the right CPU baseline. These are the entries the authors would need to validate to make the strongest claims robust.

free parameters (4)
  • PPO hyperparameter set (grid-searched on Pong) = lr=5e-4, 512 envs, rollout 32, 32 minibatches, 4 epochs
    Appendix C grid search on Pong only, then applied to all 16 games and the 3 LLM games; the learning-curve claims depend on this config transferring.
  • Per-game score/termination/action encodings
    Hand- or LLM-derived per game (Section 3.3, Appendices B/D); e.g., Pong reward = (V14//10)-(V14%10). Wrong encodings would invalidate Figure 3.
  • Frame skip and observation stacking = 4 frames; 4-channel stack
    RL-facing time resolution; 'fidelity' and learning dynamics are conditional on these choices (Section 3.2).
  • Emulated instruction frequency = 700 Hz
    Fixed-rate timing asserted as authentic (Section 3.2); original CHIP-8 systems ran at varying speeds, so this is a modeling choice.
axioms (5)
  • domain assumption The JAX emulator's instruction semantics match the CHIP-8 specification (Weisbecker 1978 / Octo conventions) used by the 21 ROMs.
    Invoked in Section 3.2 fetch-decode-execute description; correctness of all environment dynamics rests on this.
  • ad hoc to paper The games' original mechanics are preserved under 4-frame-skip, fixed-rate (700 Hz) emulation with menu-bypass startup sequences.
    Section 3.2 and Section 5 claim 'perfect behavioral fidelity'; no differential test against a reference interpreter is reported.
  • domain assumption CHIP-8 games impose 'similar cognitive demands to Atari' and therefore transfer as an RL benchmark.
    Sections 1 and 3.1 justify the benchmark value; this underpins the significance of the suite.
  • domain assumption EnvPool/ALE Pong is a representative CPU baseline for the throughput comparison.
    Section 4.2, Figure 4; the 14x claim is specific to this hardware (RTX 3090, i7 20 cores) and this comparison, and EnvPool's own paper reports far higher ALE throughput on high-end hardware.
  • domain assumption Scoring and termination registers were correctly identified for each of the 16 trained games.
    Section 3.3 and Appendix B static/dynamic analysis; Section 4.3 admits several games needed LLM extraction because manual analysis was difficult.

pith-pipeline@v1.3.0-alltime-deepseek · 18999 in / 19707 out tokens · 138948 ms · 2026-08-04T12:48:33.454406+00:00 · methodology

0 comments
Cite this review

Pith. "Pith review of Octax: Accelerated CHIP-8 Arcade Environments for Reinforcement Learning in JAX." pith.science (2026). https://pith.science/paper/5GJRCNDG

@misc{pith2026251001764,
  author       = {Pith},
  title        = {Pith review of: Octax: Accelerated CHIP-8 Arcade Environments for Reinforcement Learning in JAX},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5GJRCNDG}},
  note         = {Machine review of arXiv:2510.01764}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Reinforcement learning (RL) research requires diverse, challenging environments that are both tractable and scalable. While modern video games may offer rich dynamics, they are computationally expensive and poorly suited for large-scale experimentation due to their CPU-bound execution. We introduce Octax, a high-performance suite of classic arcade game environments implemented in JAX, based on CHIP-8 emulation, a predecessor to Atari, which is widely adopted as a benchmark in RL research. Octax provides the JAX community with a long-awaited end-to-end GPU alternative to Atari games, offering image-based environments, spanning puzzle, action, and strategy genres, all executable at massive scale on modern GPUs. Our JAX-based implementation achieves orders-of-magnitude speedups over traditional CPU emulators. We demonstrate Octax's capabilities by training RL agents across multiple games, showing significant improvements in training speed and scalability compared to existing solutions. The environment's modular design enables researchers to easily extend the suite with new games or generate novel environments using large language models, making it an ideal platform for large-scale RL experimentation. Our open-source framework is available at https://github.com/riiswa/octax/.

Figures

Figures reproduced from arXiv: 2510.01764 by Hector Piteau, Thomas Michel, Waris Radji.

Figure 1
Figure 1. Figure 1: Overview of CHIP-8 game environments implemented in [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: OCTAX architecture: ROM loading, CHIP-8 emulation pipeline, and RL environment integration. The system transforms game ROMs through fetch-decode-execute cycles into vectorized JAX operations suitable for GPU acceleration. This section presents our JAX implementation of CHIP-8 emulation. We detail the design deci￾sions that enable GPU acceleration while maintaining behavioral fidelity to original games, and… view at source ↗
Figure 3
Figure 3. Figure 3: PPO learning curves across 16 games: Interquartile Mean (IQM) returns using 10th-90th percentile ranges [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Performance scaling of OCTAX and EnvPool across parallelization levels. The solid purple line is the number of steps per second (higher is better), and the dashed green line is the total execution time in seconds (lower is better). ronment counts, with 50 independent measurements per configuration. The primary metric is environment steps per second, calculated as (number of environments × 100 steps) divide… view at source ↗
Figure 5
Figure 5. Figure 5: Rendering of the Target Shooter game, gen [PITH_FULL_IMAGE:figures/full_fig_p007_5.png] view at source ↗
Figure 7
Figure 7. Figure 7: Environment generation pipeline. Automated environment generation pipeline. Our pipeline consists of seven replica￾ble steps for automatic CHIP-8 game generation. In Step 1, we construct a corpus of CHIP-8 tutorials, documentation, and programming examples, ensuring the LLM under￾stands the architecture’s instruction set, memory layout, and common coding patterns. In Step 2, we embed this corpus into a pro… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

16 extracted references · 15 linked inside Pith

  1. [7]

    Benchmarking the spectrum of agent capabilities.arXiv preprint arXiv:2109.06780,

    Danijar Hafner. Benchmarking the spectrum of agent capabilities.arXiv preprint arXiv:2109.06780,

    Pith/arXiv arXiv

  2. [9]

    Viktor Makoviychuk, Lukasz Wawrzyniak, Yunrong Guo, Michelle Lu, Kier Storey, Miles Macklin, David Hoeller, Nikita Rudin, Arthur Allshire, Ankur Handa, et al

    URLhttps://github.com/keraJLi/rejax. Viktor Makoviychuk, Lukasz Wawrzyniak, Yunrong Guo, Michelle Lu, Kier Storey, Miles Macklin, David Hoeller, Nikita Rudin, Arthur Allshire, Ankur Handa, et al. Isaac gym: High performance gpu-based physics simulation for robot learning.arXiv preprint arXiv:2108.10470,

    Pith/arXiv arXiv

  3. [10]

    Adastop: adaptive statistical testing for sound comparisons of deep rl agents.arXiv preprint arXiv:2306.10882,

    Timothée Mathieu, Riccardo Della Vecchia, Alena Shilova, Matheus Medeiros Centa, Hector Kohler, Odalric- Ambrym Maillard, and Philippe Preux. Adastop: adaptive statistical testing for sound comparisons of deep rl agents.arXiv preprint arXiv:2306.10882,

    Pith/arXiv arXiv

  4. [11]

    Revisiting rainbow: Promoting more insightful and inclusive deep reinforcement learning research.arXiv preprint arXiv:2011.14826,

    Johan S Obando-Ceron and Pablo Samuel Castro. Revisiting rainbow: Promoting more insightful and inclusive deep reinforcement learning research.arXiv preprint arXiv:2011.14826,

    Pith/arXiv arXiv 2011

  5. [12]

    Behaviour suite for reinforcement learning.arXiv preprint arXiv:1908.03568,

    Ian Osband, Yotam Doron, Matteo Hessel, John Aslanides, Eren Sezener, Andre Saraiva, Katrina McKinney, Tor Lattimore, Csaba Szepesvari, Satinder Singh, et al. Behaviour suite for reinforcement learning.arXiv preprint arXiv:1908.03568,

    Pith/arXiv arXiv 1908

  6. [14]

    Proximal policy optimization algorithms.arXiv preprint arXiv:1707.06347,

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms.arXiv preprint arXiv:1707.06347,

    Pith/arXiv arXiv

  7. [15]

    Minatar: An atari-inspired testbed for thorough and reproducible reinforcement learning experiments.arXiv preprint arXiv:1903.03176,

    Kenny Young and Tian Tian. Minatar: An atari-inspired testbed for thorough and reproducible reinforcement learning experiments.arXiv preprint arXiv:1903.03176,

    Pith/arXiv arXiv 1903

  8. [16]

    The platform established one of the first successful portable gaming ecosystems by providing a hardware abstraction layer that enabled games to run across different systems

    10 OCTAX: Accelerated CHIP-8 Arcade Environments for Reinforcement Learning in JAX A CHIP-8 Technical Specifications A.1 Platform Overview CHIP-8 was created by Joseph Weisbecker at RCA in the mid-1970s as a virtual machine for early microcomputers. The platform established one of the first successful portable gaming ecosystems by providing a hardware abs...

    1991

  9. [2013]

    Jumanji: a diverse suite of scalable reinforcement learning environments in jax.arXiv preprint arXiv:2306.09884,

    Clément Bonnet, Daniel Luo, Donal Byrne, Shikha Surana, Sasha Abramowitz, Paul Duckworth, Vincent Coyette, Laurence I Midgley, Elshadai Tegegn, Tristan Kalloniatis, et al. Jumanji: a diverse suite of scalable reinforcement learning environments in jax.arXiv preprint arXiv:2306.09884,

    Pith/arXiv arXiv

  10. [2019]

    Navix: Scaling minigrid environments with jax.arXiv preprint arXiv:2407.19396,

    Eduardo Pignatelli, Jarek Liesen, Robert Tjarko Lange, Chris Lu, Pablo Samuel Castro, and Laura Toni. Navix: Scaling minigrid environments with jax.arXiv preprint arXiv:2407.19396,

    Pith/arXiv arXiv

  11. [2020]

    Puzzlejax: A benchmark for reasoning and learning.arXiv preprint arXiv:2508.16821,

    Sam Earle, Graham Todd, Yuchen Li, Ahmed Khalifa, Muhammad Umair Nasir, Zehua Jiang, Andrzej Banburski- Fahey, and Julian Togelius. Puzzlejax: A benchmark for reasoning and learning.arXiv preprint arXiv:2508.16821,

    Pith/arXiv arXiv

  12. [2021]

    Greener deep reinforcement learning: Analysis of energy and carbon efficiency across atari benchmarks.arXiv preprint arXiv:2509.05273,

    Jason Gardner, Ayan Dutta, Swapnoneel Roy, O Patrick Kreidl, and Ladislau Boloni. Greener deep reinforcement learning: Analysis of energy and carbon efficiency across atari benchmarks.arXiv preprint arXiv:2509.05273,

    Pith/arXiv arXiv

  13. [2022]

    9 OCTAX: Accelerated CHIP-8 Arcade Environments for Reinforcement Learning in JAX Diederik P Kingma and Jimmy Ba

    URLhttp://jmlr.org/papers/ v23/21-1342.html. 9 OCTAX: Accelerated CHIP-8 Arcade Environments for Reinforcement Learning in JAX Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization.arXiv preprint arXiv:1412.6980,

    Pith/arXiv arXiv

  14. [2023]

    JAX: composable transformations of Python+NumPy programs, 2018a

    James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Nec- ula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018a. URLhttp://github.com/jax-ml/jax. James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Lea...

    Pith/arXiv arXiv

  15. [2024]

    Brax–a differen- tiable physics engine for large scale rigid body simulation.arXiv preprint arXiv:2106.13281,

    C Daniel Freeman, Erik Frey, Anton Raichuk, Sertan Girgin, Igor Mordatch, and Olivier Bachem. Brax–a differen- tiable physics engine for large scale rigid body simulation.arXiv preprint arXiv:2106.13281,

    Pith/arXiv arXiv

  16. [2025]

    Omni-epic: Open-endedness via models of human notions of interestingness with environments programmed in code.arXiv preprint arXiv:2405.15568,

    Maxence Faldor, Jenny Zhang, Antoine Cully, and Jeff Clune. Omni-epic: Open-endedness via models of human notions of interestingness with environments programmed in code.arXiv preprint arXiv:2405.15568,

    Pith/arXiv arXiv