LIVIVE.NET STUDIOS

PRESENTS

LOADING PILOTS…

FREE PLAY · TOURNAMENT EDITION

LUNAR LANDER

PRESS START TO FLY

HIGH SCORE

MOST WINS

JOYSTICK · ROTATE

THRUST

RESET

ABOUT THIS PROJECT

About This Project

A browser arcade cabinet that flies nine trained LunarLander-v2 policies — the first-party PPO pilot plus eight imported contenders — on one shared physics engine, so you can race them head-to-head.

What this is

A single web page that runs the classic LunarLander-v2 landing task and lets you fly it, or watch a trained policy fly it. Nine policies ship with the cabinet. Every pilot reads the same eight cockpit readings, picks one of four moves, and lands on the same physics. The only difference is the model.

How it works

The environment and physics run in the browser in Python (Pyodide 0.23.4), using PyPyBox2D, a pure-Python Box2D 2.1-era solver, behind a small Gymnasium-compatible shim.
JavaScript draws the canvas and runs each policy with ONNX Runtime Web 1.19.2 on its WebAssembly CPU backend.
Third-party checkpoints are converted offline to one contract — observation[8] → logits[4] — with parity checks, using era-pinned exporters, and checked against the original policy before they fly here.
Every pilot flies the identical course and the identical hazard timeline. Same seed, same step, same sky.

The pilots

Pilot	Algorithm	Builder	Source

Sources & further reading

This project

Model origin & starting point

Environment & reference material

Runtime building blocks

Development tooling

A note on physics

Sandbox physics. Scores are this cabinet's, not the official leaderboard. Contenders trained on native Box2D 2.3 may transfer imperfectly to the browser's older Box2D 2.1-era solver.

How this was built

Development ran with AI agents under human direction. Some sprints used Paperclip, an agentic development harness. The agents ran on DeepSeek v4.1, Gemini 3.8 Flash, and GPT-6 Luna.

Credits

PyPyBox2D by Ken Lauer · Box2D · Pyodide · ONNX Runtime · Gymnasium · Stable-Baselines3. Every contender keeps credit to its original author and repository.

The Xinli Yu / RL-Projects model has no license file in its source repository.

BUILD YOUR OWN PILOT

Build your own pilot

Export your own LunarLander policy to ONNX, drop it in here, and fly it on this cabinet. The model runs in your browser only — your file never leaves your machine.

The pilot contract

Every pilot on this cabinet reads the same eight cockpit readings and writes four scores. Match this signature exactly and your model slots straight in.

Input name observation, float32, shape [batch, 8].
Output name logits, float32, shape [batch, 4].
The cabinet takes the argmax of the four output numbers. Raw scores only.
Values may be PPO logits or DQN Q-values — any four real numbers work. Do not bake in softmax or argmax.
Use float32. Keep the batch axis dynamic so the model accepts batch = 1.
Keep the ONNX opset at 17 or lower (the cabinet runs ONNX Runtime Web 1.19.2).

The eight cockpit readings (observation)

#	Reading	Meaning
0	x	horizontal position
1	y	vertical position
2	vx	horizontal velocity
3	vy	vertical velocity
4	angle	lander rotation
5	angular velocity	rotation speed
6	left leg contact	0 or 1
7	right leg contact	0 or 1

Reference: Gymnasium LunarLander-v2.

The four moves (output)

#	Action
0	do nothing
1	fire left engine
2	fire main engine
3	fire right engine

How to export

PyTorch

import torch, torch.nn as nn

class Pilot(nn.Module):
    def __init__(self, net):
        super().__init__(); self.net = net
    def forward(self, observation):
        return self.net(observation)          # -> [batch, 4]

pilot = Pilot(net).eval()
torch.onnx.export(
    pilot, torch.zeros(1, 8), "my-pilot.onnx",
    input_names=["observation"], output_names=["logits"],
    dynamic_axes={"observation": {0: "batch"}, "logits": {0: "batch"}},
    opset_version=17,
)

Stable-Baselines3

Export the actor's logits, not the full policy tuple.

import torch, torch.nn as nn
from stable_baselines3 import PPO

model = PPO.load("ppo-LunarLander-v2.zip")

class Logits(nn.Module):
    def __init__(self, policy):
        super().__init__(); self.policy = policy
    def forward(self, observation):
        features = self.policy.extract_features(observation)
        return self.policy.action_net(
            self.policy.mlp_extractor.forward_actor(features))

torch.onnx.export(
    Logits(model.policy).eval(), torch.zeros(1, 8), "my-pilot.onnx",
    input_names=["observation"], output_names=["logits"],
    dynamic_axes={"observation": {0: "batch"}, "logits": {0: "batch"}},
    opset_version=17,
)

TensorFlow / Keras

Use tf2onnx; see the repo's ashbellett exporter for the Keras 3 from_function fallback.

import tensorflow as tf, tf2onnx

model = tf.keras.models.load_model("my-model")
spec = (tf.TensorSpec((None, 8), tf.float32, name="observation"),)
proto, _ = tf2onnx.convert.from_keras(model, input_signature=spec, opset=15)
open("my-pilot.onnx", "wb").write(proto.SerializeToString())

Checklist / troubleshooting

Names must be exactly observation and logits (case-sensitive).
Shapes must be [batch, 8] in and [batch, 4] out.
No softmax or argmax in the graph.
float32, dynamic batch axis, opset ≤ 17.

Test it here

Your file stays in this browser and is never uploaded anywhere.

Drag an .onnx file here, or .

Installed custom pilots

TODO: submitting a pilot to the official cabinet release for everyone to fly is planned for a future update. For now, custom pilots live only in the browser you added them to.