Monkey Maya Studios — games in prototype

Algebra Kart footage coming soon
Prototype

Algebra Kart

Kart racing meets algebra. Every power-up is an equation. Speed is mastery.

Railroad Quest footage coming soon
Coming next

Railroad Quest

Build networks, master graph theory, out-think the AI.

Watch gameplay Read the design docs

Algebra Kart

  • Real-time networked multiplayer world — actors, vehicles, physics, interaction
  • Arcade-tuned kart physics with algebra-driven power-ups
  • AI racers driven by neural networks evolved with a genetic algorithm
  • Live, collaborative in-race music synthesis, powered by Turiya
Algebra Kart demo footage coming soon

Early Algebra Kart prototype — real-time networked racing, genetically-evolved AI drivers, and live in-race music synthesis, running on a solo-built C++ engine.

More gameplay footage

Algebra Kart clip coming soon

Playtesting vehicle physics as an active player — racing alongside AI bots whose fitness scores evolve live, shaping how their driving challenges you. A dedicated AI showcase clip is coming next.

Algebra Kart vehicle physics playtest, GIF loop
Algebra Kart clip coming soon

Same clip, GIF loop — for anywhere a video tag doesn't play nicely.

Algebra Kart gameplay screenshot showing an in-race algebra question, 5x = 30, with answer choices
Algebra Kart clip coming soon

Group questions compete while challenging the mind.

Railroad Quest

A real-time strategy game about building and connecting rail networks — teaching graph theory through the very thing you're building: routes, nodes, and the shortest path between chaos and victory.

Design Docs

We build in the open. These are the real design docs behind the games — the same ones the code gets written from, published as they're written, for anyone following along with the dev log.

AlgebraKart AI — Current Architecture

What the AI actually does today, traced from source rather than from intent — the component map, the evolution loop, the fitness signal, and an honest accounting of the defects that currently stop the network from influencing how the bots drive.

ALGEBRA KART · AS-BUILT BASELINE

AlgebraKart AI — Next Architecture

Where the AI is going: an LSTM core so behavior depends on history, 15-minute wall-clock evolution epochs with checkpoint and resume, a 40-channel sensory redesign, and three separate fitness channels for driving, algebra, and beat-making.

ALGEBRA KART · TARGET DESIGN

Maya Space — Collaborative Learning System

Four voices share one room and one clock. The full design for Turiya's group music space: session roles, sound design, tempo sync across the network, and the Mandelbrot waveform visualization that grows out of the ground as you play.

TURIYA · PARTIALLY IMPLEMENTED

More coming. Each doc is published as it's written, with its real build status on the front — what's implemented, what's still design-only. Nothing here is a pitch deck; if a section says it isn't built yet, it isn't built yet.

The engine: Turiya

Turiya is the software engine underneath every Monkey Maya game: real-time sound synthesis, shared live over a network in one space. Multiple players plug into beat machines and a range of digital instruments — tracked across a 16×16×8 pattern grid — with everyone's timing captured against a shared clock, so the whole group behaves like several DAWs recording in perfect sync, all inside the same shared sound space.

Beat Mode 16×16×8 step sequencer Oscillator Per-player synth voice NOT YET SUPPORTED Mic Input Live audio capture Turiya — Shared Sound Space Networked time-code sync · shared clock across every player CAPTURE LIVE Session Capture JSON event log — time-code + sample index NOT YET BUILT Replay & Playback Load a saved session back and play it

Solid lines are live today. Dashed lines and boxes are planned, not yet supported.

Maya Space — a collaborative learning system. A room of players and voices sharing one clock, where every sound grows a living structure out of the ground together.

Live in-engine footage of Turiya: a player walking a beat track as colored tiles react to a kick and snare pattern, with a reconstructed audio waveform playing underneath
Turiya live footage coming soon

Turiya running live — walking a beat track as the kick and snare pattern lights up the tiles beneath you, with the shared waveform playing out underneath in real time.

Play together, make music together.

Every Monkey Maya game ships with Turiya running underneath. While you race, build, or explore, everyone in your session is collaboratively generating music in real time — driven by the moves you're already making. Every session is tracked server-side, and you can save what you made in a high-quality audio format to keep, share, or remix later.

Real-time collaborative synthesis

Networked drum machines and instruments respond to gameplay, shared live across every player in a session.

Session tracking

Every sequence is logged server-side as it's created, so nothing your group makes together is lost mid-session.

High-quality export

Save what you made and take it with you in a high-quality audio format once the session ends.

Team

Ajay Bhaga AB

Ajay Bhaga

Solo Developer → Lead Designer & AI Development Manager

Ajay served as Managing Partner at Munvo Solutions, helping Fortune 500 companies design & build real-time marketing automation systems globally. Ajay has held positions at engineering companies such as IBM, Rapid7, and WatchGuard Technologies. His on-site consulting projects spanned industries including banking, financial services, high-tech, telecom, health insurance, gaming, hospitality, loyalty, airlines, publications, retail, and digital payment systems.

He's now a Staff Software Engineer in Cloud Platform Engineering at WatchGuard Technologies.

Ajay studied at the University of Toronto, where he earned a B.Sc. in Computer Science, Software Engineering.

Architecture

A look at how the engine underneath Monkey Maya's games is actually put together — drawn directly from the codebase, not marketing diagrams.

