jsmidgen

To generate a MIDI file, create a Midi.File instance, add one or more Midi.Track objects to it, and populate the tracks with musical events (notes, instrument changes, tempo, etc.). Finally, use toBytes() or toUint8Array() to serialize the file for saving or transmission.

Note that time and duration are measured in "ticks". The library uses a hardcoded value of 128 ticks per beat (e.g., a quarter note has a duration of 128).

var fs = require('fs');
var Midi = require('jsmidgen');

var file = new Midi.File();
var track = new Midi.Track();
file.addTrack(track);

track.addNote(0, 'c4', 64);

fs.writeFileSync('test.mid', file.toBytes(), 'binary');

The library supports a fluid (chained) API, allowing you to build tracks and sequences in a single continuous statement. This is useful for concise musical definitions.

Key aliases available in the fluid API:

• note() is an alias for addNote()
• instrument() is an alias for setInstrument()
• noteOn() is an alias for addNoteOn()
• noteOff() is an alias for addNoteOff()

var fs = require('fs');
var Midi = require('jsmidgen');

var file = new Midi.File();
file
  .addTrack()
    .note(0, 'c4', 32)
    .note(0, 'd4', 32)
    .instrument(0, 19)
    .addChord(0, ['c4', 'e4', 'g4'], 64)
    .noteOn(0, 'c4', 1)
    .noteOff(0, 'c4', 384);

fs.writeFileSync('test2.mid', file.toBytes(), 'binary');

The Midi.File class manages the overall MIDI file structure and serialization.

Use the Midi.File class to represent a complete MIDI file. You can specify the ticks (ticks per beat, default 128) and provide an array of Midi.Track objects. The class provides methods to serialize the file into various formats like a byte array, Uint8Array, or a Blob for browser use.

const midiFile = new Midi.File({ ticks: 480 });
const track = new Midi.Track();

// Add content to track...

midiFile.addTrack(track);

// Export to different formats
const bytes = midiFile.toBytes();
const uint8 = midiFile.toUint8Array();
const blob = midiFile.toBlob(); // Returns audio/x-midi

The Midi.Track class is used to compose sequences of MIDI events. It supports a fluid API for adding notes, chords, and meta-events (like tempo or time signature).

const track = new Midi.Track();

// Add a single note (channel, pitch, duration, time, velocity)
// Pitch can be a number (60) or a string ("c4")
track.addNote(0, "c4", 128, 0, 90);

// Add a chord (channel, array of pitches, duration, velocity)
track.addChord(0, ["e4", "g4", "c5"], 256, 100);

// Set track metadata
track.setTempo(120, 0);
track.setInstrument(0, 1, 0); // Set instrument on channel 0

// Add manual events
track.addEvent(new Midi.MidiEvent({ type: Midi.MidiEvent.NOTE_ON, channel: 0, param1: 60, time: 0 }));

Use these methods on a Midi.Track instance to add MetaEvents that control the playback environment:

• setTempo(bpm, time): Sets the beats per minute.
• setTimeSignature(numerator, denominator, time): Sets the time signature. The denominator must be an exact power of 2.
• setKeySignature(accidentals, minor, time): Sets the key signature. accidentals is the number of sharps (positive) or flats (negative). minor is a boolean.
• setInstrument(channel, instrument, time): Sets the program change (instrument) for a specific channel.

const track = new Midi.Track();

track.setTempo(140, 0);
track.setTimeSignature(4, 4, 0);
track.setKeySignature(1, true, 0); // 1 sharp, minor key
track.setInstrument(0, 1, 0);    // Channel 0, Instrument 1

The Midi.Util object provides helper functions for musical notation conversion:

• midiPitchFromNote(n): Converts a symbolic note name (e.g., "c4", "f#3") to a numeric MIDI pitch.
• noteFromMidiPitch(n, [returnFlattened]): Converts a numeric MIDI pitch to a symbolic note name. If returnFlattened is true, it prefers flats (e.g., "gb") over sharps (e.g., "f#").
• ensureMidiPitch(p): A convenience function that accepts either a number or a note name string and always returns a numeric MIDI pitch.

const Util = Midi.Util;

// Note name to pitch
const pitch = Util.midiPitchFromNote("c4"); // 60

// Pitch to note name
const note = Util.noteFromMidiPitch(60); // "c4"
const flatNote = Util.noteFromMidiPitch(61, true); // "db4"

// Flexible conversion
const p1 = Util.ensureMidiPitch("a#4"); // 73
const p2 = Util.ensureMidiPitch(73);      // 73

These constants define the types of meta-events used in MetaEvent objects.

MetaEvent.SEQUENCE        = 0x00;
MetaEvent.TEXT            = 0x01;
MetaEvent.COPYRIGHT       = 0x02;
MetaEvent.TRACK_NAME      = 0x03;
MetaEvent.INSTRUMENT      = 0x04;
MetaEvent.LYRIC           = 0x05;
MetaEvent.MARKER          = 0x06;
MetaEvent.CUE_POINT       = 0x07;
MetaEvent.CHANNEL_PREFIX   = 0x20;
MetaEvent.END_OF_TRACK    = 0x2f;
MetaEvent.TEMPO           = 0x51;
MetaEvent.SMPTE           = 0x54;
MetaEvent.TIME_SIG        = 0x58;
MetaEvent.KEY_SIG         = 0x59;
MetaEvent.SEQ_EVENT       = 0x7f;

These constants define the type of MIDI channel messages used in MidiEvent objects.

MidiEvent.NOTE_OFF           = 0x80;
MidiEvent.NOTE_ON            = 0x90;
MidiEvent.AFTER_TOUCH        = 0xA0;
MidiEvent.CONTROLLER         = 0xB0;
MidiEvent.PROGRAM_CHANGE     = 0xC0;
MidiEvent.CHANNEL_AFTERTOUCH = 0xD0;
MidiEvent.PITCH_BEND         = 0xE0;