diff --git a/.circleci/config.yml b/.circleci/config.yml
index c66f88d0e..e82eedb63 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -25,6 +25,26 @@ parameters:
     type: string
     default: master
 
+commands:
+  install-gdevelop-runtime-dependencies:
+    steps:
+      - run:
+          name: Install the runtime dependencies of GDevelop
+          # Even in CLI mode, Electron needs these libraries and a display to
+          # start up on a headless machine.
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y \
+              libnss3 \
+              libasound2t64 \
+              libgbm1 \
+              libgtk-3-0 \
+              libxss1 \
+              libatk-bridge2.0-0 \
+              libdrm2 \
+              libxkbcommon0 \
+              xvfb
+
 jobs:
   install:
     docker:
@@ -165,22 +185,7 @@ jobs:
     steps:
       - checkout
 
-      - run:
-          name: Install the runtime dependencies of GDevelop
-          # Even in CLI mode, Electron needs these libraries and a display to
-          # start up on a headless machine.
-          command: |
-            sudo apt-get update
-            sudo apt-get install -y \
-              libnss3 \
-              libasound2t64 \
-              libgbm1 \
-              libgtk-3-0 \
-              libxss1 \
-              libatk-bridge2.0-0 \
-              libdrm2 \
-              libxkbcommon0 \
-              xvfb
+      - install-gdevelop-runtime-dependencies
 
       - run:
           name: Install the dependencies of the scripts
@@ -244,6 +249,64 @@ jobs:
           name: Report whether the gameplay tests passed
           command: exit "$(cat /tmp/gameplay-tests-exit-code)"
 
+  # Check that the games are still drawn the same: their rendering tests
+  # (gameplay tests named "Rendering: ...") take screenshots compared with the
+  # images of `rendering-screenshots/` (see scripts/check-rendering-screenshots.js).
+  # The latest build of GDevelop is used: an image that differs while the game
+  # did not change is an early warning of a change of the rendering of GDevelop.
+  rendering-screenshots:
+    parameters:
+      scope:
+        description: >
+          "all" checks every game with rendering tests. "changed" only checks
+          the games whose project or expected images changed compared to `main`.
+        type: enum
+        enum: ['all', 'changed']
+        default: 'all'
+    resource_class: large
+    docker:
+      - image: cimg/node:24.13.0
+    working_directory: ~/GDevelop-examples
+
+    steps:
+      - checkout
+      - install-gdevelop-runtime-dependencies
+
+      - run:
+          name: Install the dependencies of the scripts
+          command: npm ci --omit=dev
+
+      - run:
+          name: Check the rendering of the games
+          no_output_timeout: 30m
+          # The failure is reported by the last step of the job, so that the
+          # screenshots and their differences are uploaded first.
+          command: |
+            set +e
+            SCOPE_ARGS=""
+            if [ "<< parameters.scope >>" = "changed" ]; then
+              SCOPE_ARGS="--only-changed --base-ref=origin/main"
+            fi
+            node scripts/check-rendering-screenshots.js $SCOPE_ARGS \
+              --gdevelop-branch=<< pipeline.parameters.gdevelop-branch >> \
+              --work-dir=/tmp/gdevelop-portable \
+              --artifacts-dir=/tmp/rendering-screenshots-artifacts \
+              --junit-path=/tmp/rendering-screenshots-results/results.xml
+            echo $? > /tmp/rendering-screenshots-exit-code
+
+      - store_test_results:
+          path: /tmp/rendering-screenshots-results
+      # One folder per game, with its screenshots (in
+      # `gameplay-test-screenshots/`) and, for those that differ, an image of
+      # the differences next to them (`.diff.png`, differences in magenta).
+      - store_artifacts:
+          path: /tmp/rendering-screenshots-artifacts
+          destination: rendering-screenshots
+
+      - run:
+          name: Report whether the games are drawn like their expected images
+          command: exit "$(cat /tmp/rendering-screenshots-exit-code)"
+
 workflows:
   tests:
     jobs:
@@ -271,9 +334,8 @@ workflows:
 
   # Every night (03:00 UTC): rebuild and redeploy `main`. The starters re-skinned
   # with each theme are generated by the build from the themes and assets the
-  # assets repository publishes, so this is how they catch up with it. Only this
-  # workflow runs on the schedule: the gameplay tests are not run again, as the
-  # games did not change.
+  # assets repository publishes, so this is how they catch up with it. The
+  # gameplay tests are not run again, as the games did not change.
   nightly-rebuild:
     triggers:
       - schedule:
@@ -306,6 +368,9 @@ workflows:
           name: gameplay-tests-all
           scope: 'all'
           parallelism: << pipeline.parameters.all-gameplay-tests-parallelism >>
+      - rendering-screenshots:
+          name: rendering-screenshots-all
+          scope: 'all'
 
   # On a branch / Pull Request: only check the games it modifies.
   changed-gameplay-tests:
@@ -319,3 +384,20 @@ workflows:
           name: gameplay-tests-changed
           scope: 'changed'
           parallelism: << pipeline.parameters.changed-gameplay-tests-parallelism >>
+      - rendering-screenshots:
+          name: rendering-screenshots-changed
+          scope: 'changed'
+
+  # Every night (04:17 UTC): check the rendering of the games with the latest
+  # build of GDevelop, which changes every day without any change here.
+  nightly-rendering-screenshots:
+    triggers:
+      - schedule:
+          cron: '17 4 * * *'
+          filters:
+            branches:
+              only: main
+    jobs:
+      - rendering-screenshots:
+          name: rendering-screenshots-nightly
+          scope: 'all'
diff --git a/.gitignore b/.gitignore
index 60fca0582..11259dced 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,7 @@ gameplay-test-results.json
 gameplay-test-screenshots/
 /gameplay-tests-artifacts
 /gameplay-tests-results
+
+# Written by the rendering screenshots check.
+/rendering-screenshots-artifacts
+/rendering-screenshots-results
diff --git a/README.md b/README.md
index 0a9f8e357..fa95d0df4 100644
--- a/README.md
+++ b/README.md
@@ -230,6 +230,34 @@ land on `main`, by triggering a CircleCI pipeline with the
 `run-all-gameplay-tests` parameter set to `true`. The number of parallel
 containers used is the `all-gameplay-tests-parallelism` pipeline parameter.
 
+### Rendering screenshots
+
+A few games have a _rendering test_: a gameplay test named `Rendering: ...`
+taking PNG screenshots (`harness.takeScreenshot(label, { width: 640, format: 'png' })`).
+The `rendering-screenshots` CI job runs them with the latest build of GDevelop
+and compares each screenshot with the expected image,
+`rendering-screenshots/<example>/<label>.png`. The games are drawn in software,
+which draws the same pixels from one run to the next: an image that differs
+when the game did not change is an early warning that the rendering of
+GDevelop changed. The job runs on `main`, every night, and on the branches
+changing these games, their images or the scripts.
+
+```bash
+# Compare the screenshots with the expected images.
+node scripts/check-rendering-screenshots.js
+
+# After a change of the rendering made on purpose (in GDevelop or in a game),
+# write the screenshots as the expected images, and check them in the diff.
+node scripts/check-rendering-screenshots.js --update
+```
+
+When a screenshot differs, an image of the differences (in magenta) is written
+next to it, in the artifacts of the job (under `rendering-screenshots/`).
+
+Texts are drawn with the font settings of the system, which differ from one
+machine to another: hide the layers showing texts in these screenshots
+(`hideLayers: ['UI']`).
+
 ## License
 
 All examples provided on this repository are MIT licensed, unless specified otherwise.
