BepInEx – Powerful Modding Framework for Unity Games

BepInEx is a popular modding framework designed for Unity-based games. It provides a flexible environment for loading plugins, creating custom modifications, and extending game functionality with ease.

Open Source    •    Plugin Friendly    •    Mono / IL2CPP Guidance

BepInEx 5

Established choice for many compatible Unity Mono modding setups.

BepInEx 6

Newer development line for newer runtime and IL2CPP-oriented workflows where supported.

Need Help Choosing?

Check the game's runtime, architecture, and plugin requirements before downloading.

Quick start: Identify runtime → choose build → extract to game root → launch → add compatible plugins.

BepInEx Features

Explore the core capabilities that make BepInEx a flexible plugin and patching framework for supported Unity and .NET-based games.

01

Drop-in Installation

Place the appropriate BepInEx files in the game directory and launch the game. The framework is designed to get users started without a complex installer.

02

Plugin & Modding Framework

Load and manage custom plugins for supported Unity and .NET-based games through an extensible C# plugin framework.

03

Unity Mono Support

Stable releases support Unity games that use the Mono scripting backend across supported desktop platforms.

04

Unity IL2CPP Support

BepInEx also provides tooling for Unity IL2CPP games. Support and platform compatibility can vary by BepInEx build, so check the current documentation.

05

.NET / XNA Support

BepInEx can also target supported .NET Framework games and XNA-family technologies such as XNA, FNA and MonoGame.

06

Built-in Configuration

Plugins can expose configurable settings through BepInEx configuration APIs, making options easier to manage.

07

Built-in Logging

Integrated logging helps users and developers diagnose plugin loading, runtime behavior and errors.

08

Runtime Method Patching

HarmonyX and MonoMod integration enables runtime method injection and patching without permanently modifying original game assemblies.

09

In-Memory Assembly Patching

Advanced workflows can patch managed assemblies in memory with Mono.Cecil before the game initializes.

10

Preloader Patchers

Preload-time patchers provide deeper control when assemblies need to be transformed before they are loaded.

11

Extensible Architecture

BepInEx is designed to be extended, giving plugin developers a flexible base for custom modding workflows.

12

Mod Loader Integrations

The project lists loaders/integrations for frameworks such as BSIPA, IPA, MelonLoader, MonoMod, Sybaris, UnityInjector and Unity Mod Manager.

Download

Download BepInEx

Select a build based on the target game’s runtime, operating system, architecture, and any version requirement in the game or plugin documentation.

BepInEx 5

Stable choice for many established Unity Mono modding setups. Commonly associated with an established plugin ecosystem and x86/x64 packages where applicable.

BepInEx 6

The newer development line. Relevant builds can cover newer runtime and IL2CPP-oriented use cases depending on the release channel and target game.

Not sure which version you need? Check the game runtime and architecture before downloading. Do not assume that the newest release line is the correct choice for an existing setup.

Framework Overview

What Is BepInEx?

BepInEx is a framework that provides a structured foundation for loading plugins and applying runtime modifications in compatible Unity and supported .NET-based games. Instead of every mod needing its own loader or requiring direct changes to original game assets, BepInEx can provide a common environment for plugin discovery, initialization, configuration, logging, and related workflows.

For developers, this separation is useful because plugin code can focus on features, tweaks, tools, or other supported modifications while the framework handles the loading layer. Compatibility is not universal: Unity Mono remains the most established use case, while IL2CPP requires appropriate builds and may vary by release line or channel.

Framework → Plugins → Game

BepInEx provides the framework foundation; compatible plugins provide the functionality. This separation can make supported setups easier to manage and troubleshoot.

Core Capabilities

Why Use BepInEx?

A reusable framework layer can make compatible modding setups easier to extend, configure, debug, and maintain.

Plugin Framework

Load compatible plugins that extend supported games with features, tweaks, tools, or integrations.

Runtime Modding

Apply supported runtime changes without directly rewriting original game assets where the target setup allows it.

Configuration System

Use framework and plugin configuration options to adjust behavior without repeatedly rebuilding code.

Logging & Debugging

Review logs and diagnostics that help confirm loading behavior and troubleshoot supported setups.

Cross-Platform Support

Use builds supplied for supported operating systems and environments; availability varies by runtime and release.

Developer Friendly

Build on a reusable plugin ecosystem with clear separation between loading, plugin logic, configuration, and diagnostics.

Four-Step Workflow

How Does BepInEx Work?

The exact details vary by game and build, but the core workflow is install, initialize, add compatible plugins, then verify the result.

01 — Install BepInEx

Place files from the correct BepInEx package in the appropriate game directory.

02 — Launch the Game

For a supported setup, the framework initializes when the game starts.

