Overload is a free, open source gaming project written in C++ and released under MIT. It has 2,498 GitHub stars, 288 forks and 107 open issues, and was last pushed 22 days ago. On this registry it ranks #49 of 68 tracked projects in Gaming, with 5 head-to-head comparisons available.

What is Overload?

Overload is a free, open-source 3D game engine written in C++ with Lua as its scripting language, aimed at game developers who want a compact, minimalistic engine and editor they can download, study and build themselves.

What it is

Overload is a C++20 game engine released under the MIT licence, first created in 2019 by Benjamin VIRANIN, Max BRUN and Adrien GIVRY as a graduation project and since developed as a community-driven initiative supported by dozens of contributors. It is divided into eleven modules: nine SDK libraries and two executables, the OvGame runtime and the OvEditor game editor. The README states the project's pillars as ease of use, simplicity, pragmatic design, documentation, community involvement and modern C++20, and points readers to a wiki holding sample projects, tutorials and the scripting API.

The concrete problem it solves is the assembly work that precedes a small 3D project. Instead of wiring together a renderer, a physics library, an audio library and a hand-built editor, a developer gets these as integrated modules behind one Lua-facing API: OvPhysics is built around Bullet3, OvAudio around SoLoud, OvMaths covers vectors, matrices, quaternions and transforms, OvTools covers serialization, file system, platform, events and clock, and OvDebug provides logging and assertions. Those SDK libraries are described as modular and easy to extract from a game engine context, so they can serve projects beyond the editor. The project lives in the C++ game development ecosystem, with Linux listed among its topics alongside the Windows build path.

Key capabilities

  • Lua scripting across the engine, backed by a documented scripting API in the wiki.
  • A game editor (OvEditor) with a prefab system and a material editor.
  • Physically-Based Rendering (PBR) with support for custom shaders.
  • Rigidbody physics through OvPhysics, built around Bullet3, together with skeletal animation.
  • Spatial audio through OvAudio, built around SoLoud.
  • Profiling tools for inspecting what the engine is doing at runtime.
  • Windows game building, plus an SDK of nine libraries designed to be reused outside the engine.

Who uses it and how

  • Hobbyist and small-team developers who download a pre-built release and open one of the sample projects from the wiki rather than starting from an empty scene.
  • Windows developers who clone the repository, run .\gen_proj.bat vs2022 to generate project files and open Overload.sln in Visual Studio 2022.
  • Linux developers who generate Makefiles with ./gen_proj.sh gmake and build with make -j$(nproc), installing zenity because the editor requires it.
  • Developers who want the libraries rather than the whole engine, since the SDK modules are designed to be extracted from a game engine context.
  • Teams tracking community development on the active forks the README points to, because external issues and pull requests are currently disabled.

Getting started

The quickest route is to download a pre-built binary from the releases page and open one of the sample projects linked from the wiki. Building from source means cloning the repository and running .\gen_proj.bat vs2022 on Windows, or ./gen_proj.sh gmake followed by make -j$(nproc) on Linux.

How it compares

No other engines or paid products are named in the facts available here, so Overload stands alone in this registry rather than being positioned against a named alternative. The only external components identified are the libraries it wraps, Bullet3 for physics and SoLoud for audio, which it integrates rather than competes with.

When to use it — and when not to

Overload suits developers who want a readable C++20 engine with a bundled editor and are content to build it themselves with MSVC on Windows or Clang on Linux, remembering that the Linux editor needs zenity installed. It is a poor fit for anyone who needs to report bugs upstream or contribute fixes: the README states that Overload is not currently accepting external contributions and that issues and pull requests are disabled for external users, pointing instead at forks that Overload Technologies explicitly does not vet, monitor or endorse. Choosing it therefore means accepting that you own your own fork if you need changes.

project readme (upstream, from github) — read inline

overload-banner-2

Releases | Screenshots | Features | Wiki | Contributing


platforms release size
issues pulls
license downloads


[!IMPORTANT] Overload is not currently accepting external contributions. Until further notice, issues and pull requests are disabled for external users.

Looking for community-driven development? Try one of these active forks.

