For most of a decade, GlovePIE was the answer to "how do I use this weird input device for music on Windows". It read Wiimotes, joysticks, gamepads, dance mats and gloves, it had its own scripting language, and it could emit MIDI directly. Then its author moved on, the original site stopped answering, and a generation of tutorials became links to nowhere. If you have arrived here from one of those tutorials, this piece covers three things: where the builds actually survive, what honestly replaces each half of GlovePIE today, and how to port an old .PIE script without losing behaviour you forgot was in there.
- Unmaintained. The preservation repo's own README says the creator stopped maintaining it and the original site went down.
- Builds survive on GitHub in the GlovePIEPreservation repository, from 0.28 through 0.46.
- It was two tools — a device reader and a scripting language. No single modern tool is both.
- Device half: a maintained gamepad-to-MIDI bridge. Logic half: in-DAW scripting or a rules engine.
- Windows only, always was. Mac and Linux users following a GlovePIE tutorial are on the wrong path from line one.
Is GlovePIE still maintained?
No — the community preservation repository states plainly that the original creator stopped maintaining it and that the original site went down.
You can read that sentence yourself in the repository description at github.com/GlovePIEPreservation/GlovePIE: "The original creator stopped maintaining it and the original site went down. I have uploaded my copy so people can continue using it." The repository was created in October 2018 and last received a push in March 2024 — but that push is archival housekeeping, not development. Nobody is fixing bugs in GlovePIE.
The original author's download page still exists on Carl Kenner's Google Sites page, and a 2018 snapshot of the old glovepie.org product page survives on the Wayback Machine if you want to see what the project described itself as. Those two links are the closest thing to primary documentation that still resolves.
Where can I still download GlovePIE?
From the GlovePIEPreservation repository on GitHub, which hosts copies of the builds because the original distribution is no longer reliable.
The repository contains directories for GlovePIE-0.28, 0.29, 0.40, 0.41, two variants of 0.42 (with and without Emotiv support), 0.43, 0.45 and 0.46. If your script was written against a specific build — and GlovePIE scripts often were, because function availability changed between versions — that directory listing is how you find the matching one.
Two practical notes before you do. First, you are downloading an unsigned Windows binary from a third-party mirror of an abandoned project; scan it and understand that nobody is accountable for it. Second, mixed reports about behaviour on current Windows builds are exactly what you would expect from software that stopped being tested before those Windows builds existed. There is no vendor to escalate to.
Why does no single tool replace GlovePIE?
Because GlovePIE was two products in one — a universal device reader and a general-purpose scripting language — and the modern ecosystem split those jobs between different tools.
A typical GlovePIE music script did something like: read an axis from a device, apply some arithmetic, decide whether a condition held, and emit a MIDI message. Four distinct responsibilities, expressed in one file. Today:
| GlovePIE responsibility | Modern home | Platforms | Maintained | Honest limitation |
|---|---|---|---|---|
| Read gamepads and joysticks | Universal Controller MIDI, Gamepad MIDI (Pounding Systems) | macOS + Windows + Linux | Yes | Gamepads and pads, not arbitrary exotic HID |
| Read Wiimotes and motion devices | Dedicated Wiimote tooling, or a pad with its own gyro | Varies | Patchy | This is the hardest half to replace one-for-one |
| Emit keystrokes | JoyToKey, AutoHotkey | Windows | Yes | Keystrokes carry no analog value |
| Create virtual MIDI ports | loopMIDI, IAC Driver, ALSA sequencer | Windows / macOS / Linux | Yes | Carries bytes, never changes them |
| Scripted conditional logic over MIDI | Bome MIDI Translator, Reaper JSFX, Max for Live, Logic Scripter | Varies by host | Yes | In-DAW scripting only affects that DAW |
| All of the above in one file | Nothing | — | — | This is the genuine loss, and it is worth naming |
Platform and maintenance status per each project's own site or repository at time of writing. Trademarks belong to their respective owners.
That last row is not a sales pitch for anything. GlovePIE genuinely did something no current tool does, which is let one person write one script that touched any device and any output. The honest trade is that you now get maintained, signed, cross-platform software for each piece, and you pay for it in configuration spread across two or three tools.
What replaces GlovePIE for a PS5 DualSense?
A current bridge, because GlovePIE predates the DualSense entirely and has no concept of its touchpad, gyro, adaptive triggers or its Bluetooth reporting modes.
This is worth stating flatly because people do try. A DualSense will often enumerate as a generic HID device and a GlovePIE script can read some of its axes, which creates the impression that it works. What you are getting is the subset of the controller that looked like a 2008 gamepad: a few axes and buttons, with no touchpad, no motion, no trigger resistance, and no haptics.
What the hardware can actually do, and where we cover it:
- The touchpad as an XY pad — absolute two-axis position, the single most musical input on the pad.
- Adaptive triggers as haptic feedback — MIDI going back into the controller, not just out of it.
- Gyro as a modulation source — written for Joy-Cons but the principle is identical.
- Every DualSense input, itemised — if you are rebuilding a mapping, start from this list.
- Wired versus Bluetooth — the reporting mode changes what the pad exposes.
How do you port an old script without losing behaviour?
One mapping at a time, verified in the DAW before you move to the next — because old scripts contain behaviours nobody remembers writing.
The process that works:
- Read the script and list every output. Grep the file for MIDI calls and keystroke calls. That list is your migration checklist.
- Classify each one. Simple input-to-output mapping, scaled mapping, or conditional logic. The first two port directly to a bridge's mapping editor; only the third needs a scripting home.
- Rebuild the simple ones first. They will be eighty per cent of the file and they will take ten minutes.
- Move conditional logic into the DAW. Reaper JSFX and Max for Live both edit the MIDI stream before any instrument sees it. Our JSFX processor walkthrough and Max for Live device guide build working examples.
- Test with the old rig still available. Do not uninstall anything until the new chain has survived a real session.
Does GlovePIE work on Windows 11?
Reports are mixed and there is no vendor to ask, so treat any success on a current Windows build as luck rather than support.
The deeper issue is that Windows input itself has moved on. Microsoft's current guidance points developers at GameInput in the Game Development Kit, which supersedes the XInput-era world GlovePIE was written for. Tools built against the newer API see controllers that older tools cannot, and handle hot-plug and multiple pads properly. We go into what changed in GameInput versus XInput for MIDI work.
What about the Wiimote half?
That is the genuinely hard gap, and we are not going to pretend a gamepad bridge fills it.
GlovePIE's Wiimote support was its single most distinctive feature and a lot of 2008-era music-tech experimentation ran on it. If a Wiimote specifically is your instrument, you are in preservation territory: old builds, old pairing stacks, and a lot of patience. We wrote up what is still achievable in the Wii Remote MIDI guide.
The pragmatic alternative is that the motion sensing people wanted from a Wiimote now ships inside mainstream controllers. A DualSense and a Switch Pro pad both have gyroscopes, both are current hardware with current drivers, and both are supported by maintained software. That is a different instrument rather than the same one, but it is one you can still buy and still get fixed.
What did GlovePIE get right that modern tools should copy?
One file, one syntax, every device and every output — a flatness that current tooling has mostly lost.
Three design decisions stand out even now. It treated every input source identically, so adding a new device meant learning a name rather than a new tool. It had no project format to speak of, so a script was shareable as plain text and readable by anyone. And it applied changes immediately, with no compile and no reload, which made experimentation almost frictionless.
Modern equivalents trade those properties for maintenance, signing, cross-platform support and controllers that did not exist in 2009. That is a trade worth making, but it is a trade, and anyone who used GlovePIE heavily is entitled to notice what went missing. The part most worth preserving is the plain-text, human-readable configuration — a mapping you can open in a text editor is a mapping that outlives the software that made it.
Why did a tool this useful stop being maintained?
Because it was one person's project, and one-person projects end — usually quietly, and usually without a handover.
That is worth saying plainly rather than treating as a scandal, because the same pattern runs through this entire software category. Two of the three best-known open-source gamepad MIDI projects on GitHub are archived. The abandoned-project problem here is structural, not accidental: reading input devices means tracking operating system APIs, driver models, permission systems and controller firmware, all of which change on someone else's schedule. A tool that reads HID is signing up for permanent maintenance in exchange for, usually, no money.
The practical lesson for anyone building a rig is to treat the maintenance status of an input tool as a first-class specification, alongside features and price. Ask three questions before you adopt anything in this layer: when did it last ship, who is accountable when it breaks, and what happens to my mappings if it disappears. The third one is why an open, readable preset format matters more than it sounds — a mapping you can read in a text editor outlives the software that wrote it.
We go through the same question for the GitHub projects in the open-source survey, which includes a two-minute checklist for evaluating a repository before you spend an evening on it.
What did GlovePIE scripts actually look like?
Short, readable, and deceptively powerful — which is exactly why people are still reluctant to give them up.
A typical music script was a handful of assignment lines evaluated continuously in a loop. Read a joystick axis, scale it, assign it to a MIDI control. No event handlers, no callbacks, no build step — you edited a line and the behaviour changed immediately. For a lot of people this was their first and only experience of programming, and it is genuinely a good design for the problem.
The modern equivalents split along the same lines the tool did. A mapping editor replaces the assignment lines: pick an input, pick an output, set a range, done, and nobody has to learn a syntax. In-DAW scripting replaces the conditional parts, with the significant advantage that the processing happens inside the host's timeline rather than in a separate polling loop that knows nothing about tempo or transport state.
If you miss the immediacy specifically — the edit-a-line-and-hear-it loop — the closest current experiences are Reaper JSFX, which recompiles as you type, and live-coding environments like Sonic Pi or Orca, both of which take gamepad input happily and were built around exactly that feedback loop. That is a different tool from GlovePIE, but it scratches the same itch, and both are maintained.
What should you do about an old tutorial that links to glovepie.org?
Treat it as a description of a technique rather than a set of instructions, and translate the technique to current tools.
Most of those tutorials are still useful documents. The parts that age badly are the download link and the exact function names; the parts that age well are the musical ideas — which input suits which parameter, how to scale a trigger so it feels right, why you put navigation on the d-pad. Read the tutorial for those, then build the mapping in something maintained.
Two specific translation notes. First, where a tutorial tells you to install a virtual MIDI cable, check whether your current tool creates its own port — many do now, and installing a redundant driver adds a failure point. Second, where a tutorial sets a polling interval, do not copy the number: it was chosen for 2009 hardware. Our latency comparison covers what poll rates mean today, and the routing chain guide covers the case where everything is connected and it still feels sluggish.
FAQ
Is GlovePIE still maintained?
No — the community preservation repository on GitHub states plainly that the original creator stopped maintaining it and the original site went down, and the preserved builds stop at GlovePIE-0.46.
Where can I still download GlovePIE?
The GlovePIEPreservation repository on GitHub hosts copies of the builds from 0.28 through 0.46, which exists specifically because the original distribution site is no longer reliably reachable.
What is the modern equivalent of GlovePIE for MIDI?
There is no single equivalent, because GlovePIE was both a device reader and a scripting language — a maintained gamepad bridge covers the device half and in-DAW scripting such as Reaper JSFX or Max for Live covers the logic half.
Does GlovePIE work on Windows 11?
Reports are mixed and there is no vendor to ask, since the project has had no maintainer for years, so treat any success on a current Windows build as luck rather than support.
Does GlovePIE run on macOS or Linux?
No, GlovePIE is a Windows-only application and was never ported, so Mac and Linux users looking at GlovePIE tutorials need a different tool entirely.
What replaces GlovePIE for a PS5 DualSense?
A current gamepad bridge, because GlovePIE predates the DualSense and has no knowledge of its touchpad, gyro, adaptive triggers or its Bluetooth reporting modes.
The short version
GlovePIE earned its reputation and then stopped being maintained, which is a normal end for a one-author project and not a scandal. Keep your script, keep a copy of the build from the preservation repo if you are sentimental, and rebuild the actual behaviour on tools that still ship updates. The device half is a solved problem on all three operating systems now, which it was not in 2008.
Download Universal Controller MIDI free and port your single most important mapping first. Free tier is one controller, one virtual port and three saved presets; Pro is AUD $89 one-time and adds the full mapping editor, multi-controller routing, MPE and OSC. Next: the state of open-source gamepad MIDI projects.