03 — Add Plugins

Place compatible plugin files in the appropriate BepInEx plugins directory.

04 — Customize & Play

Launch the game and verify plugin behavior, configuration, and logs.

Runtime Matrix

BepInEx Compatibility

Identify the game’s runtime and architecture first, then choose a package intended for that environment.

Unity Mono

The most established BepInEx use case. Many existing setups and plugins target compatible Unity games using the Mono scripting backend.

Unity IL2CPP

IL2CPP games require an appropriate BepInEx build and supporting workflow. Compatibility can depend on the release line, game, and tooling.

.NET-Based Games

Some supported .NET, XNA, FNA, or MonoGame scenarios may work depending on the BepInEx build and target application.

Compatibility depends on the game engine, runtime, operating system and architecture. Windows, Linux and macOS availability can differ by build. Always choose the package intended for your target setup.

Installation

How to Install BepInEx

A reliable BepInEx installation starts by matching the package to the target game’s architecture, runtime, operating system, and required major version.

01 — Identify Your Game Architecture

Determine whether the game executable is 32-bit (x86) or 64-bit (x64).

02 — Check the Runtime

Find out whether the Unity game uses Mono or IL2CPP.

03 — Download the Correct Build

Match the game's runtime, architecture, OS, and required BepInEx version.

04 — Locate the Game Root Folder

Open the folder containing the game's executable and main data directories.

05 — Extract BepInEx

Extract the selected package into the game root while preserving its directory structure.

06 — Launch the Game

On a compatible setup, launch the game so BepInEx can initialize the required files and folders.

07 — Install Plugins

Add compatible plugin files to the appropriate plugins directory and follow dependency requirements.

Installation steps can vary between BepInEx versions, game runtimes, operating systems, and game-specific setups.

Version Comparison

BepInEx 5 vs BepInEx 6

Choose the major version required by the target game and plugins. Runtime support and plugin expectations can differ between release lines.

Feature

BepInEx 5

BepInEx 6

Maturity

Established major line used by many existing setups.

Newer major development line; maturity depends on build/channel.

Unity Mono usage

Common for compatible established Mono modding setups.

Mono support may be available depending on BepInEx 6 build and target environment.

IL2CPP

Follow target-specific documentation; do not assume a BepInEx 5 package is correct.

Relevant BepInEx 6 builds can target IL2CPP scenarios depending on release/build channel.

Plugin compatibility

Many existing plugins target BepInEx 5; requirements vary.

Do not assume BepInEx 5 plugins are universally interchangeable.

Runtime architecture

Established BepInEx 5 architecture.

Newer framework architecture and runtime support direction.

Recommended use case

Use when game/plugin documentation calls for BepInEx 5.

Use when target game/tooling/plugin documentation calls for BepInEx 6.

For an existing mod setup, follow the version required by the game or plugin documentation rather than upgrading blindly.

Plugin Ecosystem

Using Plugins With BepInEx

BepInEx plugins are compiled extensions that run through the framework and can add features, tweaks, utilities, or other runtime behavior to a supported game. In many standard setups, compatible plugin files are placed in the BepInEx/plugins directory after the framework has initialized.

Compatibility matters. A plugin may target a particular BepInEx major version, game version, runtime, dependency set, or operating system. Read the plugin’s requirements before installing it, and treat third-party plugins as executable code from sources you trust.

Install

Place compatible plugin files in the required plugin directory for the framework version and game.

Configure

Edit available configuration settings when the framework or plugin exposes supported options.

Launch

Start the game and verify plugin loading through available logs, configuration, or documented behavior.

Configuration

Configure BepInEx Your Way

BepInEx and compatible plugins may expose configuration files or settings that let you adjust behavior without rebuilding code. Exact files and folders depend on framework version, build, plugins, and target game.

Common setups may include directories such as config, plugins, and patchers, plus log output. Treat this as a general pattern rather than a universal file layout.

Typical BepInEx Structure

config/ • plugins/ • patchers/ • log output — exact files can vary by version/build.

Easy Configuration

Keep supported framework and plugin options in dedicated configuration files.

Plugin-Specific Options

Adjust settings exposed by individual plugins when those plugins provide configurable values.

Helpful Logs

Use available log output to confirm loading behavior and isolate compatibility issues.

Troubleshooting

Common BepInEx Installation Issues

Test one variable at a time. Start with framework compatibility and folder placement, then add plugins gradually and review available logs.

BepInEx does not start

Check the game root, selected build, runtime, architecture, and target-specific instructions.

Plugins are not loading

Confirm plugin folder placement, framework major version, runtime compatibility, and dependencies.

Game crashes after installation

Remove newly added plugins first and test the framework by itself, then re-check build compatibility.

