GlovePIE

GlovePIE - Glove Programmable Input Emulator - is a Windows program with a scripting language inside it, and the language is the interesting part. Its job is translation: a script reads whatever exotic device you own and writes whatever ordinary device your software expects. The canonical four lines from Carl Kenner’s own documentation say the whole thing at once:

W = glove.z > -50 cm
S = glove.z < -70 cm
A = glove.x < -10 cm
D = glove.x > 10 cm

Four assignments. On the right, the position of a virtual reality glove in centimetres. On the left, the WASD keys. Nothing declares a variable, nothing opens a loop, nothing converts units, and nothing polls a device. The script is simply true continuously: while it runs, the W key is held down exactly when the glove is further forward than 50 centimetres, and released when it is not.

Origins

Kenner, a developer based in Adelaide, South Australia, came to the problem from the hardware side. The Essential Reality P5 was a 2002 consumer VR glove that was cheap, briefly fashionable, and poorly supported; Kenner had already written a third-party Dual Mode Driver for it that the P5 community preferred to the official one. The glove worked, but almost no game knew what a glove was. A driver alone could not close that gap, because the games were compiled against keyboards, mice and DirectInput joysticks.

So he wrote an emulator, and gave it a language rather than a configuration dialog. The first public version, numbered 0.10, arrived in 2004 - the copyright line carried by every subsequent release reads “Carl Kenner 2004-”, though several download catalogues date the project to 2005. Its release notes are candid about the state of things: it shipped without instructions, and shortly after upload Kenner discovered that the multiplication operator performed division, having never tested multiplication because P5 coordinates are large numbers he had only ever divided. His suggested workaround, until a fix, was to divide by the reciprocal.

That tone - a working tool, released early, annotated with its own defects - runs through the entire changelog. Later entries include “Various other bugs fixed, and new bugs introduced” and “Some new bugs added (I’m guessing)”.

The language

PIEScript is small, and its central idea is the frame loop. A script is compiled once and then executed from top to bottom, over and over, at a rate the script itself can set through PIE.FrameRate. Every assignment is therefore a standing relationship rather than a one-time event, which is why the WASD example needs no while and no event handlers. One subtlety follows directly: outside an if statement, an assignment only writes its target when the expression’s value changes, so a script does not fight with the rest of the system over a key that nothing is asking it to press. Inside an if, assignment is unconditional.

Around that core sits a deliberately permissive syntax. Assignment can be written three ways - key.Enter = glove.ButtonA, the Pascal-style :=, or backwards as expression => target. Comments can be //, /* */, ', REM or %, so users arriving from C, BASIC, Pascal or shell scripting all guess right. begin/end blocks, div and mod, and for ... to ... step ... do come straight out of Object Pascal, which is unsurprising given that the interpreter itself was written in Delphi - the 0.28 readme blames a Delphi 6 bug for temporarily dropping Windows 95, and the earliest release notes advertise that every maths function in the Delphi runtime was exposed to scripts.

Three features are unusual enough to be worth singling out.

Physical units are part of the type system. Numbers can be written 50 cm, 30 degrees, 100 ms, 100 Hz, and the compiler converts between compatible units automatically and rejects nonsense. Later versions added units of weight and force, and musical intervals - semitones, cents, octaves, major seconds - so a MIDI script can transpose in the notation a musician actually uses. Very few scripting languages of any era carry dimensions through arithmetic; for a language whose whole subject matter is sensor data, it is exactly the right choice.

Vectors and matrices are primitives. var.v = [1,-3,2] cm and var.v = 1i -3j +2k both work, var.m = p5.RotMat pulls a 3x3 rotation matrix out of the glove driver, and . is the dot product. Orientation maths is the daily work of input emulation, and it is built in rather than bolted on.

Time-aware functions are first-class. Delta(x) reports how much a value moved since the previous frame; Smooth(x) averages over frames to damp out hand tremor; Pressed, DoubleClicked and HeldDown turn a continuous signal into discrete events; wait 100 ms suspends only the macro containing it, not the script. DeadZone(joy.x, 10%) and MapRange(x, a, b, c, d) cover the two adjustments every controller mapping needs. These functions encode the difference between raw sensor output and something a game can be played with, and they are the reason a useful GlovePIE script is usually under twenty lines.