System overview

Every game runs on a custom layer built on top of Urho3D's scene graph, physics, and networking, with four gameplay systems sitting side by side and feeding a shared multiplayer replication layer.

Urho3D Engine Core Bullet Physics · SLikeNet Networking (UDP) · Node/Component Scene Graph Vehicle Physics Raycast vehicle + arcade assist forces AI · Genetic Algorithm Feed-forward network driven by evolved genotypes Procedural Vegetation Chunked, biome-based placement + LOD Turiya Per-player oscillator synth + step sequencer Network Replication Client-side prediction (CSP) · delta-replicated scene state Multiplayer Session — Server ⇆ Clients

Client-server replication

Movement feels instant for the player driving, while the server stays the single source of truth — a standard client-side-prediction pattern, tuned for kart racing.

Client CSP_Client — buffers input Predicts local vehicle state Reconciles against server snapshot Server CSP_Server — 30 Hz tick Authoritative game state NetworkActor / Vehicle delta replication Input (UDP) State snapshot

AI: neural network + genetic algorithm

Each bot's driving behavior is a small feed-forward neural network. A genetic algorithm evolves the population generation over generation, using in-race performance as the fitness signal.

Sensors Raycast inputs (8 values) Neural Network 8→7→5→3→3 soft-sign activation Vehicle Controls Steer · throttle brake Race Episode Multi-parameter fitness score Genetic Algorithm Selection → crossover → mutation next-generation network weights

AI steering pipeline (per frame)

The genetic algorithm above evolves each bot's network across generations. This is the other half: how a bot actually decides where to steer on any given frame, blending its network output with a reactive heuristic and a waypoint-following fallback.

WAYPOINT TRACKING SENSOR + NEURAL NETWORK Current track waypoint steerMarks_[ getSteerIndex() ] advances once bot is within range 4 raycast sensors Left · Up · Front · Right — obstacle distance + distance-covered + 3 flags (on-track / unflipped / speed-consistent) Heading → steering value proportional gain on heading error clamped to [-1, +1] → desiredSteer Neural network 8 inputs → evolved FFN (genetic algorithm) Reactive heuristic steer away from a blocked side, slow if boxed in Blend network × 0.3 + heuristic × 1.0 heuristic leads, network refines Waypoint found this frame? NO YES No waypoint: fallback Sensor + NN blend gets FULL steering authority “keep moving, avoid obstacles” Waypoint found: guided Waypoint steer (baseline) + blend × 0.6 (correction) stays on course, nudged around obstacles Final steer + throttle throttle eased the harder it's steering (corners taken slower, not flat-out) Vehicle control steerLevel / accelLevel → the kart actually moves Waypoint path Fallback (no waypoint) Combined output

Design credit: this engineering builds on established open and public reference work rather than reinventing every piece. Turiya, the music synthesis engine, is original; procedural vegetation started from an open-source Urho3D community reference. Full credits below — a third-party licensing review is in progress ahead of commercial release.

Where this is going

Algebra Kart and Railroad Quest are the first two games released on Turiya, our real-time, multiplayer creation and collaboration platform — with its live music synthesis engine as the foundation underneath every one of them. Think of Turiya as a co-creation time-space — the same live, social, physics-driven world every Monkey Maya game already runs on, eventually opened up as its own standalone tool for collaborative creation.

Credits & acknowledgments

Monkey Maya's engineering stands on real prior work. Full credit to everyone below.

Engine & core libraries

  • Urho3D — the open-source engine (MIT license) this game is built on, and its group of developers. Greatly inspired by OGRE and Horde3D.
  • Bullet Physics — vehicle and world physics simulation.
  • SLikeNet — UDP networking layer (RakNet-derived).

Direct inspiration for this game's code

  • Lumak (github.com/Lumak) — vehicle raycasting reference the kart physics is based on.
  • Samuel Arzt (2017, Deep Learning Cars) — the neural network / genetic algorithm design the AI drivers are based on, reimplemented from scratch in C++.
  • Urho3D community vegetation reference — the procedural vegetation system started from an open-source Urho3D vegetation/grass reference.
  • Bjarne Stroustrup — a small C++11 random-number helper adapted from The C++ Programming Language, 4th edition.
  • Xavier Glorot & Yoshua Bengio (2010) — activation function approach referenced from their deep network training research.

Research & techniques referenced by Urho3D

  • Jukka Jylänki — rectangle bin packing
  • Terathon Software — tangent generation
  • Tomas Möller & Ben Trumbore — ray/triangle intersection
  • Tom Forsyth — linear-speed vertex cache optimization
  • Chris Hecker — software triangle rasterization
  • Glenn Fiedler — networked physics
  • David Eberly — Euler angle formulas
  • Julienne Walker — red-black trees
  • Juha Nieminen — sorting algorithm comparison

Assets

  • realXtend project — Jack and mushroom models
  • OGRE — Ninja model, terrain, water, smoke, flare and status bar textures
  • Larabie Fonts — BlueHighway font
  • Mark Simonson — Anonymous Pro font
  • Veli-Pekka Tätilä — NinjaSnowWar sounds
  • Substance Share — PBR textures
  • HDRLab's sIBL Archive — IBL textures
  • allexandr007 — Dieselpunk Moto model
  • Mixamo — Mutant & Kachujin character models