Neural Apex

Race. Learn. Adapt. Master AI through every lap.

Comment

Neural Apex

Inspiration

AI is often introduced through formulas, code, and technical terminology. For beginners, this can make the differences between Machine Learning, Deep Learning, and Reinforcement Learning difficult to understand.

We wanted to create a more intuitive way to learn these concepts through experimentation.

Racing was a natural fit because every race involves prediction, pattern recognition, adaptation, uncertainty, and strategy. Instead of asking the player to manually drive the car, Neural Apex places them in the role of a race strategist and AI systems operator.

The player configures the car, selects AI priorities, launches autonomous test runs, studies the results, and improves the strategy for the next attempt.

What It Does

Neural Apex is a blocky 3D autonomous racing strategy game that teaches the practical differences between three major AI approaches:

  • ML — Predict: uses previous race data and current conditions to estimate outcomes such as lap time, tyre wear, fuel consumption, and rain probability.
  • DL — Detect: observes complex telemetry and track information to identify patterns such as overheating tyres, inconsistent braking, wet track sections, and possible mechanical problems.
  • RL — Adapt: changes driving and strategy behaviour based on the results of previous actions.

The player does not manually steer the car.

Instead, the player:

  1. Selects a race scenario.
  2. Configures the car setup, tyres, fuel, and aerodynamic balance.
  3. Chooses the priorities of the AI-assisted driver.
  4. Adds opponents using one-click bot presets.
  5. Launches an autonomous test run or race.
  6. Observes telemetry, racing lines, warnings, and AI recommendations.
  7. Makes strategic decisions such as whether to pit, conserve tyres, or increase aggression.
  8. Reviews a post-race debrief.
  9. Adjusts the configuration and runs the scenario again.

The race engineer may present conflicting recommendations from the different AI systems. This teaches the player that AI outputs can be uncertain and that humans still need to interpret information and make the final decision.

How We Built It

Neural Apex was developed as a web-based 3D experience using React, TypeScript, Vite, Three.js, and React Three Fiber.

The racing simulation uses:

  • waypoint-based autonomous vehicle movement;
  • simplified vehicle and tyre behaviour;
  • bot difficulty and personality presets;
  • scripted race and weather events;
  • telemetry and race-state tracking;
  • deterministic educational simulations for ML, DL, and RL concepts.

The AI learning systems are intentionally simplified for educational purposes.

The ML Predictor uses weighted historical and environmental inputs to generate predictions.

The DL Pattern Scanner evaluates simulated telemetry and track-state signals to recognise meaningful patterns.

The RL-inspired Adaptive Driver updates its behaviour based on previous outcomes, such as tyre degradation, crashes, overtaking success, and lap performance.

GPT-5.6 is used to generate beginner-friendly race engineer explanations, explain conflicting recommendations, and produce contextual post-race debriefs. Local fallback explanations are provided so the core game remains functional when an API response is unavailable.

Codex was used throughout the development process to:

  • plan the application architecture;
  • scaffold the project;
  • implement the 3D racing systems;
  • build the user interface;
  • create the AI education mechanics;
  • write tests;
  • configure Docker;
  • maintain project documentation;
  • debug and integrate the final experience.

The project includes Docker support so it can be launched consistently from a clean environment.

docker compose up --build

Technical and product documentation is maintained in the docs/ directory, including architecture, gameplay, AI simulation, bot behaviour, tutorial design, testing, and deployment information.

Challenges We Faced

Balancing a Game With an Educational Tool

One of the main challenges was ensuring that Neural Apex was not simply a racing game with AI terminology added on top.

Every AI system needed to produce a visible gameplay consequence and a clear learning outcome. Predictions had to be compared with actual results, detections needed to influence strategy, and adaptive behaviour had to be observable between runs.

Creating Autonomous Racing Behaviour

The project needed cars that could navigate the circuit automatically while still reacting to race conditions, strategy settings, and other competitors.

We used waypoint-based navigation and simplified behaviour states rather than attempting to build a fully realistic racing simulator. This allowed us to focus on strategy, experimentation, and education.

Explaining AI Without Overwhelming Beginners

Technical terms such as gradients, epochs, reward functions, and neural-network layers were deliberately kept out of the main experience.

Instead, the game introduces the concepts as:

  • Predict
  • Detect
  • Adapt

More detailed explanations are provided only when the player asks for them.

Handling Conflicting Recommendations

Real decision-making is rarely based on one perfect signal.

We designed situations where the ML Predictor, DL Pattern Scanner, and Adaptive Driver can disagree. The race engineer summarises the conflict, but the player remains responsible for the final decision.

Keeping the Project Runnable

A 3D frontend, simulation logic, AI explanations, and supporting services can create setup complexity.

We used Docker and documented environment configuration so judges and contributors can launch the complete project with minimal manual setup.

What We Learned

We learned that teaching AI concepts through interaction can be more intuitive than presenting definitions alone.

A player understands prediction more clearly when a rain forecast turns out to be wrong. They understand pattern recognition when telemetry detects overheating before a failure occurs. They understand adaptation when a driver changes its strategy after an unsuccessful attempt.

We also learned that uncertainty is an important part of AI education. A useful system should not only provide an answer; it should communicate confidence, limitations, and alternative interpretations.

From a technical perspective, the project strengthened our understanding of:

  • autonomous agent behaviour;
  • 3D web development;
  • race-state simulation;
  • state-machine design;
  • prompt design for contextual explanations;
  • Docker-based deployment;
  • documentation-driven development;
  • building and verifying a project with Codex.

Accomplishments That We Are Proud Of

We are proud that Neural Apex combines a complete autonomous racing experience with a clear educational purpose.

The project allows a beginner to experience the differences between ML, DL, and RL within a single race:

  • ML predicts what may happen.
  • DL detects what is currently happening.
  • RL adapts based on what happened before.

We are also proud of the experiment loop. Players can change one setting, run the scenario again, and directly compare the outcome instead of passively reading an explanation.

What Is Next for Neural Apex

Future versions could include:

  • additional circuits and weather scenarios;
  • longer championships;
  • cooperative driver and race-engineer roles;
  • player-created AI strategies;
  • more advanced telemetry analysis;
  • classroom and teacher modes;
  • shared challenges and leaderboards;
  • real reinforcement-learning agents;
  • additional concepts such as classification, recommendation systems, and computer vision;
  • multiplayer team-strategy competitions.

Our long-term goal is to turn Neural Apex into an accessible learning environment where users can experiment with AI systems, understand their limitations, and learn through every race.

Built With

Share this project:

Updates