Framework support matrix

Nebula works at the IL level (via dnlib), so it protects any managed .NET assembly regardless of the language it was written in or the app model it ships in. This page is the quick answer to “does it support my stack?” — for per-project settings, see Protecting different project types.

Runtimes

Runtime	Supported	Notes
.NET Framework 4.6.2 – 4.8.1	✅	Full support, incl. mixed net462;net6.0+ multi-targeting via the MSBuild integration.
.NET 6 / 7 / 8	✅	Full support.
.NET 9	✅	Full support.
.NET 10	✅	Full support.
.NET Standard 2.0 / 2.1 libraries	✅	Protected like any other managed library.
Mono	✅	Managed assemblies protect normally (e.g. Unity’s Mono backend).

App models

App model	Supported	Notes
Class libraries / NuGet packages	✅	preservePublicApi: true keeps your public contract; internals are renamed. Point Nebula at a .nupkg to repack a protected package.
Console apps / Windows services / daemons	✅	No public surface — protect everything for maximum strength.
ASP.NET Core / Web API	✅	Preserve controllers, DTO property names and anything bound by name; internals obfuscate freely (auto-detected).
Blazor Server	✅	Server-side assemblies protect normally.
Blazor WebAssembly	✅	The managed assemblies are downloaded to the browser — the highest-exposure target. Protect a published app with the nebula blazor command (obfuscates + repairs the integrity manifest).
WPF / WinForms	✅	Preserve XAML/designer-bound members (auto-detected; exclude the rest).
.NET MAUI / Xamarin	✅	Managed app assemblies protect on every head (Android/iOS/Windows/Mac Catalyst); keep XAML-bound members, [DllImport] preserved automatically. See Protecting MAUI & Xamarin.
Unity (Mono backend)	✅	Automatic: MonoBehaviour and ScriptableObject subclasses are preserved wholesale (Unity binds them to script assets and scene/prefab data by class name), including their magic methods (Awake/Start/Update), SendMessage/Invoke targets and [SerializeField] fields. No config needed — detection runs whenever these Unity types are present.
Unity (IL2CPP)	✅ (pre-convert)	IL2CPP transpiles the managed IL to C++ ahead of time. Run Nebula on the managed assemblies before the IL2CPP build step; the preservation rules above still apply so serialized references survive.
Single-file / self-contained	✅	Obfuscate the managed assemblies, then publish. (Anti-tamper’s self-hash no-ops inside a single-file bundle — rely on control-flow + string encryption there.)
Native AOT	✅	Obfuscate the managed IL before the AOT publish. AOT already removes IL from the shipped native image; Nebula hardens the managed layer beforehand (and any assemblies that stay managed), so your build pipeline is defended end to end.

Languages

Language	Supported	Notes
C#	✅	—
F#	✅	IL-level, so fully supported; keep autoDetect: true for F#‘s compiler-generated members.
VB.NET	✅	Fully supported.
Any IL-producing language	✅	If it compiles to a managed assembly, Nebula protects it.

Delivery & CI

Surface	Supported
Command-line (nebula, config-driven, documented exit codes)	✅
Desktop GUI	✅
MSBuild / CI integration (dotnet build and Visual Studio / msbuild.exe)	✅ — see MSBuild & CI
Multi-targeted projects (every TFM protected automatically)	✅

The recurring rule across every stack: anything resolved by name at runtime (reflection, serialization, XAML/Razor/Blazor binding) must be preserved. Nebula auto-detects most of it, and you can preserve the rest explicitly.

Don’t see your exact case? Ask us — if it compiles to a managed .NET assembly, it’s in scope.