diff --git a/examples/3d-island-terrain/3d-island-terrain.json b/examples/3d-island-terrain/3d-island-terrain.json
index 5a9955c4c..f82fc5f49 100644
--- a/examples/3d-island-terrain/3d-island-terrain.json
+++ b/examples/3d-island-terrain/3d-island-terrain.json
@@ -3423,668 +3423,22 @@
       ]
     },
     {
-      "name": "The terrain data is saved and loaded without loss",
+      "name": "Rendering: the island with its effects",
       "type": "gameplay",
       "description": "",
       "source": [
         "await harness.goToScene('Game Scene');",
-        "const { TerrainData, SampleRectangle, codec, relief, brushes, edits } = gdjs.__terrain3DExtension;",
-        "const makeBase = (resolution, reliefName) => {",
-        "  const data = new TerrainData(resolution);",
-        "  relief.generate(data, reliefName, 42);",
-        "  return data;",
-        "};",
-        "const copy = (data) => {",
-        "  const result = new TerrainData(data.resolution);",
-        "  result.copyFrom(data);",
-        "  return result;",
-        "};",
-        "// A brush stroke on a terrain of 4096 by 4096.",
-        "const stroke = (resolution, ax, ay, bx, by, radius) => ({ cellWidth: 4096 / resolution, cellHeight: 4096 / resolution, ax, ay, bx, by, radius });",
-        "",
-        "for (const reliefName of ['Flat', 'Hills', 'Mountains', 'Island']) {",
-        "  for (const resolution of [64, 256]) {",
-        "    const base = makeBase(resolution, reliefName);",
-        "    const data = copy(base);",
-        "    const changed = new SampleRectangle();",
-        "    for (let k = 0; k < 30; k++) brushes.raise(data, stroke(resolution, 1000 + k * 20, 1500, 1000 + k * 20, 1500, 300), 0.01, changed);",
-        "    brushes.smooth(data, stroke(resolution, 2000, 2000, 2500, 2600, 250), 0.5, changed);",
-        "    brushes.flatten(data, stroke(resolution, 3000, 1000, 3000, 1000, 200), 0.3, 1, changed);",
-        "    brushes.paint(data, stroke(resolution, 500, 500, 3500, 3000, 120), 1, 1, changed);",
-        "    const decoded = codec.decode(codec.encode(data, base), (decodedResolution) => makeBase(decodedResolution, reliefName));",
-        "    let maxHeightError = 0;",
-        "    for (let i = 0; i < data.heights.length; i++) maxHeightError = Math.max(maxHeightError, Math.abs(decoded.heights[i] - data.heights[i]));",
-        "    let isPaintKept = decoded.splat.length === data.splat.length;",
-        "    for (let i = 0; isPaintKept && i < data.splat.length; i++) isPaintKept = decoded.splat[i] === data.splat[i];",
-        "    const label = reliefName + ' at ' + resolution;",
-        "    harness.assert(decoded.resolution === resolution, 'The resolution is kept (' + label + ').');",
-        "    harness.assert(maxHeightError <= 0.5 / 65535 + 1e-7, 'The heights are kept (' + label + ', error ' + maxHeightError + ').');",
-        "    harness.assert(isPaintKept, 'The paint is kept (' + label + ').');",
-        "  }",
-        "}",
-        "const flatBase = (resolution) => new TerrainData(resolution);",
-        "for (const invalidText of ['', 'garbage', '1;256;!!!', '1;256;AAAA']) {",
-        "  harness.assert(codec.decode(invalidText, flatBase) === null, 'Invalid data is ignored: \"' + invalidText + '\".');",
-        "}",
-        "harness.assert(codec.encode(makeBase(512, 'Mountains'), makeBase(512, 'Mountains')).length < 100, 'Untouched data takes almost no space.');",
-        "",
-        "// Decoding paint made on another base (the relief changed) keeps valid weights.",
-        "const island = makeBase(64, 'Island');",
-        "const paintedIsland = copy(island);",
-        "brushes.paint(paintedIsland, stroke(64, 2048, 2048, 2048, 2048, 5000), 0, 1, new SampleRectangle());",
-        "const decodedOnOtherSeed = codec.decode(codec.encode(paintedIsland, island), () => {",
-        "  const other = new TerrainData(64);",
-        "  relief.generate(other, 'Island', 99);",
-        "  return other;",
-        "});",
-        "harness.assert(decodedOnOtherSeed.splat.every((weight) => weight >= 0 && weight <= 255), 'Paint decoded on another relief keeps valid weights.');",
-        "",
-        "// Brushes: raise is maximal on the segment, none outside the radius, and paint keeps the sum of weights.",
-        "const flat = new TerrainData(64);",
-        "const changedByRaise = new SampleRectangle();",
-        "brushes.raise(flat, stroke(64, 2048, 2048, 2048, 2048, 256), 0.5, changedByRaise);",
-        "harness.assert(Math.abs(flat.getHeight(32, 32) - 0.5) < 1e-6 && flat.getHeight(32, 40) === 0, 'Raising stays in the brush radius.');",
-        "harness.assert(changedByRaise.minI === 28 && changedByRaise.maxI === 36, 'The changed samples are the ones in the brush radius.');",
-        "brushes.paint(flat, stroke(64, 2048, 2048, 2048, 2048, 300), 2, 0.6, new SampleRectangle());",
-        "let maxWeightSumError = 0;",
-        "for (let i = 0; i < flat.size * flat.size; i++) {",
-        "  const weightSum = flat.splat[i * 4] + flat.splat[i * 4 + 1] + flat.splat[i * 4 + 2] + flat.splat[i * 4 + 3];",
-        "  maxWeightSumError = Math.max(maxWeightSumError, Math.abs(weightSum - 255));",
-        "}",
-        "harness.assert(maxWeightSumError <= 2 && flat.getDominantLayer(32, 32) === 2, 'Painting keeps the sum of layer weights.');",
-        "const lightlyPainted = new TerrainData(64);",
-        "for (let k = 0; k < 400; k++) brushes.paint(lightlyPainted, stroke(64, 2048, 2048, 2048, 2048, 300), 1, 0.005, new SampleRectangle());",
-        "harness.assert(lightlyPainted.splat[(32 * lightlyPainted.size + 32) * 4 + 1] === 255, 'Light paint strokes still reach the painted layer.');",
-        "",
-        "// Edits: strokes described in JSON, in fractions of the terrain.",
-        "const edited = new TerrainData(64);",
-        "edits.apply(edited, JSON.stringify([",
-        "  { tool: 'raise', x: 0.5, y: 0.5, radius: 0.2, height: 0.4 },",
-        "  { tool: 'paint', x: 0, y: 0, toX: 1, toY: 1, radius: 0.05, layer: 2 },",
-        "  { tool: 'flatten', x: 0.1, y: 0.9, radius: 0.1, z: 0.2 },",
-        "  { tool: 'smooth', x: 0.5, y: 0.5, radius: 0.3, strength: 0.5 },",
-        "]));",
-        "harness.assert(edited.getHeight(32, 32) > 0.3, 'The raise edit is applied.');",
-        "harness.assert(Math.abs(edited.getHeight(6, 58) - 0.2) < 0.01, 'The flatten edit is applied.');",
-        "harness.assert(edited.getDominantLayer(10, 10) === 1 && edited.getDominantLayer(60, 2) === 0, 'The paint edit is applied along its line only.');",
-        "const notEdited = new TerrainData(64);",
-        "for (const invalidEdits of ['not json', '{\"tool\": \"raise\"}', '[{\"tool\": \"dig\"}, null, 3]']) edits.apply(notEdited, invalidEdits);",
-        "harness.assert(notEdited.heights.every((height) => height === 0), 'Invalid edits are ignored.');",
-        "",
-        "// Heights are interpolated between samples.",
-        "const sampled = new TerrainData(64);",
-        "sampled.heights[0] = 1;",
-        "harness.assert(",
-        "  sampled.sampleHeight(0, 0) === 1 && Math.abs(sampled.sampleHeight(0.5, 0) - 0.5) < 1e-6 && sampled.sampleHeight(-10, -10) === 1 && sampled.sampleHeight(1, 1) === 0,",
-        "  'Heights are interpolated between samples and clamped outside.'",
-        ");"
-      ]
-    },
-    {
-      "name": "Sculpting changes the surface used by physics and navigation meshes",
-      "type": "gameplay",
-      "description": "",
-      "source": [
-        "await harness.goToScene('Game Scene');",
-        "const scene = harness.getCurrentRuntimeScene();",
-        "const terrainObject = scene.getObjects('Terrain')[0];",
-        "const terrain = terrainObject.__terrain3D;",
-        "const surface = terrainObject.getSurface();",
-        "harness.assert(!!surface && surface === terrain.surface, 'The terrain gives its surface.');",
-        "const player = scene.getObjects('Player')[0];",
-        "const x = player.getCenterXInScene();",
-        "const y = player.getCenterYInScene();",
-        "const versionBeforePaint = surface.getVersion();",
-        "terrain.paint(x, y, x, y, 200, 2, 1);",
-        "harness.assert(surface.getVersion() === versionBeforePaint, \"Painting doesn't change the surface.\");",
-        "terrain.raise(x, y, x, y, 200, 100);",
-        "harness.assert(surface.getVersion() !== versionBeforePaint, 'Sculpting changes the surface.');",
-        "const changedArea = surface.getChangedArea(versionBeforePaint);",
-        "harness.assert(",
-        "  !!changedArea && changedArea.maxX - changedArea.minX < 0.2 && changedArea.maxY - changedArea.minY < 0.2,",
-        "  'Only the sculpted part of the surface is updated (' + JSON.stringify(changedArea) + ').'",
-        ");"
-      ]
-    },
-    {
-      "name": "The terrain works with older GDevelop versions",
-      "type": "gameplay",
-      "description": "",
-      "source": [
-        "await harness.goToScene('Game Scene');",
-        "await harness.stepFrames(1);",
-        "const scene = harness.getCurrentRuntimeScene();",
-        "const physicsWorld = scene.getObjects('Terrain')[0].getBehavior('Physics3D')._sharedData;",
-        "",
-        "// Versions without surfaces: the terrain sets the shape of its Physics3D behavior.",
-        "const { getSurface, setSurface } = gdjs.RuntimeObject.prototype;",
-        "delete gdjs.RuntimeObject.prototype.getSurface;",
-        "delete gdjs.RuntimeObject.prototype.setSurface;",
-        "let terrainObject;",
-        "try {",
-        "  terrainObject = scene.createObject('Terrain');",
-        "} finally {",
-        "  gdjs.RuntimeObject.prototype.getSurface = getSurface;",
-        "  gdjs.RuntimeObject.prototype.setSurface = setSurface;",
-        "}",
-        "const terrain = terrainObject.__terrain3D;",
-        "harness.assert(!!terrain && isFinite(terrain.getHeightAt(100, 100)), 'The terrain is created without surfaces.');",
-        "harness.assert(terrain.bodyUpdaters.length === 1, 'The terrain changes the shape of its Physics3D behavior.');",
-        "// Away from the terrain of the scene, to only hit this one.",
-        "terrainObject.setPosition(20000, 20000);",
-        "await harness.stepFrames(1);",
-        "const { worldScale } = physicsWorld;",
-        "const physicsGroundZ = (x, y) => {",
-        "  const ray = new Jolt.RRayCast(new Jolt.RVec3(x / worldScale, y / worldScale, 50), new Jolt.Vec3(0, 0, -100));",
-        "  const collector = new Jolt.CastRayClosestHitCollisionCollector();",
-        "  physicsWorld.physicsSystem",
-        "    .GetNarrowPhaseQuery()",
-        "    .CastRay(ray, new Jolt.RayCastSettings(), collector, new Jolt.BroadPhaseLayerFilter(), new Jolt.ObjectLayerFilter(), new Jolt.BodyFilter(), new Jolt.ShapeFilter());",
-        "  const z = collector.HadHit() ? (50 - 100 * collector.mHit.mFraction) * worldScale : null;",
-        "  Jolt.destroy(ray);",
-        "  Jolt.destroy(collector);",
-        "  return z;",
-        "};",
-        "const checkPhysicsFollowsTerrain = (label) => {",
-        "  let maxError = 0;",
-        "  for (let i = 1; i < 20; i++) {",
-        "    for (let j = 1; j < 20; j++) {",
-        "      const x = terrainObject.getX() + (i / 20) * terrainObject.getWidth();",
-        "      const y = terrainObject.getY() + (j / 20) * terrainObject.getHeight();",
-        "      const z = physicsGroundZ(x, y);",
-        "      maxError = Math.max(maxError, z === null ? Infinity : Math.abs(z - terrain.getHeightAt(x, y)));",
-        "    }",
-        "  }",
-        "  harness.assert(maxError < 4, 'The physics body follows the terrain ' + label + ' (max error ' + maxError.toFixed(2) + ').');",
-        "};",
-        "checkPhysicsFollowsTerrain('when created');",
-        "const centerX = terrainObject.getCenterXInScene();",
-        "const centerY = terrainObject.getCenterYInScene();",
-        "terrain.raise(centerX, centerY, centerX, centerY, 600, 150);",
-        "terrain.raise(terrainObject.getX(), terrainObject.getY(), terrainObject.getX(), terrainObject.getY(), 300, 100);",
-        "await harness.stepFrames(1);",
-        "checkPhysicsFollowsTerrain('after sculpting');",
-        "terrainObject.deleteFromScene();",
-        "harness.assert(!gdjs.__terrain3DExtension.getGrounds(scene).has(terrain), 'The terrain is deleted without surfaces.');",
-        "await harness.stepFrames(1);",
-        "",
-        "// Versions without a world scale for the 3D renderer: 1 is used.",
-        "// Only the code of the objects is run: the engine itself uses the world scale.",
-        "const { getRenderer3DWorldScale } = gdjs.RuntimeScene.prototype;",
-        "delete gdjs.RuntimeScene.prototype.getRenderer3DWorldScale;",
-        "try {",
-        "  for (const objectName of ['Terrain', 'Grass', 'Water']) {",
-        "    scene.getObjects(objectName)[0].doStepPostEvents(scene);",
-        "  }",
-        "  harness.assert(",
-        "    scene.getObjects('Terrain')[0].__terrain3D.renderer.uniforms.terrainWorldScale.value === 1 &&",
-        "      scene.getObjects('Grass')[0].__terrainGrass.uniforms.grassWorldScale.value === 1 &&",
-        "      scene.getObjects('Water')[0].__water3D.uniforms.waterWorldScale.value === 1,",
-        "    'Without a world scale, 1 is used.'",
-        "  );",
-        "} finally {",
-        "  gdjs.RuntimeScene.prototype.getRenderer3DWorldScale = getRenderer3DWorldScale;",
-        "}",
-        "",
-        "// Versions without toolbars or tools in the scene editor.",
-        "const terrainInEditor = scene.getObjects('Terrain')[0];",
-        "let isLeftButtonCaptured = false;",
-        "const olderEditors = [",
-        "  {},",
-        "  {",
-        "    getRuntimeGame: () => harness.getRuntimeGame(),",
-        "    getSelectedObjects: () => [terrainInEditor],",
-        "    captureLeftMouseButton: () => (isLeftButtonCaptured = true),",
-        "    updateObjectProperties: () => {},",
-        "  },",
-        "];",
-        "for (const editor of olderEditors) {",
-        "  gdjs.callbacksInGameEditorPostStep.forEach((callback) => callback(editor));",
-        "}",
-        "harness.assert(!isLeftButtonCaptured, 'The tools are not used without toolbars.');"
-      ]
-    },
-    {
-      "name": "The terrain, grass and water follow the world scale of the 3D renderer",
-      "type": "gameplay",
-      "description": "",
-      "source": [
-        "await harness.goToScene('Game Scene');",
-        "const game = harness.getRuntimeGame();",
-        "const scene = harness.getCurrentRuntimeScene();",
-        "scene.getObjects('Player')[0].getBehavior('ThirdPersonCamera').activate(false);",
-        "const terrain = scene.getObjects('Terrain')[0].__terrain3D;",
-        "const grass = scene.getObjects('Grass')[0].__terrainGrass;",
-        "const water = scene.getObjects('Water')[0];",
-        "// Looking down at the ground in the middle of the island.",
-        "const targetX = 640, targetY = 1100;",
-        "gdjs.evtTools.camera.setCameraX(scene, targetX, '', 0);",
-        "gdjs.evtTools.camera.setCameraY(scene, targetY, '', 0);",
-        "gdjs.scene3d.camera.setCameraZ(scene, terrain.getHeightAt(targetX, targetY) + 800, '', 0);",
-        "gdjs.scene3d.camera.setCameraRotationX(scene, 0, '', 0);",
-        "harness.setMousePositionScreen(game.getGameResolutionWidth() / 2, game.getGameResolutionHeight() / 2);",
-        "",
-        "const measure = async (worldScale) => {",
-        "  scene.setRenderer3DWorldScale(worldScale);",
-        "  await harness.stepFrames(2);",
-        "  // The brush is drawn where the cursor hits the ground, in scene units (with Y flipped).",
-        "  const hit = terrain.raycastFromCursor(game, new THREE.Raycaster(), new THREE.Vector2());",
-        "  terrain.renderer.setBrush(hit, 50);",
-        "  const brush = terrain.renderer.uniforms.terrainBrush.value;",
-        "  let visibleBlades = 0;",
-        "  for (const chunk of grass.chunks) if (chunk.mesh.visible) visibleBlades += chunk.mesh.geometry.instanceCount;",
-        "  return {",
-        "    hit: !!hit,",
-        "    brushX: brush.x,",
-        "    brushY: brush.y,",
-        "    visibleBlades,",
-        "    waterSurfaceZ: water.__water3D.getSurfaceZ(targetX, targetY),",
-        "  };",
-        "};",
-        "const atDefaultScale = await measure(100);",
-        "const atScale1 = await measure(1);",
-        "console.log('scale 100: ' + JSON.stringify(atDefaultScale) + ' scale 1: ' + JSON.stringify(atScale1));",
-        "for (const [label, result] of [['100', atDefaultScale], ['1', atScale1]]) {",
-        "  harness.assert(result.hit, 'The cursor hits the ground at the world scale ' + label + '.');",
-        "  harness.assert(",
-        "    Math.abs(result.brushX - targetX) < 20 && Math.abs(result.brushY + targetY) < 20,",
-        "    'The brush is under the cursor at the world scale ' + label + ' (' + result.brushX.toFixed(0) + ';' + result.brushY.toFixed(0) + ').'",
-        "  );",
-        "}",
-        "harness.assert(",
-        "  atDefaultScale.visibleBlades > 0 && atDefaultScale.visibleBlades === atScale1.visibleBlades,",
-        "  'The grass fades with the distance the same way at any world scale.'",
-        ");",
-        "harness.assert(Math.abs(atDefaultScale.waterSurfaceZ - atScale1.waterSurfaceZ) < 1, 'The waves are the same at any world scale.');"
-      ]
-    },
-    {
-      "name": "Painting after the relief was changed in the scene editor",
-      "type": "gameplay",
-      "description": "",
-      "source": [
-        "await harness.goToScene('Game Scene');",
-        "await harness.stepFrames(2);",
-        "const game = harness.getRuntimeGame();",
-        "const scene = harness.getCurrentRuntimeScene();",
-        "scene.getObjects('Player')[0].getBehavior('ThirdPersonCamera').activate(false);",
-        "const terrainObject = scene.getObjects('Terrain')[0];",
-        "const terrain = terrainObject.__terrain3D;",
-        "const targetX = 640, targetY = 1100;",
-        "",
-        "// The scene editor changes the relief like this (hot-reload of the object).",
-        "const oldObjectData = scene._objects.get('Terrain');",
-        "const newObjectData = JSON.parse(JSON.stringify(oldObjectData));",
-        "newObjectData.content.Relief = 'Mountains';",
-        "const heightBefore = terrain.getHeightAt(targetX, targetY);",
-        "terrainObject.updateFromObjectData(oldObjectData, newObjectData);",
-        "harness.assert(terrainObject._getRelief() === 'Mountains', 'The relief is changed.');",
-        "harness.assert(Math.abs(terrain.getHeightAt(targetX, targetY) - heightBefore) > 1, 'The ground is changed right away.');",
-        "",
-        "gdjs.evtTools.camera.setCameraX(scene, targetX, '', 0);",
-        "gdjs.evtTools.camera.setCameraY(scene, targetY, '', 0);",
-        "gdjs.scene3d.camera.setCameraZ(scene, terrain.getHeightAt(targetX, targetY) + 800, '', 0);",
-        "gdjs.scene3d.camera.setCameraRotationX(scene, 0, '', 0);",
-        "await harness.stepFrames(1);",
-        "",
-        "const savedProperties = [];",
-        "let toolbarItems = null;",
-        "// The editor tells when the view is moved (with several fingers or Space).",
-        "let isViewMoved = false;",
-        "const editor = {",
-        "  getRuntimeGame: () => game,",
-        "  getSelectedObjects: () => [terrainObject],",
-        "  captureLeftMouseButton: () => {},",
-        "  isCapturedLeftMouseButtonPressed: () => !isViewMoved && game.getInputManager().isMouseButtonPressed(0),",
-        "  updateObjectProperties: (objectName, properties) => savedProperties.push(properties),",
-        "  showToolbar: (toolbarId, items) => (toolbarItems = items),",
-        "};",
-        "const updateTools = () => gdjs.callbacksInGameEditorPostStep.forEach((callback) => callback(editor));",
-        "updateTools();",
-        "toolbarItems.find((item) => item.id === 'Paint2').onClick();",
-        "updateTools();",
-        "const layerWeight = () => terrain.getLayerWeightAt(targetX, targetY, 2);",
-        "const weightBefore = layerWeight();",
-        "harness.setMousePositionScreen(game.getGameResolutionWidth() / 2, game.getGameResolutionHeight() / 2);",
-        "isViewMoved = true;",
-        "harness.setMouseButtonPressed(true);",
-        "for (let frame = 0; frame < 5; frame++) {",
-        "  await harness.stepFrames(1);",
-        "  updateTools();",
-        "}",
-        "harness.setMouseButtonPressed(false);",
-        "await harness.stepFrames(1, { onFrame: updateTools });",
-        "harness.assert(layerWeight() === weightBefore && savedProperties.length === 0, 'The brush is not applied while the view is moved.');",
-        "isViewMoved = false;",
-        "harness.setMouseButtonPressed(true);",
-        "for (let frame = 0; frame < 20 && layerWeight() < 0.8; frame++) {",
-        "  await harness.stepFrames(1);",
-        "  updateTools();",
-        "  await new Promise((resolve) => setTimeout(resolve, 30));",
-        "}",
-        "harness.setMouseButtonPressed(false);",
-        "await harness.stepFrames(1, { onFrame: updateTools });",
-        "const weightAfter = layerWeight();",
-        "console.log('layer 2 weight before=' + weightBefore.toFixed(2) + ' after=' + weightAfter.toFixed(2) + ' saves=' + savedProperties.length);",
-        "harness.assert(weightAfter > weightBefore + 0.3, 'The layer is painted on the mountains.');",
-        "harness.assert(savedProperties.length === 1, 'The stroke is saved.');",
-        "",
-        "// The saved data gives back the painted mountains.",
-        "terrainObject._objectData.SculptData = savedProperties[0].SculptData;",
-        "terrain.loadFromProperties();",
-        "harness.assert(Math.abs(layerWeight() - weightAfter) < 0.02, 'The saved data gives back the paint on the mountains.');",
-        "",
-        "// A heightmap image still loading: the relief is used until the image is loaded.",
-        "const imageManager = game.getImageManager();",
-        "const { getImageSource, loadResource } = imageManager;",
-        "let finishLoadingImage = () => {};",
-        "imageManager.getImageSource = () => null;",
-        "imageManager.loadResource = () => new Promise((resolve) => (finishLoadingImage = resolve));",
-        "const objectDataWithMountains = scene._objects.get('Terrain');",
-        "const objectDataWithHeightmap = JSON.parse(JSON.stringify(objectDataWithMountains));",
-        "objectDataWithHeightmap.content.HeightmapImage = 'assets/TerrainRock.jpg';",
-        "objectDataWithHeightmap.content.SculptData = '';",
-        "const mountainsHeight = terrain.getHeightAt(targetX, targetY);",
-        "try {",
-        "  terrainObject.updateFromObjectData(objectDataWithMountains, objectDataWithHeightmap);",
-        "} finally {",
-        "  imageManager.getImageSource = getImageSource;",
-        "  imageManager.loadResource = loadResource;",
-        "}",
-        "harness.assert(",
-        "  Math.abs(terrain.getHeightAt(targetX, targetY) - mountainsHeight) < 1,",
-        "  'The relief is used while the heightmap image loads.'",
+        "harness.setRandomSeed(1);",
+        "const landed = await harness.stepUntil(",
+        "  () => harness.getObjects('Player')[0].behaviors.PhysicsCharacter3D.state.IsOnFloor === true,",
+        "  { maxFrames: 120 }",
         ");",
-        "finishLoadingImage();",
-        "await harness.stepFrames(1);",
-        "harness.assert(Math.abs(terrain.getHeightAt(targetX, targetY) - mountainsHeight) > 1, 'The ground follows the heightmap.');"
-      ]
-    },
-    {
-      "name": "The tint and wetness are saved and loaded without loss",
-      "type": "gameplay",
-      "description": "Paints tints and wetness (with raised ground and painted layers) on terrains of several reliefs and resolutions: the saved data gives back the same colors. Also checks that unpainted data stays tiny, that data saved before tint and wetness existed (format 1) is still read, the tint and wetness edits, and that copies and resampled terrains keep the colors.",
-      "source": [
-        "await harness.goToScene('Game Scene');",
-        "const { TerrainData, SampleRectangle, codec, relief, brushes, edits } = gdjs.__terrain3DExtension;",
-        "const makeBase = (resolution, reliefName) => {",
-        "  const data = new TerrainData(resolution);",
-        "  relief.generate(data, reliefName, 42);",
-        "  return data;",
-        "};",
-        "const copy = (data) => {",
-        "  const result = new TerrainData(data.resolution);",
-        "  result.copyFrom(data);",
-        "  return result;",
-        "};",
-        "// A brush stroke on a terrain of 4096 by 4096.",
-        "const stroke = (resolution, ax, ay, bx, by, radius) => ({ cellWidth: 4096 / resolution, cellHeight: 4096 / resolution, ax, ay, bx, by, radius });",
-        "const areSame = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);",
-        "const isUnpainted = (data) => data.colors.every((value, index) => value === (index % 4 === 3 ? 0 : 255));",
-        "",
-        "for (const reliefName of ['Flat', 'Island']) {",
-        "  for (const resolution of [64, 256]) {",
-        "    const base = makeBase(resolution, reliefName);",
-        "    const data = copy(base);",
-        "    const changed = new SampleRectangle();",
-        "    brushes.raise(data, stroke(resolution, 1000, 1500, 1200, 1500, 300), 0.2, changed);",
-        "    brushes.paint(data, stroke(resolution, 500, 500, 3500, 3000, 120), 1, 1, changed);",
-        "    for (let k = 0; k < 10; k++) brushes.tint(data, stroke(resolution, 2000 + k * 30, 2000, 2000 + k * 30, 2000, 400), [120, 140, 60], 0.3, changed);",
-        "    brushes.tint(data, stroke(resolution, 600, 3000, 3000, 600, 200), [255, 205, 120], 1, changed);",
-        "    brushes.wet(data, stroke(resolution, 3000, 3000, 3000, 3000, 500), 1, 1, changed);",
-        "    brushes.wet(data, stroke(resolution, 3100, 3000, 3100, 3000, 200), 0.3, 0.5, changed);",
-        "    harness.assert(!isUnpainted(data), 'The brushes paint the tint and the wetness.');",
-        "    const decoded = codec.decode(codec.encode(data, base), (decodedResolution) => makeBase(decodedResolution, reliefName));",
-        "    const label = reliefName + ' at ' + resolution;",
-        "    harness.assert(areSame(decoded.colors, data.colors), 'The tint and wetness are kept (' + label + ').');",
-        "    harness.assert(areSame(decoded.splat, data.splat), 'The layers are kept (' + label + ').');",
-        "    let maxHeightError = 0;",
-        "    for (let i = 0; i < data.heights.length; i++) maxHeightError = Math.max(maxHeightError, Math.abs(decoded.heights[i] - data.heights[i]));",
-        "    harness.assert(maxHeightError <= 0.5 / 65535 + 1e-7, 'The heights are kept (' + label + ').');",
-        "  }",
-        "}",
-        "",
-        "// Unpainted tint and wetness cost almost nothing to save.",
-        "const untouched = codec.encode(makeBase(512, 'Mountains'), makeBase(512, 'Mountains'));",
-        "console.log('untouched 512 x 512 terrain: ' + untouched.length + ' characters');",
-        "harness.assert(untouched.startsWith('2;512;') && untouched.length < 100, 'Untouched data takes almost no space.');",
-        "const memoryBase = new TerrainData(256);",
-        "harness.assert(memoryBase.colors.length === memoryBase.size * memoryBase.size * 4, 'The tint and wetness take 4 bytes per sample.');",
-        "",
-        "// Data saved before the tint and the wetness existed (format 1).",
-        "const formatOneData = '1;64;AP0OygHJAQA9sAjMNNga1xrLNK8IADvMNKgwjhCNEKcwyzQAOsoB2BqOELAFrwWNENcayQEAOckB1xqNEK8FsAWOENgaygEAOss0pzCNEI4QqDDMNAA7rwjLNNca2BrMNLAIAD3JAcoBALsOAPwWKw04AgA8SccBF6IBiAEAPD83BS5QADxeXgpJewA8LMgBHLEBXQA9BgYLAL0HAIEhAPwWLA43AQA8SsgBGKEBhwEAPEA4Bi1PADxdXQlKfAA8K8cBG7IBXgA9BQUMAL0HAIEh';",
-        "const decodedFormatOne = codec.decode(formatOneData, () => new TerrainData(64));",
-        "harness.assert(!!decodedFormatOne, 'Format 1 data is read.');",
-        "harness.assert(Math.abs(decodedFormatOne.getHeight(32, 32) - 0.25) < 1e-4 && decodedFormatOne.getDominantLayer(15.6, 46.9) === 2, 'Format 1 data gives back the heights and layers.');",
-        "harness.assert(isUnpainted(decodedFormatOne), 'Format 1 data has no tint and is dry.');",
-        "",
-        "// Edits: tint and wetness strokes described in JSON.",
-        "const edited = new TerrainData(64);",
-        "edits.apply(edited, JSON.stringify([",
-        "  { tool: 'tint', x: 0.5, y: 0.5, radius: 0.1, color: '120;140;60' },",
-        "  { tool: 'wetness', x: 0.2, y: 0.2, radius: 0.1, amount: 0.5 },",
-        "  { tool: 'tint', x: 0.8, y: 0.8, radius: 0.1, color: 'not a color' },",
-        "]));",
-        "const colorAt = (data, i, j, channel) => data.colors[(j * data.size + i) * 4 + channel];",
-        "harness.assert(colorAt(edited, 32, 32, 0) === 120 && colorAt(edited, 32, 32, 1) === 140 && colorAt(edited, 32, 32, 2) === 60, 'The tint edit is applied.');",
-        "harness.assert(colorAt(edited, 13, 13, 3) === 128 && colorAt(edited, 32, 32, 3) === 0, 'The wetness edit is applied.');",
-        "",
-        "// Copies (like undo steps) and resampled terrains keep the colors.",
-        "const painted = copy(edited);",
-        "harness.assert(areSame(painted.colors, edited.colors), 'A copy keeps the colors.');",
-        "const resampled = edited.resampled(128);",
-        "harness.assert(colorAt(resampled, 64, 64, 0) === 120 && colorAt(resampled, 26, 26, 3) === 128, 'A resampled terrain keeps the colors.');"
-      ]
-    },
-    {
-      "name": "The ground is tinted and made wet by the beach, events and brushes",
-      "type": "gameplay",
-      "description": "Checks the wet sand near the water and the dry patches of the island (with the grass taking their tint), the actions and expressions to tint the ground and change its wetness, and the \"Tint\" and \"Wetness\" brushes of the scene editor (with a stand-in for the editor, with and without a color picker in its toolbar).",
-      "source": [
-        "// Each brush stroke takes a few seconds in the software renderer used to run tests.",
-        "harness.setTimeoutMs(60000);",
-        "await harness.goToScene('Game Scene');",
-        "await harness.stepFrames(2);",
-        "const game = harness.getRuntimeGame();",
-        "const scene = harness.getCurrentRuntimeScene();",
-        "scene.getObjects('Player')[0].getBehavior('ThirdPersonCamera').activate(false);",
-        "const terrainObject = scene.getObjects('Terrain')[0];",
-        "const terrain = terrainObject.__terrain3D;",
-        "",
-        "// The beach is wet near the water, and the meadow is dry.",
-        "const wetShoreZ = terrainObject._getWetShoreZ();",
-        "let beach = null;",
-        "let meadow = null;",
-        "for (let x = -1300; x < 2600 && (!beach || !meadow); x += 20) {",
-        "  const y = 750;",
-        "  const z = terrain.getHeightAt(x, y);",
-        "  if (!beach && z > -38 && z < wetShoreZ) beach = { x, y };",
-        "  if (!meadow && z > 30) meadow = { x, y };",
-        "}",
-        "harness.assert(!!beach && !!meadow, 'There is a beach and a meadow.');",
-        "harness.assert(terrain.getWetnessAt(beach.x, beach.y) === 1, 'The sand near the water is wet.');",
-        "harness.assert(terrain.getWetnessAt(meadow.x, meadow.y) === 0, 'The meadow is dry.');",
-        "",
-        "// A dry patch of the meadow (painted by the edits), and the grass growing on it.",
-        "const dryPatch = terrain.getTintAt(420, 1080);",
-        "console.log('dry patch tint: ' + dryPatch.join(';'));",
-        "harness.assert(dryPatch[2] < 150 && dryPatch[0] > dryPatch[2], 'The meadow has a dry patch.');",
-        "const grass = scene.getObjects('Grass')[0].__terrainGrass;",
-        "let tintedBlades = 0;",
-        "let blades = 0;",
-        "for (const chunk of grass.chunks) {",
-        "  const tints = chunk.mesh.geometry.attributes.grassGroundTint;",
-        "  for (let blade = 0; blade < tints.count; blade++) {",
-        "    blades++;",
-        "    if (tints.getZ(blade) < 0.5) tintedBlades++;",
-        "  }",
-        "}",
-        "console.log(tintedBlades + ' of ' + blades + ' blades take the tint of the ground');",
-        "harness.assert(tintedBlades > 0 && tintedBlades < blades / 2, 'The blades on the dry patch take its tint.');",
-        "",
-        "// Actions and expressions.",
-        "const spot = { x: meadow.x + 300, y: meadow.y - 300 };",
-        "terrainObject.TintGround(spot.x, spot.y, 120, '90;60;30', undefined);",
-        "terrainObject.WetGround(spot.x, spot.y, 120, 0.75, undefined);",
-        "await harness.stepFrames(1);",
-        "console.log('tint ' + terrainObject.GroundTint(spot.x, spot.y, undefined) + ', wetness ' + terrainObject.GroundWetness(spot.x, spot.y, undefined));",
-        "harness.assert(terrainObject.GroundTint(spot.x, spot.y, undefined) === '90;60;30', 'The tint action and expression work.');",
-        "harness.assert(Math.abs(terrainObject.GroundWetness(spot.x, spot.y, undefined) - 0.75) < 0.01, 'The wetness action and expression work.');",
-        "terrainObject.TintGround(spot.x, spot.y, 120, '255;255;255', undefined);",
-        "harness.assert(terrainObject.GroundTint(spot.x, spot.y, undefined) === '255;255;255', 'White removes the tint.');",
-        "",
-        "// The brushes of the scene editor.",
-        "const target = { x: meadow.x + 600, y: meadow.y + 200 };",
-        "gdjs.evtTools.camera.setCameraX(scene, target.x, '', 0);",
-        "gdjs.evtTools.camera.setCameraY(scene, target.y, '', 0);",
-        "gdjs.scene3d.camera.setCameraZ(scene, terrain.getHeightAt(target.x, target.y) + 800, '', 0);",
-        "gdjs.scene3d.camera.setCameraRotationX(scene, 0, '', 0);",
-        "gdjs.evtTools.camera.setCameraRotation(scene, 0, '', 0);",
-        "await harness.stepFrames(1);",
-        "const savedProperties = [];",
-        "let toolbarItems = null;",
-        "let hasColorPicker = false;",
-        "const editor = {",
-        "  getRuntimeGame: () => game,",
-        "  getSelectedObjects: () => [terrainObject],",
-        "  captureLeftMouseButton: () => {},",
-        "  isCapturedLeftMouseButtonPressed: () => game.getInputManager().isMouseButtonPressed(0),",
-        "  updateObjectProperties: (objectName, properties) => savedProperties.push(properties),",
-        "  showToolbar: (toolbarId, items) => (toolbarItems = items),",
-        "};",
-        "const updateTools = () => gdjs.callbacksInGameEditorPostStep.forEach((callback) => callback(editor));",
-        "const drag = async () => {",
-        "  harness.setMousePositionScreen(game.getGameResolutionWidth() / 2, game.getGameResolutionHeight() / 2);",
-        "  harness.setMouseButtonPressed(true);",
-        "  for (let frame = 0; frame < 8; frame++) {",
-        "    await harness.stepFrames(1);",
-        "    updateTools();",
-        "    await new Promise((resolve) => setTimeout(resolve, 40));",
-        "  }",
-        "  harness.setMouseButtonPressed(false);",
-        "  await harness.stepFrames(1, { onFrame: updateTools });",
-        "};",
-        "const getItem = (id) => toolbarItems.find((item) => item.id === id);",
-        "updateTools();",
-        "getItem('Strength').onChange(100);",
-        "getItem('Tint').onClick();",
-        "updateTools();",
-        "harness.assert(!!getItem('TintPreset#a5c45a') && !getItem('TintColor'), 'Without a color picker in the toolbar, colors are chosen among presets.');",
-        "hasColorPicker = true;",
-        "editor.isToolbarItemTypeSupported = (type) => hasColorPicker && type === 'color';",
-        "updateTools();",
-        "harness.assert(!!getItem('TintColor') && getItem('TintColor').type === 'color', 'The color of the tint is chosen with a color picker.');",
-        "getItem('TintColor').onChange('#336699');",
-        "updateTools();",
-        "await drag();",
-        "const brushedTint = terrain.getTintAt(target.x, target.y);",
-        "console.log('tint under the brush: ' + brushedTint.join(';'));",
-        "harness.assert(Math.abs(brushedTint[0] - 0x33) < 8 && Math.abs(brushedTint[1] - 0x66) < 8 && Math.abs(brushedTint[2] - 0x99) < 8, 'The tint brush paints the chosen color.');",
-        "harness.assert(savedProperties.length === 1 && savedProperties[0].SculptData.startsWith('2;'), 'The stroke is saved.');",
-        "getItem('Wetness').onClick();",
-        "updateTools();",
-        "getItem('WetnessAmount').onChange(60);",
-        "updateTools();",
-        "await drag();",
-        "const brushedWetness = terrain.getWetnessAt(target.x, target.y);",
-        "console.log('wetness under the brush: ' + brushedWetness.toFixed(2));",
-        "harness.assert(Math.abs(brushedWetness - 0.6) < 0.03, 'The wetness brush makes the ground as wet as chosen.');",
-        "",
-        "// The saved data gives back the tint and the wetness.",
-        "terrainObject._objectData.SculptData = savedProperties[savedProperties.length - 1].SculptData;",
-        "terrain.loadFromProperties();",
-        "harness.assert(terrain.getTintAt(target.x, target.y).join(';') === brushedTint.join(';') && Math.abs(terrain.getWetnessAt(target.x, target.y) - brushedWetness) < 0.01, 'The saved data gives back the tint and the wetness.');"
-      ]
-    },
-    {
-      "name": "Holes are made and filled with the brushes of the scene editor",
-      "type": "gameplay",
-      "description": "Makes a hole in the meadow with the \"Hole\" brush of the scene editor (with a stand-in for the editor), and fills it with the \"Fill holes\" brush: the ground gets back the layer around it and its collisions. Also checks the \"fill\" edit and the actions.",
-      "source": [
-        "// Each brush stroke takes a few seconds in the software renderer used to run tests.",
-        "harness.setTimeoutMs(60000);",
-        "await harness.goToScene('Game Scene');",
-        "await harness.stepFrames(2);",
-        "const game = harness.getRuntimeGame();",
-        "const scene = harness.getCurrentRuntimeScene();",
-        "scene.getObjects('Player')[0].getBehavior('ThirdPersonCamera').activate(false);",
-        "const terrainObject = scene.getObjects('Terrain')[0];",
-        "const terrain = terrainObject.__terrain3D;",
-        "const countHoleSamples = () => terrainObject.getSurface().getHeightField().heights.filter(Number.isNaN).length;",
-        "",
-        "// A spot in the meadow, looked at from above.",
-        "let meadow = null;",
-        "for (let x = -1300; x < 2600 && !meadow; x += 20) {",
-        "  if (terrain.getHeightAt(x, 750) > 30) meadow = { x: x + 600, y: 950 };",
-        "}",
-        "harness.assert(!!meadow, 'There is a meadow.');",
-        "const meadowLayer = terrain.getLayerAt(meadow.x, meadow.y);",
-        "gdjs.evtTools.camera.setCameraX(scene, meadow.x, '', 0);",
-        "gdjs.evtTools.camera.setCameraY(scene, meadow.y, '', 0);",
-        "gdjs.scene3d.camera.setCameraZ(scene, terrain.getHeightAt(meadow.x, meadow.y) + 800, '', 0);",
-        "gdjs.scene3d.camera.setCameraRotationX(scene, 0, '', 0);",
-        "gdjs.evtTools.camera.setCameraRotation(scene, 0, '', 0);",
-        "await harness.stepFrames(1);",
-        "",
-        "const savedProperties = [];",
-        "let toolbarItems = null;",
-        "const editor = {",
-        "  getRuntimeGame: () => game,",
-        "  getSelectedObjects: () => [terrainObject],",
-        "  captureLeftMouseButton: () => {},",
-        "  isCapturedLeftMouseButtonPressed: () => game.getInputManager().isMouseButtonPressed(0),",
-        "  updateObjectProperties: (objectName, properties) => savedProperties.push(properties),",
-        "  showToolbar: (toolbarId, items) => (toolbarItems = items),",
-        "};",
-        "const updateTools = () => gdjs.callbacksInGameEditorPostStep.forEach((callback) => callback(editor));",
-        "const useTool = async (toolId) => {",
-        "  updateTools();",
-        "  const toolButton = toolbarItems.find((item) => item.id === toolId);",
-        "  harness.assert(!!toolButton, 'The toolbar has the \"' + toolId + '\" tool.');",
-        "  toolButton.onClick();",
-        "  harness.setMousePositionScreen(game.getGameResolutionWidth() / 2, game.getGameResolutionHeight() / 2);",
-        "  harness.setMouseButtonPressed(true);",
-        "  for (let frame = 0; frame < 4; frame++) {",
-        "    await harness.stepFrames(1);",
-        "    updateTools();",
-        "  }",
-        "  harness.setMouseButtonPressed(false);",
-        "  await harness.stepFrames(1, { onFrame: updateTools });",
-        "  toolbarItems.find((item) => item.id === toolId).onClick();",
-        "};",
-        "const holeSamplesBefore = countHoleSamples();",
-        "await useTool('Hole');",
-        "const holeSamples = countHoleSamples() - holeSamplesBefore;",
-        "console.log('hole brush: ' + holeSamples + ' samples without collisions, hole at the center: ' + terrain.isHoleAt(meadow.x, meadow.y));",
-        "harness.assert(terrain.isHoleAt(meadow.x, meadow.y) && holeSamples > 0, 'The \"Hole\" brush makes a hole.');",
-        "",
-        "await useTool('FillHoles');",
-        "console.log('fill brush: ' + (countHoleSamples() - holeSamplesBefore) + ' samples without collisions, layer ' + terrain.getLayerAt(meadow.x, meadow.y) + ' (meadow: ' + meadowLayer + '), ' + savedProperties.length + ' saves');",
-        "harness.assert(!terrain.isHoleAt(meadow.x, meadow.y), 'The \"Fill holes\" brush fills the hole.');",
-        "harness.assert(countHoleSamples() === holeSamplesBefore, 'The ground has collisions again.');",
-        "harness.assert(terrain.getLayerAt(meadow.x, meadow.y) === meadowLayer, 'The hole is filled with the layer of the ground around it.');",
-        "harness.assert(savedProperties.length === 2 && !!savedProperties[1].SculptData, 'Each stroke is saved in the object properties.');",
-        "",
-        "// The actions.",
-        "const spot = { x: meadow.x + 400, y: meadow.y };",
-        "terrainObject.MakeHole(spot.x, spot.y, 100, undefined);",
-        "harness.assert(terrain.isHoleAt(spot.x, spot.y), 'The \"Make a hole\" action makes a hole.');",
-        "terrainObject.FillHoles(spot.x, spot.y, 100, undefined);",
-        "harness.assert(!terrain.isHoleAt(spot.x, spot.y) && terrain.getLayerAt(spot.x, spot.y) === terrain.getLayerAt(spot.x + 200, spot.y), 'The \"Fill holes\" action fills it with the layer around it.');",
-        "",
-        "// The edits: a hole, filled again except in its middle.",
-        "const { TerrainData, edits } = gdjs.__terrain3DExtension;",
-        "const data = new TerrainData(64);",
-        "data.fillLayer(2);",
-        "edits.apply(data, JSON.stringify([",
-        "  { tool: 'hole', x: 0.5, y: 0.5, radius: 0.2 },",
-        "  { tool: 'fill', x: 0.3, y: 0.5, toX: 0.7, toY: 0.5, radius: 0.2 },",
-        "  { tool: 'hole', x: 0.5, y: 0.5, radius: 0.05 },",
-        "]));",
-        "const sampleIndex = (x, y) => Math.round(y * data.resolution) * data.size + Math.round(x * data.resolution);",
-        "console.log('edits: hole in the middle ' + data.isHole(sampleIndex(0.5, 0.5)) + ', filled at 0.38;0.5 ' + !data.isHole(sampleIndex(0.38, 0.5)) + ' with layer ' + data.getDominantLayer(0.38 * data.resolution, 0.5 * data.resolution));",
-        "harness.assert(data.isHole(sampleIndex(0.5, 0.5)) && !data.isHole(sampleIndex(0.38, 0.5)), 'The \"fill\" edit fills holes.');",
-        "harness.assert(data.getDominantLayer(0.38 * data.resolution, 0.5 * data.resolution) === 2, 'The \"fill\" edit uses the layer around the hole.');"
+        "harness.assert(landed, 'The player lands on the island.');",
+        "await harness.stepFrames(30);",
+        "await harness.takeScreenshot('the view of the player', { width: 640, format: 'png' });",
+        "const player = harness.getObjects('Player')[0];",
+        "harness.lookAt({ from: { x: player.centerX - 700, y: player.centerY + 300, z: player.z + 900 }, to: { x: player.centerX, y: player.centerY, z: player.z } });",
+        "await harness.takeScreenshot('the island from above', { width: 640, format: 'png' });"
       ]
     }
   ],
diff --git a/examples/3d-light-playground/3d-light-playground.json b/examples/3d-light-playground/3d-light-playground.json
index 62445aeb7..0c17fb654 100644
--- a/examples/3d-light-playground/3d-light-playground.json
+++ b/examples/3d-light-playground/3d-light-playground.json
@@ -8850,6 +8850,21 @@
         "    'camera moves (saw ' + seen.size + ': ' + [...seen].join(', ') + ').');",
         "await harness.takeScreenshot('one kind held steady while the camera swept');"
       ]
+    },
+    {
+      "name": "Rendering: the lights of each scene",
+      "type": "gameplay",
+      "description": "",
+      "source": [
+        "harness.setMaxScreenshots(8);",
+        "for (const sceneName of ['Sun and Shadows', 'Point Lights', 'Spot Lights', 'Mixed Lights']) {",
+        "  await harness.goToScene(sceneName);",
+        "  harness.setRandomSeed(1);",
+        "  await harness.stepFrames(10);",
+        "  await harness.takeScreenshot(sceneName, { width: 640, format: 'png' });",
+        "}",
+        "harness.assert(true, 'Every scene was drawn.');"
+      ]
     }
   ]
 }
diff --git a/examples/starting-expanded-3d-house-horror/starting-expanded-3d-house-horror.json b/examples/starting-expanded-3d-house-horror/starting-expanded-3d-house-horror.json
index cb01b0113..5a86f62fd 100644
--- a/examples/starting-expanded-3d-house-horror/starting-expanded-3d-house-horror.json
+++ b/examples/starting-expanded-3d-house-horror/starting-expanded-3d-house-horror.json
@@ -10528,6 +10528,20 @@
         "harness.assert(highest > 300, 'The monster climbed the stairs (highest: ' + Math.round(highest) + ').');",
         "harness.assert(caught, 'The monster caught the player upstairs, which restarted the scene.');"
       ]
