NEON TURRET RUSH:
A THREE.JS 3D SYNTHWAVE TURRET SHOOTER

What Is Neon Turret Rush?

Neon Turret Rush is a free portrait 3D turret shooter for phones and desktop. A glowing cyan tank turret guards the bottom of a neon synthwave grid that glows cyan near the lane and fades to magenta toward the sides, under a starry purple sky with low-poly mountains on the horizon. Formations of faceted crystal drones sweep down the grid toward it. The turret fires laser bolts on its own, so the whole game is aiming: drag a finger across the screen and the turret head swings to the spot you touch, with a cyan targeting bracket locking onto the drone in your line of fire.

Drones arrive in blocks of up to three rows, and every wave brings more of them, faster, with tougher crystals joining in. Chained kills build a combo up to x8, and glowing pickups give you spread shot, a slow-mo pulse or a shield repair. Neon Turret Rush is a Three.js game that runs as a 3D browser game on WebGL, developed by Shane Brumback and hosted by Indie Forge Studio, where you can play it at indieforgestudio.com/games/neon-turret-rush/. It is free with no download.

How to Play Neon Turret Rush

• Aim: touch and drag anywhere on the screen. The turret points at the spot on the battle lane under your finger and fires automatically.
• Formations: drones march in rows of up to six that close in toward your turret as they come, so sweep across a row while it is still far away.
• Drones: pink arrowheads die in one hit, magenta diamonds take two from wave two, orange octahedrons take two and weave side to side from wave three, and big violet crystals take five hits from wave five.
• Power-ups: pickups drop off to the side of your line of fire, so swing over and shoot one to collect it: Spread Shot fires a five-bolt fan, Slow-Mo Pulse slows time and blasts nearby drones, Shield +1 repairs your base.
• Combo and shield: every four kills in a row within about two seconds of each other raise the multiplier, up to x8. A drone reaching your base resets it and costs one of three shield points. Lose them all and the run ends. P pauses and M mutes.

How Neon Turret Rush Is Built with Three.js

Neon Turret Rush is a single self-contained ES module on a self-hosted Three.js build. The look comes from flat-shaded faceted shapes, vertex colours, additive glow sprites and bright edge lines, so it loads fast on phones with no model files.

• The floor is one plane with a canvas-drawn white grid texture set to repeat, tinted by per-vertex colours that blend from cyan in the middle to magenta at the sides and far away. Scrolling the texture offset each frame makes the grid rush toward you without moving any geometry.
• The sky is a canvas gradient. An additive horizon glow band, 26 low-poly cone mountains with purple edge lines and a field of points for stars finish the backdrop.
• The drones fly on a gently rising battle lane, so far drones sit high on the screen and sweep down to the turret. They are flat-shaded Lambert crystals (a custom arrowhead, two double pyramids and an octahedron) with edge lines and a glowing core sprite, and their lanes converge toward the base as they close in.
• The turret is a small low-poly tank built from cylinders and boxes, with cyan light strips and a rotating head with a ringed barrel. Laser bolts are pooled capsules with an additive glow capsule around them.
• Kills throw out stretched tetrahedron shards and an additive flash sprite. Aiming casts a ray from the touch point onto the sloped battle lane, so the turret points at your finger even though the camera is tilted.

Built for Mobile and Portrait Play

Neon Turret Rush is designed for one finger on a phone held upright. It runs in a centered 9:16 portrait frame on every screen. The neon HUD shows a 7-digit score with a crosshair icon at the top left, your best score, shield and combo just under it, and a WAVE counter at the top right. Pointer events give touch and mouse one aiming code path. How to Play opens a scrollable help panel that pauses rendering, and the pause menu offers Resume or Main Menu.

To stay smooth on phones the renderer caps the device pixel ratio, bolts, shards and flashes come from fixed pools, drones are removed as soon as they die, and the game pauses itself when you switch tabs or apps.

Code from Neon Turret Rush

Drones arrive in formation. A block spawns up to three rows a few units apart, and each row spreads its drones evenly across the grid with a random offset:

function spawnRow(z) {
  const kind = pickKind(), maxN = kind === 'ico' ? 2 : Math.min(6, 4 + Math.floor(S.wave / 3));
  const n = Math.max(1, Math.min(S.spawnQ, maxN - ((Math.random() * 2) | 0)));
  const span = Math.min(20, 4.8 * (n - 1)), off = (Math.random() - 0.5) * (20 - span);
  for (let i = 0; i < n; i++) spawnDrone(kind, (n === 1 ? (Math.random() - 0.5) * 18 : -span / 2 + (span * i) / (n - 1) + off), z);
  S.spawnQ -= n;
}

From games/neon-turret-rush/game.js

The battle lane rises gently away from the turret, so far drones fly high on the screen and look a little larger to stay readable:

const SLOPE = 0.62;
const elev = (z) => 1.15 + Math.max(0, -z - 1.5) * SLOPE;
const farScale = (z) => 1 + Math.max(0, -z) * 0.028;

From games/neon-turret-rush/game.js

Each drone's lane also narrows as it closes in, to 35% of its starting offset at the base, which pulls a formation together as it reaches the turret:

function droneX(d) { // formation lanes converge on the base as the drones close in
  const t = Math.min(1, Math.max(0, -d.z / -SPAWN_Z));
  return d.x0 * (0.35 + 0.65 * t);
}

From games/neon-turret-rush/game.js

Aiming turns a screen touch into a turret angle. A ray from the camera through your finger is intersected with that sloped lane, and the hit point decides where the turret points:

const lanePlane = new THREE.Plane().setFromNormalAndCoplanarPoint(new THREE.Vector3(0, 1, SLOPE).normalize(), new THREE.Vector3(0, elev(-1.5), -1.5));
function aimAt(clientX, clientY) {
  const r = frame.getBoundingClientRect();
  ndc.set(((clientX - r.left) / r.width) * 2 - 1, -(((clientY - r.top) / r.height) * 2 - 1));
  ray.setFromCamera(ndc, camera);
  let a;
  if (ray.ray.intersectPlane(lanePlane, hitP) && hitP.z < 0) a = Math.atan2(hitP.x, Math.max(0.6, -hitP.z));
  else a = ndc.x * MAX_AIM;
  S.aimT = Math.max(-MAX_AIM, Math.min(MAX_AIM, a));
}

From games/neon-turret-rush/game.js

Frequently Asked Questions