mtasa-blue: Open Source Gaming — 1.9K★ on GitHub

What is mtasa-blue?

Multi Theft Auto: San Andreas (mtasa-blue) is a GPL-3.0-licensed C++ game engine that adds networked multiplayer to Rockstar North's Grand Theft Auto: San Andreas, and it is aimed at server operators and Lua developers who want to build, host and run custom multiplayer game modes on top of that single-player PC game.

What it is

Multi Theft Auto is a software project that adds network play functionality to Rockstar North's Grand Theft Auto game series, in which that functionality is not originally found. It is a modification that incorporates an extendable network play element into a proprietary commercial single-player PC game. The software works through code injection and hooking techniques, so the game is manipulated without altering any original files supplied with the game. It installs itself as an extension of the original game, adding core functionality such as networking and GUI rendering while exposing the original game's engine functionality through a scripting language. The project was founded in early 2003 as an experimental piece of C/C++ software, was formerly closed source, and has migrated to open source to encourage other developers to contribute and to show insight into its source code and design for educational reasons. The engine is built on the "Blue" concept, a game engine framework whose class design follows Grand Theft Auto's own design, which is what allows the code to be inserted into the original game.

The concrete problem it solves is that Grand Theft Auto: San Andreas ships as a single-player PC game with no network play at all. Multi Theft Auto supplies that missing layer rather than replacing the game: it extends the original title with new game functionality, including tweaks and crash fixes, plus a completely new graphical interface, a networking component and a scripting component. Gameplay beyond the default minimal sandbox style is written in Lua, which is embedded in both the client and the server, and both sides run and synchronize those scripts on top of the framework's classes and functions. All gameplay content is grouped into a "resource", an archive containing Lua scripts, images, sounds, custom models or textures together with a metadata file that describes the content and any dependencies on other resources.

Key capabilities

Lua scripting embedded in both the client and the server, with scripts running and synchronizing on both sides.
A resource system that packages Lua scripts, images, sounds, custom models and textures as an archive plus a metadata file describing the content and its dependencies.
Automatic dependency handling, where a resource can import functionality from common resources that are then downloaded and started automatically.
Code injection and hooking that manipulates the game without altering any original files supplied with it.
A completely new graphical interface, networking component and scripting component layered onto the original engine.
Engine tweaks and crash fixes delivered as part of the extension rather than as patches to game files.
Access control over resources for server administrators, alongside the minimal sandbox-style Grand Theft Auto gameplay that supports custom game modes for up to hundreds of online players.

Who uses it and how

Server operators who host custom game modes written in Lua for up to hundreds of online players at a time.
Third-party developers who extend the platform by layering scripts on top of the framework's classes and functions.
Server administrators who manage which resources players may access and rely on automatic download of required resources to clients.
Community members who coordinate through the project's Discord server and contribute translations through its Crowdin localization project.

Getting started

The README excerpt supplied here does not name an install command, package or container image; the project's distribution and download point is its website at https://multitheftauto.com, with community support available through the linked Discord server.

How it compares

The facts provided name no similar multiplayer platforms and no list of paid products that this project replaces, so it stands alone in this registry. It is distinguished within these facts only by its model of extending a proprietary commercial single-player game rather than shipping a standalone title.

When to use it — and when not to

Choose it if you already own Grand Theft Auto: San Andreas and want to operate your own servers, since MTA is an extension of that game rather than a standalone product, and a self-hoster must run game servers and author, package and maintain Lua resources with their dependencies and access rules. It is a poor fit for anyone wanting a hosted service or a game that does not depend on a proprietary commercial title. The honest weaknesses visible here are a large open-issue count of 1,053 and an excerpt that is truncated and documents neither installation nor server requirements.

project readme (upstream, from github) — read inline

Multi Theft Auto: San Andreas

Multi Theft Auto (MTA) is a software project that adds network play functionality to Rockstar North's Grand Theft Auto game series, in which this functionality is not originally found. It is a unique modification that incorporates an extendable network play element into a proprietary commercial single-player PC game.

Introduction

Multi Theft Auto is based on code injection and hooking techniques whereby the game is manipulated without altering any original files supplied with the game. The software functions as a game engine that installs itself as an extension of the original game, adding core functionality such as networking and GUI rendering while exposing the original game's engine functionality through a scripting language.

Originally founded back in early 2003 as an experimental piece of C/C++ software, Multi Theft Auto has since grown into an advanced multiplayer platform for gamers and third-party developers. Our software provides a minimal sandbox style gameplay that can be extended through the Lua scripting language in many ways, allowing servers to run custom created game modes with custom content for up to hundreds of online players.

Formerly a closed-source project, we have migrated to open-source to encourage other developers to contribute as well as showing insight into our project's source code and design for educational reasons.

Multi Theft Auto is built upon the "Blue" concept that implements a game engine framework. Since the class design of our game framework is based upon Grand Theft Auto's design, we are able to insert our code into the original game. The game is then heavily extended by providing new game functionality (including tweaks and crash fixes) as well as a completely new graphical interface, networking and scripting component.

