# RLBot: the framework behind Rocket League bots in five languages

> RLBot is the framework that lets people write their own bots for Rocket League's offline modes, exposing game state like car and ball position and carrying button presses back. The repository is explicitly incomplete for legal reasons, and the README tells bot makers to start from the example projects instead.

**RLBot/RLBot** — A framework that allows people to write their own Rocket League bots.

- Repository: https://github.com/RLBot/RLBot
- Stars: 621 · Forks: 120
- Language: Python
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/rlbot-rlbot

## The README tells you not to use this repository

The first line of the README reads YOU PROBABLY SHOULDN'T PULL THIS REPO, and the reason follows immediately. If you just want to make a bot, you do not need to be here, and instead you should start from one of the example projects, of which there are five. There is a Python example, a Java example, a C# example that also covers other .NET languages, a Scratch interface, and a Rust crate published on crates.io. There is a separate GUI project, RLBotGUI, for the case where you just want to play with bots rather than write one, and it is described as the way to easily start matches with bots. This is a well organised framework repository, and the fact that it steers newcomers away is a sign of maturity rather than of confusion. The framework itself is described as helping people create bots for use in Rocket League's offline modes, just for fun, and it works by providing values from the game like car and ball position, and carrying back button presses. The scope is explicitly offline, which is the boundary that matters legally and technically.

## Why the repository is incomplete, and what that means for contributors

The Framework Contributors section is the part of the README that any potential contributor needs to read carefully, because it describes a repository that cannot yet be what it wants to be. The repository is currently incomplete to meet the legal needs of the Psyonix API, and it is missing the source code behind RLBot.exe and a few other files. If you want to make a code change that involves RLBot.exe, or the interface dll since it is closely related, you will need some help from someone with access to the closed repo. The expectation stated is that everything will be open-sourced eventually, and then the repository will be back in business. There is also a specific notice about how your work will be handled. The maintainers intend to cherry-pick any commits you make into the closed repository, and at a later date, when they have permission to open-source everything, they will force push the closed repository to the master branch, so your commits will still be there with proper attribution, but work in progress will need to be rebased at that time. In practice, contributing here means writing code in a staging area with an unusual workflow, and the parts most contributors would want to touch are the parts that are closed.

## setup.bat does three jobs, one of which is a prerequisite

The Quick Start is two steps, running setup.bat or the equivalent on Linux or Mac, then opening a terminal and executing python runner.py. The development workflow section expands on what the setup script does, and the first item is about your installation rather than about code. It sets up your rlbot installation in pip to link to your local files in the folder, so once you have done this, running rlbot from anywhere on your computer will reference those local files, including the dlls. The second item is the one people miss. It generates important code based on the .fbs message spec, and it is therefore a prerequisite for running anything. The third is that it installs the Python package dependencies. That ordering is a good illustration of a generated-code project, since a flat buffer schema is the source of truth for the interface between Python and the native layer, and the generated bindings have to exist before the runner can start. The requirements file in the repository confirms the arrangement, since it installs the rlbot package in editable mode from ./src/main/python, with a comment explaining that changes to Python files are reflected even though pip is involved, and that runtime dependencies indicated in src/main/python/setup.py are installed automatically, with the instruction that a new runtime dependency belongs there rather than in the requirements file.

## DLL copying, batch files and a Gradle build for the native side

The native side is built with Gradle, since the top level holds build.gradle, settings.gradle, a gradle directory, gradlew and gradlew.bat. The scripts in the repository divide the work by purpose. There is setup.bat with setup.sh and setup_mac.sh for the initial setup on the three platforms, runner.bat, runner.py, runner_gui.bat and runner_gui.py for launching, and copy-dlls-mac.sh alongside copy-dlls.bat and copy-dlls-release.bat, the latter two of which the README explains for anyone working on the dll or exe files. copy-dlls.bat copies the debug versions of any built dlls from Visual Studio into the correct subdirectory in the Python source folder, and copy-dlls-release.bat copies the release versions. There is also build-and-copy-exe.bat for building the executable, prepare-python-distribution.bat, and publish-to-pypi-prod.bat, publish-to-pypi-test.bat and publish-to-pypi.sh for releasing the Python package. The presence of separate debug and release copy steps, and of a Mac-specific copy script, reflects a cross-platform build that has to place the right binary flavour in the right place before the Python side will run.

