Haul Yeah! is coming to Xbox Series X|S — wishlist now
Haul Yeah!’s Xbox Store page is live. Wishlist our delivery-driving sandbox for Xbox Series X|S, watch the new trailer and bring a mate for local split-screen co-op.
Moonjump Receives Early-Stage Funding from the Inaugural Canberra Screen and Games Fund
We're thrilled to announce that Moonjump has been selected as a recipient of the inaugural Canberra Screen and Games Fund, receiving early-stage game concept prototyping funding to support the development of our upcoming title. The fund was announced today by Michael Pettersson MLA, ACT Minister for Business, Arts and Creative Industries, as part of a broader investment in Canberra's growing screen and games sector. We're proud to be among the local studios recognised in this first round alongs
Starlight Engine: Rebuilding Raylib for Console, Custom Rendering & Neural Locomotion
Every studio hits the same wall eventually. You're deep into production, the engine you licensed does 80% of what you need, but that last 20% is where your game actually lives. At Moonjump, that wall came early. The project needed PlayStation export without a six-figure middleware license. It needed a renderer pipeline inside Maya that let artists iterate without waiting for full builds. And it needed character locomotion that could handle thousands of animation states without eating the memory
Game Dev Mechanics: Screen Space Ambient Occlusion (SSAO) — How It Works
Screen Space Ambient Occlusion (SSAO) darkens corners, crevices, and contact points in real time by sampling the depth buffer around each pixel. This article explains the complete algorithm — from the AO integral and G-buffer setup through hemisphere kernel generation, noise rotation, the
Game Dev Mechanics: Skeletal Animation & Skinning — How It Works
Skeletal animation and skinning are the foundation of every character animation in 3D games — discover how bone hierarchies, inverse bind matrices, and linear blend skinning transform static meshes into fluidly moving characters in real time.
Building From the Ground Up
We're building something big. Moonjump is developing a new action-adventure title for PS5 and PC. We're not ready to share the name or show footage yet, but the project is real, it's in active development, and it's the reason this studio exists. Starlight Engine Rather than licensing an off-the-shelf engine, we built our own. Starlight Engine started as an extension of raylib — a clean, minimal C library for games — and grew from there. We stripped out what we didn't need, rewrote the render
Game Dev Mechanics: Third-Person Camera Systems — How It Works
Learn how third-person camera systems work in games, from basic follow cameras to smooth exponential damping and collision avoidance with raycasting. Explore the math and interact with a live Three.js demo.
Game Dev Mechanics: Navigation Meshes (NavMesh) — How It Works
Learn how navigation meshes decompose walkable game environments into convex polygons for fast, smooth AI pathfinding — from Recast generation to the funnel algorithm.
Game Dev Mechanics: Procedural Dungeon Generation — How It Works
Learn how roguelikes generate unique dungeon layouts every run using Binary Space Partitioning (BSP) trees, with an interactive 3D demo you can explore and regenerate.
Game Dev Mechanics: Procedural Locomotion — How It Works
Learn how procedural locomotion generates lifelike walking animations at runtime using step triggering, gait coordination, and two-joint inverse kinematics — no pre-baked animation clips required.
Game Dev Mechanics: Volumetric Lighting (God Rays) — How It Works
Learn how volumetric lighting and god rays work in games, from the physics of light scattering and the Beer-Lambert law to the screen-space radial blur technique used in modern game engines.
Game Dev Mechanics: Octrees — How It Works
Octrees partition 3D space into eight recursive subdivisions, enabling lightning-fast spatial queries for collision detection, frustum culling, and more. Learn the algorithm, the math, and explore an interactive 3D visualization.
Game Dev Mechanics: Poisson Disk Sampling — How It Works
Learn how Poisson disk sampling generates natural, evenly-spaced point distributions for placing objects in game worlds — from trees and rocks to spawn points and audio sources — using Bridson's elegant O(n) algorithm.
Game Dev Mechanics: Normal Mapping — How It Works
Normal mapping lets flat polygons appear richly detailed by encoding surface normals in a texture. Learn the math behind tangent space and the TBN matrix, walk through a GLSL implementation, and interact with a live Three.js demo that generates a brick normal map in real time.
Game Dev Mechanics: Bloom (Post-Processing) — How It Works
Learn how bloom post-processing creates the signature cinematic glow seen in nearly every modern game. We break down the complete rendering pipeline — brightness extraction, Gaussian blur, and HDR compositing — with math, shader code, and an interactive Three.js demo.
Game Dev Mechanics: Toon Shading (Cel Shading) — How It Works
Learn how toon shading (cel shading) works — from quantized diffuse lighting and hard specular cutoffs to inverted-hull outlines — and explore the technique with an interactive Three.js demo.
Game Dev Mechanics: Parallax Scrolling — How It Works
Learn how parallax scrolling creates the illusion of depth by moving background layers at different speeds. Explore the math, implementation patterns, and an interactive Three.js demo of this classic game development technique.
Game Dev Mechanics: Metaballs & Implicit Surfaces — How It Works
Explore how metaballs use overlapping scalar fields to create organic, blobby shapes that smoothly merge and separate. Learn the math behind implicit surfaces, falloff functions, and real-time GPU rendering techniques used in games like LocoRoco and World of Goo.
Game Dev Mechanics: Flow Fields — How It Works
Learn how flow fields provide efficient pathfinding for hundreds of agents simultaneously by computing a single vector field that guides all movement, using the same three-layer algorithm behind RTS games like Supreme Commander.
Game Dev Mechanics: Projectile Trajectories & Ballistics — How It Works
From grenade arcs in Halo to artillery shells in World of Tanks, projectile ballistics is one of gaming's most fundamental physics mechanics. Learn the kinematic equations, inverse aiming solutions, and arc visualization techniques that power it all.
Game Dev Mechanics: GPU Instancing — How It Works
GPU Instancing collapses thousands of draw calls into one by uploading a single mesh to the GPU and supplying a buffer of per-instance transforms — enabling vast forests, armies, and asteroid fields to render at full speed with minimal CPU overhead.
Game Dev Mechanics: Voronoi Diagrams — How It Works
Voronoi diagrams partition space into cells based on nearest-neighbor distance to seed points, powering procedural map generation, real-time fracture physics, Worley noise textures, territory control systems, and GPU-accelerated signed distance fields across virtually every genre of game.
Game Dev Mechanics: Verlet Integration — How It Works
Verlet integration is a numerically stable physics simulation technique that powers cloth, rope, and ragdoll physics in games. This article breaks down the position Verlet formula, Thomas Jakobsen's constraint relaxation method, and how a three-line integration loop can produce convincing
Game Dev Mechanics: Behavior Trees — How It Works
Behavior Trees are the hierarchical AI architecture behind enemies in Halo, The Last of Us, and Unreal Engine — learn how Selectors, Sequences, and Leaf nodes combine to create believable, modular AI with a live interactive demo.
Game Dev Mechanics: Ray Marching & Signed Distance Fields — How It Works
Discover how Signed Distance Fields and ray marching let you render complex 3D shapes using pure mathematical functions — no meshes, no vertices, just elegant equations running entirely on the GPU.
Game Dev Mechanics: Separating Axis Theorem (SAT) — How It Works
The Separating Axis Theorem is the mathematical backbone behind precise convex-shape collision detection in countless games. Learn how it works, how to compute the Minimum Translation Vector for physics resolution, and see it in action with a fully interactive demo.
Game Dev Mechanics: Wave Function Collapse — How It Works
Wave Function Collapse is an elegant constraint-satisfaction algorithm that generates infinite variety from simple tile rules — powering the remarkably natural-looking worlds of games like Townscaper, Bad North, and Caves of Qud.
Game Dev Mechanics: Water Simulation — How It Works
Water simulation is one of the most visually striking — and mathematically rich — techniques in game development. Learn how Gerstner waves, FFT-based ocean rendering, and the shallow water equations work together to create convincing real-time water.
Game Dev Mechanics: Cellular Automata — How It Works
Cellular automata use dead-simple neighbor-counting rules to transform random noise into organic cave systems — one of procedural generation's most elegant algorithms, used everywhere from Spelunky to Dwarf Fortress.
Game Dev Mechanics: Marching Cubes — How It Works
Marching Cubes converts a 3D scalar field into a smooth triangle mesh in real time — it's the algorithm behind metaballs, volumetric terrain, and procedural cave generation in modern games.
Game Dev Mechanics: Noise Functions (Perlin & Simplex) — How It Works
Discover how Perlin and Simplex noise functions generate the coherent randomness behind procedural terrain, textures, and animations in modern games — complete with an interactive 3D terrain generator you can tune in real time.
Game Dev Mechanics: Occlusion Culling — How It Works
Occlusion culling identifies and discards geometry the camera cannot possibly see — hidden behind walls, buildings, or terrain — before it ever reaches the GPU, slashing draw calls and unlocking dramatically higher scene complexity.
Game Dev Mechanics: Shadow Mapping — How It Works
Shadow mapping is the foundational two-pass technique behind real-time shadows in virtually every modern 3D game — a clever algorithm that asks whether the light can see each pixel, with bias tricks, PCF filtering, and cascaded variants for large open worlds.
Game Dev Mechanics: Level of Detail (LOD) — How It Works
Learn how Level of Detail (LOD) systems automatically swap between high- and low-complexity meshes as objects move closer or farther from the camera, and why this technique is the backbone of performance in every large-scale 3D game.
Game Dev Mechanics: Frustum Culling — How It Works
Frustum culling is the foundational visibility technique that stops your GPU from drawing objects the camera can’t see. Learn the math behind view frustums, plane extraction, bounding volume tests, and hierarchical culling used in every modern 3D game engine.
Game Dev Mechanics: Rigid Body Physics — How It Works
Rigid body physics powers every tumbling crate, bouncing ball, and ragdoll in games. Learn how impulse-based collision response works—the math behind every major physics engine—and explore it live in an interactive 3D simulation.
Game Dev Mechanics: Finite State Machines — How It Works
Discover how Finite State Machines power enemy AI in games from Pac-Man to Dark Souls, and learn to build your own FSM with states, transitions, and hierarchical extensions.
Game Dev Mechanics: Steering Behaviors — How It Works
Discover how Craig Reynolds' steering behaviors — Seek, Flee, Arrive, and Wander — give game characters natural autonomous movement using elegant vector math you can implement in an afternoon.
Game Dev Mechanics: Spatial Hashing — How It Works
Spatial hashing transforms O(n²) collision detection into an O(n) operation by dividing the world into a uniform grid and using a hash map to find only nearby object pairs — cutting tens of thousands of checks down to dozens every frame.
Game Dev Mechanics: Particle Systems — How It Works
Particle systems power every explosion, flame, and magical effect in games. Learn the math of particle motion, emitter types, object pooling, and GPU rendering techniques that let thousands of simultaneous particles run at 60 fps.
Game Dev Mechanics: Rope & Cloth Physics — How It Works
Discover how games simulate ropes, capes, and flags using Verlet integration and distance constraints — a surprisingly elegant algorithm that produces remarkably realistic results in real time.
Game Dev Mechanics: Inverse Kinematics — How It Works
Inverse Kinematics (IK) is the mathematical technique behind natural-looking limb movement in games — discover how the FABRIK algorithm elegantly solves the chain-reaching problem and how to implement it from scratch.
Game Dev Mechanics: Raycasting — How It Works
Raycasting is the algorithm that conjured 3D corridors in Wolfenstein 3D and still drives mouse-picking, AI line-of-sight, and real-time ray-traced shadows today. Learn the DDA algorithm from first principles and see it visualized live in an interactive demo.
Game Dev Mechanics: A* Pathfinding — How It Works
A* (A-star) is the most widely used pathfinding algorithm in game development. Learn how it combines exact movement costs with heuristic estimates to efficiently find shortest paths through any environment.
Game Dev Mechanics: Bézier Curves — How It Works
Bézier curves power smooth camera paths, projectile arcs, UI animations, and spline geometry across countless games. This article breaks down the math from linear interpolation to De Casteljau's algorithm, with an interactive demo where you sculpt the curve in real time.
Game Dev Mechanics: Procedural Terrain Generation — How It Works
A deep dive into procedural terrain generation: how Perlin noise, fractal Brownian motion, and domain warping combine to produce infinite, believable landscapes — plus a live interactive Three.js demo you can explore and reseed in real time.
Game Dev Mechanics: Quadtrees — How It Works
Quadtrees are a spatial partitioning data structure that dramatically accelerate collision detection and scene queries by recursively dividing 2D space — learn the algorithm, the math, and see it in action with an interactive Three.js demo.
Game Dev Mechanics: Spring Physics — How It Works
Spring physics powers countless game effects — from bouncy platforms and swaying ropes to camera lag and ragdoll characters. Learn the math behind Hooke's Law, numerical integration, and spring chains, then see it all in an interactive simulation you can grab and drag.
Game Dev Mechanics: Flocking with Boids — How It Works
Discover how three simple rules — separation, alignment, and cohesion — create stunningly realistic flocking behavior used in games from Half-Life 2 to The Witcher 3.