Scripting Assistant - For vMix
A typed development environment for writing VB.NET scripts for vMix, delivered as a Visual Studio Code extension.
It reads your actual .vmix project, offers completions built from the inputs and title fields it finds there, emits the native code vMix expects, and validates your script with the same VB.NET compiler vMix itself uses.
Disclaimer: This is an unofficial community extension. It is not affiliated with, endorsed by, or supported by vMix or StudioCoast Pty Ltd. "vMix" is a registered trademark of StudioCoast Pty Ltd.
Compatible with: vMix 21 to 29 — only the functions of the version in use are offered. Each function's minimum version is the first official vMix function reference that documents it; the oldest one vMix still publishes is for version 21, so older versions get everything documented there.
Contents
Why a typed syntax
Every vMix automation call goes through a single entry point:
API.Function("SetText", Input:="Score vMix", SelectedName:="txtHome.Text", Value:="3")
The function name, the input name and the field name are all plain strings. Nothing checks them: a typo in "SetText", a renamed input or a field that no longer exists fails silently at showtime.
This extension replaces those strings with typed members drawn from your own project:
API.Title.SetText(InputsList.Score_vMix, ObjectsList.txtHome_Text, "3")
You get completion, signature help and validation while you write, and the extension translates the call back to the native form on export. Both directions are lossless — see Import and export.
What a vMix script can and cannot do
vMix runs scripts in a restricted environment, and much of what works in a normal VB.NET project does not work there. The limits below were confirmed in writing by vMix support in September 2026, in answer to questions asked while building this extension. That exchange does not make the extension official: it remains an independent community project.
The extension follows these limits instead of the full language, so what it offers and accepts is what vMix will run.
Confirmed by vMix support
Each limit, what it means for your script, and what the extension does about it.
1. Only VB.NET 2.0 is supported, inside a single Sub or Function.
- Your script: write Visual Basic 2005 — no
Sub, Function, Class or Structure of your own, and no syntax added after 2005, such as If(a, b, c), lambdas, $"..." or ?..
- The extension: validates with the .NET Framework 2.0 compiler and reports anything newer.
2. .NET Framework 2.0 is the only guaranteed version. Recent vMix versions run on .NET 4.x internally, but not all of them.
- Your script: a class or member added after .NET 2.0 —
String.IsNullOrWhiteSpace, Tuple, LINQ — may fail on some installations.
- The extension: offers and validates .NET 2.0 by default. .NET 4.8 can be turned on in
vmixScripting.dotNetFramework, marked as not officially supported.
3. Imports cannot be used.
- Your script: classes outside the namespaces vMix imports are written in full, for example
System.Collections.Generic.List(Of String).
- The extension: reports
Imports and shows the full name to write instead.
4. Namespaces imported by default: System, System.IO, System.Net, System.Diagnostics and System.Xml.
- Your script:
WebClient, File or XmlDocument can be written without the namespace.
- The extension: uses exactly these imports when validating.
5. Classic Visual Basic functions do not work: Left, Mid, Len, UCase, InStr, Now…
- Your script: use the methods of
String, Convert or DateTime instead.
- The extension: flags them and offers the equivalent, for example
Left(name, 3) → name.Substring(0, 3).
6. System.Diagnostics and System.Reflection are blocked for security reasons, even though System.Diagnostics is imported.
- Your script:
Process.Start, Stopwatch or Assembly.LoadFrom will not work.
- The extension: does not offer them and reports their use as an error.
7. Undocumented functions may be removed or stop working at any time, for example Console.WL and Me.CurrentLine, which are for internal use.
- Your script: they appear in many scripts shared online, but should not be relied on.
- The extension: warns about them and replaces
Console.WL with Console.WriteLine.
8. Only basic scripting is intended to be supported.
- Your script: for anything larger, vMix recommends a separate application that controls vMix through its Web or TCP API. It keeps vMix safe from performance or reliability problems and allows any language.
- The extension: recommends that approach in the messages about blocked features.
Observed in practice
These come from the vMix forum and from scripts shared publicly, not from vMix support:
- Nothing that needs a user-interface thread works: no Windows Forms or WPF windows.
Async/Await and System.Threading.Tasks are not available, and there is no JSON library; read JSON as text or ask vMix for XML.- Inputs do not expose their name or key directly: read them from the XML that
API.XML() returns, which is what the typed state of vMix makes easy.
- A long loop must pause with
Sleep, or it takes a whole processor core and vMix can drop frames.
If something here turns out to be wrong for your vMix version, or you find a limit that is missing, please say so in the Q & A.
Features
The state of vMix, typed
Reading the state of vMix means asking for its XML and walking it with XPath strings:
Dim xmlString As String = API.XML()
Dim xmlDoc As New System.Xml.XmlDocument
xmlDoc.LoadXml(xmlString)
Dim node As System.Xml.XmlNode = xmlDoc.SelectSingleNode("/vmix/inputs/input[@number='1']")
Dim title As String = ""
If node IsNot Nothing AndAlso node.Attributes("title") IsNot Nothing Then title = node.Attributes("title").Value
Nothing checks that XPath. A mistyped element or attribute does not fail: it returns Nothing, and the script goes on with an empty value. That is why the same six lines, with the Nothing checks, are copied into script after script — and why the checks are so often left out.
The same thing, written with dots and completed as you type:
Dim xmlDoc As XmlDocument = API.XML.OpenCurrent()
Dim title As String = xmlDoc.SelectSingleNode(vmix.inputs.input.Number(1)).Attribute(title)
This is syntax of the extension. It is not VB.NET and it is not a vMix function. API.XML.OpenCurrent(), the vmix. path tree, .Value and .Attribute(...) exist only in the editor. They do not appear in the .NET documentation or in the vMix scripting guide, and pasting them into the vMix script editor will not compile. What vMix receives is the native code above: the export writes it, and one typed line can become several native lines.
API.XML.OpenCurrent() returns the current state as an XmlDocument. On export it becomes the three lines vMix expects. It reads the state from the running vMix, so the editor checks the address in vmixScripting.apiUrl: it has to be a valid URL, and what answers there has to be the vMix state XML. When it is not, the line says what is wrong — an invalid address, nothing answering, another HTTP code, or something that is not vMix.- The
vmix. tree is the state XML written with dots: vmix.active, vmix.recording, vmix.inputs.input, vmix.inputs.input.text, vmix.overlays.overlay, vmix.transitions.transition, vmix.mix.active, vmix.audio.busA, vmix.dynamic.value1. Filters take the value: vmix.inputs.input.Number(1), .Title("Camera 1"), .Key(k), .ShortTitle(s), vmix.inputs.input.text.Name("Headline"). It is a compile-time constant — the export replaces it with the XPath string, so it costs nothing at run time — and a variable in a filter is concatenated into the expression. A path that is not part of the vMix XML is reported while you write instead of returning Nothing at showtime.
.Value and .Attribute(name) read the element text and an attribute. The attribute name is written without quotes and completed from the element you queried. Both write the Nothing check for you and return an empty string when the node is not there, so a missing input never crashes the script. When the schema says the value is a number or a boolean, the conversion is written too, following the type you declared.- Loops work the same:
For Each node As XmlNode In xmlDoc.SelectNodes(vmix.inputs.input), and then node.Attribute(title).
The native form keeps working. A script written the way vMix documents it — API.XML(), LoadXml, XPath in strings, .InnerText, .Attributes("x").Value — is left exactly as it is, is never reported as an error, and comes back byte for byte after an export. Scripts brought in from vMix are shown with the typed syntax; turn off vmixScripting.typedXmlOnImport to keep them native.
Contextual IntelliSense
Completion for the full vMix API, organised by category. Suggestions are filtered by what can legally appear at that position, and valid value ranges are shown inline.
As in Visual Studio, optional parameters are not marked with a question mark: each one adds an overload, so Fade is offered as Fade(), Fade(Input) and Fade(Input, Duration), and SetOutput2 as SetOutput2(Value) and SetOutput2(Input, Value). The functions that take audio buses have one overload per combination, from AudioBusOn(Input, M) to AudioBusOn(Input, M, A, B, C, D, E, F, G). Signature help and hover show the same overloads, and the one being used follows the arguments you have typed. Parameters always keep the official order — Input, SelectedName, Value, Duration.
Inside the parentheses only what belongs there is suggested — for an Input parameter, the inputs of the linked project:
Title field awareness
When a project is linked, the extension opens each GT Title (.gtzip) and reads its document.xml, populating ObjectsList with the title's text and image elements. Fields are filtered by their parent input and by kind: SetText offers text elements only, SetImage offers image elements only.
.NET classes
vMix scripts can use the .NET Framework base classes. Where a type is expected (Dim x As, New, CType(x, …)) the list offers types:
After a dot come the real members of the expression's type, with the same description Visual Studio shows as Quick Info: summary, parameters and return value. It follows the expression through calls and indexes: wc.DownloadString(url).Split(","c)(0)., doc.SelectSingleNode(…).InnerText.
Signature help lists every overload and describes the parameter being typed, and hovering a member, a type or a variable shows its Quick Info:
The types and signatures are read by reflection from the .NET Framework itself, limited to the classes vMix scripts actually use. vMix supports VB.NET 2.0 scripts, so .NET Framework 2.0 is what the extension offers and validates against. Recent vMix versions run on .NET 4.x internally, but not all of them, which is why 4.8 is only an opt-in setting (vmixScripting.dotNetFramework), marked as not officially supported. The descriptions come from the official .NET API documentation; when the .NET Framework IntelliSense files for your Windows language are installed (for example, Spanish), they are shown in that language.
Supported namespaces
Imported by vMix, usable without qualification:
- System —
String, Integer, Double, Boolean, DateTime, TimeSpan, Math, Convert, Array, Environment, Exception, Random, Uri
- System.IO —
File, Directory, Path, FileInfo, FileStream, StreamReader, StreamWriter
- System.Net —
WebClient, WebRequest, HttpWebRequest, HttpWebResponse, WebHeaderCollection, NetworkCredential
- System.Xml —
XmlDocument, XmlNode, XmlNodeList, XmlElement, XmlAttribute, XmlReader
Written qualified, since vMix scripts cannot declare Imports:
- System.Collections.Generic —
List(Of T), Dictionary(Of TKey, TValue), KeyValuePair(Of TKey, TValue)
- System.Collections —
Stack
- System.Text —
StringBuilder, Encoding, UTF8Encoding
- System.Text.RegularExpressions —
Regex, Match, MatchCollection
- System.Net.Sockets —
TcpClient, UdpClient, NetworkStream
- System.Threading —
Thread
- System.Globalization —
CultureInfo
What vMix does not allow is reported while you write:
System.Diagnostics and System.Reflection are blocked by vMix for security reasons, so they are not offered, and using them — Process.Start, Stopwatch, Assembly.LoadFrom — is flagged as an error.- Classic Visual Basic functions such as
Left, Mid, Len, UCase, InStr or Now do not work in vMix scripts. They are flagged, and a quick fix rewrites them with the String method that does the same: Left(name, 3) → name.Substring(0, 3), InStr(text, ",") → (text.IndexOf(",") + 1).
Console.WL and Me.CurrentLine appear in scripts shared online but are internal to vMix and not documented, so they may stop working in any version. They are flagged, with a quick fix to Console.WriteLine.- Events —
WebClient.DownloadStringCompleted and the like — are left out, because there is no way to handle them: AddHandler needs AddressOf a Sub, and a script cannot declare one.
For anything beyond basic scripting, vMix recommends an independent application that talks to vMix through its Web or TCP API.
vMix's documentation only says that scripts can use "the vast majority of the built in base classes in the .NET framework", so this list was put together from the vMix help, forum and knowledge base and from public vMix scripts. Some namespace or class may be missing or included unnecessarily, and the list is open to feedback: if a class works in your scripts and is not offered, or something listed does not work in vMix, please say so in the Q & A.
Signature help
The full signature with parameter names, types, documentation and accepted value range, shown while you type inside the parentheses.
Real compiler errors
vMix compiles scripts with the VB.NET compiler bundled with the .NET Framework. This extension invokes that same compiler — vbc.exe, already present on every Windows installation, nothing to install.
Your script is compiled in the background against stubs of the vMix objects, and the compiler's own errors are surfaced with their original code (BC30451), in your system language, linked to the Microsoft documentation.
This catches what pattern matching cannot: undeclared variables, misspelled members, unclosed blocks, type mismatches, and the Sub/Function declarations vMix does not permit.
What is compiled is the exported native code rather than what you typed, since the typed syntax does not exist as far as vbc.exe is concerned. Compilation is debounced, each run cancels the previous one, and a typical script takes about 140 ms.
The 56 scripts of a real production project compile without a single error.
Quick fixes
Errors come with the light bulb (Ctrl+.), as in Visual Studio. The fixes are driven by the compiler's own error codes and by the linked project, so they suggest names that actually exist:
| Error |
Fix offered |
BC30451 — name not declared |
A similar variable or vMix object if it looks like a typo (totla → total); otherwise Generate Dim totales As Integer, with the type inferred from how the variable is used and the declaration placed where it stays in scope |
BC30456 — not a member (.Textt, Console.WritLine) |
The closest member of that type: the vMix objects, and common .NET types read by reflection from the .NET Framework |
BC30272 — argument not accepted (Bus:=, Inpt:=) |
The valid argument taken from the signature the compiler reports, or removal of the argument |
| Unknown vMix function, input or title field |
The closest name in the function database or the linked project; fields are limited to that title |
InputsList.X / ObjectsList.X not in the project |
The closest existing member |
Navigation and refactoring
| Shortcut |
Action |
F2 |
Rename a variable across the script. Only variables declared in the script can be renamed, and names that are reserved or already taken are rejected |
F12 |
Go to the variable's declaration. On InputsList.X, open the linked project |
Shift+F12 |
Find all references |
| — |
Occurrences of the variable under the cursor are highlighted, with assignments distinguished from reads |
Ctrl+K Ctrl+D (or Shift+Alt+F) |
Format the document with pretty listing and block indentation, as in Visual Studio, including Case indented inside Select Case. Ctrl+K Ctrl+F formats only the selection |
| — |
Pasted code is formatted automatically (editor.formatOnPaste is on by default for vMix Script) |
Ctrl+K Ctrl+S |
Surround With: wrap the selected lines in If, If…Else, Try…Catch, Try…Finally, For, For Each, Do…Loop Until, While, With or a '#Region |
Live vMix preview
A read-only split showing the script exactly as vMix will receive it, updated as you type and following the scroll position of the source.
The highlighted lines on the right are the ones the extension translated; lines already written in native syntax pass through untouched. The preview opens automatically with each script, below the editor, and a status bar button toggles it. Ctrl+K V opens it, and a second command opens it to the side instead.
Project integration
Link the .vmix file that vMix saves and the extension reads:
- Inputs, with their number and title.
- GT Title fields from each
.gtzip (txtScore.Text, imgLogo.Source). Title files are located relative to the project, so a moved project folder still resolves.
- Data sources and their tables, for the
DataSource* functions.
- Scripts, for import and export.
External changes to the project file are detected and reloaded automatically. When vMix is running, Refresh Inputs from vMix reads the live state over the HTTP API instead.
The input list shows each input's type next to its number and name, as in 3. First time (Video), using the names vMix gives them. With vMix running, the type comes from vMix itself. With only the project file, it comes from the number the .vmix file stores for each input. vMix does not publish what those numbers mean, so each one was checked against a running vMix 24 with every input online:
- Confirmed: Video, Image, Photos, Capture (cameras and capture cards), Desktop Capture, Audio (audio input devices), Audio File, Video Delay, Colour, Video List, Virtual Set, Image Sequence, NDI, Browser, VLC, GT (titles), SRT and Mix.
- From public projects: Replay (A and B), Blank, vMix Call, Virtual inputs, Output and Preview. These come from
.vmix projects and vMix API samples published by other users, not from a check on a single machine, so they are very likely right but not confirmed.
- Not confirmed yet: network streams (RTMP, RTSP, HLS, UDP), DVD, PowerPoint, Flash, Xaml titles, Zoom, Microsoft Teams and OMT, plus any type added in later versions of vMix. With vMix running they show the name vMix gives them; with only the project file they are shown without a type, rather than with a guess.
If you use any of the types that are not confirmed, please send a .vmix project that contains them to sysprofilecomar@gmail.com, together with the vMix version, so they can be checked and added.
The status bar also shows the connection with vMix: vMix 29 when vMix answers at the address in vmixScripting.apiUrl, with its version, or vMix not connected, with the reason in the tooltip. Clicking it checks again and, if something is wrong, offers to change the address.
Run selected lines in vMix. Select one or more lines with vMix function calls and a ▶ Run in vMix button appears above the selection; the same action is in the lightbulb for the line under the cursor. Each line is sent, in order, to the vMix at vmixScripting.apiUrl through its web API, so API.Title.SetText(InputsList.Score, ObjectsList.Name_Text, "HELLO") changes the title right away, without exporting or saving anything. The web API runs one function at a time, not VB code, so a line runs only when every value is fixed — an input or field from the lists, text in quotes or a number. A line with a variable, an If or anything else that needs VB is not sent, and the message says which line and why; when that happens, nothing in the selection is sent.
Every command is available from the status bar item, which also reports the linked project and its input count:
The menu includes:
- Export Script (VB.NET) — translates the current script into the native code to paste into vMix.
- Import Script from project — opens a script of the linked
.vmix project, with the typed syntax applied.
- Run script in vMix — starts the script in the running vMix (
ScriptStart).
- Refresh Inputs from vMix — reads the inputs and title fields from the running vMix.
- Check the connection with vMix — checks that vMix answers at the address in
vmixScripting.apiUrl.
- Verify script round-trip — exports and imports the script again to make sure nothing is lost.
- Export as .vb file — saves the native code to a separate file.
- Live vMix preview (below) and (to the side) — the script as vMix will receive it, updated while you type.
- New script from template — starts a script from a common pattern.
- Open project — links a
.vmix file.
- Settings — opens the extension settings.
- Install VS 2022 keymap — installs Microsoft's Visual Studio keymap, so the shortcuts are the ones you know.
Import and export
Export converts the current .vmixscript to native VB.NET and copies it to the clipboard, ready to paste into vMix. It can also write the script straight into the linked project: only the <Scripting> section is rewritten, the rest of the file is preserved byte for byte, and a backup is taken first. Strings and comments are never modified.
Import lists the scripts stored in the linked project and converts the selected one to the typed syntax.
The imported script opens in typed syntax, with the preview on the right showing it converted back to what vMix receives:
Both directions are verified against a real production project: its 56 scripts import and export back without loss. Twenty-nine return byte for byte; the remaining twenty-seven differ only in the order or spacing of named arguments, which vMix parses identically. The import converts at least one call in 55 of the 56.
Visual Studio–style editing
The editor reproduces Visual Studio 2022 behaviour for VB.NET, restricted to what vMix actually compiles: VB.NET 2.0 (Visual Basic 2005) inside a single Sub.
- Pretty listing. Committing a line — pressing Enter, or moving to another line — reformats it:
dim x as integer=5 becomes Dim x As Integer = 5, Foo( a ,b ) becomes Foo(a, b), Sleep (500) becomes Sleep(500). Named arguments stay tight, as in Visual Studio (Input:="Camera 1"). Strings and comments are never touched.
- Contextual casing. Keywords take their canonical form; variables keep the casing of their declaration, so a variable named
text is not rewritten to Text; members after API., InputsList. and ObjectsList. take their real names.
- End constructs. Pressing Enter after
If x inserts Then and End If, and likewise for For/Next, Do/Loop, While/End While, Select Case, Try/Catch, With, Using and SyncLock. Nothing is inserted when the block is already closed.
- Code blocks. Typing
if and pressing Tab writes the whole block with the cursor on the condition, as in Visual Studio:
If condition Then
End If
Enter confirms the field and moves to the next one, so you write the condition, press Enter and are already inside the block. The same for ifelse, for, foreach, while, do, select, try, with, using and region. Only blocks that compile in vMix are offered: there is no sub, function, class or property, because a script is a single implicit Sub.
- Smart indentation, folding and comments. Blocks indent and outdent on their own, fold (including
'#Region markers), and Ctrl+K Ctrl+C comments the selection.
Native vMix syntax
Scripts written the way vMix documents them are fully supported, with completion inside the string literals:
| Position |
Suggestions |
Input.Find(", Input:=", Overlay.Find(1).In(" |
Input names from the project |
API.Function(", .Function(" |
vMix functions, with description and example |
SelectedName:=", .Text(" |
Fields of that title (txtScore.Text) |
Value:=" |
Script names for ScriptStart, data sources and tables, accepted values |
Diagnostics report inputs, title fields and functions that do not exist, arguments API.Function does not accept, and syntax newer than VB.NET 2.0 that vMix will refuse to compile — If(a, b, c), lambdas, $"...", ?., Integer?, collection initialisers, and implicit line continuation without _.
Title fields are checked against the linked project: Text, SetText or SetImage on an input that is not a title, such as a video, is reported, and Text without a field name on a title with several fields suggests naming one — .Text and .Text() are the same call and both compile. After ObjectsList. or inside .Text(, the list shows the fields of that input or, when it has none, says so instead of offering fields.
Hovering a function or input name inside a string shows its documentation.
Also included
- vMix objects. Completion for
Input.Find(...), Input.Preview, Input.Output, .Text("field"), .Function(...), .WaitForCompletion(ms), Overlay.Find(n), Console.WriteLine and Sleep(ms), as documented in the vMix VB.NET scripting guide.
- Data sources. Names and tables from the linked project, offered in the
DataSource* functions.
- Snippets. Common patterns, plus per-input shortcuts generated from the project (
cut-Camera_1, fade-Intro, gt-Score).
- Navigation. Document outline, folding, and
Ctrl+Click from InputsList.X to the linked project.
- Localisation. Messages, IntelliSense details, snippets and templates in English, Chinese (Simplified and Traditional), Czech, French, German, Italian, Japanese, Korean, Polish, Portuguese, Russian, Spanish and Turkish — every display language of VS Code — following the Windows display language — the same language
vbc.exe reports its errors in — or the language chosen in vmixScripting.language. Command titles in menus follow the VS Code display language.
Getting started
1. Install
Search for Scripting Assistant - For vMix in the Extensions view, or install it from the Visual Studio Marketplace.
2. Link a project
From the Command Palette (Ctrl+Shift+P), or from the status bar item:
Scripting Assistant: Open project...
Select your .vmix file. The extension loads its inputs and extracts the fields of every GT Title.
3. Write a script
Create a file with the .vmixscript extension. The first line must be a comment holding the script name, which is what identifies it inside the project:
'Lower Third In
Type API. to browse the categories, then the function and its parameters. The live preview on the right shows the native code as you go.
4. Export
From the Command Palette or the status bar item:
Scripting Assistant: Export Script (VB.NET)
The translated code is copied to the clipboard, ready to paste into vMix — or the extension can write it into the linked project for you.
Typed syntax reference
What you write:
API.Title.SetText(InputsList.MyTitle, ObjectsList.txtName_Text, "Hello")
API.Transition.Cut()
API.Transition.Fade(InputsList.Camera_1, 1000)
API.Audio.SetVolume(InputsList.Music, 80)
API.DataSources.DataSourceSelectRow("vMix", "Teams", 3)
Input.Find(InputsList.MyTitle).Text(ObjectsList.txtName_Text) = "Hi"
Sleep(1000)
What vMix receives:
API.Function("SetText", Input:="MyTitle", SelectedName:="txtName.Text", Value:="Hello")
API.Function("Cut")
API.Function("Fade", Input:="Camera 1", Duration:=1000)
API.Function("SetVolume", Input:="Music", Value:="80")
API.Function("DataSourceSelectRow", Value:="vMix,Teams,3")
Input.Find("MyTitle").Text("txtName.Text") = "Hi"
Sleep(1000)
Typed calls emit only the arguments API.Function accepts in VB.NET: Input, SelectedName, Value and Duration. Calls that cannot be represented without losing information — Mix:= or SelectedIndex:=, for instance — are left as API.Function(...) on import rather than converted approximately.
Literals are quoted for you
In API.Function, Value is a String and Duration is an Integer — a distinction that is easy to get wrong by hand. Write the literal in its natural form and the export applies the right one:
| You write |
vMix receives |
Why |
API.Audio.SetVolumeChannel1(InputsList.Mic, 100) |
Value:="100" |
Value is a String, so the number is quoted |
API.Transition.Fade(InputsList.Intro, 1000) |
Duration:=1000 |
Duration is an Integer, so it is left bare |
API.Transition.Fade(InputsList.Intro, "1000") |
Duration:=1000 |
The quotes are removed |
Variables and expressions are passed through exactly as written, since their type cannot be known.
Settings
vmixScripting.projectPath — The .vmix project to read inputs, title fields, data sources and scripts from. Empty until a project is linked.vmixScripting.compilerDiagnostics — Validate the script with vbc.exe. Default: true.vmixScripting.vbcPath — Explicit path to the vbc.exe to validate with. Default: auto-detected.vmixScripting.livePreviewAuto — Open the live vMix preview automatically with each script. Default: true.vmixScripting.prettyListing — Reformat each line as it is committed. Default: true.vmixScripting.endConstructs — Close blocks automatically on Enter. Default: true.vmixScripting.enableHotReload — Reload the project when the .vmix file changes on disk. Default: true.vmixScripting.enableLinter — Warn about consecutive calls on one input without Sleep, untyped API.Function calls, and loops with no exit. Default: true.vmixScripting.apiUrl — vMix HTTP API address, used to run scripts, refresh inputs and read the state. It must be a URL such as http://127.0.0.1:8088; the status bar shows whether vMix answers there. Default: http://localhost:8088.vmixScripting.checkFunctionUpdates — Check the published sources once a day and offer to update the function database. Default: true.vmixScripting.requireScriptName — Require the first line to be a comment with the script name. Turn it off to write code you copy and paste into vMix: exporting, running or updating the project then asks for the name when it needs one. Default: true.vmixScripting.typedXmlOnImport — Write the state XML with the typed syntax when a script is brought in from vMix; off keeps the native VB.NET. Default: true.vmixScripting.vmixVersion — vMix version the scripts are written for: it decides which functions are offered, since each one has a minimum version. auto takes it from vMix while it is running. Default: auto.vmixScripting.dotNetFramework — .NET Framework to validate and complete against. vMix supports 2.0; 4.8 is not officially supported and only applies from vMix 27. Default: 2.0.vmixScripting.language — Language of the extension: auto follows the operating system; a language code such as en, es, de, ja or zh-cn forces one. Default: auto.
Requirements
- Visual Studio Code 1.80 or later
- Windows, for the compiler diagnostics (
vbc.exe ships with the .NET Framework)
- A vMix installation with
.vmix project files, for the project integration features
API sources
The function database holds 792 functions, built from:
Each function's description is the full text of the official reference. When the official reference has none, it is the one from vmixapi.com; when both have text, the sentences from vmixapi.com that the official one does not cover are added after it — for example, that line breaks in SetText are sent as %0A.
Arguments follow the signature in the official VB.NET Scripting guide, where Duration is an Integer: the extension writes Duration:=500, as in the guide's own example API.Function("CubeZoom",,1000). Other references write Duration:="500", which vMix also accepts because the text is converted to a number.
Staying current
Once a day the extension rebuilds the database from the first two sources and compares it with the one in use. When vMix publishes new or changed functions — or a new version of its help — it offers to update, with the list of changes available before accepting. Nothing changes without confirmation, and the updated database takes effect immediately, without restarting. Only those two public pages are downloaded and nothing is sent. The check can be run on demand with Scripting Assistant: Check for vMix function updates, or turned off with vmixScripting.checkFunctionUpdates.
Feedback
Questions and bug reports go to the Q & A tab of the Marketplace page.
Reports about specific vMix API functions are particularly useful: a wrong parameter type, a missing overload or an incorrect value range in the function database is hard to find without someone hitting it in production. When reporting one, include the call as you wrote it and what vMix did with it.
Third-party notices
vMix API function data
The vMix function data comes from the data file of The Unofficial vMix API Reference
(public/data/api.json, also served at vmixapi.com), which is distributed under the MIT License:
MIT License
Copyright (c) 2025 Nick Roberts
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
.NET API documentation
Contains descriptions of .NET types and members (summary, parameters and return value) taken from
.NET API reference documentation by Microsoft and the .NET Foundation,
licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).
Changes: only the entries for the classes offered by the extension were kept, cross-references were converted to short
type names, C# keywords to their Visual Basic form, and remarks and examples were omitted.
When the Windows display language is not English and the .NET Framework IntelliSense files for that language are installed
on the computer, descriptions are read from those local files; they are not included in the extension.
The .NET type and member signatures are read from the metadata of the .NET Framework 2.0.
License
MIT
Built for the vMix community. vMix is a registered trademark of StudioCoast Pty Ltd.