## Ten bots reliably, sixty-four with caveats

The Framework Info section contains the honest limits of the framework in a single sentence. RLBot works for up to 10 bots reliably, it can be used up to 64, but it can result in issues, and the examples given are bots disappearing after goals and spawning inside one another. This is the kind of constraint that a bot author hits immediately, because the natural first project is a match with several of your own bots to see them behave differently, and the difference between ten and sixty-four is the difference between a working experiment and a flaky one. The mechanism behind those symptoms is not explained in the README, so it would be speculation to say what causes a bot to vanish after a goal, and the practical response is simply to treat ten as the ceiling for reliable work and to test above it. The requirements are Rocket League and Python 3.6 or newer, which is a low floor, and the file structure at the top level supports the split between configuration and code with an rlbot.cfg file, the source under src/, the images directory for the project's own artwork, and the .gitattributes and .gitignore files.

## Getting back to the official release

The README explains how to undo a local development installation, and the instruction is short enough that it is worth knowing before you start. When you are done with development and want to get back to the official rlbot version vended from PyPI, the easiest way is to run pip uninstall rlbot, and the next time you execute a bat file from one of the RLBotExample repositories, a fresh copy will be installed from pip. That behaviour is a direct consequence of the editable install, where your local checkout shadows the published package, and the project has thought about the round trip so that a contributor does not end up with a permanently broken pip state. The distribution channels are several, with badges for the PyPI package, a bintray hosted Maven artefact, a NuGet package named RLBot.Framework, and the Rust crate, which is the same Rust binding the README points bot makers at. Deployment guidance lives in a separate wiki page, and the wider documentation is at the RLBot wiki.

## Where the framework sits against writing your own interface

The alternative to RLBot is to write your own interface to the game, and for the offline modes that is not a small undertaking, because the game exposes what it exposes and the interface is the work. The framework's value is that it already solved the parts that are tedious rather than interesting, which is the message passing between the game and your bot, the coordinate and orientation conventions, the frame timing, and the mapping from a state snapshot to the control inputs your bot decides on. Once that exists, the interesting part of a bot is the decision logic, and the framework lets you write only that, in whichever of the five languages the example projects cover. The cost is the dependency. You are building against a framework whose core is not fully open source, whose behaviour is coupled to a game that Psyonix updates, and whose API is documented in a wiki rather than in the code you can read. The framework also does not try to be anything more than a harness, since there is no training, no simulation and no reinforcement learning tooling in the repository, so a project that wants to learn a driving policy rather than script one will not find what it needs here.

## Conclusion

Adopt the RLBot example projects if you want to write a Rocket League bot and pick the language you already know, since the framework core is deliberately not the place to start. Skip this repository as a contribution target unless you are working on the parts that are actually open, since the README states it is missing the source behind RLBot.exe and that changes touching that binary need help from someone with access to the closed repository. Verify first which example project matches your language, that your Rocket League and Python versions fit the requirements, and that you read the deployment notes before assuming a local pip install of rlbot is the official build.

## FAQ

### How do I start making a Rocket League bot with RLBot?

The README says not to clone the framework repository, and to start from an example project instead: RLBotPythonExample, RLBotJavaExample, RLBotCSharpExample, the Scratch interface, or the rlbot crate on crates.io. RLBotGUI is the route if you only want to run matches with existing bots rather than write your own.

### Why is the RLBot repository missing some of its source code?

The README states the repository is currently incomplete to meet the legal needs of the Psyonix API, and it is missing the source code behind RLBot.exe and a few other files. Changes involving that executable or the closely related interface dll need help from someone with access to the closed repository, and the project expects to open-source everything eventually.

### How many bots can RLBot run at the same time?

It works for up to 10 bots reliably, and it can be used up to 64, but at higher counts it can produce issues such as bots disappearing after goals and spawning inside one another. The requirements listed are Rocket League and Python 3.6 or newer.

## Sources

- [Issues](https://github.com/RLBot/RLBot/issues)
- [License: MIT](https://github.com/RLBot/RLBot/blob/master/LICENSE)
- [README](https://github.com/RLBot/RLBot/blob/master/README.md)
- [RLBot/RLBot on GitHub](https://github.com/RLBot/RLBot)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rlbot-rlbot