The history, the technology, and how it's still used today — a deep dive for anyone browsing this collection.
On this page
MIDI stands for Musical Instrument Digital Interface. It's important to be clear about what it is not: MIDI does not carry audio. A MIDI file or MIDI cable never contains a recorded waveform the way an MP3 or WAV file does.
Instead, MIDI is a messaging protocol — a compact, structured way of describing musical performance instructions: which note was pressed, how hard, when it was released, which instrument should play it, how the pitch bent, which knob got turned. It's closer to sheet music than to a recording — a set of instructions that some sound-producing device (a synthesizer, a sampler, a software instrument) then has to interpret and turn into actual sound.
That distinction is the reason a 3–5 minute song can be stored in a MIDI file that's often just a few kilobytes, versus several megabytes for the same song as audio — and it's why every song in this collection can be played, re-instrumented, sped up, or transposed on the fly rather than just streamed back verbatim.
Before 1983, electronic instruments were an island-hopping mess. Early synthesizers from Moog, ARP, Sequential Circuits, Roland, Oberheim, Korg, and Yamaha could each be voltage-controlled or clock-synced in their own proprietary way — a Roland could usually only talk to another Roland, if that. Musicians who wanted to layer or sequence gear from different manufacturers were mostly out of luck.
Dave Smith, founder of Sequential Circuits (maker of the Prophet-5), had already built one of the first practical microprocessor-controlled polyphonic synths. In 1981, together with engineer Chet Wood, he wrote a paper for the Audio Engineering Society proposing a "Universal Synthesizer Interface" (USI) — a standardized digital connection that any manufacturer's instrument could use to talk to any other.
Smith took the idea to Japan and worked with engineers from Roland, Yamaha, Korg, and Kawai to refine it. Roland's founder, Ikutaro Kakehashi, was a driving force on the Japanese side — pushing hard for an open standard that no single company controlled, which is a big part of why MIDI succeeded where earlier proprietary sync systems hadn't. The proposal was renamed MIDI along the way.
At the 1983 Winter NAMM show, Smith and Roland engineer Tom Oberheim (of Oberheim Electronics) publicly connected a Sequential Circuits Prophet 600 to a Roland JP-6 with a MIDI cable — pressing a key on one and having the other respond. It worked, in front of the industry that had to agree to adopt it.
The MIDI 1.0 Detailed Specification was published in August 1983. In 1984 the manufacturers formed the MIDI Manufacturers Association (MMA) to maintain and extend the standard going forward (today its international counterpart is AMEI, the Association of Musical Electronics Industry, in Japan).
MIDI 1.0 is a simple, asynchronous serial protocol. Physically, classic MIDI hardware ports run at 31,250 bits per second over a 5-pin DIN connector (only 3 of the 5 pins actually carry current, using an opto-isolated current loop so devices don't need a shared electrical ground). A single MIDI cable carries up to 16 channels at once, so one connection can address 16 independent instrument parts simultaneously.
Every MIDI message is built from bytes where the top bit tells the receiver what kind of byte it's looking at: a status byte (top bit = 1) says what type of message follows and which channel it targets, and one or more data bytes (top bit = 0, so 0–127) carry the actual values. A "running status" optimization lets a sequence of same-type messages skip repeating the status byte, saving bandwidth on a link that (by modern standards) is very slow.
These are the workhorse messages — the ones that actually describe a performance:
| Message | Status nibble | Carries |
|---|---|---|
| Note On | 0x9n | note number (0–127, middle C = 60) + velocity (how hard it was struck, 0–127) |
| Note Off | 0x8n | note number + release velocity |
| Polyphonic Key Pressure | 0xAn | per-note aftertouch — pressure applied to an already-held key |
| Control Change (CC) | 0xBn | controller number (0–127) + value — modulation wheel, volume, pan, sustain pedal, etc. |
| Program Change | 0xCn | which instrument patch (0–127) the channel should use |
| Channel Pressure | 0xDn | a single aftertouch value applying to the whole channel |
| Pitch Bend | 0xEn | a 14-bit value (two data bytes combined) for smooth pitch sliding |
n in the status nibble is the channel number (0–15), which is exactly why MIDI 1.0 tops out at 16 channels per cable — a channel number only gets 4 bits to live in.
Control Change messages are extensible by controller number; a handful are standardized enough that virtually every synth respects them:
| CC# | Purpose |
|---|---|
1 | Modulation wheel |
7 | Channel volume |
10 | Pan |
11 | Expression |
64 | Sustain pedal (on/off) |
120–127 | Channel mode messages — all sound off, reset all controllers, local control, all notes off, omni/mono/poly mode |
Alongside per-channel messages, MIDI defines System Common and System Real-Time messages used to keep multiple devices in sync: MIDI Clock (a steady tempo pulse), Start/Continue/Stop, Song Position Pointer, and MIDI Time Code (MTC, a way of transmitting SMPTE-style timecode for syncing to video or tape).
There's also System Exclusive (SysEx) — messages bracketed by 0xF0 ... 0xF7 that let a manufacturer send arbitrary, device-specific data: full patch dumps, deep synth-editor parameters, firmware, anything the standard messages don't cover. Every manufacturer gets a registered ID byte so devices can recognize and ignore SysEx that isn't meant for them.
The files in this collection are Standard MIDI Files — the 1985 format for saving a MIDI performance to disk. A .mid file is a small binary container made of "chunks":
MThd) declaring the format type and timing division:
MTrk), each a stream of (delta-time, event) pairs — the delta-time says how many ticks to wait since the previous event before this one fires.Besides ordinary MIDI channel events, a file can contain meta-events that only exist inside files (never sent over a live cable): tempo (microseconds per quarter note — which is how a fractional BPM gets expressed exactly), time signature, key signature, track/instrument names, lyrics, markers, and end-of-track.
Because a file only stores note numbers, velocities, timing, and instrument numbers — not a single sample of audio — even a dense, multi-instrument arrangement compresses down to a few kilobytes. That's the whole reason a collection of this size can exist as plain files rather than needing enormous audio storage.
Program Change messages select "instrument 42" on a channel, but MIDI 1.0 on its own never said what instrument 42 actually was — every manufacturer's synth had its own patch list. General MIDI (GM) fixed that by standardizing all 128 program numbers to a fixed instrument list (1 Acoustic Grand Piano, 25 Nylon Guitar, 41 Violin, and so on) split into instrument families, plus a standard drum map on channel 10 where specific note numbers always mean specific percussion sounds (note 36 = Bass Drum, 38 = Acoustic Snare, 42 = Closed Hi-Hat, etc.).
GM guarantees that a file requests the same instrument everywhere. It does not guarantee the same instrument sounds the same everywhere — a "Grand Piano" rendered by a 1990s Roland sound module, a SoundFont bank, and a modern software synth can sound quite different, because GM standardizes the note/instrument mapping, not the actual timbre or synthesis method.
This is exactly why this site lets you pick a playback engine. Switching between the site's Tone.js, SoundFont, and FluidSynth players plays the identical underlying MIDI data — same notes, same timing, same instrument numbers — through different sound-generation engines, so the same song can sound noticeably different depending on which one is rendering it. That's General MIDI's device-independence working as designed: the file just carries the instructions.
Beyond playing notes, MIDI grew a family of specialized uses built on the same wire:
The 5-pin DIN port is now mostly a legacy option; MIDI itself moved onto newer transports without changing its core message format:
Ratified in January 2020, MIDI 2.0 is the first major architectural revision since 1983 — and it was designed to be backward-compatible, so MIDI 1.0 gear keeps working forever. Devices negotiate up to the newer protocol automatically using MIDI-CI (Capability Inquiry); if the other end doesn't support it, everything just falls back to MIDI 1.0.
Adoption has been gradual: operating-system-level support (Windows, macOS/Core MIDI, Android) and a growing number of controllers and software instruments now speak MIDI 2.0, but the installed base of MIDI 1.0 gear — and the millions of MIDI 1.0 files already in the world, including this whole collection — means the original protocol isn't going anywhere.
Very few pieces of 1980s consumer electronics standards are still in daily, unmodified use over 40 years later. A few reasons MIDI is: