WinBatch

WinBatch is a commercial scripting and automation tool for Microsoft Windows, created by Morrie Wilson at Wilson WindowWare in Seattle and first released in 1991. It answered a question Microsoft had left open: Windows 3.x shipped with no scripting facility of its own, leaving administrators who were used to DOS batch files with no way to automate a graphical desktop. WinBatch filled that gap with an interpreted language — the Windows Interface Language (WIL) — whose built-in functions could launch programs, activate windows, send keystrokes, display dialogs, and manage files, INI settings, and system state. Its official documentation describes a library of hundreds of built-in functions, with structure and syntax that are “a cross between DOS batch commands, BASIC, Fortran, and C.”

The product proved remarkably durable. After Wilson WindowWare closed its doors in July 2017, the newly formed Island Lake Consulting LLC acquired WinBatch and has continued shipping multiple releases per year ever since — the most recent, WinBatch 2026C, arriving in March 2026, roughly 35 years after the first version.

History & Origins

Wilson WindowWare was founded in 1989, when Windows was still an application launcher perched atop DOS. Its first product, Command Post, was a shell and menuing utility whose custom menus were written in a small scripting language — and that language turned out to be more valuable than the shell around it. In 1991 it was spun out as its own product: WinBatch, a “batch language for Windows.”

WinBatch grew into a family. A corporate edition added a code binder that packaged a script together with the interpreter into a single distributable file — the ancestor of WinBatch+Compiler, which produces standalone executables. By 1997 the same language engine also powered WebBatch, a CGI-scripting edition for web servers, and smaller menu utilities that carried on the Command Post tradition.

The modern product bundles more than an interpreter: WinBatch Studio, a syntax-aware editor and debugger, and a dialog designer that generates custom GUI dialogs as WIL code. Wilson WindowWare remained a small independent software house for nearly three decades before ceasing operations in July 2017, when Island Lake Consulting took over the product and kept its release rhythm unbroken.

Design Philosophy

WinBatch embodies a few consistent convictions:

1. Automate the interface, not just the file system. DOS batch files could copy files and run programs; they could not click an OK button. WinBatch treats the Windows user interface itself as scriptable — windows can be found, activated, resized, and driven with keystrokes.
2. One function where other languages need a page. High-level built-ins for prompting the user, copying file sets, editing INI files, and managing windows keep scripts short. The documentation’s own boast is that what would take pages of code in other languages is often handled by a single WIL function.
3. Be learnable by batch-file authors. Statements are line-oriented, variables need no declaration, and the syntax deliberately borrows from DOS batch, BASIC, Fortran, and C — the languages its audience of administrators already knew.
4. Extend forever, break nothing. The language has grown by accretion — COM/OLE automation, Unicode, user-defined functions, maps, 64-bit integers — while decades-old scripts continue to run.

Key Features

A WinBatch script is a plain text file, conventionally with a .wbt extension. A small example in the classic style:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

; backup.wbt — copy reports, then notify via Notepad
source = "C:\Reports"
target = "D:\Backup\Reports"
DirMake(target)
FileCopy(StrCat(source, "\*.xlsx"), target, @FALSE)

Run("notepad.exe", "")
WinWaitExist("Notepad", 5)
SendKeysTo("Notepad", "Backup finished!{ENTER}")
Message("Backup", "Report files copied.")
Exit

Characteristic elements:

• Dialog functions as primitives. Message, AskLine, AskYesNo, and their relatives put GUI interaction one line away, and the dialog designer generates full custom dialogs in script form.
• Window management and keystroke sending built in. Functions to find, wait for, activate, and close windows — and to send keystrokes to a specific application — are core library features, not add-ons.
• A large standard library. The official reference documents hundreds of functions across file and directory management, binary file access, string handling, clipboard operations, DDE, multimedia, and system control, with DLL-based extenders adding networking and system-management families on top.
• The compiler. WinBatch+Compiler turns scripts into self-contained .exe files for deployment to machines without WinBatch installed.
• Modern data structures, added late but genuinely. User-defined functions and multi-dimensional arrays arrived in 2001; map (key-value) collections in 2019; native 64-bit integers in 2021; nested arrays-and-maps in 2024.

The language is dynamically typed: variables hold strings, integers, or floating-point values, with conversions handled at run time. Per the vendor’s system requirements, current releases officially support Windows client versions from XP up to and including Windows 11, and Windows Server 2003 through Server 2022, on Intel/AMD x86 or x64 processors.

Evolution

WinBatch’s history divides into three long eras:

• The 16-bit era (1991–circa 2001). From Command Post’s menu language to WinBatch, WinBatch+Compiler, and WebBatch on Windows 3.x, 95, and NT. The 16-bit line was retired with the 2001 releases.
• The modern-Windows era (2001–2017). Year-based versions (WinBatch 2001 onward) added user-defined functions and arrays, then progressively tracked Windows itself: COM automation, Unicode, User Account Control, and code signing.
• The Island Lake era (2017–present). The 2017 acquisition preserved the release cadence. Recent years brought the interactive WinBatch Console and maps (2019), 64-bit integers and DPI-aware dialogs (2021), nested data structures (2024), and a steady stream of maintenance releases through WinBatch 2026C in March 2026.

Current Relevance

WinBatch occupies a niche it largely defined: turnkey Windows automation for administrators and power users. The landscape changed enormously around it — Microsoft eventually shipped Windows Script Host and then PowerShell, while free tools like AutoIt and AutoHotkey came to dominate hobbyist UI automation — yet WinBatch retains a paying customer base, active technical-support forums, and a vendor that ships several releases a year. It remains proprietary, commercial, and Windows-only, with a free time-limited evaluation version available; the compiler edition is still valued in corporate environments for producing signed, self-contained executables.

Why It Matters

WinBatch matters because it was among the earliest serious answers to a real gap: graphical Windows had abandoned the scriptability DOS users took for granted, and WinBatch restored it years before Microsoft addressed the problem itself. The pattern it established — a friendly interpreted language whose built-ins reach into windows, keystrokes, and dialogs — anticipated the entire genre of Windows automation tools that followed, and its core use case lives on in what is now called robotic process automation.

It is also a quiet study in software longevity: a product designed by one person for Windows 3.x that outlived its original platform, survived its creator company’s closure, and passed intact to a successor that still extends it — adding new data types and functions in the 2020s. Very few commercial scripting tools from 1991 can claim an unbroken release history into 2026.