Skip to content
Nebula.NET · Glass.NET · Keyright — now available

Developer tools that protect and empower your software.

Delta1 Labs builds professional engineering tools for teams that ship real products — harden your .NET code with Nebula.NET, inspect any assembly with the free Glass.NET, and license your software with Keyright.

See it for yourself

The same method, before and after Nebula.NET

Both panes were decompiled with Glass.NET — our own free decompiler. On the left, an unprotected build reads like source. On the right, the Nebula-protected build is control-flow-flattened with key-masked dispatch, encrypted strings and masked constants — the logic is gone.

Unprotected.dll — decompiled readable
public static bool IsLicenseValid(string key, int seatsUsed, int seatLimit)
{
    if (string.IsNullOrEmpty(key)) return false;
    if (seatsUsed >= seatLimit) return false;
    int sum = 0;
    foreach (char c in key) sum += c;
    return sum % 97 == 13;
}
Nebula-protected.dll — decompiled protected
public static bool IsLicenseValid(string key, int seatsUsed, int seatLimit)
{
    int num = 0x400353ED ^ xotyjwt.k;
    int num2 = 0x18487BFA ^ xotyjwt.k;
    do {
        num = num * (0x87C67ED ^ xotyjwt.k) + (0x38E7B9CE ^ xotyjwt.k);
        num2 += 0x18487BFB ^ xotyjwt.k;
    } while (num2 < (0x18487BE0 ^ xotyjwt.k));
    num ^= 0x3BF95EDB ^ xotyjwt.k;                 // non-foldable dispatch key
    int num3 = (((Environment.TickCount | 1) & 1) != 0)
        ? (-2093190924 ^ xotyjwt.k) : (-2093190931 ^ xotyjwt.k);
    while (true)
    {
        switch (num3 ^ num)                        // dispatch on state XOR key
        {
        case 11: num3 = !string.IsNullOrEmpty(key) ? (-2093190914 ^ xotyjwt.k)
                                                   : (-2093190913 ^ xotyjwt.k); break;
        case 2:  num3 = (seatsUsed < seatLimit) ? (-2093190923 ^ xotyjwt.k)
                                                : (-2093190927 ^ xotyjwt.k); break;
        case 14: c = text[num5]; num3 = -2093190932 ^ xotyjwt.k; break;
        case 16: num4 += c;      num3 = -2093190919 ^ xotyjwt.k; break;
        case 12: return num4 % (0x18487B9B ^ xotyjwt.k) == (0x18487BF7 ^ xotyjwt.k);
        case 17: _ = (0x6580C877 ^ xotyjwt.k) * (0x19ED3329 ^ xotyjwt.k);  // bogus state
                 num3 = -2093190924 ^ xotyjwt.k; break;
        // ... 28 key-masked states, encrypted strings, non-prunable decoy states ...
        }
    }
}

Try it yourself: obfuscate a build with Nebula.NET, open it in the free Glass.NET, and compare.

Our products

A growing suite of engineering tools

We take on the hard problems developers actually face — protecting .NET code with Nebula.NET, reading it with the free Glass.NET decompiler, and licensing it with Keyright. More are on the way.

N Free · from $1199/seat

Nebula.NET

.NET obfuscation & hardening

Rename, flatten control flow, encrypt strings and harden your .NET assemblies against reverse engineering — with a CLI, GUI and MSBuild integration.

K Free · from $49/mo

Keyright

Software licensing for your app

Licensing infrastructure for software vendors: signed offline license files and online activation, node-locking, seats, entitlements and tiers, per-tenant signing keys, revocation, a customer portal and self-service trials — with SDKs for .NET, Node, Python and Java. Hosted for you.

G Free & open

Glass.NET

Free .NET decompiler

Decompile .NET assemblies back to clean, readable C# and navigate them like source — Go to Definition, Find All References, Go To All, call/type hierarchy, C#/IL views and project export. Free, powered by the ILSpy engine.

Why Delta1 Labs

Serious tools, honestly built

We hold our tools to the standard we'd want as engineers: correct, testable, and respectful of your time and money.

Built for real codebases

Our tools handle multi-assembly solutions, modern .NET and legacy frameworks, reflection, XAML and more — not just toy samples.

Verifiable, not cosmetic

Protection you can inspect in a decompiler. Every transform is tested for correctness so your app behaves identically after hardening.

CLI, GUI & CI-ready

Point-and-click for one-off jobs, a command line and MSBuild targets for your pipeline. Automate protection on every build.

Yours to own

A fair licensing model with a free tier, transparent pricing and licenses that work offline once activated. No surprises.

Featured · Nebula.NET

Ship .NET code that's hard to reverse-engineer

Nebula renames symbols, flattens control flow, encrypts strings and hardens your binaries against tampering and debugging — while staying byte-for-byte faithful to your app's behavior.

  • Identifier renaming with public-API preservation
  • Real control-flow flattening (dispatcher state machines)
  • Per-build string encryption with an unbranded decryptor
  • Anti-tamper & anti-debug with configurable reactions
  • CLI, desktop GUI and MSBuild integration
terminal
# Protect a build from a config file
$ nebula --config nebula.config.json

Nebula.NET 1.0.9 — by Delta-1 Labs
  ✓ renamed        1,204 symbols
  ✓ control-flow   58 methods flattened
  ✓ strings        encrypted (per-build key)
  ✓ anti-tamper    enabled
→ protected/MyApp.dll  (verified identical runtime)

Ready to harden your software?

Start free, upgrade when you need the full protection suite.