+    },
+    {
+      "name": "Rendering: the house",
+      "type": "gameplay",
+      "description": "",
+      "source": [
+        "await harness.goToScene('Game Scene');",
+        "harness.setRandomSeed(1);",
+        "harness.setTimeoutMs(120000);",
+        "await harness.stepFrames(10);",
+        "harness.assert(harness.getObjects('Player').length === 1, 'The player is in the house.');",
+        "// The texts are hidden: they are drawn with the font settings of the system, which differ from one machine to another.",
+        "await harness.takeScreenshot('the view of the player', { width: 640, format: 'png', hideLayers: ['UI'] });"
+      ]
     }
   ],
   "eventsFunctionsExtensions": [
diff --git a/examples/starting-platformer/starting-platformer.json b/examples/starting-platformer/starting-platformer.json
index 9a916d6db..af7de41e1 100644
--- a/examples/starting-platformer/starting-platformer.json
+++ b/examples/starting-platformer/starting-platformer.json
@@ -1280,6 +1280,22 @@
         "// the test results.",
         "await harness.takeScreenshot('the level once every coin has been collected');"
       ]
+    },
+    {
+      "name": "Rendering: the level",
+      "type": "gameplay",
+      "description": "",
+      "source": [
+        "await harness.goToScene('Game Scene');",
+        "harness.setRandomSeed(1);",
+        "const landed = await harness.stepUntil(",
+        "  () => harness.getObjects('Player')[0].behaviors.PlatformerObject.state.IsOnFloor === true,",
+        "  { maxFrames: 120 }",
+        ");",
+        "harness.assert(landed, 'The player lands on the ground.');",
+        "await harness.stepFrames(10);",
+        "await harness.takeScreenshot('the level', { width: 640, format: 'png' });"
+      ]
     }
   ],
   "eventsFunctionsExtensions": [
diff --git a/package-lock.json b/package-lock.json
index 414afd6aa..ee4a25082 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12,11 +12,13 @@
         "axios": "^0.21.1",
         "dree": "^2.6.1",
         "minimist": "^1.2.5",
+        "pngjs": "^7.0.0",
         "shelljs": "^0.8.4"
       },
       "devDependencies": {
         "@types/jest": "^26.0.23",
         "@types/minimist": "^1.2.1",
+        "@types/pngjs": "^6.0.5",
         "@types/shelljs": "^0.8.8",
         "jest": "^27.0.1",
         "prettier": "^2.3.0",
@@ -996,6 +998,16 @@
       "integrity": "sha512-7EIraBEyRHEe7CH+Fm1XvgqU6uwZN8Q7jppJGcqjROMT29qhAuuOxYB1uEY5UMYQKEmA5D+5tBnhdaPXSsLONA==",
       "dev": true
     },
