The VB Family: VB6, VBA and VBScript

The tree has one trunk. BASIC (1964) led through many dialects to Visual Basic 1.0 in 1991 and to Visual Basic 6.0 in 1998. Three things grew out of that trunk, and one of them is a break:

Source: Support Statement for Visual Basic 6.0 on Windows, Office VBA language reference, VBScript Language Reference

Support statements change, so this section says what the official pages state on the check date and then describes the direction in general terms.

Visual Basic 6. The IDE (the Visual Basic 6.0 development environment) has been out of support since 2008-04-08. The runtime is covered by an "It Just Works" commitment: Microsoft supports the VB6 runtime for the lifetime of the Windows version that it ships with, and the support is limited to serious regressions and critical security issues. In practice this means that a VB6 program may keep running on a supported Windows, but nobody supplies a supported compiler, new controls or a language that changes. Anything you build with the VB6 IDE today depends on tools that have been out of support for many years. Installing the IDE from an unofficial archive is not something this section describes or recommends.

VBA. VBA belongs to Office. Its language reference is part of the Office documentation, and its life follows Office’s. VBA code in a document runs inside the host, uses the host’s object model and, since Office applications moved to 64-bit, needs PtrSafe and LongPtr for Declare statements. Microsoft blocks macros in files that came from the internet by default, which matters to anyone who distributes macro-enabled documents. For new work, Office offers other extension models; this section does not cover them.

VBScript. Microsoft announced the deprecation of VBScript in October 2023. The "Deprecated features" page says that VBScript will become a feature on demand before it is removed from Windows, and the "Resources for deprecated features" page adds that the feature on demand is initially preinstalled so that existing scripts keep running while you prepare. The Windows IT Pro blog post on the timeline describes the later phases in general terms: the feature on demand stops being preinstalled, then it is disabled by default, then it is removed. The dates are in that blog post (the publisher blocks scripted access, so it is listed without a link check); this page does not repeat them because they are plans and can move. Scripts that must survive should be rewritten in PowerShell or in a .NET program, and Internet Explorer hosting is irrelevant, because Internet Explorer is retired.

Classic ASP. Classic ASP is the original server-side page model on IIS, using VBScript or JScript in .asp files. It is an optional IIS feature, it is not a .NET technology and it is a legacy platform. The successors on .NET are ASP.NET Web Forms (which can use Visual Basic code-behind on .NET Framework) and, for new work, ASP.NET Core, which has no Visual Basic templates or Razor syntax: see Web, HTTP and Services and Migrating to Modern ASP.NET.

Visual Basic .NET. The language is supported, stable and "consumption-only": 17.13 is the current version and the compiler accepts nothing newer. See History, Versions and Language Strategy.

Source: Support Statement for Visual Basic 6.0 on Windows, Deprecated features, Resources for deprecated features

A VB6 project is a set of text files plus binary resources. The project file (.vbp) lists the pieces. A form (.frm) holds the visual design as text at the top and the code below it; the binary parts of a form (images, icons) go to a .frx file. Standard modules are .bas files (plain procedures and global variables), class modules are .cls files and user controls are .ctl files. The IDE builds an .exe (a standalone program), an ActiveX .dll or .ocx (a COM component) and registers the component in the Windows registry.

Three details of that file are worth decoding. The Begin ... End block is the designer’s output (Visual Basic .NET puts the same information in a .Designer.vb file, or in XAML for WPF). The handler cmdAdd_Click is connected to the button by its name; Visual Basic .NET uses Handles or AddHandler instead, as explained in Events and Handlers. And txtTitle = "" assigns to the control’s default property (Text), which Visual Basic .NET no longer allows without an index; see Properties and Default Properties.

The Windows Forms equivalent, with the designer file and the Application.myapp startup, is on Windows Forms Applications.

The biggest source of old-code bugs is the type system. The table lists the VB6 and VBA types and what happens to them in Visual Basic .NET.

Source: Data types (Visual Basic), Data type summary (VBA)

The program below prints the facts behind that table. It also shows what Variant turned into. The TypeName and VarType functions still exist in Visual Basic .NET, which helps when you port old code that inspects a variant.

Output:

Source: Data types (Visual Basic), Decimal data type

The Currency line deserves a note. VB6’s Currency stored a 64-bit integer divided by 10,000, so the range printed is exactly the one that the arithmetic gives. Moving it to Decimal keeps every value, and Decimal goes far beyond that range, but code that relied on Currency rounding to four places must now round explicitly with Math.Round(value, 4). See Numbers and Math.

Some VB6 syntax is simply not Visual Basic .NET. The compiler says so clearly, which is a gift when you migrate: each row below was put in a separate program with Option Strict On and the SDK printed the message shown.

Source: BC30807, BC30804, BC30814 and the other messages in the table

Some old-looking constructs do still compile, and that is itself a trap. The following were checked and work in Visual Basic .NET on .NET 10: assigning the result to the function’s own name (Total = x * 2, an old way to return a value, still compiles next to Return), Debug.Print, Left$ and the other $ string function names, Mid, UBound, LBound, ReDim Preserve, TypeName, VarType, IIf, Call, Err.Number, On Error (which is documented on its own page: see Unstructured Error Handling: On Error), the FileOpen family and MsgBox (the last needs Windows Forms on .NET: see The My Namespace). A program in which every old construct still compiles is not necessarily correct: Mid is still 1-based while Substring is 0-based, IIf still evaluates both branches while If() does not, and the function-name assignment does not leave the procedure the way Return does.

In VB6 and VBA a parameter without a modifier is passed ByRef: the callee can change the caller’s variable. In Visual Basic .NET the default is ByVal, and you must write ByRef when you mean it. Code that you migrate must make that decision for each parameter.

