Babylon.js — batteries included

The same "scene, camera, light, mesh" language as three.js — but notice what comes free: a drag-to-orbit camera is one line, engine-wide glow is two, and 2D text floating over the 3D world (the GUI system) is built in. That's the "engine vs library" difference, live. Babylon 9.22 (Apache-2.0, free) loads from a CDN — no installs, no Node.js.

const engine = new BABYLON.Engine(canvas, true);
const scene = new BABYLON.Scene(engine);
scene.clearColor = BABYLON.Color4.FromHexString("#191527FF");

// drag-to-orbit camera: ONE line, mouse handling included
const cam = new BABYLON.ArcRotateCamera("cam",
  -1.2, 1.1, 8, BABYLON.Vector3.Zero(), scene);
cam.attachControl(canvas, true);   // ← try dragging the scene!

new BABYLON.HemisphericLight("light",
  new BABYLON.Vector3(0.4, 1, 0.2), scene);

// a station core + two orbiting "ships"
const core = BABYLON.MeshBuilder.CreateTorusKnot("core",
  { radius: 1, tube: 0.3, radialSegments: 96 }, scene);
const coreMat = new BABYLON.StandardMaterial("m", scene);
coreMat.emissiveColor = BABYLON.Color3.FromHexString("#5A63C8");
core.material = coreMat;

const ships = [];
for (let i = 0; i < 2; i++) {
  const s = BABYLON.MeshBuilder.CreateBox("ship" + i,
    { width: 0.5, height: 0.12, depth: 0.3 }, scene);
  const m = new BABYLON.StandardMaterial("sm" + i, scene);
  m.emissiveColor = BABYLON.Color3.FromHexString(
    i ? "#D6A878" : "#9DBE9D");
  s.material = m;
  ships.push(s);
}

// engine-wide GLOW: two lines (chapter 06's bloom, included free)
const glow = new BABYLON.GlowLayer("glow", scene);
glow.intensity = 0.9;

// 2D text floating over the 3D world: the built-in GUI system
const gui = BABYLON.GUI.AdvancedDynamicTexture.CreateFullscreenUI("ui");
const label = new BABYLON.GUI.TextBlock();
label.text = "drag to orbit — 2D GUI over 3D, built in";
label.color = "#A9A3C4";
label.fontSize = 16;
label.top = "42%";
gui.addControl(label);

// orbits: chapter 05 easing thinking, in 3D
let t = 0;
engine.runRenderLoop(() => {
  t += engine.getDeltaTime() / 1000;
  core.rotation.y = t * 0.2;                  // stately
  ships.forEach((s, i) => {
    const a = t * (0.5 + i * 0.3) + i * Math.PI;
    s.position.set(Math.cos(a) * 3, Math.sin(t * 0.7 + i) * 0.6,
                   Math.sin(a) * 3);
    s.rotation.y = -a;                        // face the direction of travel
  });
  scene.render();
});

Loading Babylon.js from the CDN… the Run button wakes up when it arrives. (This page needs internet for that file.)

Try tweaking: glow.intensity 0.9 → 0 (feel how much the glow was carrying) · ship count 2 → 8 · orbit speeds 0.5 + i * 0.3 → give one ship 4.0 and watch "stately" and "frantic" share a scene · the torus knot's radialSegments 96 → 16 for low-poly chunk.

The comparison to feel: in three.js, the orbit camera, glow layer, and GUI would each be an addon you import and wire up; here they're one or two lines each because Babylon is an engine. Neither approach is better — it's control vs speed. Chapter 11 holds the whole map, and the Babylon Playground is the zero-setup place to keep going.

In Godot: drag-to-orbit + glow + UI-over-3D is orbit_glow_3d.gd, ready to download: a yaw node → pitch node → camera-on-a-stick rig (six honest lines of drag math where Babylon ships ArcRotateCamera), an emissive material, Environment.glow_enabled for the bloom, and a CanvasLayer for the label. In Unity: Cinemachine's Orbital Follow (or the same two-transform rig by hand), an HDR emissive material + URP Bloom, and UGUI for the label. In Unreal: a SpringArm + Camera on a Pawn — the rig, prebuilt — an emissive material (bloom is on by default), and UMG for the label.