+    "node_modules/@types/pngjs": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/@types/pngjs/-/pngjs-6.0.5.tgz",
+      "integrity": "sha512-0k5eKfrA83JOZPppLtS2C7OUtyNAl2wKNxfyYl9Q5g9lPkgBl/9hNyAu6HuEH2J4XmIv2znEpkDd0SaZVxW6iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/prettier": {
       "version": "2.2.3",
       "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.2.3.tgz",
@@ -3318,6 +3330,15 @@
         "node": ">=8"
       }
     },
+    "node_modules/pngjs": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-7.0.0.tgz",
+      "integrity": "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.19.0"
+      }
+    },
     "node_modules/prelude-ls": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
@@ -4900,6 +4921,15 @@
       "integrity": "sha512-7EIraBEyRHEe7CH+Fm1XvgqU6uwZN8Q7jppJGcqjROMT29qhAuuOxYB1uEY5UMYQKEmA5D+5tBnhdaPXSsLONA==",
       "dev": true
     },
+    "@types/pngjs": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/@types/pngjs/-/pngjs-6.0.5.tgz",
+      "integrity": "sha512-0k5eKfrA83JOZPppLtS2C7OUtyNAl2wKNxfyYl9Q5g9lPkgBl/9hNyAu6HuEH2J4XmIv2znEpkDd0SaZVxW6iQ==",
+      "dev": true,
+      "requires": {
+        "@types/node": "*"
+      }
+    },
     "@types/prettier": {
       "version": "2.2.3",
       "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.2.3.tgz",
@@ -6666,6 +6696,11 @@
         "find-up": "^4.0.0"
       }
     },
+    "pngjs": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-7.0.0.tgz",
+      "integrity": "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow=="
+    },
     "prelude-ls": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
diff --git a/package.json b/package.json
index 27e6fff5f..7506ae8fc 100644
--- a/package.json
+++ b/package.json
@@ -17,11 +17,13 @@
     "axios": "^0.21.1",
     "dree": "^2.6.1",
     "minimist": "^1.2.5",