⚠️ WARNING: Overload Technologies does not vet, monitor, or endorse these forks, and is not responsible for any damage they may cause. Use them at your own risk.

What's Overload?

Overload is a free, open-source 3D game engine made in C++ with Lua as its scripting language.

Originally created in 2019 by Benjamin VIRANIN, Max BRUN, and Adrien GIVRY as a graduation project, it has since evolved into an community-driven initiative supported by dozens of contributors.

Overload pillars are:

  • 🐣 Ease of use – Inspired by other commercial engines, so you feel right at home.
  • 🧊 Simplicity – Minimalistic by design, avoiding unnecessary complexity.
  • 💭 Pragmatic Design – Features are carefully considered and deeply integrated.
  • 📄 Documentation – Scripting API and documented source-code.
  • 🤝 Community-Driven – Welcoming contributions and feedback from all developers.
  • ⚙️ Modern C++20 – Leveraging the power and safety of up-to-date C++ features.

Features

  • Lua scripting
  • Game editor
  • Prefab system
  • Physically-Based Rendering (PBR)
  • Custom shaders support
  • Windows game building
  • Profiling tools
  • Material editor
  • Spatial audio
  • Rigidbody physics
  • Skeletal animation
  • And many more to come...

Check out our issues and pull requests to learn more about what's coming next!

Documentation

Check-out Overload's documentation to find sample projects, tutorials & the scripting API!

Getting Started

Before running Overload, we highly recommend downloading one of Overload's sample projects!

Pre-Built Binaries

In a rush? Get the latest release!

Building From Sources

Windows (MSVC)

git clone https://github.com/Overload-Technologies/Overload
cd Overload
.\gen_proj.bat vs2022 # generate project files for Visual Studio 2022
.\Overload.sln # Open the solution in Visual Studio

[!note] Officially supported actions for gen_proj.bat are: vs2022 (default), gmake, codelite.
Refer to premake's website for more information.

Linux (Clang)

git clone https://github.com/Overload-Technologies/Overload
cd Overload
./gen_proj.sh gmake # generate project files for Makefile
make -j$(nproc) # build the project using all available CPU cores

[!important] The editor requires zenity to be installed on Linux.

[!note] Officially supported actions for gen_proj.sh are: gmake (default), codelite.
Refer to premake's website for more information.

Architecture

Overload is divided into 11 modules: 9 libraries (SDK), and 2 executables (Applications).

Overload SDK

The Overload SDK is the core of the engine. It is a set of libraries used by our applications: OvGame and OvEditor. We designed theses libraries with reusability in mind. They are highly modular and easy to extract from a game engine context.

  • OvDebug: Logging and assertions.
  • OvTools: Serialization, file system, platform, events, clock, and more.
  • OvMaths: Vectors, matrices, quaternions, transforms.
  • OvAudio: Audio engine, built around SoLoud.
  • OvPhysics: Physics engine, built around Bullet3.
  • OvRendering: Rendering engine, built around BareGL.
  • OvWindowing: Handles inputs and windows using GLFW.
  • OvUI: Widget-based UI, leveraging ImGui under the hood.
  • OvCore: Component-based scene system, scripting, and resource management.

Overload Applications

Overload applications use the Overload SDK to operate.

  • OvGame: A data-driven executable for any game built with Overload.
  • OvEditor: An editor for building your game.

editor

Dependencies

Overload depends on a few third-party libraries:

Contributing

Overload is open to contributions of all kinds. Feel free to open issues (feature requests or bug reports) or submit pull requests.

If you'd like to contribute, please refer to our contribution guildelines.

Minimum Requirements

RAM 1GB
OS Windows 7 & Linux
GPU Graphics card supporting OpenGL 4.5
CPU x86_64

Screenshots

editor shading reflections pbr custom-shaders intel-sponza intel-sponza-2 intel-sponza-3

Frequently asked questions

Is Overload free to use?

Overload is open source under the MIT 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 Overload do?

3D game engine with lua scripting

What is Overload written in?

Overload is primarily written in C++. Its source is publicly available at https://github.com/Overload-Technologies/Overload, and it has 2,498 GitHub stars.