Wishlist Now
Wishlist on Steam

Author · 48 articles

Kieren Hovasapian

News

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

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

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

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.

News

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Esc