WIL

WIL — the Windows Interface Language — is a procedural scripting language created by Morrie Wilson at Wilson WindowWare in Seattle. It reached the public in 1991 as the language inside WinBatch, and it set out to answer a question Microsoft itself had left open: Windows 3.x shipped with no real scripting facility, so how was anyone supposed to automate it? WIL’s answer was a language that reads like a friendlier DOS batch file but can open windows, push buttons, send keystrokes, read and write files and INI settings, and glue applications together. Its official documentation describes a general-purpose language with over 500 built-in functions spanning file management, window management, string handling, clipboard access, DDE, multimedia, and system control. Remarkably, the language never stopped: after Wilson WindowWare closed its doors in 2017, Island Lake Consulting LLC took over WinBatch and still ships multiple releases a year — the most recent, WinBatch 2026C, arriving in March 2026.

History & Origins

Wilson WindowWare was founded in 1989, in the era when Windows was still an application launcher perched on top of DOS. Its first product, Command Post, was a shell and menuing utility that let users build custom menus of commands — and the little scripting language those menus were written in turned out to be more interesting than the shell itself. Morrie Wilson’s copyright notices in the early manuals reach back to 1988, marking how long the underlying code had been gestating.

In 1991 the menuing language inside Command Post was spun out as its own product: WinBatch, a “batch language for Windows.” The language it embodied came to be called the Windows Interface Language, or WIL. According to the product’s own documentation, WIL’s structure and syntax are a cross between DOS batch commands, BASIC, Fortran, and C — an honest description of a language designed to feel familiar to the DOS-era administrators who were its natural audience. Shortly after WinBatch’s debut, a corporate edition appeared with a code binder that combined a bytecode form of a script with the interpreter into a single distributable file — the ancestor of today’s WinBatch+Compiler, which produces standalone executables.

WIL was deliberately designed as a language with multiple implementations. Alongside WinBatch, the same engine powered the PopMenu and FileMenu menu utilities, and in the mid-1990s Wilson WindowWare carried WIL to the web with WebBatch, a CGI-scripting edition for web servers that swapped the window-management functions for web-oriented ones while keeping the core language intact.

The company itself remained a small, long-lived independent software house for nearly three decades. In July 2017 Wilson WindowWare ceased operations, and WinBatch was acquired by the newly formed Island Lake Consulting LLC, which has maintained and extended the product — and the language — ever since.

Design Philosophy

WIL’s design reflects 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. WIL treats the Windows user interface itself as scriptable territory — activating windows, sending keystrokes to applications, and displaying its own dialogs and menus. The name “Windows Interface Language” is literal.
2. One function where other languages need a page. The documentation’s own boast is that “what would take pages of code in other languages is often taken care of by a single WIL function.” High-level built-ins — for prompting the user, manipulating INI files, managing windows — do the heavy lifting, so scripts stay short.
3. Be learnable by batch-file authors. Statements are line-oriented, variables need no declaration, and the syntax borrows what its audience already knew: the flavor of DOS batch and BASIC, with expression syntax closer to C and Fortran.
4. Keep the language stable, extend it forever. Rather than breaking changes, WIL has grown by accretion: over the years the vendor added support for COM/OLE automation, ActiveX controls, .NET interop, Unicode, User Account Control, and code signing, while decades-old scripts continue to run.

Key Features

A WIL script (conventionally a .wbt file) is a plain text file of statements — assignments, function calls, and control structures. A small example in the classic style:

1
2
3
4
5
6
7
8

; greet.wbt — a small WIL script
name = AskLine("Greeter", "What is your name?", "World")
greeting = StrCat("Hello, ", name, "!")
Message("Greetings", greeting)

; Launch another program
Run("notepad.exe", "")
Exit

Characteristic elements of the language:

• Dialog functions as primitives. Message, AskLine, AskYesNo, and related functions put GUI interaction one line away — the language assumes a human might be on the other end of the script. A dialog designer in WinBatch generates full custom dialogs in WIL code.
• Window management built in. Functions to find, activate, resize, and close windows, and to send keystrokes to specific applications, are part of the core library — the essence of driving programs that offer no automation API of their own.
• Variable substitution. Delimiting a variable name with percent signs (in the batch-file tradition) substitutes its value into a statement, a device inherited from WIL’s DOS-batch ancestry.
• Rich standard library. The official reference counts more than 500 functions across file and directory management, binary file access, string handling, clipboard operations, DDE, multimedia, floating-point and integer arithmetic, and system control.
• Extenders. DLL-based extender modules add specialized function families — networking, communications, and system management among them — without changing the core language.
• Growth into modern structures. User-defined functions and multi-dimensional arrays arrived in 2001; map (key–value) collections in 2019; native 64-bit integers in 2021; and nested arrays-within-maps in 2024.

WIL is dynamically typed: variables hold strings, integers, or floating-point values, with conversions handled by the language and its functions at run time.

Evolution

WIL’s history divides into three long eras:

• Wilson WindowWare, 16-bit era (1989–circa 2001). From Command Post’s menu language to WinBatch, WinBatch+Compiler, and WebBatch. The 16-bit line was retired around 2001 as the 32-bit version became the sole focus.
• Wilson WindowWare, modern-Windows era (2001–2017). Year-based versions (WinBatch 2001 onward) delivered steady growth: user-defined functions and arrays in 2001, and progressive support for COM automation, .NET interop, Unicode, UAC, and code signing as Windows itself evolved.
• Island Lake Consulting era (2017–present). The 2017 acquisition kept the release cadence unbroken. Recent years brought the WinBatch Console for interactive command-line use and maps (both 2019), native 64-bit integers (2021), nested data structures (2024), and a continuing stream of maintenance and security releases — including a 2025 fix for a remote-code-execution vulnerability in WebBatch — through WinBatch 2026C in March 2026.

Current Relevance

WIL occupies a niche it largely defined: turnkey Windows desktop automation for administrators and power users. The competitive landscape changed enormously around it — Microsoft eventually shipped its own scripting in the form of Windows Script Host and then PowerShell, and free tools such as 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. The product remains proprietary, commercial, and Windows-only, with the compiler edition still valued in corporate settings for turning scripts into signed, self-contained executables.

For the code archaeologist, WIL is that rarity: commercial software from the Windows 3.0 era whose language is still being extended — with new data types and functions added in the 2020s — rather than merely kept on life support.

Why It Matters

WIL matters because it was among the earliest serious answers to a real gap: graphical Windows had abandoned the scriptability that DOS users took for granted, and WIL 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, from Visual Basic-style macro languages to AutoIt and AutoHotkey, and its use-case lives on in what is now called robotic process automation.

It is also a quiet study in software longevity. A language designed by one person for Windows 3.x has outlived the platform it was built for, survived its creator company’s closure, and passed intact to a successor that still develops it — a roughly 35-year unbroken run that very few commercial scripting languages can match.