VB.NET obfuscator

Protect your compiled Visual Basic .NET from casual reverse engineering — free, in the browser, in about a minute.

VB.NET and C# compile to the same thing

A .NET decompiler does not care which language you wrote. Visual Basic .NET and C# both compile to the same .NET assembly — IL plus a metadata table carrying every type, method and field name. In fact, point ILSpy or dnSpy at a VB.NET .dll and it will happily show you readable C#, names and all. That shared metadata is exactly what an obfuscator rewrites, so VB.NET is protected the same way and to the same degree as C#.

So the flow is identical: build your project, then upload the compiled assembly. You get back a copy with the names scrambled that runs exactly the same.

How to obfuscate VB.NET code

  1. Build in Release so you upload the assembly you ship, not a debug build.
  2. Find the output — bin\Release\net8.0\YourApp.dll (or .exe).
  3. Upload it on the home page and download the obfuscated copy (named YourApp.obfuscated.dll so it can't overwrite the original).
  4. Run your test suite against the obfuscated build before shipping.

The VB.NET-specific things to check

Because obfuscation works on the compiled assembly, the only risk is code that looks a member up by its original name at runtime. A few of these are more common in VB.NET than in C#, so they are worth a specific look:

  • Late binding (Option Strict Off). Calling a method or property on an Object without a compile-time type resolves by name at runtime. If that target gets renamed, the call fails. Prefer Option Strict On where you can; where you can't, test those paths on the obfuscated build.
  • CallByName. This invokes a member by its string name by design — the same trap as reflection. Keep the members it targets out of renaming, or avoid it.
  • The My namespace and settings. My.Settings and friends are generated code that generally survives fine, but settings bound by property name behave like any other name-based lookup — confirm they load after obfuscating.
  • Serialization (XML, JSON, binary settings) relies on member names just as it does in C#; keep <DataContract>/<JsonPropertyName> attributes explicit.

Everything else just works. The same rule and the same fixes as the rest of .NET apply — obfuscation and reflection walks through each failure mode, and how to test your obfuscated build is the workflow that catches them before your users do.

What it protects — and what it does not

  • Names are rewritten for private and internal members always, and for the public surface of an application (a library's public API is preserved so callers still work).
  • String literals are readable by default. A connection string or key stays visible unless you enable string encryption (Pro). Secrets do not belong in a client binary regardless — see what obfuscation actually protects against.
  • It is not a licensing system. A check that runs on the user's machine can be defeated; obfuscation raises the cost, server-side validation changes the outcome.

Free vs Pro for VB.NET

The free tier renames symbols in the browser with no account. Pro adds string encryption, control-flow obfuscation, call-reference proxying and optional method virtualization, plus larger files, batch mode and a CI/CD API. The layer decision guide matches each to the threat it answers.

VB.NET is one of several .NET languages this works for — anything that compiles to a managed assembly (C#, F#) obfuscates the same way. See also the .NET obfuscator overview and the C# obfuscator, or by output type: EXE obfuscator · DLL obfuscator.