Gameplay content

By default, Multi Theft Auto provides the minimal sandbox style gameplay of Grand Theft Auto. The gameplay can be heavily extended through the use of the Lua scripting language that has been embedded in the client and server software. Both the server hosting the game, as well as the client playing the game are capable of running and synchronizing Lua scripts. These scripts are layered on top of Multi Theft Auto's game framework that consists of many classes and functions so that the game can be adjusted in virtually any possible way.

All gameplay content such as Lua scripts, images, sounds, custom models or textures is grouped into a "resource". This resource is nothing more than an archive (containing the content) and a metadata file describing the content and any extra information (such as dependencies on other resources).

Using a framework based on resources has a number of advantages. It allows content to be easily transferred to clients and servers. Another advantage is that we can provide a way to import and export scripting functionality in a resource. For example, different resources can import (often basic) functionality from one or more common resources. These will then be automatically downloaded and started. Another feature worth mentioning is that server administrators can control the access to specific resources by assigning a number of different user rights to them.

Development

Our project's code repository can be found on the multitheftauto/mtasa-blue Git repository at GitHub. We are always looking for new developers, so if you're interested, here are some useful links:

Build Instructions

Windows

Prerequisites

Visual Studio 2026 with:
- Desktop development with C++
- Optional component C++ MFC for latest v145 build tools (x86 & x64) or if that's missing C++ MFC for x64/x86 (Latest MSVC)
Microsoft DirectX SDK
Git for Windows (Optional)

Execute win-create-projects.bat
Open MTASA.sln in the Build directory
Compile
Execute: win-install-data.bat

Visit the wiki article "Compiling MTASA" for additional information and error troubleshooting.

GNU/Linux

You can build the MTA:SA server on GNU/Linux distributions only for x86, x86_64, armhf and arm64 CPU architectures. ARM architectures are currently in experimental phase, which means they're unstable, untested and may crash randomly. Beware that we only officially support building from x86_64 and that includes cross-compiling for x86, arm and arm64.

Build dependencies

Please always read the utils/docker/Dockerfile for up-to-date build dependencies.

make
GNU GCC compiler (version 10 or newer)
libncurses-dev
libmysqlclient-dev

Build instructions: Script

Note: This script always deletes Build/ and Bin/ directories and does a clean build.

$ ./linux-build.sh [--arch=x86|x64|arm|arm64] [--config=debug|release] [--cores=<n>]
$ ./linux-install-data.sh  # optional step

If build architecture --arch is not provided, then it's taken from the environment variable BUILD_ARCHITECTURE (defaults to: x64).

If build configuration --config is not provided, then it's taken from the environment variable BUILD_CONFIG (defaults to: release).

If the number of jobs --cores is not provided, then the build will default to the amount of CPU cores.

If you are trying to cross-compile to another architecture, then set AR, CC, CXX, GCC_PREFIX environment variables accordingly (see utils/docker/Dockerfile for an example).

Build instructions: Manual

$ ./utils/premake5 gmake
$ make -C Build/ config=release_x64 all
$ ./linux-install-data.sh  # optional step

If you don't want to build the release configuration for the x86_64 architecture, you can instead pick another build configuration from: {debug|release}_{x86|x64|arm|arm64}.

GNU/Linux: Docker Build Environment

If you have problems resolving the required dependencies or want maximum compatibility, you can use our dockerized build environment that ships all needed dependencies. We also use this environment to build the official binaries.

Pulling the Docker image

$ docker pull ghcr.io/multitheftauto/mtasa-blue-build:latest

Building with Docker

These examples assume that your current directory is the mtasa-blue checkout directory. You should also know that /build is the code directory required by our Docker image inside the container. After compiling, you will find the resulting binaries in ./Bin. To build the unoptimised debug build, add --config=debug to the docker run arguments.

# x86_64
docker run --rm -v `pwd`:/build ghcr.io/multitheftauto/mtasa-blue-build:latest --arch=x64

# x86
docker run --rm -v `pwd`:/build ghcr.io/multitheftauto/mtasa-blue-build:latest --arch=x86

# arm
docker run --rm -v `pwd`:/build ghcr.io/multitheftauto/mtasa-blue-build:latest --arch=arm

# arm64
docker run --rm -v `pwd`:/build ghcr.io/multitheftauto/mtasa-blue-build:latest --arch=arm64

Premake FAQ

How to add new C++ source files?

Execute win-create-projects.bat

License

Unless otherwise specified, all source code hosted on this repository is licensed under the GPLv3 license. See the LICENSE file for more details.

Frequently asked questions

Is mtasa-blue free to use?

mtasa-blue is open source under the GPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does mtasa-blue do?

Multi Theft Auto is a game engine that turns Grand Theft Auto: San Andreas into networked multiplayer.

What is mtasa-blue written in?

mtasa-blue is primarily written in C++. Its source is publicly available at https://github.com/multitheftauto/mtasa-blue, and it has 1,892 GitHub stars.