VBA Compatibility

VBA Padlock compiles VBA (Visual Basic for Applications) into protected bytecode executed inside your secured DLL.

Use this page as your practical compatibility guide: what compiles into the DLL, what stays in the host document (and why), and what to adapt when needed.

Class modules compile into the DLL, and are removed from the protected document, making them ideal for your most sensitive logic:

The bundled 05_ClassModuleDemo example shows a class compiled into the DLL while the workbook keeps working against it.

All standard VBA operators are supported:

• Arithmetic: +, -, *, /, \ (integer division), Mod, ^
• Comparison: =, <>, <, >, <=, >=
• Logical: And, Or, Not, Xor, Eqv, Imp
• String: & (concatenation), Like (pattern matching, incl. character-list ranges)
• Other: Is, TypeOf...Is, chained indexing x(a)(b) (read access)

VBA Padlock includes a comprehensive set of built-in functions that mirror standard VBA functions. See the Script Functions Reference for the complete list, including:

• String functions (Mid, Left, Right, InStr, InStrRev, Replace, Split, Join, Trim, LTrim, RTrim, UCase, LCase, StrComp, StrReverse, Chr, ChrW, Asc, AscW, Hex, Space, String, Format, FormatNumber, FormatCurrency, FormatPercent, FormatDateTime)
• Math functions (Abs, Sqr, Sin, Cos, Tan, Atn, Log, Exp, Round, Int, Fix, Sgn, Rnd, Val)
• Date functions (Now, Date, Time, Timer, DateAdd, DateDiff, DatePart, DateSerial, DateValue, TimeSerial, TimeValue, Weekday, WeekdayName, MonthName, Year, Month, Day, Hour, Minute, Second)
• Type functions (TypeName, VarType, IsObject, IsMissing, IsArray, IsDate, IsEmpty, IsNull, IsNumeric, IsError)
• Conversion functions (CInt, CLng, CLngLng, CDbl, CSng, CStr, CBool, CByte, CDate, CCur, CDec, CVErr)
• Flow functions (IIf, Choose, Switch, CallByName)
• Utility functions (Array, DoEvents, RGB, Nz, LBound, UBound, Randomize, InputBox, MsgBox)

VBA Padlock ships with ready-to-use constant libraries: thousands of Office constants (xl*, wd*, pp*, ac*, mso*, fm*) plus Financial and ErrorHandler helper modules. Select them in the References dialog; the right host constants are pre-selected automatically.

See the Script Libraries & Constants reference for the full catalog, usage instructions, and code examples.

The automatic analysis (the compile gate) keeps some code in the Office file, not because it doesn’t compile, but because it must run there. The Protection Review shows each decision with its reason:

These verdicts are behavior, not errors: a partially-protected module still works perfectly; the kept procedures simply remain readable VBA.

Compiled scripts have full access to the host Office application through the Application object. You can manipulate worksheets, documents, presentations, and databases exactly as you would in regular VBA.

' PROTECTED CODE (compiled into the DLL)
Sub WriteToCell(CellAddress, Value)
    Application.ActiveSheet.Range(CellAddress).Value = Value
End Sub

Function ReadFromCell(CellAddress)
    ReadFromCell = Application.ActiveSheet.Range(CellAddress).Value
End Function

' PROTECTED CODE (compiled into the DLL)
Function GetDocumentInfo()
    Dim Doc
    Set Doc = Application.ActiveDocument
    GetDocumentInfo = "Document: " & Doc.Name & Chr(13) & _
                      "Pages: " & Doc.ComputeStatistics(wdStatisticPages)
End Function

' PROTECTED CODE (compiled into the DLL)
Function GetDatabaseInfo()
    Dim DB
    Set DB = Application.CurrentDb
    GetDatabaseInfo = "Database: " & DB.Name & Chr(13) & _
                      "Queries: " & DB.QueryDefs.Count
End Function

' PROTECTED CODE (compiled into the DLL)
Function AddTitleSlide(Title, Subtitle)
    Dim Pres, Sld, SlideIndex
    Set Pres = Application.ActivePresentation
    SlideIndex = Pres.Slides.Count + 1
    Set Sld = Pres.Slides.Add(SlideIndex, ppLayoutTitle)
    Sld.Shapes.Title.TextFrame.TextRange.Text = Title
    Sld.Shapes.Placeholders(2).TextFrame.TextRange.Text = Subtitle
    AddTitleSlide = SlideIndex
End Function

Symbolic constants (wdStatisticPages, ppLayoutTitle, xlUp, …) resolve when the matching constants library is ticked in References, which is the default for your host.

The wrappers generated by Produce call your compiled procedures for you: same names, same signatures. If you write callers by hand (advanced scenarios), the generic entry point is VBAPL_Execute:

' CALLER CODE (inside the Office document)
Sub RunMyProtectedCode()
    Call VBAPL_Execute("WriteToCell", "A1", "Hello!")
