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.
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.
Plugin & Modding Framework
Load and manage custom plugins for supported Unity and .NET-based games through an extensible C# plugin framework.
Unity Mono Support
Stable releases support Unity games that use the Mono scripting backend across supported desktop platforms.
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.
.NET / XNA Support
BepInEx can also target supported .NET Framework games and XNA-family technologies such as XNA, FNA and MonoGame.
Built-in Configuration
Plugins can expose configurable settings through BepInEx configuration APIs, making options easier to manage.
Built-in Logging
Integrated logging helps users and developers diagnose plugin loading, runtime behavior and errors.
Runtime Method Patching
HarmonyX and MonoMod integration enables runtime method injection and patching without permanently modifying original game assemblies.
In-Memory Assembly Patching
Advanced workflows can patch managed assemblies in memory with Mono.Cecil before the game initializes.
Preloader Patchers
Preload-time patchers provide deeper control when assemblies need to be transformed before they are loaded.
Extensible Architecture
BepInEx is designed to be extended, giving plugin developers a flexible base for custom modding workflows.
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.
What is BepInEx?
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.
How do I install BepInEx?
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.
Is BepInEx safe to use?
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.
Does BepInEx work with every Unity game?
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.
What is the difference between BepInEx 5 and BepInEx 6?
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.
Where do BepInEx plugins go?
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.
Does BepInEx support IL2CPP games?
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.
How do I know whether my game is 32-bit or 64-bit?
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.
How can I tell whether a Unity game uses Mono or IL2CPP?
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.
Why does BepInEx not start after installation?
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.
Why are my BepInEx plugins not loading?
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.
Does BepInEx work on Linux and macOS?
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.
Can I use BepInEx 5 plugins with BepInEx 6?
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.
Where are BepInEx configuration and log files?
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.
Do I need to reinstall BepInEx after a game update?
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.