Harmony

Pros of Cecil

• Lower-level IL manipulation, offering more fine-grained control
• Broader scope, allowing for more extensive code modification and analysis
• More mature project with a longer history and wider adoption

Cons of Cecil

• Steeper learning curve due to its lower-level nature
• Requires more code to achieve simple runtime patching tasks
• Less focused on runtime patching, making some common modding tasks more complex

Code Comparison

Cecil (modifying a method):

var assembly = AssemblyDefinition.ReadAssembly("MyAssembly.dll");
var method = assembly.MainModule.GetType("MyNamespace.MyClass").Methods.First(m => m.Name == "MyMethod");
var il = method.Body.GetILProcessor();
il.InsertBefore(method.Body.Instructions[0], il.Create(OpCodes.Ldstr, "Hello, World!"));
il.InsertBefore(method.Body.Instructions[0], il.Create(OpCodes.Call, method.Module.ImportReference(typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }))));

Harmony (patching a method):

var harmony = new Harmony("com.example.patch");
var original = typeof(MyClass).GetMethod("MyMethod");
var prefix = typeof(MyPatch).GetMethod("Prefix");
harmony.Patch(original, new HarmonyMethod(prefix));

Pros of BepInEx

• Provides a complete modding framework, including plugin loading and configuration management
• Supports multiple Unity game engines and non-Unity games
• Offers a user-friendly GUI for configuring mods and plugins

Cons of BepInEx

• Steeper learning curve for beginners due to its comprehensive nature
• May have a larger performance overhead compared to Harmony alone
• Requires more setup and configuration for simple patching tasks

Code Comparison

BepInEx (plugin example):

[BepInPlugin("com.example.plugin", "Example Plugin", "1.0.0")]
public class ExamplePlugin : BaseUnityPlugin
{
    void Awake()
    {
        // Plugin startup logic
        Logger.LogInfo("Plugin is loaded!");
    }
}

Harmony (patch example):

[HarmonyPatch(typeof(TargetClass), "TargetMethod")]
class Patch
{
    static void Postfix(ref int __result)
    {
        __result *= 2;
    }
}

BepInEx is a comprehensive modding framework that includes plugin management and configuration tools, while Harmony focuses specifically on runtime method patching. BepInEx offers more features but may be overkill for simple patching needs, whereas Harmony is more lightweight and focused on method manipulation.

Pros of MelonLoader

• Provides a complete modding framework, including mod loading and management
• Supports a wider range of Unity games, including IL2CPP-based games
• Offers built-in console and logging features for easier debugging

Cons of MelonLoader

• Larger and more complex, potentially harder to integrate for simple patching needs
• May have a steeper learning curve for developers new to modding
• Could introduce more overhead due to its comprehensive feature set

Code Comparison

MelonLoader:

[HarmonyPatch(typeof(ExampleClass), "ExampleMethod")]
public class ExamplePatch
{
    public static void Postfix(ref int __result)
    {
        __result *= 2;
    }
}

Harmony:

var harmony = new Harmony("com.example.patch");
var original = typeof(ExampleClass).GetMethod("ExampleMethod");
var postfix = typeof(ExamplePatch).GetMethod("Postfix");
harmony.Patch(original, postfix: new HarmonyMethod(postfix));

Both libraries use similar patching concepts, but MelonLoader provides attribute-based patching, while Harmony offers more programmatic control. MelonLoader is better suited for comprehensive modding projects, while Harmony excels in targeted patching scenarios.

Pros of runtime

• Comprehensive .NET runtime implementation with extensive features and optimizations
• Official Microsoft project with robust community support and regular updates
• Covers a wide range of .NET functionalities, including core libraries and runtime components

Cons of runtime

• Large and complex codebase, potentially challenging for newcomers to navigate
• Primarily focused on core .NET functionality, not specifically designed for modding or patching

Code Comparison

runtime:

public static unsafe int Main(string[] args)
{
    int exitCode = 0;
    try
    {
        exitCode = ProgramMain(args);
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine(ex);
        exitCode = 1;
    }
    return exitCode;
}

Harmony:

public static void PatchAll()
{
    var harmony = new Harmony("com.example.patch");
    harmony.PatchAll();
}

Summary

Runtime is a comprehensive .NET runtime implementation, offering a wide range of features and optimizations. It's an official Microsoft project with strong community support. However, its large codebase can be challenging to navigate, and it's not specifically designed for modding.

Harmony, on the other hand, is a specialized library for runtime patching, making it more suitable for modding scenarios. It offers a simpler API for patching methods but has a narrower focus compared to the broader functionality of runtime.