Wrong x86 or x64 build

Match the framework package architecture to the game executable when separate builds are supplied.

Mono vs IL2CPP confusion

A package intended for Mono is not automatically correct for an IL2CPP game. Use the runtime-specific setup required by target documentation.

Why BepInEx

A Flexible Foundation for Game Modding

BepInEx is useful as a reusable framework layer: open-source, extensible, developer-oriented, and supported by an established modding ecosystem.

Open Source

Transparent ecosystem

Extensible

Built around plugins

Developer Focused

Useful tooling and logging

Community Driven

Established modding ecosystem

Download & Setup Guidance

BepInEx Download & Modding Framework

If you are looking for a BepInEx download, start with the target game rather than simply choosing the newest-looking package. Identify whether the game uses Unity Mono or IL2CPP, confirm whether the executable is x86 or x64, and check which operating-system build and major BepInEx line the game or plugin documentation requires.

For many established Unity modding setups, BepInEx 5 remains a common framework choice, especially where existing Mono-focused plugins and guides depend on it. BepInEx 6 is the newer development line and may be relevant to newer runtime or IL2CPP-oriented workflows depending on the build and release channel.

A typical BepInEx installation places the selected framework package in the game root, launches the game so the framework can initialize, and then adds compatible BepInEx plugins to the appropriate plugin directory. Configuration files can expose settings, while logs can help diagnose loading or compatibility problems.

BepInEx is best understood as a Unity modding framework and plugin-loader foundation rather than a guarantee that every mod works with every game. Compatibility can change with game updates, framework builds, plugin versions, runtimes, and operating systems.

Frequently Asked Questions

BepInEx FAQ

15 practical answers covering installation, versions, runtimes, plugins, operating systems, logs, architecture, safety, and troubleshooting.

BepInEx is an open-source plugin and modding framework used with compatible Unity and supported .NET-based games. It provides a structured environment for loading plugins, configuration, and diagnostics. The correct build depends on the target game’s runtime, architecture, operating system, and required BepInEx release line.

Identify whether the game is x86 or x64 and whether it uses Mono or IL2CPP. Download the compatible BepInEx package, extract it into the game root according to that build’s instructions, and launch the game so the framework can initialize. Then add compatible plugins to the appropriate plugins directory.

BepInEx is open source, but safety also depends on where you obtain files and which third-party plugins you run. Use trusted sources, verify releases or checksums when available, and remember that plugins contain executable code. Do not assume every third-party download is automatically safe.

No. Compatibility depends on Unity version, scripting backend, architecture, operating system, game-specific protections, framework build, and other technical details. Confirm target-specific support before installing.

BepInEx 5 is the established major line used by many existing Unity Mono modding setups. BepInEx 6 is the newer development line with a different architecture and newer runtime direction. Exact support depends on build and release channel, and plugins are not guaranteed to be interchangeable between major versions.

In many standard installations, compatible plugin assemblies are placed in the BepInEx plugins directory inside the game root. A plugin may still require subfolders, dependencies, configuration, or a specific framework version, so follow the plugin author’s instructions.

Appropriate BepInEx builds can be used for some IL2CPP-oriented modding scenarios, particularly in the newer development line, but support is not universal. The correct package depends on the game, architecture, operating system, framework build, and release channel.

Use the game’s executable information or trusted game/modding documentation to determine its architecture. Match x86 to a 32-bit target and x64 to a 64-bit target when separate packages are provided.

Use trusted game-specific modding documentation or established runtime-identification guidance. File layout can provide clues, but target-specific documentation is more reliable than assuming a single filename proves the runtime.

Common causes include extracting files into the wrong folder, using the wrong architecture, choosing a package for the wrong runtime, or installing a framework version not supported by the target game. Test the framework without extra plugins and review available logs or game-specific documentation.

Check that plugin files are in the correct plugins directory and target the installed BepInEx major version, game version, runtime, and architecture. Also verify required dependencies. Add plugins one at a time when troubleshooting.

BepInEx has supported non-Windows scenarios, but platform availability is not identical across every runtime, release line, game, or build. Check package and target-game documentation rather than assuming universal compatibility.

Do not assume so. Major framework versions can differ in APIs, runtime behavior, dependencies, and plugin expectations. Use the BepInEx version specified by the plugin author or a plugin release explicitly built for your installed major version.

Many setups use directories such as BepInEx/config and BepInEx/plugins, and some builds produce log output. Exact filenames, locations, and behavior can vary by BepInEx version, build, configuration, and installed plugins.

Not always, but a game update can change files, runtime behavior, or compatibility with the framework and plugins. If a previously working setup stops loading, confirm that framework files are still present and check whether updated BepInEx or plugin builds are required.

Scroll to Top