Reflection Basic Script

Reflection Basic Script is the proprietary, BASIC-derived macro and automation language embedded in Reflection, the long-running terminal-emulation and host-connectivity suite originally developed by WRQ (Walker, Richer & Quinn). Rather than being a general-purpose programming language, Reflection Basic exists to drive a terminal session: it scripts logins to enterprise hosts, navigates green-screen menus, scrapes data off emulated displays, transfers files, and performs unattended host automation. It is a niche, product-specific language — but for decades it was the glue that connected modern Windows desktops to IBM mainframe, IBM i (AS/400), HP, DEC, and UNIX systems.

A note on dates. The “2000” often associated with Reflection Basic actually marks when Microsoft VBA was added to the product, not when the language first appeared. Reflection Basic predates VBA — it was the suite’s original scripting language, dating to roughly the early-to-mid 1990s. Because authoritative documentation does not pin an exact first-appearance year, this page uses hedged dating throughout.

History & Origins

WRQ was founded in 1981 in Seattle by Doug Walker, Mike Richer, and Marty Quinn. The company’s flagship product, Reflection, began as a terminal emulator for connecting PCs to Hewlett-Packard HP 3000 minicomputers, and over the 1980s and 1990s it grew into a broad host-connectivity family supporting IBM 3270 mainframe terminals, IBM 5250 (AS/400) terminals, DEC VT-series terminals, UNIX, and X11 (via Reflection X).

As the product matured on the Windows platform, WRQ added a built-in macro language so users could record and write automation for their host sessions. That language became known as Reflection Basic — a dialect in the BASIC family, comfortable to anyone who had used Microsoft’s BASIC or, later, Visual Basic. Its first appearance is best estimated as the early-to-mid 1990s; documentation describing programming with Reflection was in circulation by the late 1990s.

Around 2000, in the Windows 2000 era, WRQ added support for Microsoft Visual Basic for Applications (VBA) to Reflection. From that point the older, proprietary Reflection Basic compiler and the new VBA engine coexisted — VBA gradually becoming the standard while Reflection Basic remained for backward compatibility.

Design Philosophy

Reflection Basic was designed around one job: automating a terminal session. Its design reflects that focus:

• Familiar BASIC syntax — variables, If/Then, For/Next loops, subroutines, and functions in the procedural BASIC tradition, lowering the barrier for business users and administrators who were not professional programmers.
• Event-driven hooks — macros could be bound to menu items, toolbar buttons, keystrokes, and session events, so automation triggered naturally from the user interface.
• Host-aware primitives — the language’s value lay in its connection to the emulator’s object model: reading and writing the emulated screen, waiting for the host, sending keystrokes, and transferring files.
• Record-and-edit workflow — like many macro systems, Reflection let users record an interactive session into a script and then refine it by hand.

Key Features

Relationship to Visual Basic and VBA

Reflection Basic sits squarely in the BASIC / Visual Basic lineage, which is why the transition to VBA was so natural for the product. In modern Reflection documentation, the legacy connection survives even at the command line: the /RB (“Reflection Basic”) startup switch is treated as equivalent to /VBA, and Micro Focus’s own knowledge base notes that although the switch is still named /RB, current versions invoke the Visual Basic compiler rather than the older Reflection Basic compiler. In other words, Reflection Basic was the original language; VBA became the standard, and the two were maintained side by side for compatibility. Reflection also exposes a COM/Automation object model, so its sessions can be driven by external VBA hosts such as Microsoft Excel.

Evolution and Ownership

The Reflection product — and with it Reflection Basic — passed through a long chain of corporate owners:

• 1981 — WRQ founded; Reflection product line established through the 1980s and 1990s.
• c. 2000 — VBA support added; Reflection Basic begins its slow handoff to VBA.
• 2005 — WRQ merges with Attachmate, forming what becomes The Attachmate Group.
• 2014 — Micro Focus acquires The Attachmate Group.
• 2023 — OpenText completes its acquisition of Micro Focus.
• 2024 — Rocket Software closes its acquisition of OpenText’s Application Modernization and Connectivity business, including Reflection, for approximately US$2.275 billion — the product’s current owner.

Throughout these transitions the Reflection product continued to ship, rebranded over time (Reflection 2008/2011/2014, then Reflection Desktop). The scripting story consolidated around Microsoft VBA, with Reflection Basic surviving mainly as a legacy compatibility concept.

Current Relevance

Today the Reflection suite — now under Rocket Software — remains in active use wherever organizations still depend on legacy host systems, and current versions standardize on VBA for new automation. “Reflection Basic” in the modern product is best understood as the legacy macro language it grew out of: a name preserved in switches and older scripts rather than the recommended path for new work. For the many enterprises with decades-old Reflection macros, however, that legacy still matters, because those scripts continue to keep green-screen workflows running.

Why It Matters

Reflection Basic is a window into an enduring class of software: the embedded automation language. It was never meant to compete with general-purpose languages; it existed so that ordinary users could teach a terminal emulator to do their repetitive host work. In doing so it helped countless organizations bridge the gap between modern Windows desktops and mainframe-era applications that could not — or would not — be replaced. Its arc, from a proprietary BASIC dialect to a VBA-compatible legacy layer, also mirrors a broader industry trend: vendor-specific scripting languages giving way to Microsoft’s VBA as the common denominator for desktop automation. As an artifact of programming history, Reflection Basic is a reminder of how much enterprise computing has always depended on quietly connecting the new to the old.