+    "pngjs": "^7.0.0",
     "shelljs": "^0.8.4"
   },
   "devDependencies": {
     "@types/jest": "^26.0.23",
     "@types/minimist": "^1.2.1",
+    "@types/pngjs": "^6.0.5",
     "@types/shelljs": "^0.8.8",
     "jest": "^27.0.1",
     "prettier": "^2.3.0",
diff --git a/rendering-screenshots/3d-island-terrain/the-island-from-above.png b/rendering-screenshots/3d-island-terrain/the-island-from-above.png
new file mode 100644
index 000000000..43ae832c4
Binary files /dev/null and b/rendering-screenshots/3d-island-terrain/the-island-from-above.png differ
diff --git a/rendering-screenshots/3d-island-terrain/the-view-of-the-player.png b/rendering-screenshots/3d-island-terrain/the-view-of-the-player.png
new file mode 100644
index 000000000..70de1c621
Binary files /dev/null and b/rendering-screenshots/3d-island-terrain/the-view-of-the-player.png differ
diff --git a/rendering-screenshots/3d-light-playground/mixed-lights.png b/rendering-screenshots/3d-light-playground/mixed-lights.png
new file mode 100644
index 000000000..2bfc00ac8
Binary files /dev/null and b/rendering-screenshots/3d-light-playground/mixed-lights.png differ
diff --git a/rendering-screenshots/3d-light-playground/point-lights.png b/rendering-screenshots/3d-light-playground/point-lights.png
new file mode 100644
index 000000000..1ab80c19c
Binary files /dev/null and b/rendering-screenshots/3d-light-playground/point-lights.png differ
diff --git a/rendering-screenshots/3d-light-playground/spot-lights.png b/rendering-screenshots/3d-light-playground/spot-lights.png
new file mode 100644
index 000000000..998a78f7e
Binary files /dev/null and b/rendering-screenshots/3d-light-playground/spot-lights.png differ
diff --git a/rendering-screenshots/3d-light-playground/sun-and-shadows.png b/rendering-screenshots/3d-light-playground/sun-and-shadows.png
new file mode 100644
index 000000000..47e54445b
Binary files /dev/null and b/rendering-screenshots/3d-light-playground/sun-and-shadows.png differ
diff --git a/rendering-screenshots/starting-expanded-3d-house-horror/the-view-of-the-player.png b/rendering-screenshots/starting-expanded-3d-house-horror/the-view-of-the-player.png
new file mode 100644
index 000000000..aad781eda
Binary files /dev/null and b/rendering-screenshots/starting-expanded-3d-house-horror/the-view-of-the-player.png differ
diff --git a/rendering-screenshots/starting-platformer/the-level.png b/rendering-screenshots/starting-platformer/the-level.png
new file mode 100644
index 000000000..8a81e0424
Binary files /dev/null and b/rendering-screenshots/starting-platformer/the-level.png differ
diff --git a/scripts/check-rendering-screenshots.js b/scripts/check-rendering-screenshots.js
new file mode 100644
index 000000000..91c85f4ec
--- /dev/null
+++ b/scripts/check-rendering-screenshots.js
@@ -0,0 +1,282 @@
+// @ts-check
+/**
+ * Check that the games are still drawn the same: run the rendering tests of
+ * the games (their gameplay tests named "Rendering: ...", taking PNG
+ * screenshots) with a real GDevelop, and compare each screenshot with the
+ * expected image in `rendering-screenshots/<example slug>/<label>.png`.
+ *
+ * The games are drawn in software (SwiftShader), which draws the same pixels
+ * from one run to the next: an image that differs means that the rendering
+ * of GDevelop (or of the game) changed.
+ *
+ * Usage:
+ *   node scripts/check-rendering-screenshots.js [options]
+ *
+ *   --update                   Write the screenshots as the expected images
+ *                              (after a change of the rendering made on
+ *                              purpose). Check them in the diff.
+ *   --projects=a.json,b.json   Check only these games.
+ *   --only-changed             Check only the games whose project or expected
+ *   --base-ref=origin/main     images changed compared to --base-ref (every
+ *                              game if the scripts or the CI changed).
+ *   --gdevelop-branch=master   Branch of GDevelop to take the build from.
+ *   --gdevelop-version=5.6.286 Skip reading the version from the branch.
+ *   --work-dir=...             Where GDevelop is downloaded and extracted.
+ *   --artifacts-dir=...        Where the results, logs, screenshots and the
+ *                              differences with the expected images go.
+ *   --junit-path=...           Where the JUnit report is written.
+ *   --timeout-ms=600000        Time budget for a single game.
+ */
+const path = require('path');
+const shell = require('shelljs');
+const args = require('minimist')(process.argv.slice(2));
+
+const {
+  findProjectsWithGameplayTests,
+} = require('./lib/GameplayTestsProjectFinder');
+const { getGDevelopExecutable } = require('./lib/GDevelopPortableBuild');
+const { writeJUnitReport } = require('./lib/GameplayTestsJUnitReport');
+const {
+  runProjectGameplayTests,
+  getProjectArtifactsPath,
+} = require('./lib/GameplayTestsRunner');
+const { findChangedFiles } = require('./lib/ChangedProjectFiles');
+const {
+  RENDERING_TESTS_FILTER,
+  EXPECTED_SCREENSHOTS_DIRECTORY_NAME,
+  isRenderingTestName,
+  getScreenshotFileName,
+  getExpectedScreenshotsPath,
+  findScreenshotDifference,
+} = require('./lib/RenderingScreenshots');
+
+/** @typedef {import('./lib/GameplayTestsJUnitReport').ProjectRunResult} ProjectRunResult */
+/** @typedef {import('./lib/GameplayTestsJUnitReport').GameplayTestResult} GameplayTestResult */
+/** @typedef {import('./lib/GameplayTestsProjectFinder').ProjectWithGameplayTests} ProjectWithGameplayTests */
+
+const repositoryPath = path.resolve(__dirname, '..');
+const update = !!args['update'];
+const onlyChanged = !!args['only-changed'];
+const baseRef = args['base-ref'] || 'origin/main';
+const gdevelopBranch = args['gdevelop-branch'] || 'master';
+const gdevelopVersion = args['gdevelop-version'] || undefined;
+const workPath = path.resolve(
+  args['work-dir'] || path.join(repositoryPath, '.gameplay-tests-work')
+);
+const artifactsPath = path.resolve(
+  args['artifacts-dir'] ||
+    path.join(repositoryPath, 'rendering-screenshots-artifacts')
+);
+const junitPath = path.resolve(
+  args['junit-path'] ||
+    path.join(repositoryPath, 'rendering-screenshots-results/results.xml')
+);
+const timeoutMs = Number(args['timeout-ms']) || 10 * 60 * 1000;
+
+// Changing these can change the result of every game.
+const FILES_REQUIRING_A_FULL_CHECK = [
+  '.circleci/config.yml',
+  'package-lock.json',
+  'scripts/check-rendering-screenshots.js',
+  'scripts/lib/GameplayTestsRunner.js',
+  'scripts/lib/GDevelopPortableBuild.js',
+  'scripts/lib/RenderingScreenshots.js',
+];
+
+/**
+ * @param {ProjectWithGameplayTests[]} projects
+ * @returns {ProjectWithGameplayTests[]}
+ */
+const keepProjectsToCheck = (projects) => {
+  const explicitProjects =
+    typeof args['projects'] === 'string'
+      ? args['projects'].split(',').map((project) => project.trim())
+      : [];
+  if (explicitProjects.length > 0)
+    return projects.filter((project) =>
+      explicitProjects.includes(project.relativePath)
+    );
+  if (!onlyChanged) return projects;
+
+  const changes = findChangedFiles({ baseRef });
+  if (!changes) {
+    shell.echo('⚠️ Checking every game: the changed files are unknown.');
+    return projects;
+  }
+  if (
+    changes.changedFiles.some((changedFile) =>
+      FILES_REQUIRING_A_FULL_CHECK.includes(changedFile)
+    )
+  ) {
+    shell.echo('ℹ️ Checking every game: the scripts or the CI changed.');
+    return projects;
+  }
+  return projects.filter((project) =>
+    changes.changedFiles.some(
+      (changedFile) =>
+        changedFile === project.relativePath ||
+        changedFile.startsWith(
+          `${EXPECTED_SCREENSHOTS_DIRECTORY_NAME}/${project.exampleSlug}/`
+        )
+    )
+  );
+};
+
+/**
+ * Compare the screenshots of the rendering tests of a game with the
+ * expected images (or write them as the expected images when updating).
+ * @param {ProjectWithGameplayTests} project
+ * @param {ProjectRunResult} projectRunResult
+ * @returns {GameplayTestResult[]} One result per screenshot.
+ */
+const checkScreenshots = (project, projectRunResult) => {
+  const projectArtifactsPath = getProjectArtifactsPath({
+    artifactsPath,
+    relativePath: project.relativePath,
+  });
+  const expectedScreenshotsPath = getExpectedScreenshotsPath({
+    repositoryPath,
+    exampleSlug: project.exampleSlug,
+  });
+  if (update) {
+    // Images of screenshots not taken anymore would never be checked again.
+    shell.rm('-rf', expectedScreenshotsPath);
+    shell.mkdir('-p', expectedScreenshotsPath);
+  }
+
+  /** @type {GameplayTestResult[]} */
+  const screenshotResults = [];
+  for (const result of projectRunResult.results) {
+    for (const screenshot of result.screenshots || []) {
+      const label = screenshot.label || '';
+      const testName = `${result.testName} — ${label}`;
+      if (!screenshot.file || !screenshot.file.endsWith('.png')) {
+        screenshotResults.push({
+          testName,
+          status: 'failed',
+          errors: [
+            "The screenshot is not a PNG: take it with `{ format: 'png' }`.",
+          ],
+        });
+        continue;
+      }
+      const screenshotPath = path.join(projectArtifactsPath, screenshot.file);
+      const expectedScreenshotPath = path.join(
+        expectedScreenshotsPath,
+        getScreenshotFileName(label)
+      );
+      if (update) {
+        shell.cp(screenshotPath, expectedScreenshotPath);
+        screenshotResults.push({ testName, status: 'passed' });
+        continue;
+      }
+      const difference = findScreenshotDifference({
+        screenshotPath,
+        expectedScreenshotPath,
+      });
+      screenshotResults.push(
+        difference
+          ? { testName, status: 'failed', errors: [difference] }
+          : { testName, status: 'passed' }
+      );
+    }
+  }
+  return screenshotResults;
+};
+
+(async () => {
+  const projects = keepProjectsToCheck(
+    findProjectsWithGameplayTests({ repositoryPath }).filter((project) =>
+      project.testNames.some(isRenderingTestName)
+    )
+  );
+  if (projects.length === 0) {
+    shell.echo('✅ No game with rendering tests to check.');
+    writeJUnitReport({ projectRunResults: [], junitPath });
+    return;
+  }
+  shell.echo(
+    `ℹ️ Checking the rendering of ${projects.length} game(s):\n` +
+      projects.map((project) => `   - ${project.relativePath}`).join('\n')
+  );
+
+  const { executablePath, version } = await getGDevelopExecutable({
+    branch: gdevelopBranch,
+    version: gdevelopVersion,
+    workPath,
+  });
+  shell.rm('-rf', artifactsPath);
+  shell.mkdir('-p', artifactsPath);
+
+  /** @type {ProjectRunResult[]} */
+  const projectRunResults = [];
+  for (const project of projects) {
+    shell.echo(`\n▶ ${project.relativePath}`);
+    const projectRunResult = await runProjectGameplayTests({
+      executablePath,
+      repositoryPath,
+      relativePath: project.relativePath,
+      exampleSlug: project.exampleSlug,
+      artifactsPath,
+      timeoutMs,
+      testNamesOrFilters: [RENDERING_TESTS_FILTER],
+    });
+    // The rendering tests themselves must pass, and their screenshots be
+    // the expected ones.
+    projectRunResults.push({
+      ...projectRunResult,
+      results: [
+        ...projectRunResult.results.filter(
+          (result) => result.status !== 'passed'
+        ),
+        ...checkScreenshots(project, projectRunResult),
+      ],
+    });
+  }
+  writeJUnitReport({ projectRunResults, junitPath });
+
+  /** @type {string[]} */
+  const failureLines = [];
+  let checkedCount = 0;
+  for (const projectRunResult of projectRunResults) {
+    if (projectRunResult.runError) {
+      failureLines.push(
+        `   ❌ ${projectRunResult.relativePath} — ${
+          projectRunResult.runError.split('\n')[0]
+        }`
+      );
+    }
+    for (const result of projectRunResult.results) {
+      checkedCount++;
+      if (result.status === 'passed') continue;
+      failureLines.push(
+        `   ❌ ${projectRunResult.relativePath} — "${result.testName}": ${
+          (result.errors || [result.status])[0]
+        }`
+      );
+    }
+  }
+  shell.echo(
+    `\nℹ️ GDevelop ${version} — ${checkedCount} screenshot(s) ${
+      update ? 'written as the expected images' : 'checked'
+    }.`
+  );
+  shell.echo(`ℹ️ Screenshots and differences: ${artifactsPath}`);
+  if (failureLines.length > 0) {
+    shell.echo(failureLines.join('\n'));
+    shell.echo(
+      update
+        ? '❌ Some rendering tests did not pass: their images were not all written.'
+        : '❌ Some games are not drawn like their expected images. If the change is on purpose, update the images with `node scripts/check-rendering-screenshots.js --update`.'
+    );
+    shell.exit(1);
+  }
+  shell.echo(
+    update
+      ? `✅ The expected images were written in ${EXPECTED_SCREENSHOTS_DIRECTORY_NAME}/: check them in the diff.`
+      : '🎉 Every game is drawn like its expected images.'
+  );
+})().catch((error) => {
+  shell.echo(`❌ ${error && error.stack ? error.stack : error}`);
+  shell.exit(1);
+});
diff --git a/scripts/lib/ChangedProjectFiles.js b/scripts/lib/ChangedProjectFiles.js
index 0cdb9330d..1f5d9547d 100644
--- a/scripts/lib/ChangedProjectFiles.js
+++ b/scripts/lib/ChangedProjectFiles.js
@@ -16,6 +16,7 @@ const FILES_REQUIRING_A_FULL_RUN = [
   'scripts/lib/GDevelopPortableBuild.js',
   'scripts/lib/GameplayTestsJUnitReport.js',
   'scripts/lib/GameplayTestsProjectFinder.js',
+  'scripts/lib/GameplayTestsRunner.js',
 ];
 
 /**
diff --git a/scripts/lib/GameplayTestsRunner.js b/scripts/lib/GameplayTestsRunner.js
new file mode 100644
index 000000000..373d4efeb
--- /dev/null
+++ b/scripts/lib/GameplayTestsRunner.js
@@ -0,0 +1,223 @@
+// @ts-check
+/**
+ * Run the gameplay tests of a game with the GDevelop CLI, and gather its
+ * results, output and screenshots in a folder of artifacts.
+ */
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const shell = require('shelljs');
+
+/** @typedef {import('./GameplayTestsJUnitReport').ProjectRunResult} ProjectRunResult */
+/** @typedef {import('./GameplayTestsJUnitReport').GameplayTestResult} GameplayTestResult */
+
+/** The folder GDevelop writes the screenshots of a run into. */
+const SCREENSHOTS_DIRECTORY_NAME = 'gameplay-test-screenshots';
+
+/**
+ * The folder holding the results, GDevelop's output and the screenshots of
+ * the run of a game.
+ * @param {Object} options
+ * @param {string} options.artifactsPath
+ * @param {string} options.relativePath Project file, relative to the
+ * repository root.
+ * @returns {string}
+ */
+const getProjectArtifactsPath = ({ artifactsPath, relativePath }) =>
+  path.join(
+    artifactsPath,
+    relativePath.replace(/\//g, '__').replace(/\.json$/, '')
+  );
+
+/**
+ * Run the gameplay tests of a single game project.
+ * @param {Object} options
+ * @param {string} options.executablePath
+ * @param {string} options.repositoryPath Root of the repository.
+ * @param {string} options.relativePath Project file, relative to the
+ * repository root.
+ * @param {string} options.exampleSlug
+ * @param {string} options.artifactsPath Where the folder of the results,
+ * logs and screenshots of the game is written.
+ * @param {number} options.timeoutMs Time budget for the whole game.
+ * @param {string[]} [options.testNamesOrFilters] Only run the tests with
+ * these names, or matching these filters where `*` matches anything (all the
+ * tests when not given).
+ * @returns {Promise<ProjectRunResult>}
+ */
+const runProjectGameplayTests = async ({
+  executablePath,
+  repositoryPath,
+  relativePath,
+  exampleSlug,
+  artifactsPath,
+  timeoutMs,
+  testNamesOrFilters = [],
+}) => {
+  const projectPath = path.join(repositoryPath, relativePath);
+  const projectArtifactsPath = getProjectArtifactsPath({
+    artifactsPath,
+    relativePath,
+  });
+  shell.mkdir('-p', projectArtifactsPath);
+
+  // GDevelop writes its results next to the project file. Its `--results-path`
+  // option cannot be used: the main process only forwards the CLI flags it
+  // knows about, and drops that one (its value would even end up parsed as a
+  // second project to open). So the files are moved to the artifacts folder
+  // after the run instead.
+  const resultsPath = path.join(
+    path.dirname(projectPath),
+    'gameplay-test-results.json'
+  );
+  const screenshotsPath = path.join(
+    path.dirname(projectPath),
+    SCREENSHOTS_DIRECTORY_NAME
+  );
+  // Leftovers from a previous run would be mistaken for this run's results.
+  shell.rm('-f', resultsPath);
+  shell.rm('-rf', screenshotsPath);
+
+  const startTime = Date.now();
+  const { exitCode, output, timedOut } = await runGDevelopCli({
+    executablePath,
+    repositoryPath,
+    timeoutMs,
+    cliArguments: [
+      projectPath,
+      '--run-command',
+      'RUN_ALL_TESTS',
+      '--no-sandbox',
+      '--disable-update-check',
+      ...testNamesOrFilters.flatMap((testNameOrFilter) => [
+        '--cmd-args',
+        testNameOrFilter,
+      ]),
+    ],
+  });
+  const durationMs = Date.now() - startTime;
+
+  fs.writeFileSync(
+    path.join(projectArtifactsPath, 'gdevelop-output.log'),
+    output
+  );
+
+  // The screenshots a test took are written by GDevelop next to the results,
+  // in the game folder. Move them into this game's artifacts folder, next to
+  // the results file they belong to, so that CI stores both together.
+  const artifactsScreenshotsPath = path.join(
+    projectArtifactsPath,
+    SCREENSHOTS_DIRECTORY_NAME
+  );
+  // A previous attempt of the same game (a run retried after a timeout) would
+  // otherwise end up nested inside its own folder.
+  shell.rm('-rf', artifactsScreenshotsPath);
+  if (fs.existsSync(screenshotsPath)) {
+    shell.mv(screenshotsPath, artifactsScreenshotsPath);
+  }
+
+  /** @type {GameplayTestResult[]} */
+  let results = [];
+  let runError;
+  if (fs.existsSync(resultsPath)) {
+    try {
+      results = JSON.parse(fs.readFileSync(resultsPath, 'utf8'));
+    } catch (error) {
+      runError = `The results file written by GDevelop could not be read: ${error}`;
+    }
+    shell.rm('-f', resultsPath);
+    // GDevelop records where it wrote each screenshot as an absolute path in
+    // the game folder — where they no longer are. Point them at the file
+    // sitting next to the results instead, so the stored results are usable
+    // as they are (in the CI artifacts, or downloaded).
+    for (const result of results) {
+      for (const screenshot of result.screenshots || []) {
+        if (!screenshot.file) continue;
+        screenshot.file = path.posix.join(
+          SCREENSHOTS_DIRECTORY_NAME,
+          path.basename(screenshot.file)
+        );
+      }
+    }
+    fs.writeFileSync(
+      path.join(projectArtifactsPath, 'results.json'),
+      JSON.stringify(results, null, 2)
+    );
+  }
+  if (!runError && results.length === 0) {
+    runError = timedOut
+      ? `GDevelop did not finish within ${Math.round(
+          timeoutMs / 1000
+        )}s and was killed.`
+      : `GDevelop exited with code ${exitCode} without writing any test result. ` +
+        `Last lines of its output:\n${output
+          .split('\n')
+          .slice(-30)
+          .join('\n')}`;
+  }
+
+  return { relativePath, exampleSlug, durationMs, results, runError };
+};
+
+/**
+ * Spawn the GDevelop executable, capturing its output and killing it if it
+ * takes too long. Never rejects: the caller reports the failure.
+ * @param {Object} options
+ * @param {string} options.executablePath
+ * @param {string} options.repositoryPath
+ * @param {number} options.timeoutMs
+ * @param {string[]} options.cliArguments
+ * @returns {Promise<{ exitCode: number | null, output: string, timedOut: boolean }>}
+ */
+const runGDevelopCli = ({
+  executablePath,
+  repositoryPath,
+  timeoutMs,
+  cliArguments,
+}) =>
+  new Promise((resolve) => {
+    // Even in CLI mode, Electron needs a display to initialize its graphics
+    // stack on a headless Linux machine.
+    const child = spawn(
+      'xvfb-run',
+      ['-a', '--server-args=-screen 0 1280x800x24', executablePath].concat(
+        cliArguments
+      ),
+      { cwd: repositoryPath }
+    );
+
+    let output = '';
+    let timedOut = false;
+    /** @param {Buffer} data */
+    const onData = (data) => {
+      const text = data.toString();
+      output += text;
+      // Only echo the lines of the test runner itself: the editor is very
+      // verbose (asset loading, network errors on a CI machine...).
+      for (const line of text.split('\n')) {
+        if (line.includes('[CLI]')) shell.echo(`   ${line.trim()}`);
+      }
+    };
+    child.stdout.on('data', onData);
+    child.stderr.on('data', onData);
+
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGKILL');
+    }, timeoutMs);
+
+    child.on('error', (error) => {
+      clearTimeout(timeoutId);
+      resolve({ exitCode: null, output: `${output}\n${error}`, timedOut });
+    });
+    child.on('close', (exitCode) => {
+      clearTimeout(timeoutId);
+      resolve({ exitCode, output, timedOut });
+    });
+  });
+
+module.exports = {
+  runProjectGameplayTests,
+  getProjectArtifactsPath,
+  SCREENSHOTS_DIRECTORY_NAME,
+};
diff --git a/scripts/lib/RenderingScreenshots.js b/scripts/lib/RenderingScreenshots.js
new file mode 100644
index 000000000..39907cac5
--- /dev/null
+++ b/scripts/lib/RenderingScreenshots.js
@@ -0,0 +1,125 @@
+// @ts-check
+/**
+ * Compare the screenshots taken by the rendering tests of the games (the
+ * gameplay tests named "Rendering: ...") with the expected images stored in
+ * `rendering-screenshots/<example slug>/<screenshot label>.png`.
+ */
+const fs = require('fs');
+const path = require('path');
+const { PNG } = require('pngjs');
+
+/** The rendering tests of a game are the gameplay tests named like this. */
+const RENDERING_TESTS_FILTER = 'Rendering:*';
+const EXPECTED_SCREENSHOTS_DIRECTORY_NAME = 'rendering-screenshots';
+
+// A pixel differs when one of its channels changed by more than this.
+const CHANNEL_TOLERANCE = 8;
+// An image differs when more than this proportion of its pixels differs.
+const MAX_DIFFERING_PIXELS_RATIO = 0.001;
+
+/**
+ * @param {string} testName
+ * @returns {boolean}
+ */
+const isRenderingTestName = (testName) => testName.startsWith('Rendering:');
+
+/**
+ * @param {string} label
+ * @returns {string}
+ */
+const getScreenshotFileName = (label) =>
+  `${
+    label
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '') || 'screenshot'
+  }.png`;
+
+/**
+ * @param {Object} options
+ * @param {string} options.repositoryPath
+ * @param {string} options.exampleSlug
+ * @returns {string}
+ */
+const getExpectedScreenshotsPath = ({ repositoryPath, exampleSlug }) =>
+  path.join(repositoryPath, EXPECTED_SCREENSHOTS_DIRECTORY_NAME, exampleSlug);
+
+/**
+ * @typedef {Object} ImageComparison
+ * @property {number} differingPixelsRatio
+ * @property {PNG} diff The image drawn, darkened, with the pixels that
+ * differ in magenta.
+ */
+
+/**
+ * @param {PNG} actual
+ * @param {PNG} expected Must have the same size as `actual`.
+ * @returns {ImageComparison}
+ */
+const compareImages = (actual, expected) => {
+  const diff = new PNG({ width: actual.width, height: actual.height });
+  let differingPixelsCount = 0;
+  for (let index = 0; index < actual.data.length; index += 4) {
+    let maxChannelDifference = 0;
+    for (let channel = 0; channel < 4; channel++) {
+      maxChannelDifference = Math.max(
+        maxChannelDifference,
+        Math.abs(actual.data[index + channel] - expected.data[index + channel])
+      );
+    }
+    const isDiffering = maxChannelDifference > CHANNEL_TOLERANCE;
+    if (isDiffering) differingPixelsCount++;
+    diff.data[index] = isDiffering ? 255 : actual.data[index] * 0.3;
+    diff.data[index + 1] = isDiffering ? 0 : actual.data[index + 1] * 0.3;
+    diff.data[index + 2] = isDiffering ? 255 : actual.data[index + 2] * 0.3;
+    diff.data[index + 3] = 255;
+  }
+  return {
+    differingPixelsRatio: differingPixelsCount / (actual.width * actual.height),
+    diff,
+  };
+};
+
+/**
+ * Compare a screenshot with its expected image. When they differ, the
+ * differences are written next to the screenshot (`.diff.png`).
+ * @param {Object} options
+ * @param {string} options.screenshotPath
+ * @param {string} options.expectedScreenshotPath
+ * @returns {string | null} Why the screenshot is not the expected one, or
+ * null if it is.
+ */
+const findScreenshotDifference = ({
+  screenshotPath,
+  expectedScreenshotPath,
+}) => {
+  if (!fs.existsSync(expectedScreenshotPath)) {
+    return `There is no expected image (${path.basename(
+      expectedScreenshotPath
+    )}): create it with \`node scripts/check-rendering-screenshots.js --update\`.`;
+  }
+  const actual = PNG.sync.read(fs.readFileSync(screenshotPath));
+  const expected = PNG.sync.read(fs.readFileSync(expectedScreenshotPath));
+  if (actual.width !== expected.width || actual.height !== expected.height) {
+    return `The screenshot is ${actual.width}x${actual.height} instead of ${expected.width}x${expected.height}.`;
+  }
+  const { differingPixelsRatio, diff } = compareImages(actual, expected);
+  if (differingPixelsRatio <= MAX_DIFFERING_PIXELS_RATIO) return null;
+  fs.writeFileSync(
+    screenshotPath.replace(/\.png$/, '.diff.png'),
+    PNG.sync.write(diff)
+  );
+  return `${(differingPixelsRatio * 100).toFixed(
+    2
+  )}% of the pixels differ from the expected image (see the .diff.png next to the screenshot, differences in magenta).`;
+};
+
+module.exports = {
+  RENDERING_TESTS_FILTER,
+  EXPECTED_SCREENSHOTS_DIRECTORY_NAME,
+  isRenderingTestName,
+  getScreenshotFileName,
+  getExpectedScreenshotsPath,
+  compareImages,
+  findScreenshotDifference,
+};
diff --git a/scripts/lib/__tests__/RenderingScreenshots.spec.js b/scripts/lib/__tests__/RenderingScreenshots.spec.js
new file mode 100644
index 000000000..7473b6823
--- /dev/null
+++ b/scripts/lib/__tests__/RenderingScreenshots.spec.js
@@ -0,0 +1,105 @@
+// @ts-check
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { PNG } = require('pngjs');
+const {
+  getScreenshotFileName,
+  findScreenshotDifference,
+} = require('../RenderingScreenshots');
+
+/**
+ * A 100x100 grey image, with a square of another color in its top left corner.
+ * @param {{ squareSize: number, squareColor: [number, number, number] }} square
+ * @returns {Buffer}
+ */
+const createFakeScreenshot = ({ squareSize, squareColor }) => {
+  const image = new PNG({ width: 100, height: 100 });
+  for (let y = 0; y < 100; y++) {
+    for (let x = 0; x < 100; x++) {
+      const index = (y * 100 + x) * 4;
+      const color =
+        x < squareSize && y < squareSize ? squareColor : [128, 128, 128];
+      image.data[index] = color[0];
+      image.data[index + 1] = color[1];
+      image.data[index + 2] = color[2];
+      image.data[index + 3] = 255;
+    }
+  }
+  return PNG.sync.write(image);
+};
+
+describe('RenderingScreenshots', () => {
+  /** @type {string} */
+  let folderPath;
+  /** @type {string} */
+  let screenshotPath;
+  /** @type {string} */
+  let expectedScreenshotPath;
+  beforeEach(() => {
+    folderPath = fs.mkdtempSync(path.join(os.tmpdir(), 'rendering-'));
+    screenshotPath = path.join(folderPath, 'screenshot.png');
+    expectedScreenshotPath = path.join(folderPath, 'expected.png');
+    fs.writeFileSync(
+      expectedScreenshotPath,
+      createFakeScreenshot({ squareSize: 10, squareColor: [255, 0, 0] })
+    );
+  });
+  afterEach(() => {
+    fs.rmSync(folderPath, { recursive: true, force: true });
+  });
+
+  it('names the expected images after the labels of the screenshots', () => {
+    expect(getScreenshotFileName('Sun and Shadows')).toBe(
+      'sun-and-shadows.png'
+    );
+    expect(getScreenshotFileName('The island, from above!')).toBe(
+      'the-island-from-above.png'
+    );
+  });
+
+  it('accepts a screenshot drawn with tiny color changes', () => {
+    fs.writeFileSync(
+      screenshotPath,
+      createFakeScreenshot({ squareSize: 10, squareColor: [250, 4, 3] })
+    );
+
+    expect(
+      findScreenshotDifference({ screenshotPath, expectedScreenshotPath })
+    ).toBe(null);
+  });
+
+  it('reports a screenshot where something is drawn differently, with an image of the differences', () => {
+    fs.writeFileSync(
+      screenshotPath,
+      createFakeScreenshot({ squareSize: 20, squareColor: [255, 0, 0] })
+    );
+
+    expect(
+      findScreenshotDifference({ screenshotPath, expectedScreenshotPath })
+    ).toMatch(/^3\.00% of the pixels differ/);
+    const diff = PNG.sync.read(
+      fs.readFileSync(path.join(folderPath, 'screenshot.diff.png'))
+    );
+    const pixelInTheDifferences = (15 * 100 + 15) * 4;
+    expect(
+      Array.from(
+        diff.data.slice(pixelInTheDifferences, pixelInTheDifferences + 4)
+      )
+    ).toEqual([255, 0, 255, 255]);
+  });
+
+  it('reports a screenshot without expected image', () => {
+    fs.writeFileSync(
+      screenshotPath,
+      createFakeScreenshot({ squareSize: 10, squareColor: [255, 0, 0] })
+    );
+
+    expect(
+      findScreenshotDifference({
+        screenshotPath,
+        expectedScreenshotPath: path.join(folderPath, 'missing.png'),
+      })
+    ).toMatch(/There is no expected image/);
+  });
+});
diff --git a/scripts/run-gameplay-tests.js b/scripts/run-gameplay-tests.js
index 15d2e6ca2..6b2bd277e 100644
--- a/scripts/run-gameplay-tests.js
+++ b/scripts/run-gameplay-tests.js
@@ -34,7 +34,6 @@
  */
 const fs = require('fs');
 const path = require('path');
