Visual Basic .NET

Visual Basic .NET (now officially just Visual Basic, often abbreviated VB.NET to distinguish it from its predecessor) is Microsoft’s reinvention of the world’s most popular rapid-application-development language for the .NET platform. First appearing in public betas in 2001 and officially released on February 13, 2002 alongside Visual Studio .NET 2002 and .NET Framework 1.0, it kept classic Visual Basic’s readable, keyword-rich syntax — Dim, Sub, End If, code that reads almost like English — while replacing everything underneath: a fully object-oriented type system, compilation to the Common Language Runtime, and complete access to the same .NET libraries as C#. That trade — familiarity on the surface, a clean break below — made VB.NET one of the most widely used enterprise languages of the 2000s and, simultaneously, the center of one of the most contentious migrations in programming history.

History & Origins

The weight of success

By the late 1990s, classic Visual Basic was arguably the most-used programming language in the world. Visual Basic 6.0 (1998) let millions of developers — many without formal computer science backgrounds — build Windows database front-ends and business tools by dragging controls onto forms. But VB6 was showing its age: its object model lacked implementation inheritance, its runtime was COM-based, and its error handling still leaned on On Error Goto.

When Microsoft designed the .NET Framework — announced at its Professional Developers Conference in mid-2000 — it made a decisive choice: rather than port VB6’s runtime forward, Visual Basic would be rebuilt as a first-class citizen of the new Common Language Runtime, sharing a type system, garbage collector, and class library with the brand-new C#. The result, developed by Microsoft’s Visual Basic team (with language architect Paul Vick among its principal designers), was Visual Basic .NET.

The “Visual Fred” controversy

VB.NET was deliberately not backward compatible. Default parameter passing changed from ByRef to ByVal, arrays became zero-based only, integer sizes changed, COM-era constructs disappeared, and the forms engine was replaced by Windows Forms. Microsoft shipped an Upgrade Wizard, but substantial VB6 programs rarely converted cleanly, and a vocal part of the community argued the new language was Visual Basic in name only — derisively nicknaming it “Visual Fred.” Petitions asked Microsoft to keep developing classic VB; Microsoft instead ended mainstream support for the VB6 IDE in 2005 and extended support in April 2008 (while, notably, committing to keep the VB6 runtime working on later versions of Windows). The rupture pushed some VB6 developers to VB.NET, some to C#, and some away from Microsoft’s stack entirely — a cautionary tale about breaking changes that language designers still cite.

Co-evolution with C#

Through the 2000s VB.NET and C# leapfrogged each other; around Visual Studio 2010 Microsoft adopted an explicit “co-evolution” strategy, adding major features — LINQ before it, then Async/Await, iterators, and the Roslyn compiler platform — to both languages together. VB.NET routinely ranked among the most widely used languages of that era, and it has remained in or near the top ten of the TIOBE popularity index for much of the language’s life.

Design Philosophy

VB.NET’s design goal was to make the full power of the CLR available in a syntax optimized for readability and approachability:

• Words over symbols. Blocks end with End If, End Sub, and Next instead of braces; logical operators are And, Or, and Not; inheritance is Inherits. Code is case-insensitive, and the IDE normalizes casing for you.
• Safety with an escape hatch. The language is statically and strongly typed, but Option Strict Off permits late binding and implicit conversions — a deliberate bridge for developers arriving from VB6 and VBA, and useful for COM automation.
• Batteries for common tasks. The My namespace (added in 2005) gives one-line access to the computer, file system, network, application settings, and user information — rapid application development distilled into an API.
• Event-driven at heart. The Handles keyword and WithEvents declarations wire methods to events declaratively, preserving the forms-and-events programming model that made classic VB famous.
• Full CLR citizenship. Everything C# can express at the IL level — classes, interfaces, generics, delegates, lambdas, async methods — VB.NET can too, and both compile to the same intermediate language with essentially equivalent runtime behavior.

Key Features

A small example showing VB.NET’s flavor — modules, string interpolation, LINQ, and the Handles-style declarative readability the language is known for:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

Imports System

Module Program
    Sub Main()
        Console.WriteLine("Hello, World!")

        Dim numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

        ' LINQ query syntax reads like SQL
        Dim evens = From n In numbers
                    Where n Mod 2 = 0
                    Select n * n

        For Each square In evens
            Console.WriteLine($"Square: {square}")
        Next
    End Sub
End Module

Distinctive capabilities accumulated over the years include:

• XML literals (VB 9.0, 2007): XML can be embedded directly in source code with expression holes — a feature C# never adopted.
• LINQ with query syntax richer than C#’s, including Aggregate, Distinct, Skip While, and Take While clauses.
• Async/Await (VB 11, 2012), introduced simultaneously with C# 5.
• String interpolation, NameOf, and null-conditional operators (?.) from VB 14 (2015).
• Tuples, binary literals, and digit separators from VB 15 (2017).

Evolution

The turning point came in March 2020, when Microsoft announced that while Visual Basic would be fully supported on .NET 5 and beyond — including Windows Forms, which returned to VB on modern .NET — the language itself would no longer gain new features. The February 2023 update to Microsoft’s .NET language strategy formalized this: Visual Basic is a stable language. The compiler is maintained, bugs are fixed, Visual Studio tooling continues to improve, and new versions still appear (VB 17.13 shipped with Visual Studio 2022 version 17.13 in February 2025), but they adopt a “consumption-only” approach — enabling VB code to use new runtime and library features without adding new syntax. Microsoft has also stated it does not anticipate bringing VB to newer workloads such as web front-ends or cross-platform UI frameworks.

Current Relevance

Visual Basic in 2026 is a maintained, supported, deliberately finished language. It ships in every .NET SDK — dotnet new console -lang VB works on Windows, macOS, and Linux, per Microsoft’s documentation of VB support for console applications and class libraries on modern .NET — and Windows Forms development in VB remains officially supported on current .NET releases. Its center of gravity is the vast installed base of enterprise applications written over two and a half decades: by Microsoft’s own description, workloads grouped largely around Windows Forms applications and libraries. For the developers and businesses that own that code, stability is a feature, not a failing — VB programs written years ago still compile, and the migration path from .NET Framework to modern .NET keeps them viable. New greenfield .NET projects, however, overwhelmingly choose C#, and community energy has followed; third parties have even built VB-inspired successor languages (such as RemObjects’ Mercury) for developers who want the syntax with a still-evolving feature set.

Why It Matters

Visual Basic .NET matters for three reasons. First, scale: it carried millions of classic VB developers — the largest programming community of its day — into the managed-code era, and an enormous amount of the world’s line-of-business software was and is written in it. Second, as a natural experiment in language design: the VB6-to-VB.NET break demonstrated both the power and the cost of discarding backward compatibility, and the “co-evolution” years demonstrated that two languages with radically different syntaxes could share one runtime, one compiler platform, and one library ecosystem as equals — a founding proof of the CLR’s multi-language promise. Third, as a model for how a language ends well: rather than abandonment, Microsoft chose explicit, documented stability — maintained, supported, and frozen — giving VB.NET a rare status in programming history: a language allowed to be finished while tens of thousands of applications built on it keep running.