- https://en.wikipedia.org/wiki/MIDI - short for Musical Instrument Digital Interface) is a technical standard that describes a protocol, digital interface and connectors and allows a wide variety of electronic musical instruments, computers and other related devices to connect and communicate with one another. A single MIDI link can carry up to sixteen channels of information, each of which can be routed to a separate device.
MIDI carries event messages that specify notation, pitch and velocity, control signals for parameters such as volume, vibrato, audio panning, cues, and clock signals that set and synchronize tempo between multiple devices. These messages are sent via a MIDI cable to other devices where they control sound generation and other features. This data can also be recorded into a hardware or software device called a sequencer, which can be used to edit the data and to play it back at a later time 4 Advantages of MIDI include compactness (an entire song can be coded in a few hundred lines, i.e. in a few kilobytes), ease of modification and manipulation and choice of instruments.
- MIDI's Creator Finally Steps Into the Spotlight - Dave Smith
- MIDI From The Inside - Jeff Rona
- https://en.wikipedia.org/wiki/Black_MIDI - a music genre consisting of compositions that use MIDI files to create a song remix containing a large number of notes, typically in the thousands, millions, billions, or even trillions. People who make black MIDIs are known as blackers. However, there are no specific criteria of what is considered "black"; as a result, finding an exact origin of black MIDI is impossible.
- -1510.01806- Music Viewed by its Entropy Content: A Novel Window for Comparative Analysis - Polyphonic music files were analyzed using the set of symbols that produced the Minimal Entropy Description which we call the Fundamental Scale. This allowed us to create a novel space to represent music pieces by developing: a) a method to adjust a description from its original scale of observation to a general scale, b) the concept of higher order entropy as the entropy associated to the deviations of a frequency ranked symbol profile from a perfect Zipf profile. We called this diversity index the "2nd Order Entropy". Applying these methods to a variety of musical pieces showed how the space of "symbolic specific diversity-entropy" and that of "2nd order entropy" captures characteristics that are unique to each music type, style, composer and genre. Some clustering of these properties around each musical category is shown. This method allows to visualize a historic trajectory of academic music across this space, from medieval to contemporary academic music. We show that description of musical structures using entropy and symbolic diversity allows to characterize traditional and popular expressions of music. These classification techniques promise to be useful in other disciplines for pattern recognition and machine learning, for example.
- Somascape : MIDI Ways - Introductory guide to MIDI
- YouTube: The Basics of MIDI - Presented by Alesis (1991). Featuring Craig Anderton with Steve Smythe. This is an instructional video that was made in 1991 to help musicians better understand how MIDI (Musical Instrument Digital Interface) works. You won't find any computer monitors, software plugins or DAW's in this video. Most MIDI configurations back in the day were point-to-point device communication. However, many of these basic MIDI concepts still remain today.
- Tobi Wulff: Control All Your Programs with MIDI Controllers
- The MIDI Specification is published by the MIDI Manufacturer's Association, ie, MMA (although this online document gives you the same information for free, in easier-to-understand language, and in many cases, with even more detail than the official document).
MIDI is an asynchronous serial interface. The baud rate is 31.25 Kbaud (+/- 1%). There is 1 start bit, 8 data bits, and 1 stop bit (ie, 10 bits total), for a period of 320 microseconds per serial byte. The MIDI circuit is current loop, 5 mA. Logic 0 is current ON. One output drives one (and only one) input. To avoid grounding loops and subsequent data errors, the input is opto-isolated. It requires less than 5 mA to turn on. The Sharp PC-900 and HP 6N138 optoisolators are satisfactory devices. Rise and fall time for the optoisolator should be less than 2 microseconds.
The standard connector used for MIDI is a 5 pin DIN. Separate jacks (and cable runs) are used for input and output, clearly marked on a given device (ie, the MIDI IN and OUT are two separate DIN female panel mount jacks). 50 feet is the recommended maximum cable length. Cables are shielded twisted pair, with the shield connecting pin 2 at both ends. The pair is pins 4 and 5. Pins 1 and 3 are not used, and should be left unconnected.
A device may also be equipped with a MIDI THRU jack which is used to pass the MIDI IN signal to another device. The MIDI THRU transmission may not be performed correctly due to the delay time (caused by the response time of the opto-isolator) between the rising and falling edges of the square wave. These timing errors will tend to add in the "wrong direction" as more devices are daisy-chained to other device's MIDI THRU jacks. The result is that there is a limit to the number of devices that can be daisy-chained.
- MIDI Technical Fanatic's Brainwashing Center - a cyberplace dedicated to those individuals who wish to attain a higher level of existence than that of the plodding, MIDI-illiterate scum around them. Here, you will find MIDI technical documents and programming information, MIDI tutorials which explain various MIDI topics in easy-to-understand terms, MIDI software tools, examples of some very good uses of MIDI (in the form of well-constructed MIDI sequencer files), and blueprints for the surgical installation of a MIDI jack upon the human body so that a musician can directly communicate with his MIDI gear.
- MIDI.org: Summary of MIDI Messages
- MIDI Ref - a quick overview and a reference guide
- Complete MIDI 1.0 Detailed Specification v. 96.1 3rd Ed. (PDF) - The Complete MIDI 1.0 Detailed Spec.pdf
- MIDI - status codes - MIDI Status & Data Bytes
Blank midi files:
MThd^@^@^@^F^@^@^@^A^A<E0>MTrk^@^@^@^R^@<FF>^C Pattern 1<9E>^@<FF>/^@ # generated by non-sequencer MThd^@^@^@^F^@^@^@^A^A<80>MTrk^@^@^@^S^@<FF>X^D^D^B^X^H^@<FF>Q^C^HR<AE>^@<FF>/^@" # generated by onlinesequencer.net (thanks to holstein via IRC!)
- MIDI Key Number Chart - There are TWO conventions for numbering keys (notes) in MIDI. The most common is the one below where MIDDLE C (note #60; $3C) is C3 (C in the 3rd octave). However, another convention was adopted by Yamaha Corp. for their synthesizer products which parallels the Octave Designation System used in Music Education formulated by the Acoustical Society of America. In that convention, Middle C is designated "C4". The "C3 Convention" is the most commonly used octave designation system on standard MIDI keyboards and this is the convention we will use for this class.
- https://github.com/milasudril/midi-constants - An unofficial MIDI SDK. This repository contains all (General)MIDI constants in semicolon delimited text files.
CCs (Continuous Controllers)
- MIDI Continuous Controllers - MIDI CC
A MIDI continuous controller command consists of the MIDI controller command followed by two data bytes that specify the controller number and the controller's value:
0xb0 | channel = MIDI continuous controller command 0 .. 127 = MIDI continuous controller number 0 .. 127 = MIDI continuous controller value
- MIDI.org: CC messages
"I tend to favor using 74 (filter cutoff), 71 (Resonance) 91 (Reverb) and 93 (Chorus) as these are widely adopted by many hardware and software synths."
Undefined CCs: 3, 9, 14-15, 20-31, 85-90, 102-119
- https://en.wikipedia.org/wiki/MIDI_timecode - (MTC), or MIDI time division, embeds the same timing information as standard SMPTE timecode as a series of small 'quarter-frame' MIDI messages. MTC allows the synchronisation of a sequencer or DAW with other devices that can synchronise to MTC or for these devices to 'slave' to a tape machine that is striped with SMPTE. For this to happen a SMPTE to MTC converter needs to be employed.
- https://en.wikipedia.org/wiki/MIDI_beat_clock - also known as MIDI timing clock or simply MIDI clock, is a clock signal that is broadcast via MIDI to ensure that several MIDI-enabled devices such as a synthesizer or music sequencer stay in synchronization. Unlike MIDI timecode, the MIDI beat clock is tempo-dependent. Clock events are sent at a rate of 24 ppqn (pulses per quarter note). Those pulses are used to maintain a synchronized tempo for synthesizers that have BPM-dependent voices and also for arpeggiator synchronization. It does not transmit any location information (bar number or time code) and so must be used in conjunction with a positional reference (such as timecode) for complete sync. Because of limitations in MIDI and synthesizers, devices driven by MIDI beatclock are often subject to clock drift. For this reason, it is a common practice on equipment that supports another clock source such as ADAT or wordclock to use both that source and MIDI beatclock.
"In MIDI notes are measured in pulses rather than in time. The note start time and duration will be a discrete number of pulses. Pulses per quarter note can be found in the header part of the MIDI file and specifies how many midi pulses make up one quarter note. This is useful for determining note values - if the current PPQN is 96 and a note's duration is 48 we know that it's a quaver. It's also vital for determining the rate at which the MIDI file should be played. The tempo tells us how long each pulse should last. The BPM measures how many quarter notes happen in a minute. To work out the length of each pulse we can use the following formula: Pulse Length = 60/(BPM * PPQN)"
- JACK MIDI Clock — Utility to send MIDI Clock pulses that follow the JACK Transport.
- https://github.com/x42/mclk.lv2 - MIDI Clock and MIDI realtime-message generator. It can run freely with dedicated BPM, start/stop/continue controls or generate MIDI Clock using host-provided musical time. mclk.lv2 supports Transport, Song-Position and MIDI Clock and allows to only generate a subset.
- https://github.com/widdly/midiclock - OSC controlled ALSA midi clock source. Receive OSC messages on localhost.. /tempo i, /start, /stop, /continue. Send MIDI clock messages via ALSA midi port.
- https://github.com/ambinaut/click-track-to-MIDI-clock-converter - listens to incoming click track and creates a MIDI clock signal.
- https://en.wikipedia.org/wiki/MIDI_Machine_Control - MMC, a subset of the MIDI specification, provides specific commands for controlling recording equipment such as multi-track recorders. MMC messages can be sent along a standard MIDI cable for remote control of such functions as Play, Fast Forward, Rewind, Stop, Pause, and Record. These are "System Exclusive" (SysEx) messages, specifically Real Time Universal SysEx messages.
- https://en.wikipedia.org/wiki/General_MIDI - or GM is a standardized specification for music synthesizers that respond to MIDI messages. GM was developed by the American MIDI Manufacturers Association (MMA) and the Japan MIDI Standards Committee (JMSC) and first published in 1991.
While MIDI 1.0 by itself provides a communications protocol which ensures that different instruments can interoperate at a fundamental level (e.g., that pressing keys on a MIDI keyboard will cause an attached MIDI sound module to play musical notes), GM goes further in two ways: it requires that all GM-compatible synthesizers meet a certain minimal set of features, such as being able to play at least 24 notes simultaneously (polyphony), and it attaches specific interpretations to many parameters and control messages which were left under-specified in the MIDI 1.0 spec, such as defining instrument sounds for each of the 128 possible program numbers.
- https://github.com/polluxsynth/xtor - an editor for MIDI synthesizers (or indeed any MIDI device), currently configured (solely) for the Waldorf Blofeld. If offers two way communication of both single parameter changes as well as complete patch dumps, thus both operating as a visualization as well as graphical editor.
- https://github.com/Manuel-K/SimpleSysexxer - a universal tool to exchange MIDI system exclusive data (aka SysEx) with digital musical instruments. Personal copy with minor changes.
- https://github.com/linuxmao-org/sysexxer-ng - A universal tool to exchange MIDI system-exclusive data.It's a rewrite from scratch of sysexxer.
- https://github.com/christofmuc/KnobKraft-orm - free modern cross-platform MIDI Sysex Librarian
- https://github.com/masc4ii/SysexLive - A MIDI sysex transmitter for two or four synths
Sample Dump Standard
- Creating Cakewalk Instrument Definitions - The Cakewalk Pro Audio and Sonar software packages use instrument definition files to allow them to control any hardware MIDI devices that you may have attached to your computer.The most obvious difference that an instrument definition file makes is that you can easily select the full range of sounds provided by your instrument from within a MIDI track's properties dialog box, but the definition also comes into play when you insert controller messages and when you play MIDI drums into a track, as you will see individual drum names instead of note names in the Event View.
- Free and opensource MIDI instrument definition library "MIDIInstrumentLibrary" - "MIDIInstrument library" is free, open source library for creating and editing MIDI instrument definition. It enables you to create and delete MIDI instrument definition, import Cakewalk's Instrument Definition files (*.ins), add, remove, get and set tone names, control-change names, and so on. It provides functions to access each element in MIDI instrument definition.
MIDNAM / MIDDEV
- MIDI Names, Device Types, & Events in XML - MIDINameDocument
- https://github.com/at0m-c/midnam - A repository for .midnam files of devices
- Name That Patch - EMusician - Apple adopted a universal MIDI patch-list management system as part of Core MIDI in Mac OS X. The scheme uses two XML (Extensible Markup Language) documents.
- MIDIDevice Files - MIDIDevice files are used on the Macintosh as a description of a MIDI device or MIDI instrument. MIDIDevice files are found in the folder or subfolder of /Library/Audio/MIDI Devices These files contain xml format text which describes the MIDI devices in your system. If you currently have any of these files, you will usually find that there is one file per device manufacturer (eg. one file for Roland, one for Korg, one for Yamaha, and so on).
- Midnams - Digicake Studio - This page contains many .midnam OSX synth patch names that have been sent to me over the years. If you have done one (or more!) yourself then please email it to me and I will upload it. Option click to download. Any problems feel free to hassle me – I’m often a bit slow to reply but I do eventually! Most of the patches were written specifically for Protools, by Avid Technology, Inc.
- https://github.com/grammoboy2/lscp2midnam - LinuxSampler LSCP to MIDNAM scripts
- https://github.com/AkiyukiOkayasu/pum - a C++ header-only library for USB-MIDI.
- The MIDI Manufacturers Association (MMA) and the Association of Music Electronics Industry (AMEI) announce MIDI 2.0 Prototyping - 
- https://github.com/atsushieno/cmidi2 - a tiny library to process MIDI 2.0 UMP (Universal MIDI Packet).MIDI 2.0 is designed to be allocation free by defining every message in 32bit, 64bit, or 128bit packet, including sysex messages. This library populates those packets simply in integer values. It should be usable within realtime audio applications.
- MIDI.org: MIDI Programming and DIY Tools
- https://github.com/openAVproductions/openAV-Ctlra - a plain C library that supports easily programming with hardware controllers like USB HID devices. Recently controllers have become much more powerful and feature-rich devices, resulting in tight integration between software and hardware controllers. This places a burden on software developers, who must support individual devices. This library makes it easier to access these powerful hardware control surfaces trough a simple API, which exposes buttons, encoders, sliders, and a grid as components of the controller device. The details of the USB HID protocol, and the implementation of the device communication are abstracted.
- https://github.com/gdsports/midiuartusbh - MIDI DIN to MIDI USB Host Converter
- MIDI - Message List - The Unofficial YAMAHA Keyboard Resource Site
- YouTube: Yamaha Styles - The Single Finger Mode
"Example: When the key of 'C' is selected as the Root Note, pressing any white key to the left of it will produce the C7 chord. The C note together with any black key to the left of it will produce a Cm chord. The C key together with any white and black key to the left of it (three keys together) will produce the Cm7 chord."
- Drumroll - allows to play Dream Cheeky USB Roll Up Drum Kit on Linux
- https://github.com/Lt-Henry/gnome-drumroll - User space midi driver and gui for a cheap usb drum
- Terpstra Keyboard - 280 Color Changing Continuous Controllers
- https://github.com/jcard0na/haxo-hw - an electronic musical instrument that resembles a saxophone. It is designed to be an inexpensive and fully customizable travel saxophone. You will never get the same expressiveness or depth of sound of a real saxophone. But with a haxophone you should be able to play alone or with friends wherever you might be. The mechanical keys and unique ergonomics give it a different kind of satisfying feel. 
- MegaDrum - a very powerful yet affordable MIDI drum trigger. It can be used with many varieties of Edrum kits/pads/cymbals and outputs MIDI signals which can be fed to a computer with drum sampling software,e.g. BFD, Toontrack, Addictive Drums, to produce wide variety of drum sounds or it can be connected to a drum machine. It can be compared with Roland TMC-6 but with more inputs and more capabilities. MegaDrum started as DIY project and over time evolved into a a versatile device which can be ordered as a complete module, kit or you can still build it yourself. MegaDrum is fully plug-n-play and is USB MIDI Class Compliant, i.e. will work with Windows, Mac OS X, Linux without additional drivers!
- MidiSizer - Peter Kvitek’s DIY projects webpage. Mostly related to MIDI and Synthesizers at this point. MidiALF, MidiREX, MidiGAL, MidiThru, Midi2CV, etc.
- ECE 4760 - deals with microcontrollers as components in electronic design and embedded control. The course is taught by Bruce Land, who is a staff member in Electrical and Computer Engineering. The course is taught using PIC32 processors. 
- https://github.com/electricityforprogress/MIDIsprout - a Biodata Sonification system, capable of reading microfluctuations in conductivity across the surface of a plant's leaf and translating those changes into MIDI notes.
Want: channel faders, mixer fader, buttons, pots. No keys.
- Controllers.cc - a website for comparing midi controllers and small midi keyboards to help you find the right controller. All of the images and descriptions are from the original product pages.
- https://github.com/ryanlaws/gear-cc-lists-for-tidal - the CC numbers of specific MIDI equipment, in a format intended for TidalCycles
- openMIDI - a community project driven by Morningstar Engineering
- https://github.com/tadfmac/mi-muz - mi:muz avr-core : tiny experimental midi board with attiny841, attiny441, attiny85, attiny45, attiny84, attiny44, atmega8
- https://github.com/mimuz/mimuz-exp2 - a next generation of mi:muz:expr Tiny MIDI experimental board series. It based on STM32F042K6. mi:muz:exp2 is supported easy programming operation by DFU mode, and STM32F0Cube software environment but it does not supported mbed yet.
- https://github.com/mimuz/mimuz-tuch - mi:muz:tuch MIDI Controller with flexible touch keys
- C-Thru Music - We've used the Harmonic Table concept to make two high quality MIDI controllers. They're no longer in production. 
- Hackaday: modulum - A pendulum-based MIDI controller.
- https://github.com/jessecrossen/hautmidi - Experimental MIDI input devices.
- https://github.com/nettings/gpioctl - been written to provide hardware volume control for an audio engine running on the Raspberry Pi, via a rotary encoder connected to the GPIOs. It can directly interact with the ALSA mixer, or you can create JACK MIDI messages to remote-control any JACK MIDI capable client. Since it uses a generic GPIO interface via libgpiod, it might also be useful on other hardware platforms. I cannot test this personally, but your feedback is welcome.
- https://github.com/michele-perrone/OpenMidiSurface - An open source and universal MIDI controller based on the STM32F303VCT6 microcontroller
- https://github.com/dvhdr/launchpad-pro - Open source firmware for the Launchpad Pro grid controller
- https://github.com/charlesfleche/lpd8editor - A linux editor for the Akai LPD8
- MIDIpal - a smart and small MIDI processor. Insert it between a MIDI keyboard (or sequencer) and a MIDI sound module to unleash powerful compositional tools and effects.
- https://github.com/echolox/smartbcr2k - Smart Midi Controller Interface (SMCI). The aim of this project is to create a framework to augment any Midi controllers with more intelligent features like: Simulate more controls than the device actually has; Different behavior and functionality of controls (buttons, dials, etc.) based on Views/Pages; Automation of values (think of LFOs on Control Changes before we even hit the DAW); Save and load snapshots of the current values; Mapping controls to behave like other controls to create Macros; The only requirements for a Midi controller for all of this to work are: Has to allow Control Changes to be sent to the unit for visual feedback (LEDs, motorized faders etc.); Buttons can be set to function in momentary mode, not (just) toggle mode. Prime examples would be Behringer's BCR 2000 and BCF 2000.
- https://github.com/original-male/midipus - an intelligent MIDI switch. One bidirectional ALSA sequencer connection (the head) is switched between multiple bidirectional outputs (the arms) by special, out of band messages. Data arriving on inactive arms is analyzed, compressed, and relayed to the head upon switching. This allows, for instance, a single BCF2000 to control Ardour, envy24control, Rosegarden, ZynAddSubFX and FreeWheeling at once in a paged, exclusive fashion; without any undesirable interaction between clients and without the BCF and the clients' parameter values drifting out of sync. ... Included in this distribution are several SysEx files to automatically reprogram a BCF2000 to work with Midipus.
- Zaquencer - custom firmware for the Behringer BCR2000 that will turn it into a standalone MIDI step sequencer.
- nanoKONTROL2/KORG KONTROL Editor - windows/wine
- https://github.com/royvegard/Nano-Basket - configure midi control codes, nanoKONTROL 1 only
"The LED will light-up or go dark when a message with the control change number or note number that’s assigned to that button is received from the computer. The LED will light-up when an On Value or Note On message is received, and will go dark when an Off Value or Note Off message is received. Don’t forget to set LED mode to external via the Korg software"
- https://github.com/aaronmjacobs/Kontroller - Get input from and control the LEDs of the KORG nanoKONTROL2, c++
- https://github.com/zooxo/midimoc - Shell (bash) script to operate music player (moc) with midi controller (Korg nanokontrol2)
- https://github.com/riban-bw/nanoKONTROL-Config - Configuration tool for Korg nanoKONTROL
- https://github.com/amiguet/pyo-nk2 - python pyo
- https://github.com/paulreimer/ofxNanoKontrol2 - openframework
- https://github.com/davidgranstrom/NanoKontrol2 - supercollider
- https://github.com/Pierousseau/reaper_generic_control - A plugin for Reaper DAW, to use the KORG Nanokontrol2 control surface (and maybe some similar surfaces as well)
- https://github.com/rektide/web-midi-nanokontrol - this library provides utilities to dump and load configuration via web-midi, as well as classes to represent the Scene blobs.
- candor user manual - this linux software enables a monome 256 user to capture and playback audio from up to 8 channels simultaneously, managing a maximum of 48 remembered wav soundfiles without a computer display. it is a client of the Jack Audio Connection Kit (http://jackaudio.org, http://www.monome.org/).
- https://github.com/tttapa/MIDI_controller - This is a library for creating a MIDI controller using an Arduino or Teensy board.
- https://github.com/madskjeldgaard/14bit-midi-teensy-supercollider - An example of a simple 14 bit midi controller setup with Teensy, cpp and SuperCollider
- https://github.com/andr-ew/bleached - small/inexpensive 7-knob teensy midi controller.
- T r i n i t y - Trinity is a universal musical instrument and original sounding modular groovebox. It can function as any type of digital synthesizer, sequencer, controller, arpeggiator or almost anything that can be programmed into a micro-controller. Trinity is designed to be connected and combined with other Trinities of different functions in a chain, so that you can create your own music making environment. It is ready to communicate with the outer world via MIDI and different sync and CV methods using MIDI Bastl.
Livid Builder series
- Livid Builder - a line of Do-It-Yourself parts and components that empowers makers from beginners to experts to envision, design, and assemble their own MIDI control devices. Centered around Livid’s legendary Brain v2 and Brain Jr., these DIY controllers have powered devices from home brew projects to commercially available products and are designed to have you up and running quickly. Create your own physical computing device using buttons, knobs, encoders, drum pads, arcade buttons, joysticks, accelerometers, faders, other sensors, and LED’s. Use the Omni Board to connect components in thousands of configurations using a single circuit board design without the need to do any of your own wiring. Previous devices created have ranged from a MIDI controlled mandolin to a flame organ, the Builder series only limit is your creativity.
In addition to the Brain products, Livid’s online shop stocks parts, components, Builder Box kits, and more so you have everything you need to start building your own controller device today. No experience necessary, our in depth wiki and tutorials provide you with the knowledge you need to become your own inventor.
- https://github.com/ravelox/raveloxmidibox - A self-contained MIDI controller using a Raspberry Pi and raveloxmidi
- YouTube: Building a MIDI Controller
- https://github.com/andr-ew/toes - USB and DIN MIDI foot controller
- https://github.com/cester-ino/Midi_project - Arduino based modular midi system
- https://github.com/neroroxxx/BMC - an all-in-one Scalable MIDI Controller library with a companion Desktop/Browser Editor App specifically designed for the Arduino-Compatible Teensy development Boards. BMC allows you to build your own MIDI Controllers with a mixed number of Buttons/Leds/Encoders/Pots/Relays etc with only a few lines of code!BMC is only available for Teensy LC, 3.2, 3.5, 3.6, 4.0, 4.1.
- https://github.com/gljubojevic/akai-mpk-mini-editor - preset editor is for Akai MPK mini controller using Web MIDI Api.For demo/test go to https://gljubojevic.github.io/akai-mpk-mini-editor/
- https://github.com/PiOverFour/MPK-M2-editor - Alternative to the official AKAI MPKMini MkII Editor
- https://github.com/tsmetana/mpk3-settings - GTK UI to configure Akai MPK mini III MIDI keyboard
- Novation Launch Control XL - old one was the zero-sl-mkii
- NoLaE - Novation LaunchControl Editor, is a Linux tool that acts as a filter/mapper for Novation LaunchControl XL controllers. There is no editor for LaunchControl on Linux and, as far as I can tell, if you don't have a Windows or OSX computer, virtualization won't work with it. It can work with (possibly) any existing mapping already set on the LC, and, much more important, it allows you to set custom midi actions for every controller. NoLaE uses mididings to interface between LC and your MIDI devices. Mididings is a powerful MIDI router and processor based on Python.
- https://gitlab.com/SpotlightKid/launchcontrol - A Python library for controlling Novation Launchpad and Launch Control devices
- https://www.keithmcmillen.com/products/boppad - drum pad
- https://www.keithmcmillen.com/products/quneo - controller
- https://www.keithmcmillen.com/products/qunexus - mini keyboard
- https://www.keithmcmillen.com/products/softstep/ - foot controller
- YouTube: QuNexus General Tutorials + QuNeo masterclass
- FOSDEM 2019 - Building a Hardware MIDI Player - "An exploration of using Go to build a hardware MIDI player, complete with floppy drive, on a minimal Linux distribution, gokrazy. Without our standard system utilities, in this talk we'll explore Go's syscall interface, as well as Linux's other interfaces, such as netlink and kobject. There will also be sweet, sweet chiptunes."
- https://github.com/tttapa/Control-Surface - Arduino library for MIDI control and input.
- https://github.com/Bananut-Electronics/MiDispositivoMIDI_V3 - Open source Arduino MIDI controller.
- https://github.com/Shik-Tech/N32B - N32B Midi controller is an open source hardware and software. We use the arduino pro micro as the heart of the controller. The N32B is basically an arduino shield and easy to solder.
- https://github.com/vonkonow/LEET-Synthesizer - LEET is a modular & affordable ($6) MIDI synth for your favorite DAW.
- https://github.com/frederickk/prost - uses Arduino Pro Micros as intermediary to allow Midi host to Midi host communication.
- https://github.com/notam02/Teensy-Head-Tracker - A DIY head tracker for 3D audio production
- https://github.com/rppicomidi/midi2usbhost - Make a Raspberry Pi Pico a USB Host to bridge modern USB MIDI to old school MIDI IN and MIDI OUT
- https://github.com/rsta2/pico - Some small programs for the Raspberry Pi Pico
- https://github.com/sinedied/pi-midi-host - Setup a Raspberry Pi as a headless MIDI USB host, with auto-connection and MIDI merging of all sources.
- https://github.com/FrankBuss/beat707 - A MIDI sequencer
- https://github.com/kukas/48Knobs - DIY Arduino MIDI controller featuring 48 rotatory potentiometers (knobs). The values are sent out by MIDI CC signals through DIN-5 or USB port. The intended use is to control various software synthesizers but it can be used as a virtual mixer control or as an input device for custom software
- https://github.com/mimuz/mimuz-tuch - a USB MIDI controller with capacitive touch sensor. It has now two indivisual versions, AVR or STM32.
- LambdaControl - based on the MIDIbox project, which provides a complete solution for basic tasks like reading analog and digital inputs (faders, knobs and encoders). However, the RGB button matrix of LambdaControl, which works like the matrix of a Novation Launchpad, required a complete custom development.LambdaControl consists of the following parts: components from the MIDIbox project for the basic I/O and USB MIDI connection (this repository), separate microcontroller which controls the RGB matrix, and a MIDI Remote Script that connects the controller with Ableton Live over USB. Additionally, I created a repository for the hardware parts like the RGB button matrix PCB or the 3D printable case.
- https://github.com/antichambre/MIOS32 - MIOS32 with MCAN, DIPCOREF4 and Dual USB support
- Hackaday.io: DIY EVI-Style Windcontroller - The EVI (Electronic Valve Instrument), a trumpet-style electronic musical instrument in the Wind controller family, was developed in the early 1970s by inventor and musician Nyle Steiner. The EVI is an endangered instrument and the EVI player is an endangered musician. Explore the development of a DIY EVI Windcontroller for survival of this great instrument.
- https://github.com/recri/pennywhistle - MIDI breath controller and synthesizer, Teensy 3.6
Arduino Midi Ribbon Controller
- https://github.com/HanYangZhao/MidiLin - Violin inspired Midi Controller
- Hackaday: Cheap DIY MIDI to USB Adapter
- https://github.com/paradajz/OpenDeck - a platform suited both for prototyping and developing custom MIDI controllers. Platform uses class-compliant USB MIDI which makes it compatible with any MIDI software on any OS. Main part of the platform is board on which various components used to build a MIDI controller can be connected.
- https://github.com/fo-am/midimutant - circuit based for using the Raspberry Pi built in uart as a midi output.
Arduino MIDI Library
- https://github.com/FortySevenEffects/arduino_midi_library - This library adds MIDI I/O communications to an Arduino board.
- https://github.com/lathoub/Arduino-BLE-MIDI - This library implements the BLE-MIDI transport layer for the FortySevenEffects Arduino MIDI Library
- https://github.com/diyelectromusic/RF24MIDI - RF24 MIDI Transport for use with the Arduino MIDI Library and nrf24L01 radios.
- https://github.com/earlephilhower/ESP8266Audio - Arduino library for parsing and decoding MOD, WAV, MP3, FLAC, MIDI, AAC, and RTTL files and playing them on an I2S DAC or even using a software-simulated delta-sigma DAC with dynamic 32x-128x oversampling.
Twisted Pair MIDI Extender
- https://github.com/HanYangZhao/TeensyMidiMerger - Teensy 3.6 bases USB midi merger. Merges midi signal from 4 USB midi devices (using midi host) and outputs via 1 standard midi port as well as teensy usb out
- https://github.com/FeverDreamEmulator/midiRouter - Open-Source Midi RouterThis projects aims to make midi easier to deal with, more accessible, and more affordable for musicians.
- World's Smallest MIDI Synthesizer - It's essentially the same circuit as my synthesizer cable and running the same code. It saps power from the midi signal and outputs sound on a little piezo buzzer. 
- https://github.com/LenShustek/miditones - Convert MIDI files to a simplified time-ordered sequence of note commands
- Ardio - a MIDI synthesizer. It listens on all MIDI channels for regular MIDI data. It is a 16 channel Arduino based audio device.Software and schematics are designed by firstname.lastname@example.org. The PCB design is by Sebastius. One arduino takes care of the MIDI processing, the other two get commands ("play a note on pin x, this frequency") via i2c.
- miniMO – mini synth module - 8-bit Programmable Synthesizer Module
Tang-Nano MIDI Sounder
- https://github.com/kingyoPiyo/Tang-Nano_MIDI_Sounder - a MIDI sounder that operates on the Tang Nano FPGA board equipped with the GW1N-1 FPGA chip. Inputting a 38.4kbps MIDI UART message to pin 18 of the Tang Nano FPGA produces a sound.
See also Sequencer
- uCApps.de - Non-commercial DIY Projects for MIDI Hardware Geeks
- MIDIbox SEQ V4 - 16 Track Live Step and Morph Sequencer + advanced Arpeggiator
- MIDIbox.org Blog - News about MIDIbox Projects
- MIDIbox Knowledge Base - MIDIbox DIY-projects consist of hardware (MBHP) and software (MIOS + Application). Some projects have special designed modules, others only require a Core module. If you have problems understanding the structure of a MIDIbox, just think of your PC: Processor ⇒ PIC18F, Mainboard ⇒ Core Module, Keyboard ⇒ DIN Module, Soundcard ⇒ FM (OPL3) or SID Module
Graphics Card ⇒ DOUT Module (with connected LEDs), Display ⇒ LCD Module (Liquid Crysal Display), BIOS ⇒ the Bootloader, Operating Sytem (Windows, Linux, Macintosh) ⇒ MIOS.hex (MIDIbox Operating System), The application you work with ⇒ for example MB64e.hex, MBSID.hex, MBSeq.hex
- https://github.com/levosos/Arpeggino - an Arduino based MIDI arpeggiator, sequencer, recorder and looper. It supports playing MIDI arpeggios in every scale and pattern, and in many rhythms.When pressing one of the keys, an arpeggio of the respective scale degree will be playing. If not in recording mode, the arpeggio will stop playing once the key is released.
- https://github.com/Beat707/Beat707-Mikro - Open Source Arduino Compatible MIDI Sequencer / Groove Box & Sample Player
- https://github.com/Beat707/Beat707-NXT - Open Source Arduino Compatible MIDI Sequencer
- https://github.com/Beat707/Beat707-MPU - Beat707 MIDI Key Switch, using the ATtiny2313
- Axoloti - a platform for sketching music-DSP algorithms running on standalone hardware.
- Using a Raspberry Pi as a RTP-MIDI Gateway for macOS 
- https://github.com/ravelox/pimidi - a simple proxy to send MIDI NoteOn, NoteOff, Control Change (CC) and Program Change (PC) events from the local machine via RTP MIDI or to receive any MIDI events from a remote source via RTP MIDI and write them to a file.
- Arduino: MIDI Device - This tutorial shows how ho use the 'Native USB port of an Arduino or Genuino Zero, DUE or 101 board as a MIDI device using the Arduino MIDI USB library. The library can be installed using the arduino library manager.
- The Hairless MIDI<->Serial Bridge - Hairless MIDI<->Serial Bridge is the easiest way to connect serial devices (like Arduinos) to send and receive MIDI signals. 100% Free Software. For Mac OS X, Windows & Linux.
- NOTEMIDI - a Linux interface for MIDI output via the RS-232 serial port on notebook (laptop) computers. NOTEMIDI can be used with external MIDI keyboards/sound modules that have a serial interface (such as the Roland Sound Canvas or Yamaha MU-x series sound modules) or the the MIDIator MS-124W Serial-to-MIDI interface. October 10, 2002. NOTEMIDI has been deprecated for a very long time and I no longer support it.
- https://github.com/mixxxdj/hss1394 - High-speed MIDI-over-Firewire device access library for Windows and Mac OSX.
- Advanced Linux Sound Architecture - ALSA provides audio and MIDI functionality to the Linux operating system. ALSA has the following significant features: Efficient support for all types of audio interfaces, from consumer sound cards to professional multichannel audio interfaces. Fully modularized sound drivers. SMP and thread-safe design. User space library (alsa-lib) to simplify application programming and provide higher level functionality. Support for the older Open Sound System (OSS) API, providing binary compatibility for most OSS programs.
- Alsa Opensrc Org - unofficial wiki, Independent ALSA and linux audio support site
aconnect -i # list MIDI input devices aconnect -o # list MIDI output devices
aseqdump -p ## # detect events from keyboard number ##
- http://alsa-project.org/main/index.php/SALSA-Library - SALSA-Lib is a small, light-weight, hot and spicy version of the ALSA library, mainly for embedded systems with limited resources. The library is designed to be source-level compatible with ALSA library API for limited contents. Most of function calls are inlined, and accesses directly to the hardware via system calls. Some components like ALSA sequencer aren't supported, and most of all, the alsa-lib plugins and configurations are completely dropped. Thus, neither dmix nor format conversion is available with SALSA-lib.
ALSA MIDI Raw
- http://linux.die.net/man/1/amidi - amidi is a raw MIDI command-line utility which allows to receive and send SysEx (system exclusive) data from/to external MIDI devices. It can also send any other MIDI commands. amidi handles only files containing raw MIDI commands, without timing information. amidi does not support Standard MIDI (.mid) files.
ALSA MIDI Sequencer
- Advanced Linux Sound Architecture - Sequencer - 1999, Frank van de Pol, Netherlands
The ALSA sequencer interface is designed to deliver the MIDI-like events between clients/ports. A typical usage is the MIDI patch-bay. A MIDI application can be connected arbitrarily from/to the other MIDI clients. The routing between clients can be changed dynamically, so the application can handle incoming or outgoing MIDI events regardless of the devices or the application connections.
The sequencer core stuff only takes care of two things: scheduling events and dispatching them to the destination at the right time. All processing of MIDI events has to be done within the clients. The event can be dispatched immediately without queueing, too. The event scheduling can be done either on a MIDI tempo queue or on a wallclock-time queue.
modprobe snd-seq-dummy # provides virtual 'MIDI Through' loopback port. on by default. sudo rmmod snd_seq_dummy # disable dummy kernel module. doesn't work after boot?
options snd-seq-dummy ports=16 # for extra MIDI Through ports
snd-virmidi driver - convert between ALSA sequencer ports and old OSS raw midi ports # enable
- https://jan.newmarch.name/LinuxSound - programming. book now unavailable online.
- https://github.com/original-male/asspatch - an ALSA Sequencer subscription management daemon. Thisthird-party application automates virtual MIDI connections in your Linuxstudio. 12 years since last commit.
SendMIDI / ReceiveMIDI
- https://github.com/gbevin/SendMIDI - Multi-platform command-line tool to send out MIDI messages
- https://github.com/gbevin/ReceiveMIDI - Multi-platform command-line tool to monitor and receive MIDI messages
- arecordmidi - a command-line utility that records a Standard MIDI File from one or more ALSA sequencer ports. To stop recording, press Ctrl+C.
- KASEQ - ALSA MIDI Kommander is a DCOP interface (inter-process communication daemon used in KDE 3) exposing many ALSA Sequencer features for shell scripts, Kommander scripts, or KDE programs requiring MIDI Sequencer services. A few MIDI utilities have been developed with this tool, which can be used both as programming examples and as real work tools. It depends on KDE 3.x and the Qt library.
- https://github.com/i3149/chimidi - MidiRoulette, Play with a friend, play with a stranger.
- https://github.com/cirlabs/miditime - MIDITime converts any kind of time series data into pitch, attack and duration values based on musical options that you set up, then outputs a .mid file.
- BallSequencer - a sequencer VSTi based around the idea of MIDI messages being generated by balls moving around inside a rectangular area. Notes are triggered whenever a ball collides with the boundary of the rectangle. You can set parameters that will control the movement of each ball, in addition to possible note and velocity values.
- MidiQuickFix - allows you to directly edit the events in a Midi file. It is intended to make it easy to find and fix small problems in a Midi sequence without the need for a complex Midi sequencing program. It has also become a useful Midi and karaoke file player.
- https://github.com/original-male/asspatch - an ALSA Sequencer subscription management daemon. This third-party application automates virtual MIDI connections in your Linux studio. Several graphical patchbays and connection editors exist for the ALSA Sequencer interface. Unfortunately, all suffer from some serious practical limitations--such as insanely complex XML patchbay definitions, lack of working snapshot capability, inability to create common subscription types, and general brain damage.
- FTAP - a Linux-based program (written by Steve Finney) for tapping and music performance experiments. It connects to a standard MIDI input device (e.g., a keyboard or drum pad) for collecting MIDI keystroke data, and sends MIDI signals to a MIDI tone generator or sampler for audio output; MIDI messages are processed with millisecond accuracy and precision. FTAP is described in an article in Behavior Research Methods, Instruments, and Computers (Finney, S.A. (2001a), " FTAP: A Linux-based program for tapping and music experiments", v 33, pp 65-72).
- https://github.com/wdouglass/midictrl - a simple program that adapts midi devices to linux event inputs. It allows the use of a midi controller as a general input device. Right now, we support the AKAI LPD8 drum controller. hopefully we'll support more in the future.
- https://github.com/j4kim/midiscriptor - Control your Linux system with MIDI devices
- https://github.com/chronopoulos/jack-midi-timestamp - a simple timing log for JACK MIDI events
JACK MIDI Commander
- https://github.com/x42/jack_midi_cmd - JACK app to generate custom MIDI messages.
- https://en.wikipedia.org/wiki/RTP-MIDI - also known as AppleMIDI, is a protocol to transport MIDI messages within RTP (Real-time Protocol) packets over Ethernet and WiFi networks. It is completely open and free (no license is needed), and is compatible both with LAN and WAN application fields. Compared to MIDI 1.0, RTP-MIDI includes new features like session management, device synchronization and detection of lost packets, with automatic regeneration of lost data. RTP-MIDI is compatible with real-time applications, and supports sample-accurate synchronization for each MIDI message.
- RTP MIDI: An RTP Payload Format for MIDI - An RTP Payload Format for MIDI
- RFC 4695 - RTP Payload Format for MIDI
- RFC 6295 - RTP Payload Format for MIDI
- https://github.com/davidmoreno/rtpmidid - RTP MIDI (AppleMIDI) daemon for Linux
- https://github.com/folkertvanheusden/frtpm - A simple RTP-MIDI to ALSA gateway/pipe/bridge. Run it somewhere and it can bidirectionally bridge MIDI from/to ALSA to/from RTP-MIDI.
- https://github.com/xitiomet/jack-rtp-midi-bridge - simple way to make JACK stuff talk to Apple MIDI devices.
- https://github.com/ravelox/pimidi - a simple proxy to send MIDI NoteOn, NoteOff, Control Change (CC) and Program Change (PC) events from the local machine via RTP MIDI or to receive any MIDI events from a remote source via RTP MIDI and write them to a file.The reason for writing this was to generate note events from a Raspberry Pi to send them to Logic Pro X. In particular, using the Raspberry Pi to handle input from drum pads. As some people have started to use this, there have been several requests for the ability to send Control Change and Program Change events too. I've included some very basic python scripts for testing.
- TiMidity++ is a software synthesizer. It can play MIDI files by converting them into PCM waveform data; give it a MIDI data along with digital instrument data files, then it synthesizes them in real-time, and plays. It can not only play sounds, but also can save the generated waveforms into hard disks as various audio file formats.
- aplaymidi - a command-line utility that plays the specified MIDI file(s) to one or more ALSA sequencer ports.
aplaymidi -l # get list of MIDI ports aplaymidi -p 24:0 midi_file.mid # play MIDI file on port 24:0
- pmidi - Midi player for ALSA. As you can specify the client and port to connect to on the command line it is also useful for testing ALSA or clients that need to receive sequencer events. This program does not have a graphical display, if you require one then you can use pmidi in conjunction with Takashi Iwai's aseqview program to display the song being played.
- WildMIDI is a simple software midi player which has a core software synthesizer (softsynth) library that can be use with other applications. The WildMIDI library uses Gravis Ultrasound patch files to convert MIDI files into audio which is then passed back to the calling application for further processing or output. The API of the library is designed so that it is easy to include WildMIDI into applications that wish to include MIDI file playback. With multiple MIDI file support you can develop applications to mix several midi files together at the same time and use a different patch set for each MIDI file.
- https://github.com/jerash/jpmidi - a Midi-file player that uses Jack-Midi and synchronises to Jack-Transport.
- https://github.com/dblanchemain/mcMidiPlayer - Midi multichannel file player for Jack. This utility makes it possible to read multichannel files (3,4, ... 8 ...). These files are activated by pressing a Midi key from a keyboard or a midi file. The 128 keys are available. mcMidiPlayer uses libFaust to manage Midi connections and audio outputs via Jack.
- Jack-smf-utils - a set of two utilities - jack-smf-player and jack-smf-recorder - whose purpose is to play and record MIDI streams from/to Standard MIDI Files (i.e. the files with .mid extension) using JACK MIDI. It uses libsmf as a backend.
- https://github.com/jpcima/midiplay - MIDI file player for desktop computer. The program is not named yet. The development is in an early stage, but the program is working well and has many features.It works on Linux and Windows. Probably Mac too.
- AdlMIDI - a commandline program that plays MIDI files using software OPL3 emulation (FM synthesis).
- https://github.com/Wohlstand/libADLMIDI - A MIDI play library with OPL3 (YMF262) emulator
Drumstick Karaoke / kmid2
- Drumstick Karaoke - kmid2, MIDI/karaoke player for Windows, Mac OSX and Linux.
- https://github.com/jpcima/smf-dsp - Advanced MIDI file player for desktop computer
- https://github.com/pedrolcl/Linux-SonivoxEas - for Linux and Qt, is a Linux MIDI Synth library based on the Sonivox EAS Synthesizer published by Google on the Android Open Source Project. It is a real time GM synthesizer without needing external soundfonts, using embedded samples instead. It consumes very little resources, so it may be indicated in Linux projects for small embedded devices.
- http://www.un4seen.com/ - BASSMIDI
- https://github.com/mosmeh/primesynth - SoundFont-powered MIDI synthesizer
- https://github.com/thePurpleMonkey/MIDI-Synthesizer - project requires Python 3 to run.
- https://github.com/Wohlstand/BW_Midi_Sequencer - Header-only MIDI Sequencer code which can play MIDI, XMI and MUS files
- https://github.com/Henrixounez/v-midi - V Midi File Parser / Player
- https://github.com/hselasky/midipp - MIDI Player Pro
- https://github.com/KeppySoftware/OmniMIDI - A fork of the original BASSMIDI Driver by Kode54, with more features.
- https://github.com/mosmeh/primesynth - SoundFont-powered MIDI synthesizer for Windows only
- Ardio - a MIDI synthesizer. It listens on all MIDI channels for regular MIDI data.It is a 16 channel Arduino based audio device.Software and schematics are designed by email@example.com. The PCB design is by Sebastius.One arduino takes care of the MIDI processing, the other two get commands ("play a note on pin x, this frequency") via i2c.
- https://github.com/bwhitman/pushpin - MIDI synthesizer for the Game Boy Color
- https://github.com/SBRK/dsmi - An easy-to-use MIDI library for the Nintendo DS and Apple iPhone.
- https://github.com/MaurizioB/MidiMemo - An automatic MIDI recorder for Linux
- https://github.com/gbevin/MIDITapeRecorder - an open source Audio Unit v3 plugin with a radically different approach towards MIDI recording.MIDI messages are recorded and played back with the same accuracy and precision as audio recordings. Most modern DAWs, even at their highest resolution, still change the timing of MIDI messages to accommodate for their editing features. These changes impact the playback of your performance as MIDI messages get reordered and delayed, causing changes in how they influence sound, sometimes in very significant ways.
- MIDI-utils - This is a set (one for now) of useful MIDI-translation tools for Linux-based Digital Audio Workstations. These tools are mainly simplistic hacks but they do come in handy in some cases. midi2midi - A simple program that translates input MIDI-notes into other MIDI-notes or MIDI CC messages to other MIDI CC messages or even MIDI-notes into Jack Transport commands using small configuration files. The whole purpose for this program being written is that basically all MIDI equipment (at least the ones I own) have their own little quirks. This is just a way to circumvent these quirks.
- usbpiano - Linux ALSA MIDI driver for Dream Cheeky/Dream Link USB Roll-Up Piano
- worked for me: gcc usbpiano.c -o usbpiano -lusb -lasound # compiled program might need to be run as root
- ttymidi - a GPL-licensed program that allows external serial devices to interface with ALSA MIDI applications. The main motivation behind ttymidi was to make Arduino boards talk to MIDI applications without the need to use (or build) any extra hardware.
Linux pSeudo MIDI Input
- Linux pSeudo MIDI Input - simple user-space drivers support using certain homemade, repurposed, or commercial devices as MIDI controllers on Linux. ps/2 keyboard, joystick, mouse, monterey keyboard. ALSA.
- Kbdz (KeyboardZ) is a realtime events framework, dedicated to audio. A daemon (background app) that turns your PC keyboards/mice into MIDI controllers. Uses ALSA Sequencer interface, allowing one to tranform linux event devices to midi controller, to perform transformation (mapping) on the events.
- Shelljam - turn your non-touch-sensitive keyboard and a two-axis MIDI controller (mouse) hardware input into MIDI signals
- https://github.com/Jajcus/badumtss-machine - a little application that converts any Linux input device into a MIDI keyboard. It was created to see if toy percussion set from a Guitar Hero game can be used as electronic drums (it can, not this way).
- https://github.com/midilab/input2midi - Application to remap common HID devices like keyboards, mouse and joysticks into fully MIDI compilant devices.
- https://gitlab.com/IGBC/spacemidi - Midi translator for spacenav compatible 6DoF controllers
Computer keyboard to MIDI
- https://github.com/teknopaul/usbkbd2 - Converts old USB keyboards into midi keyboards
- https://github.com/noedigcode/keytarboard - A small app that translates keyboard presses into Jack MIDI notes. The keyboard is mapped like a guitar, with Shift, Caps Lock, Tab and ` being the open fret notes (E, A, D and G, respectively).
- midikbd - allows the use of the computer keyboard as a simple monophonic MIDI keyboard. Midikbd is monophonic because of the impracticality of detecting KeyUp and KeyDown events in an xterm. If the Space-bar is pressed (or any other ascii-key which does not map to a note), then the current note is stopped; otherwise, each note lasts until the next note is played.
- https://github.com/ovenwerks/midikb - keyboard to JACK MIDI program, fork of actkbd. modular config.
- https://github.com/JunShern/Pyano - A powerful virtual MIDI keyboard (play piano and so much more, with your computer keyboard!).
- YouTube: Jackson Five - I Want You Back Cover on Keyboard(s) - demo
- https://github.com/fps/kmidik - A very very simple virtual midi keyboard app that makes glorious use of global shortcuts
- https://github.com/jhammen/keycode2midi - Simple Linux application that listens on an input device and sends a MIDI note when a keypress is detected
- qwerty-keyboard realtime midi - Press a key and a midi note is sounded. Perl.
- https://github.com/Krasjet/kb - Customizable virtual MIDI keyboard daemon for JACK.
- https://github.com/akapelrud/xkb2midi - xkb (X11) to JACK midi mapping utility that allows you to remap a standard X keyboard device to output specific midi notes over JACK
- https://github.com/gdsports/USBHIDKbd2MIDI - DIY MIDI button controller from QWERTY USB keyboard
Mouse / trackpad
- Ratón - translates mouse movements into MIDI controller messages. Those movements are mapped through a user-defineable curve, which can change the characteristics of the mouse's location. Changing the curve can then expand, contract or step the controller messages to match the specific purpose. Ratón uses the ALSA sequencer MIDI interface, so audio apps such as JACK-rack, MuSE or Rosegarden can use it's controller stream.
- https://github.com/GModal/raton - Raton was a mouse-to-midi continuous controller for the Linux platform I wrote in 2005. It uses alsa midi, was written with Glade2 and requires GTK2.4+ libraries (which are OLD).
- Kontroll - a small utility that generates midi cc messages from the mouse position. It is inspired by the MouseX and MouseY UGens in Supercollider. It simply creates an alsa sequencer port which you can then connect with your favourite patchbay. The mouse position is independent of window focus and is relative to the screen origin at the upper left.
- TouchMIDI - turns your touchpad into a MIDI controller!
- linux-miditouch - The miditouch application was developed for graphic tablets able to generate touch events. Touch events are converted in midi "note on" and "note off" events. The application is by default configured for the Bamboo Touch 2FG low-cost tablet.
- https://github.com/balandinodidonato/LeapMapper - An open-source application to map Leap Motion data into MIDI and OSC messages.
- aseqjoy is a Joystick to ALSA MIDI Sequencer Converter. In fact it’s a really tiny piece of software that turns a joystick into a MIDI controller for the ALSA sequencer infrastructure. Its original purpose was to test the MIDI interface of terminatorX but that turned out to be fun, so it made it here in the hope that it could be useful for other experiments.
- Rejoystick - a program that maps keypresses on your gamepad/joypad/joystick to keypresses on a keyboard when you are running X. Since it uses SDL to communicate with the gamepad device, it can work on every platform that provides SDL and an X environment. (Though it is yet to be tested on Cygwin e.g.)
- https://github.com/AntiMicroX/antimicrox - Graphical program used to map keyboard buttons and mouse controls to a gamepad. Useful for playing games with no gamepad support.
- https://github.com/original-male/lsmi - simple user-space drivers support using certain homemade, repurposed,or commercial devices as MIDI controllers on Linux, even though the devicesthemselves are not capable of generating MIDI messages; this does not includethings like MIDI-over-serial or PIC based projects, which are true MIDIdevices.
- https://github.com/osune/MidiJoystick - a MIDI client for the Jack Audio Connection Kit on Linux, which lets you use your joystick to emit MIDI commands
- https://github.com/hauspie/joy2jack - a tool to convert joystick events to jack midi events. It was developped to use the Wii Rockband Drum USB controller as a virtual MIDI drum kit (using hydrogen or Qsynth for example).
- https://github.com/gretchycat/js2midi - Joystick to midi driver
- Midi Toys - Thumb mixer works with a playstation 2 style controller, a study in user interaction.
- https://github.com/falkTX/nooice - Joysticks as JACK-MIDI devices
- https://github.com/rbdrum2midi/rbdrum2midi - Use your RockBand and Guitar Hero game drumkits as midi controllers.
- https://github.com/brummer10/Mamba - Virtual Midi keyboard for Jack Audio Connection Kit
- jack-keyboard - a virtual MIDI keyboard, allows you to send JACK MIDI events using your PC keyboard. It's somewhat similar to vkeybd, except it uses JACK MIDI instead of ALSA, and the default keyboard mapping is much better - it uses the same layout as trackers (like Impulse Tracker) did, so you have two and half octaves under your fingers.
- https://github.com/jmaibaum/jack-keyboard - Fork of jack-keyboard in order to port it to GTK+3. Check the GitHub Network.
- https://github.com/boomshop/jack-keyboard - Fork of jack-keyboard in order to port it to GTK+3
- Klaviatur - A simple keyboard LV2 plugin with a MIDI output port. Useful for testing synth plugins or patches when you don't have a real keyboard nearby. Provided in ll-plugins.
- https://sourceforge.net/projects/akkeyrdion - Turn your computer keyboard into a chromatic accordion keyboard. Ah, but it already is.. RtMIDI.
- Virtual MIDI Piano Keyboard (VMPK) - a MIDI events generator and receiver. It doesn't produce any sound by itself, but can be used to drive a MIDI synthesizer (either hardware or software, internal or external). You can use the computer's keyboard to play MIDI notes, and also the mouse. You can use the Virtual MIDI Piano Keyboard to display the played MIDI notes from another instrument or MIDI file player. To do so, connect the other MIDI port to the input port of VMPK. No Jack MIDI support  :(
- https://github.com/svn2github/vmpk_real - older version, 0.51, RtMIDI (Jack MIDI)
- https://github.com/mechanical-snail/vmpk_layouts_contrib - an unofficial repository for user-contributed keyboard layouts for Virtual MIDI Piano Keyboard (VMPK). These are additional layouts, besides the ones included with VMPK.
- Virtual Keyboard (Vkeybd) - This program is originally for AWE32/64 driver on OSS/Free, but it works now on ALSA, too. Start the program with --device alsa option.
- Proxima Controller - A MIDI controller application for Windows and Linux. No CCs or Jack MIDI.
- https://github.com/henriqueleng/svmidi - very simple virtual midi keyboard. ALSA or sndio.
- https://sourceforge.net/projects/vpiano - A virtual piano based on MIDI played by ordinary keyboard and mouse.
- FreePiano - a opensource software that can let you play music with your computer keyboard. Windows VST
- https://github.com/atsushieno/xmmk - cross-platform virtual MIDI keyboard
- https://github.com/metachronica/audio-midihaskey - Virtual MIDI keyboard for microtonal music. It works with JACK Audio Connection Kit.
- https://github.com/kushview/virtual-midi-controller - A software MIDI controller.
- https://gitlab.com/gabrbedd/ivory - multi-touch virtual keyboard controller that can be used tosend MIDI note and controller info to other programs or hardware.
- https://github.com/vsicurella/SuperVirtualKeyboard - a MIDI-controller plugin that allows you to explore different keyboard layouts with the intention of making microtonal scales easier to digest and compose with.This plugin does not yet offer retuning capabilities, so you will have to alter your synth's tuning.
- https://github.com/spaceface777/viano - MIDI piano app, written in V, including dedicated midi input and audio modules. Supports generating sound waves (sine/triangle/sawtooth/square), and automatic loading and repitching (soon) of audio samples
- https://github.com/Stazed/midiguitar - midi player and generator similar to virtual piano keyboards, but for a guitar.
to better order
- MIDI Controller - a small program that lets you set MIDI controller values using sliders and buttons in a GTK+ window. The GUI is an XML-based Glade file which can be replaced without rebuilding the program, so you can build your own controller GUIs in Glade.
- xphat - a MIDI slider box for Linux/X. Each slider can emit any MIDI message (except Active Sense). Most of the modes for each slider feature a well-defined MIDI message type (such as Note On, Controller N, Pitch Bend, etc.) which contain one parameter which can be varied by moving the slider. One exception to this is "Sysex" mode, which allows a slider to be programmed with an arbitary sequence of bytes, including parameters that can be altered.
- DrumPads - a set of virtual drum pads that can be played with the keyboard, mouse, or touchscreen. It features 12 pads and 100 high-quality drum samples. It can be controlled with the keyboard and is designed to let you play the drums two-handed, with the QWER and TYUI keys controlling pads 1-4, ASDF and GHJK keys controlling pads 5-8, and ZXCV and BNM, keys controlling pads 9-12. DrumPads also works well with touchscreens, allowing you to play using multi-touch to sound multiple drums at the same time.
- PIZ midiPads - 1 to 64 buttons/sliders/XY-pads that send learnable midi messages, with resizable GUI. Very configurable. Each pad can optionally show an svg/png/jpg/gif image (drag & drop to load images).
- KHAGAN — Widgets of Dominance
- Ctrlr - Control any MIDI enabled hardware: synthesizers, drum machines, samplers, effects. Create custom User Interfaces. Host them as VST or AU plugins in your favorite DAWs.
- Midiball - a simple standalone musical application for Linux to generate midi events from the motion of a virtual ball. It uses Qt and ALSA midi API. It can be also used with the jack daemon.
- Accordion - Accordion emulation written in C. Uses PC keyboard and space bar to emulate a three row button accordion. There is a choice of midi instruments and keys, now including C System and B System. A Windows and a Mac version have been released. Now including bass. The 12 bass buttons play uni-sonic bass notes for B/C/C#, C System and B System.
- Melodeon - Melodeon/accordion emulation written in C. Uses PC keyboard function keys and space bar to emulate a one row melodeon with bass. There is a choice of midi instruments, keys and button layout. Windows, Linux and Mac versions have been released. The bass works on the linux version, but using it can cause strange things to happen,
- https://github.com/obbardc/midi-cc-keyboard - Basic midi keyboard to test CC messages
- midifade - a Curses and ALSA application which provides on-screen faders, to control various midi-controllers on various midi-channels. It uses a simple user-interface: The Left and Right arrow keys move from one fader to the next, the Up and Down arrow keys adjust the value of the current fader by 1, the PageUp and PageDown keys adjust the value by 10, and the Home and End keys set it to maximum (127) or minimum (0).
- showq - MIDI controlled theatre cue player that can play audio or trigger MIDI events. Applicaton can be controlled by midi. It can play through alsa or through Jack Audio Connection Kit.
Linux Show Player
- Linux Show Player - or LiSP for short, a free cue player designed for sound-playback in stage production. The goal of the project is to provide a complete playback software for musical plays, theater shows and similar.
- beatings - a web application for the exploration of tuning and temperaments which pays particular attention to auditory phenomena resulting from the interaction of the spectral components of a sound.The aim is to foster new research in the pursuit of perceptually grounded principles explaining voice leading, as well as provide a tool for musical practice and education, areas where the old art of musical tunings and temperaments, with the notable exception of early music studies, appears to have long been neglected in favour of the practical advantages of equal temperament.
- https://github.com/larzeitlin/Chord - Stand-alone MIDI tool with circle of fifths interface
- https://github.com/lucianoiam/consul - VST plugin that provides a LAN accesible web UI for controlling other MIDI learn-enabled plugins running on a desktop DAW
- MIDI Progger - an Android app that shows a searchable list of programs. When the user taps on a program, MIDI messages (bank and program change) are sent via a USB MIDI cable connected to the device. Programs are defined in so-called mididef files. Users can create their own mididef files and place it in a directory named mididef in the phone's storage root.Definition files are included for the Korg X50, Roland Juno-DS and Yamaha P-140.
- TouchDAW - a full-featured DAW control and general purpose MIDI control app for Android tablets and phones. It allows you to remote control popular digital audio workstation software as known from standard hardware control surfaces - $
- Lemur - the professional MIDI and OSC controller app that doesn't cut any corners, has evolved. Now easier to use than ever, more customisable and with more out-of-the-box functionality. Any software or hardware that receives MIDI or OSC can be controlled by Lemur. Control DJ software, live electronic music performance software, studio production software (DAWs), VJ software, visual synthesis software, stage lighting and more. - MIDI/OSC interface, iOS/Android/macOS/Windows - $
- LiveControl 2 - The long-awaited Live iPad controller from Liine and ST8 is finally here. Built on what we learned from making Mu, Griid, Kapture Pad and Lemur, LiveControl 2 gives you every single feature you need to jam, produce and perform with Ableton Live. The interface is divided across four pages: Launch, Modulate, Play and Sequencer. Each page is deep and feature-rich, while the layout is clear and intuitive. Best of all, LiveControl 2 is completely free for all Lemur users.
- https://git.open-music-kontrollers.ch/lv2/shells_bells.lv2/about - a just-for-fun LV2 plugin bundle. Its main purpose is to test the d2tk tool kit inside an LV2 plugin UI. Its UI drops you into a shell and whenever you sound the bell, a MIDI note is played back on its DSP side.
- MIDI Surf - a browser-based MIDI controller that is optimised to work on a range of devices, including tablets and smartphones. It is highly customisable, enabling you to make a controller that is exactly what you need to make or perform your music at any given moment.
- QmidiNet - A MIDI Remote Controller via UDP/IP Multicast
- QmidiCtl is a MIDI remote controller application that sends MIDI data over the network, using UDP/IP multicast.
- multimidicast - sends and receives MIDI from Alsa sequencers over your network. It uses UDP multicast datagrams and is thus subscriptionless and plug'n'play. It is designed to interoperate with QmidiNet, TouchDAW, and the windows software ipMIDI.
- aseqnet - ALSA sequencer connectors over network
- Relayer - enables musicians who play the AXiS-49, the QWERTY computer keyboard, the Thummer, or any MIDI controller, to play in a wide variety of isomorphic note layouts and tunings using either a Dynamic Tonality synth or a standard multitimbral synth. Windows/Mac.
- https://github.com/TheSOB88/8scale - Keyboard MIDI player for xenharmonic scales
- https://github.com/metachronica/audio-midihaskey - Virtual MIDI keyboard for microtonal music
- https://github.com/mindhog/mawb#isokbd---isomorphic-keyboard-controller - Included in this package are the beginnings of isokbd.py, a script which lets you emulate hexagonal isomorphic keyboard controllers from a standard US layout computer keyboard.
- https://github.com/Woyten/tune - Make xenharmonic music and create synthesizer tuning files for microtonal scales.
- https://github.com/vsicurella/everytone-tuner - a free JUCE-based tool for remapping and retuning polyphonic MIDI data via pitchbend messages, primarily for use with synthesizers that support MPE.
- https://github.com/dsheeler/v4l2_wayland - Computer vision midi instrument.
- Webcam MIDI - a cross-platform open source application that lets the user play virtual instruments in front of a webcam. It is used as a MIDI controller together with a synthesizer.
MIDI to computer keyboard
- https://gitlab.com/enetheru/midi2input - Convert live midi ON events into simulated key presses
- https://github.com/Themaister/sussybard - Simple app which converts MIDI key inputs to X key presses, designed for playing FF XIV Bard
- https://github.com/agraef/midizap - control your multimedia applications with MIDI
- MIDI2LR - an application that translates MIDI Control Change commands into Lightroom actions.
- https://github.com/SpotlightKid/python-rtmidi/tree/master/examples/midi2command - shows how you can use python-rtmidi to receive MIDI messages and execute different external programs and scripts when a MIDI message is received. A configuration file defines which program is called depending on the type and data of the received message.
- https://github.com/zawwz/zmidimap - Map midi signals coming from ALSA midi devices to shell commands
Audio to MIDI
Onset Trigger LV2
- https://github.com/x42/onsettrigger.lv2 - An audio to midi converter currently intended for Bass/Kick-drums.
- https://github.com/metachronica/audio-dsp-midi-trigger - LV2 plugin which detects peaks by audio signal and sends MIDI notes.
- https://github.com/dsheeler/harmonizer.lv2 - uses the aubio toolkit for note onset and pitch detection on audio input and outputs midi.
- https://github.com/shish/mic2midi - Whistle / Hum / Sing into a microphone, generate MIDI signals to drive a sequencer
./main.py <input url> <output url> ./main.py alsa:// rtmidi://0 ./main.py file://song.wav file://song.mid
- https://github.com/kichiki/WaoN - a Wave-to-Notes transcriber, that is, the inverse of 'timidity' (and its descendants timidity++, and timidity with Gtk+). "WaoN" also has a meaning of harmony of notes or chord in Japanese! My original intention is to pick up voicing of harmony from sound of my favorite pianists.
- https://github.com/ahlstromcj/waonc - A follow-on to Kengo Ichiki's "waon" project that converts audio to MIDI, provides organized code and perhaps some new features.
- MIYAESI - converting a Wave file into MIDI and extracting the notes out of it. This project is done as a final year project of Computer Science and Engineering Department, University of Moratuwa.
- Midingsolo - aims to do a real-time audio note recognition software for monophonic signals (like solos). The input must be a monophonic wave signal (only one voice, with one melodic instrument). The result are MIDI events launched trough the ALSA sequencer. (recognized notes are printed to the standard output too)
- http://subpixels.com/processing/spxlAudioToMidi - small application made with Processing to produce MIDI control messages from a live audio feed. Auto-levelling frequency band meters are used to obtain "peak" output values across the entire audio spectrum analysed (whereas it is usual to have strong bass response with weaker treble response), and easing is applied to make the levels less erratic. In addition to tracking the high values, low values are tracked and the output range is maximised to span the low to high range. 10 separate monitor outputs are supplied, where each monitor is attached to one of the frequency band meters and that meter's output is scaled to the particular output range for the monitor, allowing for a reduced final output range as well as inverted ranges. Controls are provided to select the MIDI output device and the MIDI channel to use, as well as for selecting which monitors are connected to which meters and the monitor output ranges. v10 windows only, v04 - linux, mac
- https://github.com/simpassi/audio2midi - Tool for pushing audio samples through sliced FFT into polyphonic MIDI
- https://github.com/justinsalamon/audio_to_midi_melodia - Extract the melody notes from an audio file and export them to MIDI and (optionally) JAMS files.
- https://github.com/aniawsz/rtmonoaudio2midi - Real-time note recognition in monophonic audio stream
- https://github.com/jaym910/polyphonic_track - Polyphonic pitch tracking in real time using machine learning algorithms implemented in Python and an audio engine using Pure Data. Note tracking data is converted to MIDI and can be sent to DAWs, midi-capable hardware, etc.
- https://github.com/folkertvanheusden/wav-to-midi - Converts a pcm sound file (e.g. .wav) to a midi file (.mid)
- https://github.com/geraldmwangi/GuitarMidi-LV2 - A concept for guitar to midi as an lv2 plugin
Video to MIDI
- http://audiocookbook.org/gms/ - processing
MIDI to text
- https://github.com/markc/midicomp - will both read and write SMF files in 0 or format 1 and also read and write it's own plain text format. This means a SMF file can be turned into easily parseble text, edited with any text editor or filtered through any script language, and "recompiled" back into a binary SMF file.
- https://github.com/Yxven/Midi2Text - (fork) extracts data from a MIDI file into a tab-delimited text file. The file contains BPM, time signature, information about each note, etc. The text file can then be read into other applications, such as a spreadsheet or game.
- https://github.com/ahlstromcj/midicvt - This project supports MIDI-to-text-to-MIDI conversions like midicomp and midi2text (it is derived from those projects), and adds support for direct MIDI-to-MIDI conversions driven by an INI file, using a C++ add-on. The C++ project can also transform the patch numbers of files, converting the to General MIDI (GM) format, for example.
- https://github.com/codyd51/offkeyboard - allows operating a computer using a guitar, or bass guitar, or other instrument. Notes on the instrument can be mapped to key presses, key combos, or mouse movements/clicks.
- YouTube: I Played Minecraft Using ONLY a Bass
amidi -l Dir Device Name IO hw:0,0 M Audio Audiophile 24/96 MIDI IO hw:2,0,0 E-MU Xboard25 MIDI 1 amidi -p hw:2,0,0 -d
- GMIDImonitor is GTK+ application that shows MIDI events.
Doesn't display raw MIDI note number, doesn't display active sensing (and other such messages?).
- https://github.com/icsga/Miditool - A little tool to help with typical MIDI problems. With an increasing number of devices offering MIDI over USB, and thus showing up as a dedicated input/ output MIDI port in the system, it's sometimes overkill to have to fire up a DAW just to route an input device to the right target. This utility aims to help with that.
- KMidimon monitors events coming from MIDI external ports or applications via the ALSA sequencer, and from SMF (Standard MIDI files) or WRK (Cakewalk/Sonar) files. It is especially useful if you want to debug MIDI software or your MIDI setup. It features a nice graphical user interface, customizable event filters and sequencer parameters, support for MIDI and ALSA messages, and saving the recorded event list to a SMF or text file.
- MidiMon - Basic MIDI monitor, works w/ JACK or ALSA MIDI drivers - Most types of MIDI messages can be filtered from the monitor. - MIDI events can be captured to a text file (SMF planned). - UI Widgets can be hidden to reduce screen clutter.
- midisnoop - a simple MIDI monitor and prober. You can use it to monitor a MIDI device and/or software, and to send MIDI messages to a MIDI port to see how the device/software responds. midisnoop supports both ALSA and JACK MIDI ports via the RtMidi library. Dead.
- MIDI Input Viewer - a program that displays the MIDI messages at your computer's MIDI In. (It also can be used as a "software MIDI Thru" utility). Useful for checking the output of MIDI controllers, or verifying a sound module's response.
- ASeqView - ASeqView is an ALSA sequencer user-client which works as event viewr. It visualizes received events, e.g. note-on/off, controls, pitch wheels, using bar graphs, as often seen in many sequencer programs. Using this viewer, even a simple command line sequencer like pmidi or playmidi1 becomes a cool one with graphical interface. Another feature of ASeqView is redirection of events. ASeqView can output the received events to subscription ports with some modification like channel mute or pitch change. Since this works as a real-time filter client, such modifications can be applied also in real-time without complexity. Dead, ALSA only.
- MIDI Inspector - a monitor/debug tool for LV2 plugin and host authors. It captures all MIDI events sent to its event input port and presents them on its user interface for convenient nested browsing.
- https://github.com/hiben/MIDISpy - a MIDI bridge for snooping/sniffing MIDI data in Java. This application allows you to spy on MIDI data exchanged between two applications or devices. The wiki contains a screenshot that might make this description clearer. It works by building a bridge/relay for the data to display the message contents before transmitting it further. The setup is very flexible as you can use different input and output ports for the two devices in question (but this also means you have to deal with Javas confusing way of showing them...). I wrote this to analyze the SysEx message exchanged between a Akai LPK25 Keyboard and the proprietary software that is used to program the presets (that luckily runs in Wine). To do something similar you setup MIDISpy to bridge/relay the keyboard via a virtual midi device (snd-virmidi). If the application then talks to the virtual device, the keyboard will receive all data and all answers are sent back to the application. In between all messages are shown as hex dumps.
- midithru - a straight-through ALSA-MIDI client with a helpful display
- https://github.com/cullenspub/MidiMeterMon - Using DPF to create plugins for monitoring audio and midi events.
- https://github.com/vallsv/midi-display.lv2 - Device based on LV2 to display MIDI events as a Mod Device widget.
- https://github.com/gbevin/ReceiveMIDI - a multi-platform command-line tool makes it very easy to quickly receive and monitor MIDI messages from MIDI devices on your computer.All the heavy lifting is done by the wonderful JUCE library.
- https://github.com/majorx234/qt_jack_midi_debugger - a small Qt programm to debug midi msgs send through Jack Server
See also Pure Data#MIDI
- a2jmidid - daemon for exposing legacy ALSA sequencer applications in JACK MIDI system.
- https://github.com/linuxaudio/a2jmidid - a2jmidid with meson and in python3
a2jmidid -eu # start, -e export hardware (see ALSA MIDI port names in JACK), -u strips the numeric ALSA client ID from the name of the Jack port
a2j_control ehw a2j_control start
- https://github.com/free-creations/a_j_midi - A static bridge with one ALSA playback port and one JACK MIDI input port.This is a remake of a2jmidi_bridge found in the official Ubuntu distribution.
- JAMRouter - the best thing since sliced bread for routing MIDI events to/from JACK MIDI software ports and MIDI hardware supported by ALSA Raw MIDI, ALSA Sequencer, Generic Raw MIDI, and OSS MIDI. At its core, JAMRouter is a near-sample-accurate low-latency low-jitter MIDI event router and translator, designed specifically with external hardware in mind, with an initial emphasis on providing full MIDI support and SysEx translation for the Roland Juno-106, and otherwise full compatibility with practically all MIDI hardware. JAMRouter is a "must have" for any Linux MIDI musician using external MIDI hardware of any kind, especially analog synthesizers. With the right hardware and a properly tuned linux-rt (realtime) kernel, near-sample-accurate over-the-wire MIDI communication with latencies under 5 milliseconds and jitter under 150 microseconds is fully realizable. JAMRouter has already passed dozens of sample-accurate test results, and the timing continues to improve as development continues. JACK has been in the box too long. Now JACK can reliably communicate with MIDI hardware outside the box.
- https://github.com/hselasky/jack_umidi - is a daemon that provides access to raw USB/socket MIDI devices via theJack system.The daemon will not exit when a device becomes unavailable, but will wait until the device re-appears again.
- aconnect - ALSA sequencer connection manager
ALSA Patch Bay
- ALSA Patch Bay is a graphical patch bay for the ALSA sequencer API and the JACK audio API. It can use FLTK or GTKmm for the interface and take advantage LASH session management.
- midi matrix - A plugin that reroutes/filters MIDI messages by channel. MIDI channel filtering (e.g. blocking of specific channels), MIDI channel multiplication (e.g. send events from channel X to channels X, Y and Z), MIDI channel rerouting (e.g send events from channel X to channel Y)
- https://github.com/jimm/jam_patcher - a MIDI utility that listens for bank and program changes and lets you assign them to keys to be re-sent later. I wrote JamPatcher because I play with a group of friends once a week. We rent different rehearsal rooms that can contain different keyboards each time we play. Finding a patch I want to use can take time, especially if I'm unfamiliar with a keyboard or it has an ungainly menu structure. Once I've found a patch I like, I can easily assign it to a key and quickly retrieve it by pressing that key.
- https://github.com/moddevices/mod-midi-merger - A small Jack-internal client to merge MIDI events from several inputs to one output.When a new port is registered at the Jack server, this client will connect to it, if it is a MIDI port with outgoing events the name does not start with effect_ if it does not belong to itself
- https://github.com/davidmoreno/aseqkeeper - watches for the connecitons on the ALSA sequencer, and it tries to keep them connected. Rust.
- https://sourceforge.net/projects/midi-router-client - anywhere to anywhere
- https://github.com/alex-milanov/midi-pipes - App that allows you to create midi pipelines where midi message from a control device routes where midi messages will be diverted. For example if you have a midi keyboard and you want to be able to switch between different hardware or app synths that this keyboard/controller should control.
- https://github.com/plewto/Pigiron - a fully configurable MIDI routing utility written in Go. It includes a MIDI file player and has a comprehensive OSC interface.The primary Pigiron object is called an Operator. Each Operator has zero or more MIDI inputs and zero or more MIDI outputs. When an Operator receives a MIDI message, it determines if the message should be forwarded to it's outputs. An Operator may also modify the message prior to re-sending it.
- https://github.com/tschiemer/midipatcher - Virtual matrix patchbay for MIDI ports with remote control and virtual ports, file, serial, network stream support.
MIDI processing GUI
- MidiLayer - a simple and easy to use application designed to enhance your live performances. Manage slots and channels, adjust the velocity and the volume, customize the note range and connect with modulation wheels and other types of controllers, all with the help of MidiLayer.
- QMidiRoute - a MIDI event processor and router for the ALSA sequencer with a graphical interface based on the Qt toolkit.
- http://alsamodular.sourceforge.net/ - package
- Zweeger - a modular extended MIDI filter and generator. It works as a standalone tool or as a VST effect. It can be placed between any MIDI input, such as keyboards, and any tool that can be controlled by MIDI messages (effects, samplers, hardware, software...) It can also work without any input as a "simple" generator. Zweeger is composed of various elements, such as LFO, envelops, random curves, delays, note generators, ... All of them can be chained in various ways, synchronized on the tempo.
Java or Linux/Windows VST. UI is janky.
- https://github.com/jberthault/MIDILab - A Versatile MIDI Controller, Player, Recorder, Editor ... for Windows & Linux. This application provides a GUI that lets you: plug multiple devices and tweak them in realtime, play any MIDI file using connected devices or locally on a SoundFont synthesizer, record any stream and save it as MIDI files for later, edit files (well not now, but I'm on it), customize interface & behavior via xml configurations.
- SoundFontCombi - takes advantage of the ALSA sequencer to emulate a synthesizer or a master keyboard, routing MIDI events in eight parts with six MIDI outputs and two Midi inputs. It can also add functions to your master MIDI keyboard.
- mcr - a MIDI router and controller for Linux originally based on SoundFontCombi version 0.018 by Josep Andreu (Holborn). It routes incoming MIDI messages from up to two input clients (e. g. MIDI keyboard, MIDI controller) to up to six output clients (e. g. software synthesizers), applying filters to up to eight sound banks (i. e. voices, organ stops, or instruments) at the same time.
disappeared from the web??
- FMidiAutomation - a tool for automating MIDI commands. While some music programs provide automation for a few controller changes, such as volume and pan, I want this to handle any MIDI command and not be tied to a particular program. To this end, FMidiAutomation provides a sequencer of curves of MIDI command data. A user can record live data and easily adjust each recorded curve's position in the sequencer. As well, each data point of a curve can be manually edited. The end result is a fancy curve editor for MIDI data that can be sequenced. This project is far from complete and has been a sandbox for experimenting with Gtk and C++11. The Gtk2.4 branch is somewhat usable where the master branch needs the UI for the Jack connection stuff rewritten.
- XController - a MIDI routing software for Linux and is intended to control several MIDI devices (hardware/software) via one master keyboard. This includes sending program changes, sysex etc. by one keypress. XController depends on the ALSA-Library.
- Zonage - Four JACK MIDI data mappers for splitting your keyboard into zones. Pretty simple - each zone takes a midi input and truncates output data to within the key range specified in the UI. This lets you, for instance, split your keyboard into four zones and route each zone to one arpeggiator in Arpage. That was the main intent of the app.
- https://github.com/SpotlightKid/midiscenemanager - Switch between setups of MIDI devices (scenes) with a press of a button.
- QMIDICurves - a simple QT/JACK application (GPL license) that lets you change MIDI-keyboard velocity response. You can choose between pre-defined curves or create your own curves.
Midi Control Change Tools
- https://github.com/xitiomet/midi-tools - a tool for Scripting actions around Midi Control Change messages. This utility allows you to observe MIDI control change messages from every channel in real-time, and associate rules with them. It also features midi port mapping, and a websocket interface. Each Channel/CC# is treated as in individual "Control" so this application can be thought of as an "omni" mode midi input. Each "Control" can have rules associated with it that will execute "Actions" based on the type of change made to the Control. For instance you can have a rule that will execute whenever the value increases. Possible "Actions" are executing a script or program, calling a url or api, playing a sound, or Transmitting a midi message to another device.
- https://github.com/austensatterlee/MIDI-Transformer - A free VST for transforming and bending MIDI inputs
- https://github.com/wolf-plugins/wolf-mapper - MIDI remapping plugin
- MIDI Patchbay - lets you hook up your various pieces of MIDI software and hardware and pass MIDI data between them, applying assorted filters on the way. Things like key splits, MIDI channel remapping, transposition, etc. are simple.
MIDI processing plugin suites
- midifilter.lv2 - LV2 plugins to filter MIDI events. So far 27 MIDI event filters have been implemented
- CC2Note -- translate control-commands to note-on/off messages
- Channel Filter -- discard messages per channel
- Channel Map -- map any MIDI-channel to another MIDI-channel
- Enforce Scale -- force midi notes on given musical scale
- Eventblocker -- notch style message filter. Suppress specific messages
- Keyrange -- discard notes-on/off events outside a given range
- Keysplit -- change midi-channel number depending on note (and optionally transpose)
- MapCC -- change one control message into another
- Mapscale -- flexible 12-tone map
- Chord -- harmonizer - create chords from a single note in a given musical scale
- Delay -- delay MIDI events with optional randomization
- Channel Unisono - Duplicate MIDI events from one channel to another.
- Strum -- arpeggio effect intended to simulate strumming a stringed instrument (e.g. guitar)
- Transpose -- chromatic transpose MIDI notes
- Monophonic Legato - Hold a note until the next note arrives. - Play the same note again to switch it off.
- NoSensing -- strip MIDI Active-Sensing events
- NoDup -- MIDI duplicate blocker. Filter out overlapping note on/off and duplicate messages
- Note2C - Convert MIDI note-on messages to control change messages.
- Note Toggle - play a note to turn it on, play it again to turn it off.
- nTabDelay -- repeat notes N times (incl tempo-ramps -- eurotechno hell yeah)
- Passthru -- no operation, just pass the MIDI event through (example plugin)
- Quantize -- live midi event quantization
- Velocity Randomizer -- randomly change velocity of note-on events
- ScaleCC -- modify the value (data-byte) of a MIDI control change message
- Sostenuto -- delay note-off messages, emulate a piano sostenuto pedal
- Velocity Range -- filter MIDI note events according to velocity
- Velocity Scale -- modify note velocity by constant factor and offset
- https://github.com/x42/midimap.lv2 - a flexible MIDI event mapping plugin, using a rule-based lookup-table, which is loaded from a config file.
- https://github.com/SpotlightKid/midiomatic - A collection of MIDI filter, generator and processor LV2/VST2 plugins. MIDI CCRecorder, MIDI PBToCC, MIDI SysFilter,
- pizmidi - The Piz MIDI plugin collection. These are intended to be small, useful MIDI processing VST 2.4 plugins, and are available for Windows (32/64-bit), Linux (x86), and Mac OS X (PPC/x86, 32/64-bit), unless otherwise noted.
- KVR: Insert Piz Here subforum
- https://github.com/jpauwels/pizmidi/tree/master/Release/doc - individual plugin .txt docs
- KVR: piz midi plugins (windows/linux/mac)
- https://bitbucket.org/agraef/pizmidi/ - a linux fork of piz midi, a comprehensive suite of VST MIDI plugins available from http://thepiz.org/pizmidi/. These will be useful for anyone working with MIDI in their musical projects, but note that they require a VST host capable of loading pure MIDI plugins. (They should work fine with most popular open-source and commercial Linux DAWs nowadays.)
- midi16CCRouter - Changes up to 16 CCs to 16 other CCs.
- midi2qwerty16 - Use MIDI to trigger fake keystrokes to the focused window.
- midiAlias - Note values are reflected between a "Nyquist Note" and a "Zero Note," similar to the effect of audio sample aliasing.
- midiAudioToCC - Converts audio amplitude to CC messages.
- midiBlackKeyFilter - Separately adjust velocity of black and white keys, and/or send them on different channels.
- midiCCModulator - Use one CC to modulate another CC (or note velocity) in various ways: add/subtract/multiply/etc, plus logic gates (AND, NAND, * XNOR, etc).
- midiCCReset - Remembers CC values and sends them out again at selected times.
- midiCCStepper - Quantize CC events by value or in time.
- midiCCToggle - For changing momentary CC buttons into toggles.
- midiChannelize - Transforms everything to the selected channel.
- midiChordHold - Sustains a chord until another one is played.
- midiChordSplit - For splitting polyphonic material to multiple midi channels based on selected note ranges for each voice.
- midiChs_noGUI - Channel filter/changer like energyXT1 "MIDI chs" component.
- midiConverter3 - Change and convert between CC, Channel Pressure, Poly Aftertouch, Program Change, Pitch Bend, NRPN/RPN, Note On/Off, and other messages in various ways.
- midiDelay - Delay notes and/or CCs with feedback.
- midiDuplicateBlocker - Remembers all MIDI message values it gets on each channel, and blocks any repeated values until a different value is received.
- midiExactDelay - Simple delay (no dry signal, no feedback) with flexible and precise delay time.
- midiFingered - Selectively sends standard portamento on/off CC messages to emulate "fingered portamento" for synths that don't have it.
- midiForceToKey - Enforces a scale, and transposes within the scale (optionally based on MIDI notes on a selected channel).
- midiForceToRange - Transposes notes by octave into the selected range.
- midiInvertNotes - "Mirrors" notes centered around the selected note.
- midiKeySplit - Simple keyboard splitter.
- midiKeySplit4 - Four-zone keyboard splitter.
- midiMultiProgramChange - Uses input program change to trigger selected program changes on all channels.
- midiNotchFilter - Isolate, remove, or channelize specific MIDI messages.
- midiNoteGroups - Assign play and/or choke groups to MIDI notes.
- midiNoteMap - Simple 1-to-1 keyboard mapper.
- midiNoteRepeater - Repeats every Nth note a set number of times, or blocks it.
- midiNotesToCC - Converts note number and velocity to CC messages.
- midiNoteToggle - Notes (optionally within a selected range and/or channel) are toggled... play a note once to turn it on, play it again to turn it off.
- midiNRPNConverter - Converts between NRPN/RPN and CC messages, with 16 conversion slots.
- midiOverlappingNoteKiller - Prevents overlapping notes at the same pitch.
- midiPitchBendQuantize - Quantizes pitch bend messages to up to 25 values.
- midiPitchBendToNotes - Changes pitch bend plus note messages into notes at the "bent" pitch (may be useful for using Suzuki QChord with non-multitimbral instruments).
- midiPolyphony - For spreading polyphony across MIDI channels, i.e. if you play 4 notes, each one will go to a different channel. Polyphony per channel can be set from 1 to 16 notes for more flexibility. You can also use it to convert polyphonic input to monophonic output.
- midiProbability - Add probability-based effects to incoming MIDI events, optionally synced to host timeline.
- midiProgramChange - Send Program Change and/or Bank Select messages.
- midiSimpleLFO - One CC LFO with some "simple" options.
- midiScaleChanger - Transposes notes by individual scale degrees and/or globally, to change one scale into another. Among other things, this allows you to play any scale using only the white keys.
- midiSostenuto - Like a piano sostenuto pedal, but for MIDI notes instead of piano dampers.
- midiStrum - Sequentially delays notes of an input chord to simulate strumming.
- midiStuckNoteKiller - Sends note-off messages to end hanging notes when the host stops (for hosts that don't do this themselves).
- midiSwing - Delays and/or offsets velocity of and applies probability to notes (and optionally also CCs) at every other step of a selected note value.
- midiTriggerList - Use one note or CC to trigger up to 8 other notes and/or CCs.
- midiVelocityScaler - Scale/reverse/offset velocity of input notes (Note On and/or Note Off).
- midiLooper It doesn't write music for you. It's not an arpeggiator and it's not really a step sequencer. 128 independently controllable slots for recording/playing/manipulating MIDI sequences. Draw in notes, record live, or import existing MIDI files. Can be used as: MIDI looper/sampler - "extra hands" for live playing. Plays back what you play, whenever you want it to. MIDI file player, in sync with the host (or not). Seamlessly switch between patterns. Composition tool - fit any sequence to any chord progression, on the fly. All of the above, simultaneously. Win VST.
S-Production MIDI VST Plugins
- MIDI-VST-Plugins - S-CC-Init, S-CC-Matrix/-V2, S-CC-Monitor, S-CC-Sustain-Lite, S-Indicators, S-Message, S-Midi-Matrix, S-Midi-Monitor-Lite, S-Midi-Panic, S-Midi-Random, S-Midi-Senderella, S-Midi-Stepper, S-Note-Matrix, S-PC-Init, S-Poly-Limiter. Linux and Windows.
Div's MIDI Utilities
- Div's MIDI Utilities - a collection of MIDI utilities I wrote for myself, which you may find useful as well. I previously kept separate collections of MIDI utilities for Windows and for Unix, but due to an increasing amount of overlap, I have combined them into a single package.
- alsamidi2pipe and pipe2alsamidi - bridges between ALSA and the pipe-based utilities.
- average-tempo, scale-tempo, offset-tempo, average-velocity, scale-velocity, and offset-velocity
- brainstorm - functions as a dictation machine for MIDI. It listens for incoming MIDI events and saves them to a new MIDI file every time you pause in your playing for a few seconds. filenames are generated automatically based on the current time.
- intervals - plays parallel intervals for incoming MIDI messages.
- jumpoctave - use the pitch bend wheel as an octave jump control.
- metercaster - place waypoints in the sequence to tell metercaster what the proper time should be for events of your choosing, and it interpolates among them, coming up with the proper times for the rest of the events.
- tempo-map - used to acheive a similar effect to metercaster, but is far faster and more intuitive to use. Inspired by, but more powerful than the "fit to improvisation" feature in Cakewalk
- dispmidi - pretty-prints incoming MIDI messages.
- mish - a compiler for a text-based music notation language called "Mish" (MIDI shorthand)
- pipe2net, alsamidi2net, net2pipe, and net2alsamidi - utilities that speak NetMIDI, a trivial network protocol which sends standard MIDI messages over a TCP/IP connection as fast as possible.
- normalizesmf and verbosify - provides a minimal demonstration of the midifile library. It reads in a MIDI file, then writes it out again. If your sequencer complains that a file is invalid, this normalizer might make it more palatable.
- rw - can be used to split out a *nix device's input and output to separate FIFOs.
- transpose - filter-style utility transposes incoming MIDI messages by a specified interval.
- xmidiqwerty - partially completed program which lets you use a MIDI keyboard as a chording text keyboard in X11
- Pidim - a collection of small Gtk+ applications which purpose is to filter and generate MIDI events, based on the ALSA Sequencer interface, with MIDI control available.
- pidim_arpeggiate: enter the arpeggio in ABC syntax, where 'C' is the reference input note. Press [ENTER] to activate the arpeggio.
- pidim_transpose: the transposition value is specified in semitones.
- pidim_split_port: the split-note is specified as a MIDI key number.
- pidim_split_chan: same as pidim_split_port (but split over channels).
- pidim_ctrl_swap: swap the specified controller number with its value.
J's MIDI tools
- J's MIDI tools - Free MIDI plugins. Windows VST, 32-bit and 64-bit. CC value limiter, multi channel key range/transpose midi, CC controlled (or not) transposer, CC time blocker, CC64 (sustain) emulator, CC inverter, aftertouch to CC, random note delay, CC-controlled channel switcher, velocity – CC switcher, chord note-channel-switcher.
- https://github.com/cbdevnet/midimonster - Named for it's scary math, the MIDIMonster is a universal translation tool between multi-channel absolute-value-based control and/or bus protocols, such as MIDI, DMX/ArtNet and OSC. It allows the user to translate channels on one protocol into channels on another (or the same) protocol, eg
- Translate MIDI Control Changes into Notes
- Translate MIDI Notes into ArtNet
- Translate OSC messages into MIDI
- Use an OSC app as a simple lighting controller via ArtNet
- Visualize ArtNet data using OSC servers
- Control lighting fixtures or DAWs using gamepad controllers
- Play games or type using MIDI controllers
- https://github.com/nickolas360/midislide - Slide notes for MIDI plugins.
MIDI processing CLI/scripts
- amidimap - a basic MIDI mapper for the ALSA sound system. It acts as a filter, receiving and transforming MIDI events and then outputting them. Used to turn a Yamaha PSR300 keyboard into something that vaguely resembles a GM-compliant one.
- mididings is a MIDI router and processor with a domain-specific language based on Python, supporting ALSA and JACK MIDI. It is available under the GNU GPL and currently runs on Linux. The main difference between mididings and regular Python scripts is that mididings typically uses Python only at startup. Patches consist of Python objects and nested data structures, but not actual Python code to be executed once everything is set up. Internally, patches are converted to C++ objects, and the processing is done entirely in C++. It is however possible to call back into Python, if necessary. Although mididings is a Python module that can theoretically be imported in other Python applications, it’s really not designed to be used that way. Think of mididings as a standalone application, that just happens to use Python as its “user interface”.
Arch Linux package is old. Install from git for latest version.
- Yamaha One Touch chord alike
- mididings-midi-osc.py - Korg nanoKONTROL to Non Mixer 
- Novation Launchkey to Qtractor
- https://github.com/m4773rcl0ud/launchpaddings - Novation LaunchPadS
- WebDings - A web interface for controlling mididings, similar to the livedings gui included with mididings, but based on web technology and running in modern browsers.
- https://github.com/orzdk/midimatrix - MidiMatrix - Tool for manipulating alsa port MIDI routing on linux system with MidiDings integration
- https://github.com/stefets/flaskdings - A simple and effective API and UI for MIDIDINGS
- https://github.com/stefets/live-config - My musical companion with MIDIDINGS as the KERNEL
- Midish - an open-source command-line MIDI sequencer/filter for Unix-like operating systems. Implemented as a simple command-line interpreter (like a shell) it's intended to be lightweight, fast and reliable for real-time performance. Important features: multiple MIDI devices handling, synchronization to external audio/MIDI hardware/software, real-time MIDI filtering/routing (controller mapping, keyboard splitting, ...), track recording, editing, progressive quantisation ..., import and export of standard MIDI files, system exclusive messages handling
- Reactive-balsa - live MIDI event processor based on the Reactive-banana framework and ALSA. (Thus it is currently bound to Linux.) It is the successor of the package StreamEd, that uses a kind of arrow types. The MIDI event processor can be used for accompaniment, gags, games and more. It is usually inserted between a MIDI input device such as a USB piano keyboard and a MIDI controlled synthesizer, say an internal software synthesizer or an external hardware synthesizer.
Some of the included examples: split keyboard, transposition, delay, map key to filter frequency, arpeggiator: play a pattern according to pressed keys, generate a beat with controllable tempo, instrument cycling: every note is played with a different instrument, LFO-controlled change of MIDI controllers, simulate playing chords on a guitar, interval recognition trainer, keyboard with mirrored order of keys: perfect support for lefties :-)
- https://github.com/paulguy/crustymidi - JACK MIDI event scripting triggerable on events
- Mi_D - a multi-platform, multi-driver, and multi-language shared library that offers clients a simple unified, yet unique set of MIDI services that are not commonly found in existing driver interfaces. Although originally devised as MIDI architecture for Common Music, Mi_D is fully self-contained and designed to simplify greatly the addition of high-level MIDI functionality to a wide variety of clients, including applications that are not genuine MIDI sequencers.
Platform-independence is achieved by emulating a uniform API on top of existing MIDI drivers and OS services, thus abstracting from various driver- or platform-specific idiosyncrasies as well as differences in functionality among drivers. Mi_D currently runs on SGI's and both, 68k and PPC Macintoshes, using the native SGI MIDI driver and Opcode's OMS, respectively. It also includes interfaces to C/C++ and various LISP implementations. Future ports will support most likely Windows, Linux, and maybe NeXT/Rhapsody.
- https://github.com/ledfyr/midicloro - a 4-to-1 MIDI merger which adds MIDI clock, polyphonic chords and routing of channels to class-compliant USB MIDI devices. The clock, chord and routing settings can be controlled in real-time via MIDI CC. MIDIcloro is a Linux console application intended to be used on the Raspberry Pi/Raspbian to provide a small hardware solution, entirely controlled via MIDI, for connecting and improving the capabilities of USB MIDI devices.
Live Midi Router
- Live Midi Router - was designed to provide musicians a solution to drive live music softwares such as soft synths, soundfont players, instrument emulators etc.. from midi controllers on linux operating systems running alsa and jack. LiveMidiRouter is a non interactive program. A config file must be specified when starting.
- https://github.com/jjttcc/midifilter - script that, with the help of supporting perl modules, runs as an ALSA MIDI client that can receive input from a source (such as a MIDI keyboard connected to the computer), perform various filtering and other functionality based on the type and content of the MIDI input, and send the result to one or more other MIDI clients used on MIDI I/O and keeps the frills to a minimum; currently it has no built in sequencer, file read/write, MIDI recording/playback. - Java
- PatchMaster - a MIDI processing and patching system. It allows a musician to reconfigure a MIDI setup instantaneously and modify the MIDI data in real time. With PatchMaster a performer can split controlling keyboards, layer MIDI channels, transpose them, send program changes and System Exclusive messages, limit controller and velocity values, and much more. At the stomp of a foot switch (or any other MIDI event), an entire MIDI system can be totally reconfigured. PatchMaster lets you describe songs, which are lists of patches that connect instruments. Those connections can send program changes, set keyboard splits, transpose, send volume or other controller changes, and let you apply any Ruby code you want to the MIDI stream in real time. Ruby.
- https://github.com/jimm/keymaster - a MIDI processing and patching system. It allows a musician to reconfigure a MIDI setup instantaneously and modify the MIDI data in real time.With KeyMaster a performer can route MIDI between keyboards, split controlling keyboards, layer MIDI channels, transpose them, send program changes and System Exclusive messages, limit controller and velocity values, modify controllers, and much more. At the stomp of a foot switch (or any other MIDI event), an entire MIDI system can be totally reconfigured.
- Qualm - might be referred to simply as a "MIDI event processor" -- it connects to an input MIDI port, listens for events, and will output new MIDI events on an output port as necessary. For example, it can listen for particular note on/off events and use them to send out patch changes, or even duplicate one channel's pedal events on other channels so that one pedal can do the work of many. It takes a control file written in XML, consisting of a list of patches, and aset of “cues” (gathered into independent cue “streams”) which describe the patch changes and the eventsthat will trigger the next cue in the sequence. XML.
- https://github.com/sparks/themidibus - The MidiBus is a MIDI library for Processing which provides a fast and easy way to send and receive MIDI data. The MidiBus is desgined primarily for real time MIDI applications. It's focused on MIDI I/O and keeps the frills to a minimum; currently it has no built in sequencer, file read/write, MIDI recording/playback.
- https://github.com/jpcima/midi-shell - Scheme REPL for sending MIDI commands
- midisox - a SoX-like workalike, for handling MIDI files. Efeects: compand, echo, fade, key, mixer, pad, pan, pitch, quantise, repeat, stat, tempo, trim, vol
- https://github.com/ZoeB/midi-tools - Command line tools for MIDI files
- https://github.com/lukemcraig/NegativeHarmonizer - a simple python program to invert the tonality of a music file. This works very well for compositions like Bach's fugues. If you try it on popular music, you'll probably need to transpose the instruments back into their proper ranges, as the bass will be on the top. Beyond the fun of negative-harmonizing songs you know, this is a useful tool for composers and producers to add variations to their work.
- https://github.com/nickolas360/midislide - n3 MidiSlide is an LV2 plugin that allows you to use slide notes with plugins that accept MIDI input. Any plugin that supports the MIDI pitch bend controller is supported.
- https://github.com/gbevin/SendMIDI - a multi-platform command-line tool makes it very easy to quickly send MIDI messages to MIDI devices from your computer.All the heavy lifting is done by the wonderful JUCE library. This tool is mainly intended for configuration or setup through Control Change, RPN and NRPN messages, but many other MIDI messages can be sent.
MIDI Windows VST
- MIDIplugins midi plugins - Windows
- PIZ midiCurve - Maps a CC, velocity, aftertouch, and/or channel pressure according to a curve. Holds 128 presets and supports MIDI Program Change. Instructions are in the plugin (click "Help"). There is also midiPBCurve for Pitch Bend. Windows VST.
- CCStepper - a Windows VST MIDI CC data sequencer plugin, suitable for controlling MIDI capable software (softsynths or effects) or external hardware devices. CCStepper lets you create up to 8 independent sequences with up to 64 steps each, and can either be synced to your host or triggered by MIDI notes. The step rate can be set from 1/128 notes and up to 32 bars, and various randomization features allows you to create unpredictable sequences.
- NoteMapper - a VST plugin that allows you to map MIDI notes to other notes. Each incoming note can be mapped to up to three notes, even on different MIDI channels. This allows you to, for example, let one specific note trigger drum sounds in up to three different drum samplers. In addition, you can scale the note velocity, apply randomization to the velocity scaling, and set a note probability for each individual note. Windows VST.
- http://www.midiflow.com/ - iPad - $
See also Generative
- https://github.com/MikeMorenoDSP/Euklid - A real-time euclidean rhythm generator VST made with Pure Data and Camomile.
Euclidean / Music Pattern Generator
- Euclidean Pattern Generator 1.2 - Wouter Hisschemöller, Java, March 2, 2017
- SoundHelix - a free, versatile and flexible Java framework for composing and playing algorithmic random music based on constrained random generation (CRG). SoundHelix is an algorithmic random music generator (including a built-in MIDI sequencer) which can play generated songs on MIDI devices in real-time. It can also write the generated songs as MIDI files. SoundHelix is open-source software and is licensed under the GNU General Public License v3 (link is external). The project is hosted on SourceForge (link is external).
- https://github.com/gilesbowkett/archaeopteryx - Archaeopteryx is a MIDI system for Ruby. Archaeopteryx uses MIDIator for MIDI Out and recommends rbcoremidi for MIDI In. The code's quite a mess, and I definitely prefer Clojure (with Overtone) for music hacking today.
Windows VST / macOS
- Automathico - a MIDI note generator based on looped mathematical calculations. Win VST.
- Talent - an algorithmic MIDI application. This plugin was replaced by Hyperion in 2008. Talent is an algorithmic MIDI sequence generator with a simple and flexible design that lends itself to a variety of textures across 64 scales, using live MIDI control or automatic performance by settings.
- Hyperion - MIDI VST has a semi-modular structure suitable for a wide variety of tuned algorithmic applications. LFOs and counters are used to easily create dynamic MIDI sequences and change them on the fly, or to modulate other components of the architecture. Hyperion produces glissandos or subtly varying sequences for up to three parts on three separate MIDI channels using a simple chord function. It can also be used as a phrase arpeggiator to make sure that you never play out of key or out of sequence.
- Malt - uses an LFO to periodically alternate between one or both of two midi channels for generating algorithmic sequences.
- CC Cube - gives you eight sets of MIDI cc values and transmits them at tempo. You may send the cc value sets manually, or configure an algorithmic progression between them.
- HyperCube - applies periodic parameter modulation to Circuit and Hyperion for algorithmic song structuring. The grid of trimmers on the right indicates the probability for each band to progress to the next. CC Cube is a generic version of HyperCube that sends 8 cc values.
- Period Seq - generates rhythmic sequences using four counters.
- Populus - populus generates MIDI sequences with a 'biologically modeled behavioural' algorithm. The measure is treated like a 'year,' wherein notes grow, reproduce and combat.
- Skunk - a four part algorithmic percussion sequencer. Probability is used to determine which of eight sequences follows the current selection. This concatenative effect is useful for cross-rhythms and other simple rhythmic automations.
- Eckel - a midi generating Windows/Mac VST based on the eucledian algorithm. There are 8 instances of the generating part. Pulse is the actual sounding beats, space is the spacebetween the pulses. Speed is how fast they come, 0 is 4th 1 is 8th's etc. Note is the MIDI note thatthe algorithm spews out. How you actually make it work in your host is up to you to find out. Remember that Eckelsends MIDI note on and off's.
- XronoMorph - a free OS X and Windows app for creating multilayered rhythmic and melodic loops (hockets). Each rhythmic layer is visualized as a polygon inscribed in a circle, and each polygon can be constructed according to two different mathematical principles: perfect balance and well-formedness (aka MOS). These principles generalize polyrhythms, additive, and Euclidean rhythms. Furthermore, rhythms can be smoothly morphed between, and irrational rhythms with no regular pulse can also be easily constructed.
- MIDI Agent System - uses the interaction between different agents to generate MIDI notes. This is designed primarily for live use and it enables the performer to change the parameters of the agents that are generating the music in real time. For example, one agent can generate random bar markings, a second can add sequences of notes to these bars, a third can change the velocities of notes in the bars and a fourth can shift the pitches up or down. Many of the agents have knobs that can be set to respond to MIDI controllers and by varying the parameters of the agents it is possible to have real time control over very complex music. This software is written in Java and should run on any operating system.
- https://github.com/sjaehn/BSchaffl - Pattern-controlled MIDI amp & time stretch plugin to produce shuffle / swing effects.
- https://github.com/morbidrsa/humanizer.lv2 - adding a random value between -20 and 20 to the MIDI signal's velocity at with a probability of 50%.These values are currently hard coded and will hopefully be changable via a GUI from the LV2 Plugin Host in the future.
- https://github.com/erwald/rachel - a recurrent neural network for humanizing MIDI -- that is, for taking as input MIDI compositions with constant velocities (flat loudness/dynamics) and producing as output those same compositions with predicted velocity (loudness/dynamics) values for each of the contained notes. The theory behind and considerable parts of the code in this project are based on or taken from Iman Malik's thesis project StyleNet
- Circuit - algorithm is designed to create natural feeling rhythms by evening the distribution of beats and rests. Each measure is divided into short phrases, and probabilities are assigned to each step so that a part can be weighted towards the downbeat or the upbeat. Circuit can be used for live performance or run automatically. Win VST.
- Phase Seq - for sequencing unquantised loops, host synced or not. The position of each note is modulated individually by three LFOs, which can create effects like sequence stretching as well as randomisation. Win VST.
- QMidiArp - an advanced MIDI arpeggiator, programmable step sequencer and LFO for Linux. It can hold any number of arpeggiator, sequencer, or LFO modules running in parallel.
- https://github.com/emuse/qmidiarp - Linux MIDI arpeggiator, sequencer and LFO for ALSA and JACK
- hypercyclic - an LFO-driven MIDI arpeggiator, gate effect and step sequencer for mangling sustained MIDI input chords, the output of which can then drive other MIDI instruments. Multi-platform standalone and VST.
- arpage - MIDI Arpeggiator w/ JACK Tempo Sync.
- Bram Giesen : arpeggiator - a beat syncable classic arpeggiator with some extra features
- https://github.com/johanberntsson/simple-arpeggiator-lv2 - An arpeggiator LV2 plugin for music production on Linux DAWs
- https://github.com/Windfisch/arp.lv2 - a simple LV2 MIDI processor to add tracker-style arpeggiatos to your favourite soft- or hardware synth.Upon receiving a MIDI CC number 0x70, value 0xXY, pitchbend events will be emitted to shift the instrument by 0, then X, then Y, semitones, then falling back to 0. This emulates closely how trackers used to work.
- Flarps - a MIDI arpeggiator for linux based systems. Its operation is controlled by a text file, which can be edited while flarps is running. Flarps outputs MIDI events with JACK MIDI, and uses JACK transport for synchronization.
- https://github.com/dastax/midiharmony - An arpeggiator/chord generator for jack-midi, written on qt4
- https://github.com/agraef/raptor - The Raptors.pd patch implements an experimental algorithmic composition arpeggiator program with 3 parts (i.e., 3 Raptor instances running in parallel, each with their own set of parameters). A few sample presets are included in the presets folder, and you can use the raptor-preset subpatch (in the lower left corner of the main patch) to switch between these. This subpatch also has some controls to change meter and tempo. The patch accepts MIDI note input, as well as controller and system realtime messages for the most important controls as detailed below. The controller assignments should be convenient to use with popular modern MIDI controllers featuring keys, pads and rotary controllers, such as the Akai MPK mini, or more "classic" equipment like the Behringer controllers.
- Rarp - Under Linux, there are a bunch of tools, but a standalone arpegiator for ALSA does not appear to currently be a good area. Ones that do exist do not seem to have enough flexibility or usability. The number one requirement is to create a useable arpegiator for live operation.
- https://github.com/arirusso/diamond - MIDI arpeggiator in Ruby
- https://github.com/waveydab/Harmonator - a midi arpeggiator oriented towards live performance. You input a rhythm, voice pattern, and then play.
- GuitArp - a pitch-tracking VST host and arpeggiator sequencer for use with live guitar. Input from your guitar is converted into MIDI notes and run through the arpeggiator sequencer. Those notes are sent to a VST of your choice.
- Scuzzphut6 - a free VST plugin for Windows, featuring a flexible trance-gate and two delay-lines, each with its own filter and LFO. The trance-gate section features: Click-n-drag activation of the gate steps. Step ties to link steps.
Attack/decay and shuffle controls. Each of the two delay-lines features: Tempo synchronization. HP/LP filter. LFO routable to both pan and filter cutoff.
- Dualism - plugin version of the dual arpeggiators and 2X MIDI utilities found within M-theory and, as such, provides you with the ability to arpeggiate/double any other synth you wish, including hardware synths. Combining two flexible and programmable phrase arpeggiators with a pitch and speed controllable MIDI doubler, Dualism allows you to create arpeggiations that are far more complex and detailed than your standard synth arpeggiator. However, all this flexibility is contained within a small and straightforward interface, letting you quickly and comfortably create complex patterns without having to feel slowed down but the UI.
- D-Arp - a dual MIDI arpeggiator. Easy to use, it combines two arps and allows to let them run in parallel or control one by the other. Use it with any synth (-plugin) to create interesting and new sequences. Special features: host-sync, shuffle, adjustable note length with overlap at max point (for mono glide sounds), velocity adjustable or input pass thru. Clock divider for speed control includes settings for dotted or triol - also there is a manual control for step thru by sending MIDI notes on channel 16 to the plugin (for example from a drum machine !)
- Kirnu - a VST MIDI arpeggiator plug-in which is designed with real-time tweaking and usability in mind.
- Arp4midi - A wrapper for Chris Kerry's arpeggiator SEM. I have never used this plugin! Installation of MIDI plugins varies between hosts.
- MIDI Shape Shifter - MSS, is a VST MIDI plugin for mapping, generating and transforming MIDI data. This plugin's simple and flexible interface is capable of satisfying a wide range of MIDI needs. For example, MIDI Shape Shifter could be used to: * Apply a velocity curve * Generate an LFO * Create mappings between ranges of MIDI data * Filter out specified MIDI data * Apply midi compression or gate effects * Automatically harmonize notes * Create split/dual keyboard * Transpose * Control multiple parameters with a single knob * etc
- BlueARP - a Windows VST MIDI Arpeggiator with pattern sequencer style, designed for electronic music genres.
- RandARP - a VST plugin arpeggiator with many randomization features, allowing incoming notes or chords to be manipulated in various rhythmic ways. All standard arpeggiator parameters like number of octaves, note length and note order are included, but the plugin also offers complete randomization of the velocity, gate, shift and swing parameters. In addition, you can specify a note probability and randomize the note order, the octave order, and the number of octaves. All the randomization features allows you to create more interesting and unpredictable arpeggiated sequences.
- https://github.com/noedigcode/oldnotes - Small JACK MIDI client that replaces velocities of specified notes with that of the last received non-specified note.
- https://github.com/jmage619/velociraptor - A Jack midi velocity compressor with Qt based UI.
- Audio Plugins by Davi Santos - a MIDI plugin to adjust the notes velocity accordingly to a metric accent.
- Midi Chord - Harmonizer - make chords from single (fundamental) note in a given musical scale. The scale as well as intervals can be automated freely (currently held chords will change). Note-ons are latched, for multiple/combined chords only single note-on/off will be triggered for the duration of the combined chords. If a off-scale note is given, it will be passed through - no chord is allocated. Note: Combine this effect with the 'MIDI Enforce Scale' filter to weed them out.
- tonespace - a chord generator and visualizer, displays chords and scales on a grid, making it easy to understand their structure, displays chords on a piano keyboard, making it easy to play them, supports 39 chord types, 25 chord voicings/inversions, 21 scales, 18 keys, and 50 different grids. Linux, Windows, and macOS. Standalone app, VST or AU.
- https://github.com/dmgolubovsky/chordemux - a MIDI filter/router utility which receives chords on its input channel, and routes chords' notes to different channels depending on chord type and inversion. Haskell.
- midichord - generates adjusted-notes to conform to a fixed-voice
- https://gitlab.com/alextee/zchordz - map the chords of a whole Minor or Major scale onto the white keys of a piano keyboard.
- https://github.com/riban-bw/lv2 - Multi-chord is a MIDI processor. It will create a chord from each MIDI note received. Each incoming note C,C#,D,D#,E,F,F#,G,G#,A,A#,B can trigger any chord, individually configurable, e.g. incoming MIDI 'C' may trigger a C major chord whilst incoming MIDI 'C#' could trigger A minor. Each chord may have up to 3 notes. Any note configured the same as the first will not sound, e.g. setting C1='C', C2='E', C3='C' will play C + E when a MIDI 'C' is received.
Windows / Mac
- midiChords - The "Ultimate" MIDI chord VST plugin. Maps any note into 0 or more other notes. Windows / Mac.
- midiChordAnalyzer - Guesses chord names based on MIDI input, or from clicked notes on the keyboard display. You can copy the chord for pasting into midiChords (or as plain text). Windows / Mac.
- Chordz - a VST plugin that allows you to trigger full chords by playing single notes. Each trigger note is associated with a separate chord. Each chord may consist of any number of notes. Play complicated chord progressions with one finger, with a MIDI keyboard or a drum-pad, or trigger chords from single notes added in your DAW's piano roll. Windows VST.
- Chordit - a VST plugin that allows you to trigger chords by playing single notes. Use the chord-switch octave to select chord type, and play the chords with the rest of the keyboard. The plugin supports optional velocity scaling and randomization for each note of the chord. Another feature is the start and end delay (can also be randomized), which can be used to emulate strumming. Windows VST.
- ChordMem Pro - the enhanced version of the free ChordMem, a MIDI chord memory and trigger plug-in. It features 12 Chords per preset to be recorded and then played back by the single keys of an octave or the buttons of any MIDI controller. Each chord may consist of up to 12 notes. Play complicated chord progressions with the tip of one finger, with drum-pads or any other MIDI controller. Windows VST.
- Custom MIDI Auto-Harmonizer - a tool designed with composers and live performers in mind. It allows you to generate harmonized notes in real time, according to the scale specified by the detected chord. You can define your own harmonization tables, according to your needs. Windows - $
- xhip Notelogic - apply MIDI processing on a polyphonic part in order to assign each note to a MIDI channel within a limited range of channels set by the polyphony parameter. You can then use your host's features (if available) to split the MIDI part by channel into individual "voices" and you can record each one of these one at a time using a monophonic analog synthesizer or otherwise as desired. It is also possible to use this plug-in to process a polyphonic part or MIDI input from a controller optionally in real-time; while configuring one or multiple monophonic or polyphonic instruments to receive each individual MIDI channel from 1 to N (selected polyphony) to play back the polyphonic part all in real-time.
- https://github.com/cocreature/midisplit - splits midi input by channel to different outputs
Scale / tonic / tuning
x42 MIDI Keys Transpose
- MIDI Keys Transpose - Flexible 12-tone map. Allow to map a note within an octave to another note in the same octave-range +- 12 semitones. Alternatively notes can also be masked (disabled). If two keys are mapped to the same note, the corresponding note on/events are latched: only the first note on and last note off will be sent. The settings can be changed dynamically: Note-on/off events will be sent accordingly.
x42 MIDI Chromatic Transpose
- MIDI Chromatic Transpose - Chromatic transpose of midi notes and key-pressure. If an inversion point is set, the scale is mirrored around this point before transposing. Notes that end up outside the valid range 0..127 are discarded.
x42 MIDI Enforce Scale
- MIDI Enforce Scale - Filter note-on/off events depending on musical scale. If the key is changed note-off events of are sent for all active off-key notes.
- Twonker - a MIDI Plugin that allows a digital piano (or any MIDI instrument) to play tones from the Overtone Series (also known as the Harmonic Series). It is designed to run within most Digital Audio Workstations as a Synth Plugin on Windows, MacOS, and Linux. In order to allow multiple keys in Just Temperament, you would need to build twelve pianos; each tuned to a different Fundamental. To switch Just Scales from C to G, run over to the G piano and wail away. The Twonker allows a musician to play overtones in a predictable and flexible manner, using a regular MIDI-based keyboard. In essence, it behaves like twelve different pianos tuned to twelve different Just Scales. You "change the piano" by simply choosing a new Fundamental and otherwise playing normally.
- Scala - a powerful software tool for experimentation with musical tunings, such as just intonation scales, equal and historical temperaments, microtonal and macrotonal scales, and non-Western scales. It supports scale creation, editing, comparison, analysis, storage, tuning of electronic instruments, and MIDI file generation and tuning conversion. All this is integrated into a single application with a wide variety of mathematical routines and scale creation methods. Scala is ideal for the exploration of tunings and becoming familiar with the concepts involved. In addition, a very large library of scales is freely available for Scala and can be used for analysis or music creation.
Written in Ada. Not the programming language Scala.
- Scala scale file (.scl) format - The files are human readable ASCII or 8-bit character text-files. 1)The file type is .scl .There is one scale per file.Lines beginning with an exclamation mark are regarded as comments and are to be ignored.The first (non comment) line contains a short description of the scale, but long lines are possible and should not give a read error. The description is only one line. If there is no description, there should be an empty line.The second line contains the number of notes. This number indicates the number of lines with pitch values that follow. In principle there is no upper limit to this, but it is allowed to reject files exceeding a certain size. The lower limit is 0, which is possible since degree 0 of 1/1 is implicit. Spaces before or after the number are allowed.After that come the pitch values, each on a separate line, either as a ratio or as a value in cents. If the value contains a period, it is a cents value, otherwise a ratio. Ratios are written with a slash, and only one. Integer values with no period or slash should be regarded as such, for example "2" should be taken as "2/1". Numerators and denominators should be supported to at least 231-1 = 2147483647. Anything after a valid pitch value should be ignored. Space or horizontal tab characters are allowed and should be ignored. Negative ratios are meaningless and should give a read error. For a description of cents, go here.The first note of 1/1 or 0.0 cents is implicit and not in the files.Files for which Scala gives Error in file format are incorrectly formatted. They should give a read error and be rejected.
- Scala help - Keyboard mappings determine the allocation of scale degrees to keys on a MIDI keyboard, or MIDI note numbers in general. They are automatically used when you tune a synthesizer with the SEND command, retune a MIDI file with the EXAMPLE/MIDI command or create a sequence file with the EXAMPLE/CREATE command. They can also be created by using an external text editor, and the file type should be '.kbm'. They are activated by the command LOAD/MAPPING. An example template file is example.kbm. It contains various parameters on the first few lines and then the mapping defined by scale degrees for consecutive keys. For instance if it is 0, 1, 2, 3, etc., then it will be an ordinary linear mapping. 0, 2, 3 would mean degree 0 will be on the first key (which is the given middle note), degree 2 will be on the second key, degree 3 on the third, etc. Scale degrees may be assigned to more than one key or to no key at all. This is useful for octave-based scales with less than 12 notes so gaps in the key row can be filled with duplicate notes. With scales containing notes that are alternatives for each other, unused alternatives can be left unmapped. When not all scale degrees need to be mapped, the size of the map can be smaller than the size of the scale. Otherwise it would of course need to be at least the same size as the scale, or zero for a linear mapping. With nonstandard keyboards, mappings can be made that do not repeat, so all keys can be assigned individually.
- https://github.com/Normalised/ScalaTuningCPP - Scala tuning support for C++
- Scale Workshop - by Sevish
- https://github.com/supercollider-quarks/ScalaTunings - Tunings archive from scala (http://www.huygens-fokker.org/)
- Tuning Library - Our core SCL/KBM calculation engine is available as a standalone C++ header.
- https://github.com/BrianArne/Friendsizer - a sinewave wavetable synthesizer for exploring alternate tunings. Friendsizer reads Scala (.scl) files provided by the user to create the alternate tunings. Download common Scala files or even create your own!
- https://github.com/Woyten/tune - Explore musical tunings and create synthesizer tuning files for microtonal scales.
- https://github.com/ODDSound/MTS-ESP - simple but versatile C/C++ library for adding microtuning support to audio and MIDI plugins. It allows for a single master plugin to simultaneously control the tuning of any number of connected client plugins across a DAW session.
- Mutabor - a program that supports the live music with micro tones. It allows to play any pitches, even those which are not availlable on ordinary keyboards. An important application is the "just intonation". Mutabor uses its own musical language to describe pitches, (re)tunings and reactions to events (chords, keys, MIDI signals). Furthermore, MIDI ports, MIDI files, and GMN files can be used in the same manner, mixed and output.
- Muditulib - a multi-dimensional tuning library, is a library to be implemented (wholly or partly) in music production software. It consists of a core of C functions. Additionally a Pure Data implementation is provided. This implementation consist of several classes to be used as a modular system. The library makes use of a multi-dimensional numerical pitch representation system, a variant of the very well-known one-dimensional MIDI note system. Ambitions for other implementations are very welcome. Muditulib offers new ways of approaching tuning within the scope of diatonic (roughly the majority of) tonal music within the digital domain.
- http://sig.sapp.org/doc/examples/humextra/keycor - Key correlation measurements using the Krumhansl-Schmuckler key-finding algorithm. (and also the Gabura algorithm). For use with Humdrum.
- https://github.com/Woyten/tune - Make xenharmonic music and create synthesizer tuning files for microtonal scales.
- https://github.com/xivilay/scale-remapper - Routes white keys from midi-input to chosen scale to midi output
- AutoTonic Player - Win VST
- ChordEase - makes it easier to improvise over complicated chord progressions. No matter what the chords are, you can play as if they were all in the key of C. You don't need to play sharps or flats, because ChordEase automatically adds them for you. Though ChordEase is intended for jazz, it could be useful for any type of music that modulates frequently. ChordEase alters your notes in real time in order to make them harmonically correct, while preserving their rhythm and dynamics. By delegating rapid music theory calculations to ChordEase, you gain freedom to concentrate on other aspects of improvisation and performance, such as feel and aesthetics.
- Cales - a Windows VST plugin that allows you to map your keyboard’s keys to a musical scale. This will ensure that you will always stay in key, and never hit a wrong note. When "easy mode" is enabled, you can play any scale using only the white keys with "C" always being the tonic (or "root" note). More than 20 scales are included, and you can add your own custom scales. Windows VST.
J74 Progressive SE
- J74 Progressive SE (Standalone Edition) - a desktop application for Mac and Windows specialized in chord progression making. The application can be used in combination with any Digital Audio Workstation (DAW) which supports standard MIDI and standard MIDI files import. J74 Progressive SE allows you to create chord progressions by use of composition techniques modelling (such as diatonic scale and chords exploration methods) as well as performance styles (arpeggio, humanized timing and dynamics). The tool is capable of producing extremely realistic chord progressions and arpeggios, delivered directly as MIDI files (or real-time MIDI) for use in your DAW projects. - Windows. - $/demo
- Scale Player - a MIDI effect plug-in that allows you to play different scales in any key and mode using the idea of relative notes rather that static note values. The plug-in calculates the intervals between pitches based on the selected scale and the user can move up and down the scale playing melodies, arpeggios or even chords using a few keys. The result is an unusual way of playing instruments, which can be fun, inspirational and much easier to play since you don't have to worry about hitting the wrong note, memorizing all the scales in all the keys and practicing complex riffs and phrases that can be a challenge to play the usual way. Scale player is a new kind of instrument that like any other instrument may take a bit of time to learn and master, but it will be a rewarding experience. It's ideal for live playing and with some practice you can play complicated licks and phrases that would impress everyone. - $
- MIDI Delayline - Delay all MIDI events by a given time which is given as BPM and beats. If the delay includes a random factor, this effect takes care of always keeping note on/off events sequential regardless of the randomization.
- MIDI N-Tap Delay - This effect repeats notes N times. Where N is either a fixed number or unlimited as long as a given key is pressed. BPM and delay-time variable allows tempo-ramps. On every repeat the given velocity-adjustment is added or subtracted, the result is clamped between 1 and 127.
- midiecho - Simulates tape-loop delay echo: on MIDI files, or on real-time MIDI
- Strumee - Three modulated MIDI delays for strumming and humanising MIDI. Win VST.
- Midilegato - Delays NoteOff events on one midi channel by up to 500ms to turn generated sequences into legato sequences. Win VST.
- https://github.com/sukovec/jmidiexec - Simple SW for executing external software on midi events
- https://github.com/dnschneid/mid2key/network - Convert live midi ON events into simulated key presses
- http://velato.net/ - a programming language, created by Daniel Temkin in 2009, which uses MIDI files as source code: the pattern of notes determines commands. Velato offers an unusual challenge to programmer-musicians: to compose a musical piece that, in addition to expressing their aims musically, fills the constraints necessary to compile to a working Velato program. Each song has a secret message: the program it determines when compiled as Velato.
- https://github.com/x42/mididebug.lv2 - an instrumention tool to generate arbitrary MIDI messages up to 3 bytes in length. It's mainly intented for http://moddevices.com but works in any LV2 plugin-host.
- https://github.com/usdivad/Melotrigger - Use input from one MIDI channel to trigger notes from another channel or track! VST + Pd prototype.
- https://github.com/jnguyen1098/MIDIStash - Hiding files within MIDIs using text events
- https://github.com/Natooz/MidiTok - a package for MIDI encoding / tokenization for deep neural networks. It "tokenize" MIDI files as for text in the NLP field, to use them with Transformers or RNNs. MidiTok features most known MIDI encoding strategies, and is built around the idea that they all share common parameters and methods.
- https://github.com/kosua20/MIDIVisualizer - A small MIDI visualizer, written in C++/OpenGL.
MIDI Smoke Simulator
- https://github.com/stagas/midi-visualizer - Visualize a set of MIDI events as a piano roll.
- https://github.com/casparwylie/MPERecorder - An MPE recorder and visualiser for ROLI devices, that keeps the history of a track, and allows for saving as image files or text files for replaying.
- https://github.com/jpcima/mpe-surface - Application to use an Android tablet as MIDI Polyphonic Expression keyboard (MPE)
- MidiShare has been designed in 1989 in response to problems commonly met in the development of realtime music software. It provides high level services to developers and ensures platform independance since it supports GNU/Linux, MacOS X and Windows
C / C++
- xnormidi - A C midi implementation for embedded systems.
- https://github.com/MarquisdeGeek/midilib - a pure C library to handle the MIDI protocol, as well as providing code to read and write standards-compliant MIDI files. This provides code functionality for apps wishing to support MIDI file serialism, as well as write music apps that auto-compose music.
- https://github.com/stump/libsmf - a BSD-licensed C library for reading and writing Standard MIDI Files (*.mid). It transparently handles conversions between time and pulses, tempo maps, and more.
- MidiFile - C++ classes for reading/writing Standard MIDI Files
- https://github.com/ipatix/cppmidi - a library to parse and save midi files. It's supposed to be a lightweight straight forward and easy to use library.
- https://github.com/jcelerier/libremidi - A modern C++ MIDI real-time & file I/O library. Supports Windows, macOS, Linux and WebMIDI.
- RtMidi - set of C++ classes (RtMidiIn, RtMidiOut and API-specific classes) that provides a common API (Application Programming Interface) for realtime MIDI input/output across Linux (ALSA & JACK), Macintosh OS X (CoreMIDI & JACK), and Windows (Multimedia Library) operating systems. RtMidi significantly simplifies the process of interacting with computer MIDI hardware and software.
- http://portmedia.sourceforge.net - portmidi
- https://github.com/milasudril/midiseq - a set of C++ classes for Standard MIDI File manipulation.
- https://github.com/ddiakopoulos/modern-midi - C++11 MIDI file & realtime io library . Brings together a number of support classes to read, manipulate, and generate MIDI data. For realtime input/output, the library gently wraps RtMidi for cross-platform hardware IO. Furthermore, ModernMIDI includes a comprehensive file io module for reading and writing format-0 files. Other features include common music theory concepts expessed in MIDI, along with a decently performing real-time file player. It's currently thin on the example/documentation front, but more samples will be forthcoming.
- https://github.com/harryhaaren/JACK-MIDI-Examples - A small suite of apps that demonstrate how to code JACK MIDI applications.
- https://github.com/jpcima/fmidi - a library to read and play back MIDI files. It supports both standard MIDI files and RIFF MIDI files. The functionality is exposed as a C programming interface, and it is implemented with C++. It is a simple library which is good for implementing a MIDI file player, or any program taking MIDI files as inputs. In fact, a player with a terminal interface is provided as an example. Build it with ncurses, libev and RtMidi.
- https://github.com/meshula/LabMidi - Midi IN and OUT. Standard midi file parser and player. Midi Softsynth implementation.
- https://github.com/kode54/midi_processing - My MIDI file processing code, as lifted from foo_midi and modified to use STL classes instead. Still kind of a mess.
- https://github.com/sezero/libtimidity - MIDI to WAVE converter library
- alsaseq – ALSA sequencer bindings for Python
- http://trac.chrisarndt.de/code/wiki/python-rtmidi - A Python wrapper for the RtMidi C++ library written with Cython.
- MIDIUtil is a pure Python library that allows one to write muti-track Musical Instrument Digital Interface (MIDI) files from within Python programs. It is object-oriented and allows one to create and write these files with a minimum of fuss.
- PyPortMidi is a Python wrapper for PortMidi. PortMidi is a cross-platform C library for realtime MIDI control. Using PyPortMidi, you can send and receive MIDI data in realtime from Python.
- https://github.com/vishnubob/python-midi - tries to offer a reasonable object granularity to make MIDI streams a painless thing to manipulate, sequence, record, and playback. It's important to have a good concept of time, and the event framework provides automatic hooks so you don't have to calculate ticks to wall clock, for example.
- https://gist.github.com/SpotlightKid/ee14e9ad0a15ea860d1abeaf4bc1d2c0 - Convert joystick axis position into MIDI Control Change value in-/decrements using pygame.joystick and python-rtmidi
- https://mido.readthedocs.org/en/latest Mido - MIDI Objects for Python
- https://bitbucket.org/timsavage/midikat - utilities for parsing MIDI messages. This module does not provide access to a MIDI stream. Data can be read from a MIDI stream by pygame.midi or the underlying pyportmidi. This module sits a level above and provides utilities for parsing data provided by the underlying modules.
- Python: module MIDI - offers functions: concatenate_scores(), grep(), merge_scores(), mix_scores(), midi2opus(), midi2score(), opus2midi(), opus2score(), play_score(), score2midi(), score2opus(), score2stats(), score_type(), segment(), timeshift() and to_millisecs(), where "midi" means the MIDI-file bytes (as can be put in a .mid file, or piped into aplaymidi), and "opus" and "score" are list-structures as inspired by Sean Burke's MIDI-Perl CPAN module.
- Midge - Midi sequencing from the comfort of your text editor
- YouTube: Perl in Computer Music
- https://github.com/jaudiolibs/jnajack - Java bindings to JACK Audio Connection Kit
- https://github.com/jaudiolibs/audioservers - A Java Audio Server API, partly inspired by PortAudio, providing a common callback-based API for audio programming. There are currently included backends for JavaSound and JACK.
- https://github.com/jaudiolibs/audioops - A simple Java audio processing API (inspired by LADSPA, etc.) with a selection of reusable audio filters and effects ported from a range of projects.
- PDF: Using the JACK Audio Connection Kit with JavaJens Gulden
- https://github.com/kshoji/USB-MIDI-Driver - USB MIDI Driver for Android 3.1 or later
- Midica - MIDI Compiler, Decompiler, Karaoke Player and Analyzer - an interpreter for a Music Programming Language. It translates source code to MIDI. But it can also be used as a MIDI player, MIDI compiler or decompiler, Karaoke player, MIDI file analyzer or a player for several more file formats. Midica is an open source project written in Java and hosted on GitHub: https://github.com/truj/midicaThe main purpose of the application is to develop music with a music programming language. But various other formats can also be loaded and played directly or converted to MIDI. All supported music programming languages focus on music instead of sound generation. So the programmer is dealing with: Notes and Octaves instead of frequencies Note values or Rest values instead of milliseconds Instrument names instead of mathematical sound synthesis functions
- http://tx81z.blogspot.co.uk/2011/08/micromidi-ruby-dsl-for-midi.html 
- https://github.com/jimm/midilib - a pure Ruby MIDI library useful for reading and writing standard MIDI files and manipulating MIDI event data.
- midifile.rb - a small library script for Ruby that provides facilities for reading and writing standard midifiles. It lets you use very simple code to read a midifile, breaking it out into elements (headers and events) in convenient form for further processing. It reads directly from the file, without storing it all in memory first.New files can be created as well, usually by building an object in memory, adding elements as desired, and writing the complete sequence to a file at the end. 'Generator' methods are supplied for easy creation of most kinds of events. Simple alterations (such as transposing all the notes) can actually be done without building a new object — elements can be written out immediately they are read from the input.
- https://github.com/scgolang/midi - Dead simple MIDI package for Go. Currently only supports Linux and Mac.
- MIDI.lua - Reading, writing and manipulating MIDI data
- lovemidi - a nativ crossplatform MIDI I/O library for LUA | LÖVE | Love2D
- https://github.com/justinlatimer/node-midi - A node.js wrapper for RtMidi providing MIDI I/O
- https://github.com/substack/baudio - command-line
- MIDI.js - Making life easy to create a MIDI-app on the web. Includes a library to program synesthesia into your app for memory recognition or for creating trippy effects. Convert soundfonts for Guitar, Bass, Drums, ect. into code that can be read by the browser. Supports multiple simultaneous instruments and perfect timing.
- MIDI.js MIDI.js Soundfonts - pre-rendered General MIDI soundfonts that can be used immediately with MIDI.js.
- https://github.com/justinlatimer/node-midi - A node.js wrapper for RtMidi providing MIDI I/O
- https://github.com/jazz-soft/JZZ - MIDI library for Node.js and web-browsers
- https://github.com/cuinjune/ofxMidi - Midi addon for openFrameworks
See also WebDev#Web Audio API
- A MIDI API using Node-RED · RJPW - This post builds on another post that introduces RESTful APIs using Node-RED. It should be repeated that there are other – perhaps better – ways besides a RESTful API for connecting a MIDI device to a web application. In a future post I will extend this MIDI example using web sockets, but please note that the central purpose of this discussion is not to demonstrate an ideal solution but rather to demonstrate the value of API prototyping using visual tools.
- https://github.com/danielappelt/midi-spider - a web application that enables easy data exchange with MIDI devices. It can be used as a simple sysex librarian.
- FOSDEM 2020 - WebMIDI - The connection between Web and MIDI seems as likely as the joining of Garlic with Bread! Yet, we now have the power to create music from the web browser! Either by generating MIDI files for later manipulation, or as live instruments, WebMIDI provides us with the power to build some amazing online music applications. In this short form talk, Steven will cover the internal details of the MIDI protocol, and its related file format, to show how music is represented by computers. This details both the recording and playback of music within the browser, and external application. It comes complete with live demos, synthesized sounds, and occasional music jokes!
- https://github.com/appsforartists/midicast - a web extension that streams songs from a web page to a MIDI instrument
- https://github.com/nlaredo/playmidi - a web and curses and SDL-based MIDI file player for Linux and MacOS and Chrome (via Web MIDI and Web Audio apis).
- https://code.google.com/archive/p/dsmi/ - MIDI over Wifi. receives MIDI commands and feeds them to your MIDI applications.
- https://github.com/wararyo/m5chorder - BLE Chord Pad Device
- https://github.com/jpcima/midifuzz - MIDI Fuzzer to test plugin robustness, library and LV2 plugin
- MIDICSV - translate MIDI music files into a human- and computer-readable CSV (Comma-Separated Value) format, suitable for manipulation by spreadsheet, database, or text processing utilities, and re-encoding processed CSV files into MIDI. No information is lost in transforming a MIDI file to CSV and back.
- MIDI Toolbox is a compilation of functions for analyzing and visualizing MIDI files in the Matlab computing environment. Besides simple manipulation and filtering functions, the toolbox contains cognitively inspired analytic techniques that are suitable for context-dependent musical analysis that deal with such topics as melodic contour, similarity, key-finding, meter-finding and segmentation.
- mididump - dumps a MIDI file in a text format provided by MIDI::Perl
- midiedit - a MIDI-file editor which now (since version 1.3) has a choice of two user-interface modes. In the new default mode, it uses Curses to offer a purpose-designed user-interface and MIDI::ALSA to play the notes to your synth. In the older lower-tech mode, it uses your favourite text-editor to edit the human-readable text-format provided by MIDI::Perl's $opus->dump function.
- miditurtle - turtle-sound for manipulating MIDI data
- libmidi - a very simple library created for reading and writing MIDI files. It is designed to be quick to use and quick to learn.All interaction should be done through the MIDI::File class, which parses a MIDI file. The data inside the MIDI::File class is then organized as if it were a normal MIDI file. That is, MIDI::File has a header (MIDI::Header) and a list of tracks (MIDI::Track). Each track then has a list of MIDI events.
- https://github.com/ldrolez/free-midi-chords - A collection of free MIDI chords and progressions ready to be used in your DAW, Akai MPC, or Roland MC-707/101
- https://github.com/Polydynamical/fibprimes - The music of Fibonacci and prime numbers
- https://github.com/albertmeronyo/awesome-midi-sources - A curated list of sites with MIDI files on the Web.
- https://github.com/feross/bitmidi.com - Listen to free MIDI songs, download the best MIDI files, and share the best MIDIs on the web. 
- The Largest MIDI Collection on the Internet, collected and sorted diligently by yours truly. : WeAreTheMusicMakers
- https://github.com/ldrolez/free-midi-chords - A collection of free MIDI chords and progressions ready to be used in your DAW, Akai MPC, or Roland MC-707/101
- https://github.com/asigalov61/Tegridy-MIDI-Dataset - Tegridy MIDI Dataset for precise and effective Music AI models creation.
- https://github.com/allthemusicllc/atm-cli - Command line tool for generating and working with MIDI files.
- BitMidi on Twitter: "The fact that this video exists is almost too good to be true. “Finally! A way to organize your MIDI's.” https://t.co/btAHELqn8B" / Twitter
- MIDI-OX, the world's greatest all-purpose MIDI Utility! - Windows.
- http://nerds.de/en/loopbe1.html - Windows
- QwertyKeyboardMidi is a Win32 C++ project that allows you to use your QWERTY keyboard as a MIDI controller. When coupled with MIDI Yoke it allows you to use the keyboard to control software running locally, such as Cubase or Logic.
See also Sequencers and seq66/sequencer64. non-sequencer only has start/stop MIDI CC control, Giada only has 'channel' (single sample/sequence) specific midi control.
- https://github.com/mmckegg/loop-drop-app - MIDI looper, modular synth and sampler app built using Web Audio and Web MIDI APIs
- https://github.com/mmckegg/rust-loop-drop - [WIP] Midi-only version of Loop Drop for running on low power machines like Raspberry Pi and Beaglebone
- https://github.com/BN701/Multi-Arp - Non-linear pattern sequencer with the focus on live exploration, improvisation and (sooner or later) performance. Non-linear means having more than one list of events playing at a time. The lists are interleaved, or played all at once, or played in any combination in between. A real time midi looper adds additional elements to a pattern. A single instance of the app plays one polyphonic pattern on one midi-channel. Run multiple, synchronized instances to play on different channels. Ableton Link synchronization protocol is used to keep everything playing together. You do not need to have Ableton Live or any of its components for this to work.
Red background highlight of active paramater
- pattern - contains one or more step lists and/or real time lists.
- step list - a series of notes, chords or rests played out with regular timing.
- step value - controls the rate of step list playback and indeed the overall ‘pulse’ of the sequencer. A value of 4 is essentially a quarter note, 8 is an eighth-note and so on, and values 3, 7, etc divide a four beat bar as you would expect. Step values (and beat values) can be non-integer.
- trig list - one per pattern, allows for any combination of steps from each step list to be played simultaneously. Individual trig stages can generate additional copies of an event to be scheduled at repeating times during and after a step. This enables ratcheting effects, midi echos and one shot arpeggiated chords generated using intervals from the current pattern scale (see later).
- real time list - a more traditional looper-style thing intended for the capture of phrases to be played alongside the step list data. Note events are captured and stored using beat values according to the Ableton Link timeline and are played back, quantized or unquantized, independently of step value. Playback rate for each real time list can be varied, as can loop length and start offset. Real time lists also support import of midi files. Step lists and trig lists have no interaction with real time lists.
A pattern has other properties including step value, default gate length and default note velocity. They also have a scale and a feel. These are transformations applied on-the-fly to note data as it is played back.
- Scale - transforms map notes onto major, minor and modal scales allowing transpositions based on intervals within those scales. (The problem of how to handle accidentals - notes that are not part of the current scale - is very much up in the air.
- Feel, or swing, applies a time shift to steps that fall between beats as defined by Ableton Link. A feel map defines any number of markers which control how events are swung between beats. One marker gives the familiar ‘jazzy’ swing, but two or more markers opens up the kinds of micro-timing I find in West African music and doubtless other areas or world music. The feel map doesn’t vary from beat to beat. Feel does not affect real time data.
- Pattern chains allow patterns to be played in any order. Patterns can be switched on bar boundaries as defined by Ableton Link, or can be switched naturally when their own internal cycles come to completion. Steps in the pattern chain will play in succession or a ‘goto next’ value can be set. Chain steps can be repeated a number of times before switching or set to repeat indefinitely.
Midi Note entry
- real time entry mode - which operates as a standard midi looper.
- step mode - Chords or single notes are played on the midi keyboard, requires use of the PC keyboard to enter rests and close a phrase.
- quick mode - involves holding down a note or notes. On release of the last key, the note set is entered as a monophonic sequence. There is no way to enter chords or rests in this mode.
Creation and editing of all note data is possible from within the app, but this is only intended for small additions or minor tweaks.
use # shows the current status, either P: or GLOB: with a summary of current settings. use g / globals / p / pattern # use step, gate, velocity, scale and feel between global settings buffer or from the currently playing pattern stat / status # Shows a quick summary of global parameters: Number of patterns loaded in the sequencer, Whether edit lock on or off, Current default velocity and gate
run # starts the sequencer on the next Ableton Link quantum boundary. stop # stops the sequencer on the next Ableton Link quantum boundary. q n.nn # Sets the Ableton Link quantum. This is effectively loop length for the entire sequencer. # The new quantum value will take effect when the current quantum ends. step n.nn # Sets the step value for the sequencer. The value is stored globally or with the pattern that has edit focus, # depending on whether use is set to global or pattern.
new [patternlabel] # Adds an empty pattern to the end of the pattern list. Anything you type after the word 'new' will be used as a label. # The empty pattern will have one empty step list and no real time lists. Edit focus will be set to point to the new pattern. play nn cue nn # change the playing pattern number. The pattern will change on the next quantum boundary. nn # change the playing pattern number if playlist chaining is off. e / edit # use the pattern menu to set edit focus e nn # sets edit focus, which shows which pattern is set to receive subsequent pattern commands. lock on # sets edit focus to follow the currently playing pattern, so if the playing pattern is changed, edit focus changes too. # This works when pattern chain mode is active, too. If edit is used to set edit focus directly, lock is turned off automatically. lock off # turns edit focus lock off label n/name # Sets a label for the current pattern. midi / m / channel / chan # Parameters: n[umber], real time, step, quick, off m 3 # set midi output channel to 3 m s # step mode m q # quick mode m rt # real time mode m off # switch midi out off <Tab> / <Shift-Tab> p / page 1 / page 2 / page hold change lower page display mode between step list, real time list and scale transposion activity copy # copies the pattern with edit focus to the end of the pattern list with its position reset and its label will have the word 'copy' appended. # If lock is enabled, edit focus doesn't change. reset # causes the current edit pattern's internal position counter to be reset to zero, so all lists will start playing from the beginning. # If the edit pattern also happens to be playing, then the reset will happen when global beat value returns to one. reset all # reset all patterns when global beat value returns to one. reset beat # for situaions where the current beat is incrementing in values that never reach an exact multiple of the current Ableton Link quantum value. # It takes the current beat value and shifts it to the next whole number. The sequencer will take this into account when it schedules its next step and there will be an audible glitch in timing. autoreset on # whenever a new pattern starts playing its list positions will start from the beginning each time. autoreset off # a pattern will pick up playing from where it was interrupted the last time is was playing clear # Clears the pattern which currently has edit focus. All step lists and real time lists are deleted. # The pattern's scale table and trig list is reset. delete # Deletes the pattern with edit focus and places a copy on the undo list. delete all # If delete all is used, all patterns are deleted at once. undo # Whenever a pattern is deleted or cleared, a copy of it is placed on the undo list. This command takes that copy and puts it back at the end of the pattern list. If the undo is used after a clear, the cleared pattern will remain in place.
vel n / velocity n # Sets default velocity for notes that do not have this values set individually. gate n.nn% # Gatelength is set as a percentage of current beat step length. e.g. 50% means the gate will be held open for half of each step. gate h / gate hold # If a note is followed be one or more rests, turning on gate hold means that note will be held open until the final rest, at which point normal gatelength is used. gate n / gate normal # Turn gate hold off
quit / exit # quit
- mloop - a live JACK MIDI looping system, using jack-midi. Loops are recorded, optionally with beat quantisation, and can then be played back, either once or looping. Console based. Last updated 2011.
python2 ./waf configure python2 ./waf python2 ./waf install
q # toggle quantization d # toggle delay before record s # synchronise playback b # set bpm. enter to exit 7 # select loop 7, or such t # change loop tempo. up/down arrow keys or type bpm. enter to exit r # start recording loop. press again to finish. z # start loop (once) x # start loop (loop) c # stop loop C # stop all e # erase loop S # save L # load
- https://github.com/arminmaleki/midi-looper - Extends the abilities of a humble Midi keyboard for live performance. Helps to create midi loops and adds various other control functionalities. It interfaces with Jack audio on Linux systems.
- LiveLoop - a live midi sequencer that enables you to record loop while playing piano on a keyboard. You can record, play or delete midi tracks directly with your midi controller. You can connect LiveLoop to other synthesizer software like Reason, Ableton, etc. Java, dead?
- YouTube: LiveLoop
- https://github.com/MaurizioB/mol - MIDI Organic Looper, a simple MIDI looper which does not aim to work like standard sequenced loopers. It just takes what you play and, once it recognizes a repetition, it plays. last updated 2016.
- https://github.com/tsoding/dimooper - Digital Music Looper application focused on live performance.
Rust, somewhat buggy. Slow updates.
- midiloop - creates an ALSA-MIDI client, and records and replays sets of loops. There can be up to sixteen Loopsets. Each loopset can have up to sixteen midi-channels, each of which can be muted or unmuted. Once midiloop is launched, all the user-interface is driven by the keys of the midi-keyboard (not the computer-keyboard). This leads to fast operation in a performance situation. The user-interface depends on the computer-screen being visible by the performer, because it tells you what the current status is and what your options are.
- locoseq - a midi sequencer designed for live playing looping tracks. You can create control tracks (called "meta-tracks") that drive the sequencer (schedule track x, mute, change tempo...) and you can configure how the sequencer reacts on a given input (midi-in port or keyboard). The application is build on top of the jack API, it is written in ocaml (except some C code) and uses GTK+ and glade (lablgtk2) for its GUI. The source code is available under a classic MIT license. Last updated 2008.
- TiSM - an interactive & programmable software which allows to transform, record and sequence generic Midi messages in Real - time. The main idea is to provide a system that behave like a hard sequencing machine more than a traditionnal computer sequencer software. TiSM allows to program the system behaviour by associating simple Tcl scripts with received messages (Midi keyboard, controller, computer keyboard) or sequenced messages, so the tool can be used for a lot of different real-time applications. The tool is fully customisable in order to answer to the different user needs. TISM is based on a TCL interpreter and each system functionnality is accesible with a special TCL function. The users can write TCL scripts which are executed at run-time. This allows to control the sequencer in response to external events (MIDI, keyboard... ) or scheduled events ( from the sequencer itself). Last updated 2008.
- MØØP - Midi Looper-Transformer, records all your key-strokes and knob twists and loops that, turning your instrument into a sort of player piano (that you can keep playing on). infinite overdub undo/redo - Windows/Mac
- https://github.com/jimm/strange_loops - MIDI looper