NeuralRacer-CPP: A C++ Neuroevolution Autonomous Driving Simulator Built from Scratch

NeuralRacer-CPP is a high-performance autonomous driving simulator built entirely from scratch using modern C++17, without relying on any heavyweight machine learning frameworks. It trains virtual race cars to drive autonomously on complex tracks via custom feedforward neural networks and genetic algorithms. The core of the project is to help developers deeply understand the essence of neuroevolution, demonstrate the implementation of underlying algorithms and the advantages of C++ in performance and memory management, and it has both technical exploration and AI educational value.

NeuralRacer-CPP was born from the philosophy that "true understanding comes from building with your own hands", aiming to help developers master the underlying mechanisms of neural networks (such as weight updates and forward propagation). The project is written in C++17, making full use of its advantages in performance and memory management. It has no external machine learning dependencies, only using the lightweight raylib library for graphics rendering and 2D physics simulation, focusing on algorithm efficiency and core AI logic.

The project implements a classic feedforward neural network with a 6-8-2 node configuration: input layer with 6 nodes (distance from 5-directional sensors + current vehicle speed), hidden layer with 8 nodes (feature extraction and nonlinear transformation), and output layer with 2 nodes (controlling steering and acceleration). The forward propagation process is fully implemented manually, including weight matrix multiplication, bias addition, and activation function application. The code is transparent for easy debugging and optimization, meeting the lightweight requirements of embedded AI real-time systems.

The project uses genetic algorithms instead of backpropagation to train neural networks, inspired by NEAT but with a concise implementation. Each generation simulates 100 race cars, calculating fitness based on driving distance, survival time, etc., and retains the top 10 elites. The remaining 90 cars are bred using the "Frankenstein" strategy: randomly select elite parents to copy weights, with a 10% probability of Gaussian mutation. This strategy does not require gradient calculation, avoids gradient problems, and simulates natural evolution to accumulate excellent driving strategies.

In engineering, the project manually manages memory (fixed arrays to avoid fragmentation), uses modular design (Car class, Evolution namespace, etc.), and compile-time configuration (constexpr to determine population size, etc.). In terms of education, the source code helps beginners intuitively understand neural networks (weight matrices, forward propagation), demonstrates the application of genetic algorithms in AI training, proves the value of C++ in high-performance AI scenarios, and is suitable for learning embedded AI and real-time systems.

The project is in the active development stage, and the author plans to refactor the architecture and optimize memory. Potential directions include introducing complex network topologies (convolutional/recurrent layers), multi-objective optimization, network visualization, and more sensor inputs. The project is open-source under the MIT license, encouraging community contributions. Contributions can start from improving track generation, optimizing genetic algorithms, enhancing rendering performance, etc. The code structure is clear and fully commented.