In Visual Basic .NET the same shape is written with parentheses, changes nothing unless you ask, and Set is gone:

Output:

Source: Passing arguments by value and by reference, ByRef

Notice what the last line of the output says: CreateObject("Scripting.Dictionary") creates a COM object, and COM exists only on Windows. The COM Interop and Office Automation page covers it. Passing an array ByVal still lets the callee change the elements, because the array is a reference; only the reference is copied. The same is true of Collection objects and every class instance.

Set existed because VB6 had default properties and so x = y was ambiguous between "copy the value" and "make x refer to the object". In Visual Basic .NET a default property needs an argument (an indexer), so the ambiguity is gone and so is Set. Properties were written as three procedures in VB6, Property Get, Property Let (value) and Property Set (object); Visual Basic .NET has one Property block with Get and Set. See Properties and Default Properties.

VB6 has class modules, but only interface inheritance through Implements: a VB6 class can implement an interface and can use Public, Private and Friend access, but it cannot derive from another class. Visual Basic .NET adds Inherits, MustInherit, Overridable, Overrides, generics and Interface blocks; see Inheritance and Polymorphism and Interfaces. VBScript 5.0 and later has Class ... End Class with properties and methods, but no inheritance and no Implements.

The other big difference is object lifetime. VB6 objects are reference counted: when the last reference goes away, Class_Terminate runs at once, and programs depend on it to close files and connections. Visual Basic .NET objects are garbage collected, so there is no moment at which a finalizer is guaranteed to run. Resources must be released with Using and IDisposable; see Object Lifetime and Disposal. Setting an object variable to Nothing still lets the garbage collector reclaim it, but it does not run any code.

The Visual Basic .NET shape is a class that implements IDisposable and a Using block, as in the migration table on Migrating Legacy Visual Basic.

VB6 programs used the built-in Collection object (1-based, keys are case-insensitive, items are Variant) and, for dictionaries, the COM class Scripting.Dictionary. Both have .NET relatives. The Microsoft.VisualBasic.Collection class still exists in the runtime library and keeps the VB6 rules; the generic List(Of T) and Dictionary(Of TKey, TValue) are the right choice for new code. The program below shows both, and the array rule that replaces Option Base.

Output:

Source: Collection class, Dictionary(Of TKey, TValue)

The rules to carry over from the output are these:

See Arrays, Collections and Strings and Text.

All three dialects use On Error: VB6 and VBA support On Error GoTo label and On Error Resume Next and have the Err object, while VBScript has only On Error Resume Next (and On Error GoTo 0), so a script must test Err.Number after each risky call. Visual Basic .NET has structured Try/Catch/Finally and still has On Error for compatibility. The full story, with the Err numbers, is on Unstructured Error Handling: On Error and Structured Exception Handling.

VB6 and VBA read and write files with the statements Open, Print #, Input #, Line Input #, Get, Put and Close, using a file number (FreeFile returns an unused one). VBScript has no such statements: it uses the COM class Scripting.FileSystemObject (FSO) and its TextStream objects. Visual Basic .NET uses System.IO: File, Directory, Path, StreamReader and StreamWriter. The FileOpen, PrintLine and related functions remain in the runtime library for old code. See Files, Directories and Streams.

The tested System.IO equivalents are in the migration table on Migrating Legacy Visual Basic.

VBA is the dialect that people still write every day. It is the language behind Excel, Word, Access, Outlook and PowerPoint macros, and other products embed it too. What makes it different from Visual Basic .NET is not only the syntax but the host:

The corresponding "Visual Basic .NET drives Excel from outside" pattern, with its COM caveats, is on COM Interop and Office Automation; the Open XML approach that needs no Excel at all is on file formats.

Source: Office VBA language reference, Declare statement (VBA)

VBScript is an interpreted language in .vbs files. Windows Script Host runs it with cscript.exe (console output) or wscript.exe (message boxes). Its distinguishing rules:

A PowerShell script is the usual replacement for a VBScript administration script; a small .NET console program is the replacement when the script is really an application. Both are shown in the migration table on Migrating Legacy Visual Basic. The Scripting.Dictionary of the listing is the COM class discussed in the collections section above.

Source: VBScript Language Reference, cscript, FileSystemObject

Classic ASP mixes HTML with VBScript between <% and %> delimiters. The server runs the script on each request and sends the HTML that it writes. The built-in objects are the HTTP model in miniature: Request (query string, form, cookies, server variables), Response (output, redirects, cookies), Session (per-user state), Application (state shared by all users), Server (helpers such as HTMLEncode, MapPath and CreateObject). A file named global.asa holds the Application_OnStart and Session_OnStart handlers.

The Server.HTMLEncode call is the point to keep: output written with Response.Write or <%= %> is not encoded for you, so anything that comes from a user must be encoded by hand, or the page is open to cross-site scripting. The equivalent in ASP.NET Web Forms is <%: %>, which encodes; see ASP.NET Web Forms security. The state model (session and application state) carries over to Web Forms in State Management and Caching.

Source: ASP overview

Some third-party projects aim at VB6 compatibility or at running Visual Basic on other runtimes. They are not part of Microsoft’s product line, this section does not evaluate or endorse them, and none of them changes the status of the official products. The one worth naming for historical reasons is Mono’s vbnc compiler: it is abandoned. The supported compiler is the Roslyn Visual Basic compiler in the .NET SDK (dotnet build), which runs on Windows, Linux and macOS. For the part of a VB6 program that has to stay VB6, the supported path is the runtime that ships with Windows, not an unofficial installer.

The two books that this section was checked against describe the family as it was in the mid-2000s and the 2010s. The current position, with the evidence on this page:

Several widespread misconceptions about the family, including some in beginner texts, are corrected here by stating the right form: