ZyMono

A modern, Windows-native · Unity · Mono & IL2CPP · game injector

Load your own C# or C++ mod into a Unity game — Mono or IL2CPP — and let ZyMono pick the right route from what's actually running inside the game.

Direct managed load · BepInEx / MelonLoader pipe with in-game receivers · Native LoadLibrary · In-memory manual map · Proxy preloader · MelonMod & BepInPlugin auto-registration.

🏠 Home & downloads — zlogic.eu/zymono  ·  🌐 More projects — zsync.eu  ·  🎮 Mods & mod menus — zlogic.eu

Made with care by TheHolyOneZ

---

What's new · Changelog · What is it · Features · How it works · Comparison · Get started · Build it yourself · Compatibility · FAQ

---

🆕 What's new in 0.4.0

The appearance release — settings that finally stay put, plus nine new Appearance controls.

Appearance settings now live in a real file at %APPDATA%\ZyMono\settings.json instead of the WebView's local storage, so they survive a restart, a crash or a force-kill. Settings → Appearance also gained UI scale, density, corner style, window opacity, console font and text size, an accent glow toggle with a strength slider, and reduce motion.

📖 Full history for every release — see CHANGELOG.md.

---

🧩 What is ZyMono?

ZyMono is a clean, powerful desktop app for injecting your mod into a running Unity game on Windows — whether that game runs Mono or IL2CPP, and whether your mod is written in C# or C++. You point it at a game, pick your mod DLL, and press Inject. ZyMono classifies the DLL, sees what's running inside the game, chooses the correct one of six injection routes, and tells you exactly what happened.

Every path is real and lives in-repo:

• Managed C# into Mono — direct in-memory Assembly.Load via the game's own Mono runtime.
• Managed C# via BepInEx classic — pipe route to ZyMonoReceiver.dll inside the game.
• Managed C# via BepInEx-IL2CPP — pipe route to ZyMonoReceiverIL2CPP.dll, plugin auto-registered through IL2CPPChainloader.
• Managed C# via MelonLoader — pipe route to ZyMonoMelonReceiver.dll, mod auto-registered through MelonAssembly.LoadMelonAssembly, OnInitializeMelon fires exactly as if the file had been in Mods/ at launch.
• Native C++ on-demand — LoadLibraryW + CreateRemoteThread into any running game.
• Native C++ in-memory (manual map) — full PE loader (sections, base relocations, imports, DllMain) — file never leaves your machine.
• Native C++ preloader — build-time-generated winhttp.dll / version.dll proxy stub for auto-load at next launch.

What sets ZyMono apart is that it doesn't guess. It inspects the picked DLL (managed vs native, [BepInPlugin] vs [MelonInfo], x86 / x64 / AnyCPU) and the running process (Mono vs IL2CPP, BepInEx vs MelonLoader vs nothing, is our receiver alive?) — then reshapes its own UI so you can only pick routes that make sense for what you actually have.

In one line: ZyMono is a smart Unity injector that speaks C# and C++, Mono and IL2CPP, BepInEx and MelonLoader — and picks the right lane, confirmed live, so you never fire blindly.

---

✨ Feature overview

🎯 Targets Auto-refreshing list of running Mono / IL2CPP Unity games Search / filter box (Ctrl+F) — type Raft, get Raft.exe Mono vs IL2CPP classification — both are injectable, ZyMono picks the route Runtime flavor (mono / mono-2.0-bdwgc / il2cpp), x86/x64, thread count Loader badges: BepInEx live, MelonLoader live, receiver status Selection survives a game restart; clears when the game closes Right-click → detail card, copy PID / path, open Player.log Reads Steam AppID from steam_appid.txt	🧠 Smart routing Decides from the live process and the picked DLL — not folders on disk Detects which loader is live: BepInEx (classic or IL2CPP) or MelonLoader Inspects your DLL: managed vs native, x86 / x64 / AnyCPU, [BepInPlugin], [MelonInfo] Auto picks Direct / Pipe / LoadLibrary / Manual Map — or force any Router panel with loader badge, receiver status, one-plain-English reason, ↻ re-probe Harmony usage detected from your DLL and flagged Guided install / update receiver flow — picks the correct receiver variant automatically	🔌 Confirmed delivery Three in-game receivers, one shared protocol: BepInEx classic, BepInEx-IL2CPP, MelonLoader PING → HELLO, LOAD → ACK — request/response with a version handshake Loads on the Unity main thread (Photon / Harmony / Il2CppInterop-safe) MelonMod / BepInPlugin auto-registration — send an empty entry point and the receiver hands the assembly to MelonAssembly.LoadMelonAssembly or the appropriate Chainloader Acknowledges success or hands back the exact managed exception Receiver auto-discovery, install, and update-in-place (incl. Thunderstore / r2modman profiles)
💉 Six injection routes Direct — in-memory Mono load, assembly never written to disk Pipe — through the in-game receiver on the Unity main thread Native LoadLibrary — game calls LoadLibraryW on your C++ DLL, Windows fires DllMain Native Manual Map — full in-memory PE loader (sections, relocs, imports, DllMain) Proxy preloader — writes a winhttp.dll / version.dll stub next to the game exe for auto-load at next launch Auto-registration — MelonMod / BepInPlugin sniffed from the DLL, no entry point required All routes have bounded timeouts, arch validation, pre-inject delay, and clean rejection when the pairing doesn't make sense	🔎 Entry points Reads your DLL's .NET metadata (PE → CLI tables) for managed mods Browse Namespace.Class.Method, grouped and searchable Badges: static / void / arg-count; "compatible only" filter Pick a method → auto-fills the fields and argument slots Live validation: ✓ Entry point found, not found, or not static void Paste Namespace.Class.Method into any box and it splits itself Optional unload entry point → an Eject button appears Native C++ DLLs: no entry point to fill — DllMain is the entry point, the whole column hides MelonMod / BepInPlugin DLLs: attribute detected — entry-point column hides, receiver auto-registers	💾 Profiles Save a full recipe (DLL + entry point + args + route) per game Sidebar Targets / Profiles tabs Cards with favorite, live-ready dot, one-click Inject, inline rename, ⋮ menu Save / Update / Save-as-new from the action bar Import / Export as JSON Stored in a real file (%APPDATA%\ZyMono) so nothing is lost on a crash
⚡ Auto-inject Flag a profile → it injects automatically when its game launches Master switch + per-profile flag Configurable wait time (default 5 s) so the runtime can finish loading Auto-selects the target it injected into Fires once per launch — no double-injects	🖥️ Live console Streaming log with a staged progress stepper Direct: Open → Resolve → Write → Invoke → Done Pipe: Detect → Ping → Send → Confirm → Done State chip with elapsed time; colour-coded lines Copy / Save / Clear, auto-scroll One click to open the game's Player.log Optional clear-on-inject	🎨 Polished UX Frameless window, close-to-tray, tray menu (Show / Quit) Resizable sidebar & console, remembered between runs Drag-and-drop a .dll onto the window Recent DLLs dropdown — the last 5, one click away Action bar with a live what → where summary, right under the form Widescreen layout: 1 → 2 → 3 columns as the window grows 6 accent themes + custom colour picker + high-contrast mode UI scale, density, corner style, window opacity, console font — all persisted Shortcuts: Ctrl+Enter inject · Esc cancel · Ctrl+L clear · Ctrl+F find target Global inject hotkey — fire from inside the game, no Alt-Tab

_{Categorised settings — process refresh, DLL picker folder, profile autofill, auto-inject on launch with a configurable wait time, and the global inject hotkey that works while you're in the game.}

_{Appearance — accent presets and a custom picker, an accent glow toggle with strength, UI scale, density, corner style, window opacity, console font and size, and reduce motion. Stored in %APPDATA%\ZyMono\settings.json, so it survives a restart.}

---

🚀 How injection works

(the plain-English version)

A Unity game that uses Mono runs C# internally — the same kind of code your mod is written in. Injecting means getting your DLL into that runtime and calling one method inside it (your "entry point") so your mod starts running.

ZyMono supports two ways to do this and chooses for you:

Every Unity game process has two parallel worlds inside it:

• The managed world — C# code running on a .NET runtime (Mono, or a runtime shipped by BepInEx-IL2CPP / MelonLoader on IL2CPP games). This is where mods with [BepInPlugin], [MelonInfo], Harmony patches, and Namespace.Class.Method entry points live.
• The native world — machine code running directly on the CPU, alongside the game's compiled C++. This is where mods with DllMain(DLL_PROCESS_ATTACH) live, loaded by Windows' own loader.

ZyMono knows about both and picks based on what your DLL is and what your game is running.

The managed lane — direct or pipe

• Direct — when nothing is intercepting the game, ZyMono loads your C# DLL straight into the game's Mono runtime from memory and calls your entry method. Fast and self-contained.
• Pipe — when a mod loader is live (BepInEx classic, BepInEx-IL2CPP, or MelonLoader), forcing a load can collide. So ZyMono ships three matching receivers, one per loader, each a tiny plugin that lives inside the loader. Your DLL is streamed over a named pipe, the receiver loads it on the game's main thread, and either acknowledges or hands back the exact managed exception.
• Auto-registration — if the assembly carries [MelonInfo] or [BepInPlugin], no entry point is needed. The receiver hands the assembly to MelonAssembly.LoadMelonAssembly / Chainloader and the mod runs its full OnInitializeMelon / Load() lifecycle exactly as it would from Mods/ or BepInEx/plugins/ at startup.

The native lane — LoadLibrary, Manual Map, Proxy

• LoadLibrary — the game itself calls LoadLibraryW on your C++ DLL (path resolved from the target's own kernel32 export table so it stays correct injecting into x86 games from x64). Windows fires DllMain(DLL_PROCESS_ATTACH) and you're in.
• Manual Map — full in-memory PE loader: parse headers, VirtualAllocEx, copy sections, apply base relocations (I386 / AMD64), resolve imports across every module in the target (loading missing ones through the game), invoke DllMain via a small remote shellcode. Native analog of the direct Mono route — the DLL never has to remain on disk.
• Proxy preloader — writes a build-time-generated winhttp.dll / version.dll stub with forwarded exports and a DllMain that LoadLibraryWs your mod. Drop-in same mechanism BepInEx and MelonLoader use themselves.

It decides from what's actually running — and what you actually picked

ZyMono does not guess from files on disk. It inspects the live process (Mono vs IL2CPP, which loader is mapped, whether the receiver answers a ping) and your picked DLL (managed vs native, x86/x64/AnyCPU, [BepInPlugin] vs [MelonInfo]). Then it reshapes its own UI so only routes that will actually work are available.

             ┌──────────────────────────────────────────┐
             │  Pick a game  +  pick a DLL              │
             └──────────────────┬───────────────────────┘
                                │
                     What kind of DLL is it?
                                │
                ┌───────────────┴───────────────┐
                │ MANAGED (.NET)                │ NATIVE (C++)
                ▼                               ▼
     Which loader is live in game?         Which native route?
     ┌────────────┼────────────┐            ┌───────────┬──────────────┐
     │ none       │ BepInEx    │ MelonLdr   │ LoadLib   │ Manual Map   │
     ▼            ▼            ▼            ▼           ▼
   Direct      Pipe →       Pipe →      OS loader   In-memory PE
   (Mono)      classic /    MelonMod    fires        loader, DllMain
               IL2CPP       auto-reg    DllMain      fired remotely
               receiver
                                        (Optional: install a winhttp /
                                         version proxy for auto-load at
                                         next launch)

_{Profiles & one-click inject — favourites, auto-inject flags, import/export, and a live dot when the profile's game is running.}

---

🆚 How ZyMono compares

ZyMono builds on the well-known SharpMonoInjector (SMI) technique and an earlier pipe-injection fork of it, and pushes both further. An honest comparison:

Capability	SharpMonoInjector	SMI pipe fork	ZyMono
Direct in-memory load (managed)	✅	✅	✅
Pipe route through an in-game receiver	❌	✅ (BepInEx classic only)	✅ 3 receivers (classic · IL2CPP · MelonLoader)
IL2CPP game support	❌	❌	✅ via native + IL2CPP receivers
MelonLoader detection & bridge	❌	❌	✅ full pipeline
Native C++ mod injection (LoadLibrary)	❌	❌	✅
In-memory manual map for native mods	❌	❌	✅
Proxy preloader (winhttp / version stub)	❌	❌	✅ generated at install time
MelonMod / BepInPlugin auto-registration	❌	❌	✅ zero entry-point config
Decides route from the live process and the picked DLL	❌	⚠️ from a disk folder	✅
Confirms the mod actually loaded	❌	❌	✅ ping + ack
Loads on the Unity main thread (Harmony/Photon-safe)	❌	⚠️	✅
Automatic route selection	❌	❌	✅
DLL classification (managed / native / AnyCPU / attributes)	❌	❌	✅
Entry-point validation before injecting	❌	❌	✅
Detects Harmony usage in your DLL	❌	❌	✅
Saved profiles + one-click inject	❌	⚠️	✅
Auto-inject on launch	❌	✅	✅ (configurable delay)
Receiver auto-discovery, install, & update-in-place	❌	❌	✅ correct variant picked
Global hotkey — inject without Alt-Tabbing	❌	❌	✅
Eject / reload a mod without restarting the game	❌	❌	✅ (optional unload entry point)
Searchable target list · recent DLLs · paste-to-split entry point	❌	❌	✅
High-contrast mode & adaptive widescreen layout	❌	❌	✅
Interface	WinForms / CLI	varies	Modern native UI (Tauri)

Is it better than SMI or the fork?

For simple cases, plain SharpMonoInjector is a fine, minimal tool and deserves credit — ZyMono stands on its shoulders. But it was built for a simpler world: it loads your DLL directly and assumes that's always safe.

The pipe fork added the idea of handing the load to a plugin inside BepInEx — the right instinct. But it decided whether to do that by checking for a BepInEx folder on disk, and it sent the load with no confirmation. So it could route the wrong way (a folder existing doesn't mean BepInEx actually started with the game), and you never really knew if your mod loaded.

ZyMono fixes both:

• ✅ It checks whether BepInEx is genuinely live in the running process — and pings the receiver — before choosing a route. If no loader is actually running, direct injection is used even when a BepInEx folder is present.
• ✅ Its receiver is a proper request/response protocol: it acknowledges a successful load or hands back the exact exception, and it loads on the main thread so Harmony patches apply cleanly.

Add profiles, auto-inject, entry-point validation, Harmony detection and a modern UI, and ZyMono becomes a noticeably more reliable and pleasant tool for real-world Unity modding — while staying focused purely on injection (it is not a mod-loader installer).

---

📥 Getting started

📦 Download ZyMono for Windows (v0.4.0) from the official page: zlogic.eu/zymono — grab the installer (.exe) or MSI right there. Signed and auto-updating — future versions install themselves from inside the app. This GitHub repo is the source code; prefer not to run a pre-built binary? Build it yourself in a couple of minutes.

1. Launch your game. It appears in the Targets list on the left, with its runtime and architecture.
2. Select the game. ZyMono shows what's live inside it and pre-picks a route.
3. Choose your mod .dll — browse for it, drag-and-drop it onto the window, or pick it from Recent. Set its entry point: paste the whole Namespace.Class.Method into any box and ZyMono splits it for you. It confirms the method exists: ✓ Entry point found. Not sure of the name? Hit Browse methods.
4. Leave the route on Auto (recommended) and press Inject. Watch the console step through Detect → Ping → Send → Confirm → Done.
5. Save it as a Profile so next time it's one click — or flag it for Auto-inject so it fires the moment the game launches.
6. (Optional) Set a global hotkey in Settings and re-inject from inside the game, or fill in an unload entry point to get an Eject button that reloads your mod without restarting.

💡 ZyMono injects into both Mono and IL2CPP games. Pick your DLL — the mode toggle and route panel reshape around it automatically. Native C++ mods route through LoadLibrary / Manual Map; C# mods route through the pipe if a loader is live, or Direct if not.

---

🔧 Build it yourself

Building from source guarantees the app matches the code you can read here — ideal if you'd rather not trust a pre-built download.

Prerequisites (Windows 10 / 11, x64)

• Rust — stable toolchain (MSVC)
• Node.js LTS + pnpm — npm install -g pnpm
• Microsoft Visual C++ Build Tools with the Windows 10/11 SDK
• WebView2 Runtime — already present on Windows 11
• (Only to rebuild the in-game receiver plugin) the .NET SDK 6.0+ and the .NET Framework 4.7.2 targeting pack

Build the app

git clone https://github.com/TheHolyOneZ/ZyMono
cd ZyMono
pnpm install
pnpm tauri build

Installers land in src-tauri/target/release/bundle/ — an NSIS setup.exe and an MSI. To run a live development build instead:

pnpm tauri dev

Build the in-game receiver (optional)

The pipe route uses one of three small plugins depending on which loader is live in the target game — one per project, one shared code core:

dotnet build ZyMono.Receiver           -c Release   # BepInEx classic (Mono) → ZyMonoReceiver.dll
dotnet build ZyMono.Receiver.IL2CPP    -c Release   # BepInEx-IL2CPP        → ZyMonoReceiverIL2CPP.dll
dotnet build ZyMono.MelonReceiver      -c Release   # MelonLoader           → ZyMonoMelonReceiver.dll

The MelonReceiver csproj auto-downloads MelonLoader on first build (lib/ cache). The BepInEx variants pull from the official BepInEx NuGet feed via nuget.config. ZyMono installs the correct variant based on detect_loader(pid) + engine, into BepInEx/plugins/ or Mods/ as appropriate.

---

🧩 Compatibility

	Status
OS	Windows 10 / 11 (x64)
Game runtime — Mono	✅ full support — both classic mono.dll and modern mono-2.0-bdwgc.dll
Game runtime — IL2CPP	✅ via native injection (LoadLibrary / Manual Map / Proxy preloader) or via a BepInEx-IL2CPP / MelonLoader receiver
Architecture	x86 and x64 games; managed AnyCPU DLLs load into either bitness
Mod language — C# / managed	✅ via Direct or Pipe (three receiver variants)
Mod language — C++ / native	✅ via LoadLibrary, in-memory Manual Map, or Proxy preloader
Mod loaders detected & bridged	BepInEx classic (Mono), BepInEx-IL2CPP, MelonLoader, or no loader at all
Auto-registration	✅ [MelonInfo] MelonMods and [BepInPlugin] plugins — no entry point required
Proxy preloader (native)	✅ x64 games — winhttp.dll / version.dll stub with forwarded exports

---

❓ FAQ

Does my mod need BepInEx?

No. If the game isn't running a loader, ZyMono injects directly. If it is, ZyMono routes through the receiver so your mod — and its Harmony patches — load cleanly.

Why did it choose the pipe route?

Because it detected BepInEx actually running in the game and the receiver answered a ping. That's the safe path when a loader is live.

My mod uses Harmony — is that a problem?

No — that's exactly the case the pipe route handles. ZyMono even flags Harmony usage in your DLL so you understand the routing.

It says "no receiver".

The receiver plugin isn't loaded in the game yet. Use ZyMono's Install receiver flow — it picks the correct variant (BepInEx classic, BepInEx-IL2CPP, or MelonLoader) based on what's live and drops it into the right folder (BepInEx/plugins/ or Mods/). Relaunch the game — or use Direct / native routes if a loader isn't running.

Is IL2CPP supported?

Yes — as of 0.3.0. IL2CPP has no Mono runtime, so managed C# mods only work if a compatible loader is live (BepInEx-IL2CPP or MelonLoader) and ZyMono streams the DLL to the matching receiver over the pipe. But native C++ mods load directly into any IL2CPP game via LoadLibrary or the in-memory Manual Map route — Windows is the loader, no runtime needed. There's also a Proxy preloader for auto-load at next launch.

Does ZyMono work with MelonLoader?

Yes. ZyMono ships ZyMonoMelonReceiver.dll — a real MelonMod with a pipe server and an OnUpdate-pumped dispatcher. Drop a MelonMod DLL onto ZyMono and it detects the [MelonInfo] attribute, hides the entry-point column, and (on inject) hands the assembly to MelonAssembly.LoadMelonAssembly — MelonLoader runs the full OnInitializeMelon / OnLateInitializeMelon / OnUpdate lifecycle exactly as if the file had been in Mods/ at startup.

What's the difference between LoadLibrary and Manual Map?

Both load a native C++ mod into a running game, but differ in where the DLL lives. LoadLibrary has the game call LoadLibraryW on your DLL — Windows' own loader maps it from disk and fires DllMain. Manual Map copies the DLL into the game as a memory buffer and runs the whole loader itself: section copy, base relocations, imports resolved through the target's own modules, then DllMain via a small remote shellcode. Use Manual Map when you want the file to never remain on disk (single self-contained mods); use LoadLibrary when your mod loads side files by relative path.

What is the Proxy preloader for?

It's the same mechanism BepInEx and MelonLoader use to bootstrap themselves — a tiny winhttp.dll or version.dll stub next to the game exe with forwarded exports and a DllMain that LoadLibraryWs your mod. Drop it in once, and every future game launch auto-loads your native mod before ZyMono is even open. Currently x64 only.

Can I reload my mod without restarting the game?

Yes, if your mod supports it. Fill in the optional unload entry point (e.g. MyMod.Loader.Unload) and an Eject button appears next to Inject. ZyMono calls that method on the copy of your assembly that is already loaded, so the statics it tears down are the ones your Init set up. Then just Inject again. Most mods can't unload themselves — leave the box blank and nothing changes.

Can I inject without Alt-Tabbing out of the game?

Yes. Set a global inject hotkey in Settings → Injection (F11, Ctrl+Alt+I, anything you like). Once a target and DLL are configured, the hotkey fires an injection while the game has focus and ZyMono toasts the result.

Where does ZyMono store my profiles and settings?

Profiles live in a real file at %APPDATA%\ZyMono\profiles.json and your settings — accent, theme, UI scale, routes, hotkey — in %APPDATA%\ZyMono\settings.json, so both survive crashes and force-kills. Window layout is kept per-user as well.

---

⚖️ Legal & responsible use

ZyMono is a general-purpose modding tool for Mono/Unity games you own, provided for educational and personal use. It is intended for single-player and legitimate modding scenarios. You are responsible for complying with the terms of service of any game you use it with. The developers are not responsible for how others choose to use this tool. Don't use it to gain an unfair advantage in online/competitive games, or in any way that violates a game's rules.

---

🙏 Credits

• Created & maintained by TheHolyOneZ.
• The injection technique builds on the SharpMonoInjector lineage and an earlier pipe-injection fork — reworked here with live-process routing and a confirming receiver.
• Powered by Tauri, Rust, React + TypeScript, and BepInEx for the receiver plugin.

More from TheHolyOneZ

---

📄 License

ZyMono is released under the GNU General Public License v3.0 (GPL-3.0-only). © 2026 TheHolyOneZ.

---

_{Keywords: mono injector · unity mod injector · windows dll injection · bepinex injector · harmony · sharpmonoinjector alternative · C# mod loader · unity game modding tool · mono unity injector windows}

_{Built with 💜 by TheHolyOneZ · zsync.eu · zlogic.eu}