Output is equally direct. Assigning to a key name presses it. Type("hello") sends a string. Say speaks through the Windows speech synthesiser, and Said(...) reads back from the recogniser, so voice commands are just another input column. SendOsc(ip, port, address, ...) puts a value on the network. MIDI, joystick axes through the PPJoy driver, force feedback, multiple independent mouse cursors and even Wiimote memory pokes are all reachable from the same flat namespace.

Growth by accessory

GlovePIE’s version history is a fossil record of consumer input hardware. Versions 0.21 and 0.22 added support for professional gear - Polhemus, Ascension, Intersense and WorldViz trackers, 5DT and FakeSpace gloves, the eMagin Z800 headset, and Concept 2 rowing machines. Then, in late 2006, the Wii arrived, and everything changed.

The Wii Remote was a Bluetooth HID device that any PC could pair with, and it was among the first mass-market motion controllers. Wiimote support landed in version 0.22, with Kenner’s own site announcing it on 3 December 2006, a fortnight after the console launched. From then on the changelog reads as a chase: across versions 0.23 through 0.28 came multiple Wiimotes, sensor-bar handling, the Nunchuk, the Classic Controller, calibration, battery reporting and the Wiimote speaker; 0.29 added the WiimoteScripts folder; 0.30 brought the PlayStation 3 SIXAXIS and TrackIR emulation; 0.40 added MotionPlus, gesture recognition and the Balance Board; 0.43 added drum kits and DJ Hero turntables; and 0.45 built in the Kinect. The changelog does not always pin a feature to a single version, so the version each accessory first appeared in is approximate.

The audience changed with it. A tool written for a few hundred owners of a discontinued VR glove became the default answer, for several years, to “how do I use my Wiimote on my PC” - and, after the Kinect was opened up in late 2010, to the same question about skeleton tracking.

The licence

GlovePIE’s licence is one of the strangest attached to widely used software, and it is part of why the project is remembered. Beyond the ordinary terms, it forbade any military use whatsoever - including on a military base, and including recruitment games such as America’s Army - and prohibited export to or use in Israel until stated political conditions were met. This was not merely written down: according to the 0.19 release notes, the “boycott of Israel is enforced by code,” and 0.40 lists “improved copy protection (to stop it running in Israel)” as a feature. A separate clause forbade using GlovePIE to cheat in online games, on the practical grounds that bans would hurt everyone trying to play with a glove, and another singled out NaturalPoint, whose TrackIR protocol GlovePIE emulated, prohibiting them from studying the program in any way.

Kenner also never released the source. That decision, more than anything else, determined what happened next.

Dormancy and preservation

Development stopped in early 2012. Version 0.45 on 31 December 2011 was the last full release; the 0.46 build that followed days later was a targeted patch for a Wiimote hardware revision, offered with Kenner’s own note that he did not know whether it would work. Then glovepie.org went down.

What was left was a closed-source Windows executable, built with a 2000s-era Delphi toolchain, depending on Bluetooth stacks and driver models that Windows has since changed repeatedly. A GitHub preservation project began in November 2019, re-hosting the surviving builds from 0.28 through 0.46 and copying the manual into a wiki before the original pages decayed further. A companion effort is attempting to reconstruct source code from the binary, with the explicit reasoning that a program nobody can rebuild will eventually stop running on a supported operating system.

The language’s ideas outlived the binary. FreePIE, an open-source Programmable Input Emulator whose README describes itself as “very similar to the popular utility GlovePIE, but encourages open development and integration with any device,” reproduces the same frame-loop, assignment-driven model with Python as the scripting layer.

Why it matters

GlovePIE is a case study in the value of a small domain-specific language over a configuration screen. Every competing solution of the era - vendor utilities, per-game profile editors - gave you a table of source-to-destination mappings. Kenner gave you expressions, and the difference is qualitative: you can write a dead zone, an exponential response curve, a smoothed accelerometer tilt, a chord of three keys triggered by a gesture, a mouse cursor whose speed depends on how far your hand has moved since the last frame. None of those fit in a table.

It also demonstrates, less happily, what closed source does to a tool that a community depends on. The language design was good enough that a Python-based successor copied it. The implementation was locked in a binary, and when its author moved on, the only options left were archaeology and reverse engineering - which is, in the end, why it is worth a page here.