RL-Legend-DMA is a C++-based physics prediction framework designed for high-speed vehicle simulations—specifically targeting Rocket League, a competitive vehicular soccer game where precise timing, trajectory prediction, and input execution determine success. It is not a game mod, bot, or automation tool, but rather a research-oriented framework focused on analyzing rigid-body dynamics in real time. Its stated purpose is to support developers and analysts who study how cars move, rotate, bounce, and interact with the ball under high-velocity conditions. The project frames itself as a tool for “tactical decision-making” and “mechanical precision,” with features built around telemetry, sub-tick timing, and visual overlay.

What it does
RL-Legend-DMA implements several tightly coupled capabilities, all centered on predictive modeling of physics behavior during active simulation:

  • Real-time trajectory estimation, calculating ball paths with bounce reflection modeling and velocity decay analysis
  • Maneuver synchronization, auditing controller input timing down to sub-tick resolution to validate execution of advanced moves like “fast-aerial” and “flip-reset”
  • Spatial orientation mapping, rendering 3D orientation vectors for all active entities (cars and ball) to support field awareness analysis
  • Boost-flow telemetry, tracking boost consumption rates and correlating them with movement vectors to identify optimal repositioning paths
  • Low-latency DirectX 12 overlay, built with ImGui, that displays predictive vectors without interfering with simulation stability

These features are implemented in C++ 23 and rely on a custom kinematic library optimized for SSE/AVX instructions. The overlay layer is separate from the simulation process and injects into the target executable, which—based on the README—is assumed to be Rocket League running locally.

Getting it running
The project does not provide source-based build instructions. According to the README, setup is binary-driven and requires administrator privileges:

  1. Confirm your system supports .NET 8 and C++ 23 runtime (no version numbers or installer links are given beyond this requirement)
  2. Download Installer.exe from the v2026 release
  3. Run the Predictor Core executable as administrator
  4. Use the Dashboard UI to select the active simulation process (e.g., RocketLeague.exe)
  5. Press F1 to toggle the physics overlay

There is no mention of Docker, CLI tools, build scripts, or cross-platform support. The installer and overlay are Windows-only, and the DirectX 12 dependency confirms this. No configuration files, environment variables, or command-line flags are documented in the provided context.

Who this is for
RL-Legend-DMA targets a narrow audience: developers and analysts working on Rocket League physics modeling, particularly those building training tools, replay analyzers, or academic studies around rigid-body dynamics in competitive vehicular simulations. It assumes familiarity with concepts like tick-based game loops, vector kinematics, and real-time telemetry pipelines. It is not aimed at end users looking for gameplay aids or cheat-like enhancements—its documentation emphasizes research, not performance improvement. The project explicitly invites contributions to the kinematics engine, suggesting it is intended as a shared infrastructure for physics accuracy work, not a finished end-user application.

How it compares
RL-Legend-DMA occupies a niche adjacent to—but distinct from—other Rocket League analysis tools. It differs from open-source prediction libraries like rlbot in that it does not interface with the game via memory reading or plugin APIs; instead, it injects a visualization layer and performs its own trajectory modeling. Unlike general-purpose physics engines (e.g., Bullet, PhysX), it is domain-specific and does not aim to simulate arbitrary environments—it assumes the exact constraints and constants of Rocket League’s internal physics. Compared to community tools like Omen or Squid, which focus on replay parsing and statistical breakdowns, RL-Legend-DMA prioritizes live, frame-accurate vector prediction and input timing validation. It is also heavier than lightweight prediction-only modules: the dependency on .NET 8, DirectX 12, and a custom SSE/AVX math engine implies higher system requirements than pure C++ libraries.

The repository has 46 stars and is licensed under MIT. Its GitHub username—philomenahighley12905169487—does not correspond to a known developer or organization in the broader Rocket League tooling ecosystem. The version tag 2026 is inconsistent with conventional semantic versioning and may indicate a date-based or internal release scheme. The project’s LICENSE file is present but not quoted or described in detail beyond the MIT badge.

This is not a framework for general vehicle simulation or robotics. It does not support ROS, Gazebo, or CARLA. It does not export data to CSV, JSON, or standard telemetry formats. It does not document its kinematic equations, parameter tuning process, or validation methodology against ground-truth game behavior. Its primary output is visual: predictive vectors overlaid on screen.

The project is hosted at https://github.com/philomenahighley12905169487/RL-Legend-DMA.

View on GitHub →