-const { spawn } = require('child_process');
 const shell = require('shelljs');
 const args = require('minimist')(process.argv.slice(2));
 
@@ -43,6 +42,7 @@ const {
 } = require('./lib/GameplayTestsProjectFinder');
 const { getGDevelopExecutable } = require('./lib/GDevelopPortableBuild');
 const { writeJUnitReport } = require('./lib/GameplayTestsJUnitReport');
+const { runProjectGameplayTests } = require('./lib/GameplayTestsRunner');
 const {
   findChangedFiles,
   keepExampleProjectFiles,
@@ -53,9 +53,6 @@ const {
 
 const repositoryPath = path.resolve(__dirname, '..');
 
-/** The folder GDevelop writes the screenshots of a run into. */
-const SCREENSHOTS_DIRECTORY_NAME = 'gameplay-test-screenshots';
-
 const gdevelopBranch = args['gdevelop-branch'] || 'master';
 const gdevelopVersion = args['gdevelop-version'] || undefined;
 const baseRef = args['base-ref'] || 'origin/main';
@@ -178,168 +175,6 @@ const onlyFailedWithTimeouts = (projectRunResult) =>
     (result) => result.status === 'passed' || result.status === 'timeout'
   );
 
-/**
- * Run the gameplay tests of a single game project.
- * @param {Object} options
- * @param {string} options.executablePath
- * @param {string} options.relativePath
- * @param {string} options.exampleSlug
- * @returns {Promise<ProjectRunResult>}
- */
-const runProjectGameplayTests = async ({
-  executablePath,
-  relativePath,
-  exampleSlug,
-}) => {
-  const projectPath = path.join(repositoryPath, relativePath);
-  const projectArtifactsPath = path.join(
-    artifactsPath,
-    relativePath.replace(/\//g, '__').replace(/\.json$/, '')
-  );
-  shell.mkdir('-p', projectArtifactsPath);
-
-  // GDevelop writes its results next to the project file. Its `--results-path`
-  // option cannot be used: the main process only forwards the CLI flags it
-  // knows about, and drops that one (its value would even end up parsed as a
-  // second project to open). So the files are moved to the artifacts folder
-  // after the run instead.
-  const resultsPath = path.join(
-    path.dirname(projectPath),
-    'gameplay-test-results.json'
-  );
-  const screenshotsPath = path.join(
-    path.dirname(projectPath),
-    SCREENSHOTS_DIRECTORY_NAME
-  );
-  // Leftovers from a previous run would be mistaken for this run's results.
-  shell.rm('-f', resultsPath);
-  shell.rm('-rf', screenshotsPath);
-
-  const startTime = Date.now();
-  const { exitCode, output, timedOut } = await runGDevelopCli({
-    executablePath,
-    cliArguments: [
-      projectPath,
-      '--run-command',
-      'RUN_ALL_TESTS',
-      '--no-sandbox',
-      '--disable-update-check',
-    ],
-  });
-  const durationMs = Date.now() - startTime;
-
-  fs.writeFileSync(
-    path.join(projectArtifactsPath, 'gdevelop-output.log'),
-    output
-  );
-
-  // The screenshots a test took are written by GDevelop next to the results,
-  // in the game folder. Move them into this game's artifacts folder, next to
-  // the results file they belong to, so that CI stores both together.
-  const artifactsScreenshotsPath = path.join(
-    projectArtifactsPath,
-    SCREENSHOTS_DIRECTORY_NAME
-  );
-  // A previous attempt of the same game (a run retried after a timeout) would
-  // otherwise end up nested inside its own folder.
-  shell.rm('-rf', artifactsScreenshotsPath);
-  if (fs.existsSync(screenshotsPath)) {
-    shell.mv(screenshotsPath, artifactsScreenshotsPath);
-  }
-
-  /** @type {GameplayTestResult[]} */
-  let results = [];
-  let runError;
-  if (fs.existsSync(resultsPath)) {
-    try {
-      results = JSON.parse(fs.readFileSync(resultsPath, 'utf8'));
-    } catch (error) {
-      runError = `The results file written by GDevelop could not be read: ${error}`;
-    }
-    shell.rm('-f', resultsPath);
-    // GDevelop records where it wrote each screenshot as an absolute path in
-    // the game folder — where they no longer are. Point them at the file
-    // sitting next to the results instead, so the stored results are usable
-    // as they are (in the CI artifacts, or downloaded).
-    for (const result of results) {
-      for (const screenshot of result.screenshots || []) {
-        if (!screenshot.file) continue;
-        screenshot.file = path.posix.join(
-          SCREENSHOTS_DIRECTORY_NAME,
-          path.basename(screenshot.file)
-        );
-      }
-    }
-    fs.writeFileSync(
-      path.join(projectArtifactsPath, 'results.json'),
-      JSON.stringify(results, null, 2)
-    );
-  }
-  if (!runError && results.length === 0) {
-    runError = timedOut
-      ? `GDevelop did not finish within ${Math.round(
-          timeoutMs / 1000
-        )}s and was killed.`
-      : `GDevelop exited with code ${exitCode} without writing any test result. ` +
-        `Last lines of its output:\n${output
-          .split('\n')
-          .slice(-30)
-          .join('\n')}`;
-  }
-
-  return { relativePath, exampleSlug, durationMs, results, runError };
-};
-
-/**
- * Spawn the GDevelop executable, capturing its output and killing it if it
- * takes too long. Never rejects: the caller reports the failure.
- * @param {Object} options
- * @param {string} options.executablePath
- * @param {string[]} options.cliArguments
- * @returns {Promise<{ exitCode: number | null, output: string, timedOut: boolean }>}
- */
-const runGDevelopCli = ({ executablePath, cliArguments }) =>
-  new Promise((resolve) => {
-    // Even in CLI mode, Electron needs a display to initialize its graphics
-    // stack on a headless Linux machine.
-    const child = spawn(
-      'xvfb-run',
-      ['-a', '--server-args=-screen 0 1280x800x24', executablePath].concat(
-        cliArguments
-      ),
-      { cwd: repositoryPath }
-    );
-
-    let output = '';
-    let timedOut = false;
-    /** @param {Buffer} data */
-    const onData = (data) => {
-      const text = data.toString();
-      output += text;
-      // Only echo the lines of the test runner itself: the editor is very
-      // verbose (asset loading, network errors on a CI machine...).
-      for (const line of text.split('\n')) {
-        if (line.includes('[CLI]')) shell.echo(`   ${line.trim()}`);
-      }
-    };
-    child.stdout.on('data', onData);
-    child.stderr.on('data', onData);
-
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      child.kill('SIGKILL');
-    }, timeoutMs);
-
-    child.on('error', (error) => {
-      clearTimeout(timeoutId);
-      resolve({ exitCode: null, output: `${output}\n${error}`, timedOut });
-    });
-    child.on('close', (exitCode) => {
-      clearTimeout(timeoutId);
-      resolve({ exitCode, output, timedOut });
-    });
-  });
-
 (async () => {
   const restrictedProjectFiles = getRestrictedProjectFiles();
   const allProjects = findProjectsWithGameplayTests({
@@ -403,6 +238,9 @@ const runGDevelopCli = ({ executablePath, cliArguments }) =>
       executablePath,
       relativePath: project.relativePath,
       exampleSlug: project.exampleSlug,
+      repositoryPath,
+      artifactsPath,
+      timeoutMs,
     });
 
     // A test that ran out of wall clock is telling us about the machine, not
@@ -423,6 +261,9 @@ const runGDevelopCli = ({ executablePath, cliArguments }) =>
         executablePath,
         relativePath: project.relativePath,
         exampleSlug: project.exampleSlug,
+        repositoryPath,
+        artifactsPath,
+        timeoutMs,
       });
       if (!hasFailure(retryResult)) {
         shell.echo(