She Who Became The Sun

Understanding She Who Became The Sun for Unity Modding

She Who Became The Sun is a BepInEx chainloader replacement that handles plugin loading in Unity games differently from the standard approach. The standard BepInEx chainloader scans assemblies, loads dependencies, and fires plugin Initialize methods in a fairly linear way. She Who Became The Sun introduces a modified loading pipeline that can handle assembly conflicts and dependency resolution in a way the vanilla loader struggles with. I set this up on a project last year where we had multiple DLLs pulling in different versions of the same Newtonsoft.Json reference. The standard chainloader would load whichever version it found first in the directory, and the rest would silently fail or cause runtime casting exceptions. With She Who Became The Sun, each plugin gets isolated into its own AppDomain-like boundary during load, so version conflicts don't cascade across the entire mod suite. This usually cuts the debugging time from a full day down to maybe two hours of sorting out which plugin owns which assembly.

Installing She Who Became The Sun

The download comes from the GitHub releases page. Grab the latest .zip from the repository, extract it, and drop the BepInEx folder into your game directory. The she-whobecame-the-sun files replace the standard chainloader.dll inside the BepInEx/core folder. Back up your existing BepInEx/core directory first. You will lose your config if you skip this step and something goes wrong during the override. After extraction, create a plugins folder at BepInEx/plugins and drop your mod DLLs there. Config files go in BepInEx/config. The core configuration for She Who Became The Sun lives in BepInEx/BepInEx.cfg. There are a few settings worth adjusting immediately. Set EnablePluginLogCache to true. This caches the plugin load log so you can review initialization order after the fact. Set UnloadObsoleteAssemblies to true if your game supports it. This helps with memory leaks when reloading mods without restarting the game entirely. The AssemblyResolveTimeout controls how long the loader waits before giving up on a missing dependency. Default is 5000 milliseconds. If your game has slow disk I/O, bump this to 10000 or you will get false missing-dependency errors.

How the Loading Pipeline Actually Works

The key difference is in how the chainloader resolves dependencies. Standard BepInEx uses a flat assembly resolver that walks the probing path once and caches the result. She Who Became The Sun uses a per-plugin assembly context. When Plugin A requires Json.Net 12.0 and Plugin B requires Json.Net 13.1, the standard loader loads one version into the default domain and Plugin B either crashes or silently references the wrong type. She Who Became The Sun keeps them separate during the load phase. It does this by intercepting AssemblyLoadContext calls and routing them through a custom resolver that tracks which plugin requested which assembly. The resolver maintains a reference table mapping assembly identity to load context. When a second plugin requests the same assembly identity, the resolver checks if a compatible version is already loaded. If the versions match exactly, it reuses the existing reference. If they differ, it attempts to load the second version into an isolated context. I hit a problem with this recently on a Unity 2019.4 project. The game itself was already loading Newtonsoft.Json 11.0.2 into the main domain before BepInEx even initialized. She Who Became The Sun's resolver saw that version, loaded the plugin's requested 12.0.3 into an isolated context, but then the plugin's code tried to cast an object returned by the game's own API, and the cast failed because the types were in different contexts. Same assembly name, different Identity from the runtime's perspective. The workaround was adding an asmdef file to the plugin that referenced the game's existing Newtonsoft.Json assembly explicitly, so the resolver would bind to the already-loaded version instead of creating a second copy. It took me about forty minutes to figure out because the error message just said "InvalidCastException" with no stack trace pointing to the assembly boundary issue.

Common Pitfalls

The most common issue people run into is assuming She Who Became The Sun solves every dependency problem. It does not. If two plugins fundamentally require incompatible APIs from the same library, no amount of assembly isolation will make them work together. The loader can separate assemblies, but it cannot separate types that share the same fully qualified name across contexts. Casting between contexts always fails. Another issue is log confusion. She Who Became The Sun produces more verbose output than standard BepInEx during initialization. You will see entries about assembly contexts being created and resolved. This is normal. Do not mistake a routine context creation log for an error. The actual error indicators are red text with "Exception" or "Failed to load" prefixes. Everything else is informational. Performance is also worth noting. The per-plugin assembly tracking adds overhead to the load sequence. On a game with thirty or more plugins, the chainloader phase can take noticeably longer than standard BepInEx. In my testing, a game that loaded in about 8 seconds with vanilla BepInEx took roughly 12 to 14 seconds with She Who Became The Sun. Not catastrophic, but measurable. If you are running a small number of mods, you will not notice the difference.

The config system is less mature than standard BepInEx. Features like automatic config migration on version changes sometimes do not trigger correctly. If you update a plugin and its config format changes, you may need to manually delete the old config file and let it regenerate. This is a known limitation.

When She Who Became The Sun Is the Right Tool

Use it when you have multiple plugins with conflicting dependency versions. Use it when the standard BepInEx loader produces casting exceptions that look like version mismatches. Use it when you need to reload mods without a full game restart and want cleaner assembly unloading behavior. Do not use it if you are only running one or two plugins with no dependency overlap. The standard chainloader is simpler, faster to initialize, and better documented for basic use cases. You gain nothing from the extra complexity. Do not use it if your game's anti-cheat detects unconventional assembly loading patterns. Some games flag the per-context resolution approach as suspicious behavior.

Troubleshooting

If plugins fail to load, check the log at BepInEx/LogOutput.log. Look for entries from the chainloader specifically. Standard BepInEx log lines are prefixed with "BepInEx" while She Who Became The Sun adds context markers like "[SunLoader]" or "[AssemblyContext]". These markers help you separate loader-level issues from plugin-level issues. If you get an AssemblyResolve timeout, increase AssemblyResolveTimeout in the config. If you get InvalidCastException on type objects that exist in both plugins, check whether the types are coming from the same assembly context. Run the game with EnablePluginLogCache set to true and review the cache file to see exactly which context each assembly was loaded into. The cache file is at BepInEx/cache/plugin_log.cache. If the game crashes during initialization before the menu appears, the most likely cause is a plugin trying to access game APIs before the base game is ready. She Who Became The Sun does not change initialization ordering. Plugins still initialize in dependency-sorted order, and the game's own Awake and Start methods run at their usual times. If a plugin calls a game method during its own Initialize(), and that method depends on something not yet initialized, it will crash just as it would with standard BepInEx. The fix is to move that call to a later lifecycle hook or add a readiness check.

The GitHub repository is the primary source for updates and documentation. There is a Discord community attached to it where issues get discussed. If you file a bug report, include your BepInEx version, the game version, the full LogOutput.log, and a list of every plugin in your plugins folder with their versions. Without that information, debugging becomes guesswork and nobody can help you effectively. Overall it is a solid improvement over the standard chainloader for complex mod setups. It is not a magic fix for bad plugin design, and it introduces its own trade-offs. But when you need it, it saves you from spending three days chasing assembly binding errors that would not exist in the first place.