End Sub

CreateObject() and GetObject() are supported in compiled scripts. You can create and use COM objects such as Scripting.Dictionary, ADODB.Connection, ADODB.Stream, etc., including indexed property writes (obj("key") = value).

Function RemoveDuplicates(ColumnIndex)
    Dim Dict
    Set Dict = CreateObject("Scripting.Dictionary")

    Dim WS, LastRow, Row, Key
    Set WS = Application.ActiveSheet
    LastRow = WS.Cells(WS.Rows.Count, ColumnIndex).End(xlUp).Row

    For Row = 2 To LastRow
        Key = CStr(WS.Cells(Row, ColumnIndex).Value)
        If Not Dict.Exists(Key) Then
            Dict.Add Key, Row
        End If
    Next Row

    RemoveDuplicates = Dict.Count
End Function

VBA Padlock supports standard VBA Declare statements, including the modern Declare PtrSafe form with LongLong and LongPtr, to call functions in external DLLs (Windows APIs and third-party DLLs). The syntax is identical to regular VBA:

Declare PtrSafe Function GetTickCount Lib "kernel32" () As Long
Declare PtrSafe Function GetComputerNameW Lib "kernel32" (ByVal lpBuffer As String, ByRef nSize As Long) As Long
Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)

LongPtr is pointer-sized at runtime (4 bytes on 32-bit Office, 8 bytes on 64-bit), and As Any is accepted as a fallback parameter type.

VBA UserForms are not compiled; they stay in the Office file with their code-behind (shown as VBA (form) in the review). For the built-in dialogs your protected app needs (activation, trial nag, EULA), VBA Padlock provides its own, configured through the Licensing Features tab.

ParamArray is currently resolved at same-module call sites; a ParamArray procedure called from a different module may be kept in VBA by the gate.

x(a)(b) chains (nested default-member/array indexing) are read-only; writing through a chained index is not supported.

VBAPL_Execute supports any number of parameters. Calls with 0 to 4 arguments use optimized dedicated DLL exports, while calls with 5 or more arguments are automatically packed into an array and routed through ExecuteVBAFunctionN. This is handled transparently.

' Call with few parameters
result = VBAPL_Execute("Main|CalculatePrice", quantity, unitPrice)

' Call with many parameters (no limit)
result = VBAPL_Execute("Reports|Generate", title, startDate, endDate, format, outputPath, includeCharts)

When omitting the module name (e.g., VBAPL_Execute("MyFunction", arg1)), the function is searched in the default Main script. To call a function in another module, use the "ModuleName|FunctionName" syntax.

Compiled scripts use Unicode (UTF-16) strings internally, consistent with modern VBA. String comparisons default to binary comparison unless the module specifies Option Compare Text (or Database in Access).

On Error GoTo, On Error Resume Next, Resume, and Resume Next work as expected. The Err object provides Number and Description properties. However, Err.Raise with custom error numbers should use values above 512 to avoid conflicts with built-in errors.

Module-level code (code outside any Sub or Function) is executed when the module is first loaded. This happens on the first call to any function in that module.

• Integer is 16-bit signed (−32,768 to 32,767)
• Long is 32-bit signed (−2,147,483,648 to 2,147,483,647)
• LongLong is 64-bit signed; LongPtr is pointer-sized
• Double follows IEEE 754 double-precision
• Arithmetic rounding uses the Round function (arithmetic rounding, not banker’s rounding)
• Hexadecimal literals use the &H prefix: &HFF (255), &H8000000F (−2,147,483,633 as Long). An optional & suffix forces Long type: &HFF&

VBA Padlock can protect projects for these Office applications:

All Office versions from Office 2016 through Office 2024 and Microsoft 365 desktop apps are supported and tested, in both 32-bit and 64-bit editions. The automatic workflow (analyze → review → produce) works end to end with all four hosts.

1. Let the analysis guide you. Open your file, read the Protection Review, and fix the reasons for kept procedures rather than restructuring blindly.

2. Keep event handlers thin. A one-line handler calling a standard-module Sub protects the logic while keeping the event wiring in the host.

3. Use Option Explicit. It catches typos at compile time and removes the unresolved-host-global reason for keeping procedures in VBA.

4. Use symbolic Office constants. Tick the right libraries in References and write xlUp, not -4162.

5. Test with Test Run. Ctrl+F5 produces the protected file and opens it in Office, the closest thing to what your users will run. For unit-style checks of individual routines, use Run DLL Function.

6. Validate frequently with Syntax Check. It reports move/keep verdicts in seconds, without building.

• Automatic Protection Workflow: How analysis and conversion work
• Script Functions Reference: All built-in functions available in compiled scripts
• Script Libraries & Constants: Office constants and utility modules for compiled scripts
• VBA Bridge API Reference: Calling the DLL from Office VBA
• Project Format Reference: Project folder structure
• Code Editor: Writing and editing compiled scripts in VBA Padlock Studio