Loading...
+
+
+
+
Mfuscator ~
#HumanWrittenCode
Now supporting Unity 6.6

Protect your Unity IL2CPP games with confidence.

An automated, cloud-based build extension designed to defend your game binaries against reverse engineering & tampering. No complex setup required.

This site uses hCaptcha and Cloudflare Turnstile. Their respective Privacy Policies and Terms may apply.

+
+
+
+
01

High-Performance Cluster

Initiate builds and track their processing through your Organization dashboard while our infrastructure handles resource-intensive workloads automatically.

02

Native Binary Analysis

Integrates with Unity's compilation process. Build servers operate at the engine/IL2CPP level without modifying your C# source code or local raw asset files.

03

Organization-Ready

Built for teams. Create an Organization, invite members, manage API keys, and audit build logs. Control access with granular, custom member permissions.

Evolved from our popular Unity Asset Store package
5/5 Average Rating
on Unity Asset Store
1,000+ Projects
protected every year
Years of Trust
by the Unity community
+
+
+
+

Defense in Depth

Mfuscator applies multiple anti-tamper mechanisms, from breaking automated dumpers to hardware-level code virtualization, so that your game's logic remains yours.

Standard IL2CPP
Readable
Assembly (x64)
; Vulnerable logic method_CheckLicense: push rbp mov rbp, rsp sub rsp, 0x20 mov rax, [rcx+0x10] ; Clear check of boolean test rax, rax jz loc_IllegalUser mov eax, 0x1 leave ret loc_IllegalUser: xor eax, eax ; ...
Mfuscator-Protected Binary CFF + Virtualization
Virtual Machine (Graph)
57 68 61 74 20 70 72 6f 6d 70 74 65 64 20 79 6f
75 20 74 6f 20 64 65 63 6f 64 65 20 74 68 69 73
3f 20 49 20 6c 69 6b 65 20 65 6c 65 70 68 61 6e
74 73 2c 20 61 6e 64 20 47 6f 64 20 6c 69 6b 65
73 20 65 6c 65 70 68 61 6e 74 73...
VM_DISPATCHER
V_OP_ADD
V_OP_NAND
V_JMP_LINK
V_OP_XNOR
VIP++
KEY_ROT

Neutralize Dumpers

Advanced Unity IL2CPP metadata encryption/relocation/extraction, custom structure layouts, and runtime export removal break automated static analysis tools like Il2CppDumper.

Hardware-Level VM

Recompiles critical x64/ARM64 machine code into a dynamically generated, architecture-agnostic virtual instruction set. Protected methods are hard to decompile or statically reverse.

Active Tamper Defense

Actively detects and blocks mod loaders (e.g., MelonLoader, BepInEx). Shields against user/kernel-mode debuggers (e.g., WinDbg, Syser) and virtual environments (e.g., VMware, VirtualBox).

Deep Engine Mutation

Generates random custom-mutated UnityPlayer.dll and internal libil2cpp. Relocates and weaves engine call graphs, strips vulnerable logic, and sanitizes internal literals.

Execution Integrity

Enforces pre-OEP integrity checks on all non-writable memory segments. Automatically code signs builds (Windows) and securely forces administrative or single-instance execution.

Asset & Stealth Shield SOON

Cosmetically renames exposed libraries (e.g., GameAssembly.dll → Game.dll) to hide your engine footprint. Full asset encryption to block AssetRipper is arriving soon.

+
+
+

Fair, Usage-Based Pricing

Pay only for successful builds using prepaid credits.
Your Organization type determines your rate and priority.

Indie

For solo developers & hobbyists

Free $0.25 / build (approx.)
Limited Time Promotion
Zero build costs for the duration of the event
  • Revenue + Funding < $200k USD
  • Full Unity IL2CPP Protection
  • Standard Build Queue
  • Community Support (Discord)
  • Up to 3 Team Members
  • Unlimited Projects
Initial credits & weekly top-ups from us

Studio

For professional teams & enterprises

$3.50 / build (approx.)
Only charged when you choose to process a build. Toggle on or off anytime.
Example $108.50/mo if built daily
  • Revenue + Funding $200k+ USD
  • All Indie technical features, plus:
  • Priority Build Queue
  • Priority Email Support
  • Unlimited Team Members
  • Data Processing Agreement (DPA)
No monthly fees • No setup costs
PCI-DSS Compliant MoR
VPC-Isolated Environment
TLS 1.3 Encryption

From the Blog

Insights into Unity security and game protection.

View All Posts
Mfuscator vs. IL-Level Obfuscators: Two Different Layers of Unity Protection
mfuscator il2cpp obfuscation unity reverse engineering code virtualization mono.cecil
July 07, 2026 Mewiof
Mfuscator vs. IL-Level Obfuscators: Two Different Layers of Unity Protection

Why Mono.Cecil-based Unity obfuscators and Mfuscator solve different problems and how to tell which one your game actually needs.

Mfuscator SaaS vs. Unity Asset Store: The Evolution of IL2CPP Protection
mfuscator unity il2cpp saas asset store game security reverse engineering code virtualization anti-tamper game development
July 06, 2026 Mewiof
Mfuscator SaaS vs. Unity Asset Store: The Evolution of IL2CPP Protection

The path from our 2023 Unity Asset Store release to the new, separate, cloud-based, transparent, and developer-friendly Mfuscator SaaS platform.

SECURE PROTECT BUILD
+
+
+
+

Frequently Asked Questions

Mfuscator is a static binary protector, not a behavioral anti-cheat. It does not monitor player gameplay and issue bans. Instead, it produces polymorphic build output (e.g., by randomly rewriting the internal engine/IL2CPP structures, encrypting IL2CPP metadata, and rearranging memory layouts) to disrupt automated dumping and increase the time required for manual analysis.

No. Mfuscator intervenes only during the build phase to protect the output. The resulting executable that you ship to players never communicates with our infrastructure. Your games are immune to retroactive changes, and you retain full ownership over processed files.

Integration is handled via a small, auto-updating SDK package. Once imported, Mfuscator hooks into the standard Unity build pipeline. When you build your project (e.g., using the "Build And Run" editor button or a BuildPipeline.BuildPlayer function call), the SDK automatically intercepts the necessary artifacts, transmits them to a build cluster for processing, and injects the handled binaries back into your output directory.

No. Our build servers perform all cross-platform/architecture analysis (e.g., x64/ARM64). You can develop on any supported OS without the requirement to install compatibility layers (e.g., WSL or Wine).

Yes. Organizations can generate dedicated API keys. These keys can be stored as secrets in your CI/CD environment and passed to the Unity build process for automated, headless (-batchmode) protection of your nightly/release builds.

You're in control of settings. By default, build processors apply virtualization to sensitive code while maintaining performance-critical loops and engine logic optimizations. In real-world scenarios, the impact is primarily isolated to startup times, leaving runtime largely unaffected.

No. The SDK only transfers compiled binary artifacts (e.g., "GameAssembly.dll", "libil2cpp.so", and "global-metadata.dat") or files produced by Unity's default build process. Raw files from your Unity project's "Assets" folder are never uploaded. Any necessary modifications to other files are performed locally on your machine by the SDK itself.

Build artifacts (both input and output archives) are retained in secure object storage for a limited duration to allow for processing and downloading. An automated cleanup worker permanently purges these files shortly after the build enters a terminal state (Completed or Failed). We do not archive your game binaries.

Mfuscator logs (not to be confused with Unity logs) are isolated by Organization. Only members of your Organization with appropriate permissions and our internal team can view them. We do not access your Unity log files (editor or player).

Credits are pooled at the Organization level: you purchase prepaid credits, which are added to your Organization's balance. You are only charged for successful processing/builds when Mfuscator is enabled; credits deducted for failed runs are automatically returned to your balance. Any member with permissions can generate API keys and trigger builds using the shared balance.

The Studio classification is required if your business's (or legal entity's) aggregate revenue and funding in the last 12 months (rolling) totals $200,000 USD or more. However, if your aggregate revenue and funding is below this threshold, you may opt for the Studio tier if you wish to benefit from priority build queues and expedited support.

Every new Organization (regardless of classification) receives an initial grant of evaluation credits upon creation to test/integrate the SDK and verify the protection process at no cost. Additionally, to support solo developers/small teams, Indie Organizations automatically receive free weekly credit top-ups if their balance drops below a certain threshold.

Migration is quick and straightforward, and we honor your original support! First, redeem your legacy credit balance by navigating to the Vouchers tab in your Organization dashboard and entering your Unity invoice number. Users who purchased the legacy asset shortly before deprecation receive a 1:1 price-to-credit conversion.

To upgrade your project:
  1. Close the Unity Editor to release any active file locks (e.g., DLLs).
  2. Delete the old Mfuscator folder and its .meta file from your project.
  3. Reopen Unity, import the new SDK package from the dashboard, and enter your new API key in the Mfuscator window.

Currently, an Account can only be bound to a single Organization. You are allowed to access/manage multiple Organizations using different Google accounts (e.g., separate personal and corporate identities).

The list is kept up to date dynamically due to Unity's quick release cycle. For the latest compatibility matrix, please authenticate and navigate to the SDK & Downloads section of the dashboard.
Still have questions? Contact us, and we will gladly answer them.
+
+
Mfuscator

Built by developers, for developers, with a focus on security and transparency.

#HumanWrittenCode

© 2022–2026 mewicu. All rights reserved.
All trademarks referenced herein are the properties of their respective owners.