MIDI Programming Tips

MIDI (Musical Instrument Digital Interface) is the language that allows music production software to communicate with synthesizers, samplers, and virtual instruments. Despite its decades-old specification, MIDI remains the backbone of modern music production. Mastering MIDI programming separates producers who create realistic, expressive performances from those whose productions sound robotic and lifeless. This comprehensive guide covers MIDI programming techniques, humanization approaches, and practical workflows that transform sequenced parts into genuine musical performances.

Overview

MIDI data captures information about notes (pitch, velocity, timing), as well as continuous controllers (modulation, expression, filter cutoff, and more). Unlike audio recording, MIDI is infinitely editable—you can adjust timing, velocity, pitch, or any parameter after the fact. This flexibility is MIDI's greatest strength and also its greatest pitfall: it's easy to create perfectly quantized, perfectly metronomic, perfectly lifeless performances. Understanding how to use MIDI's flexibility to create human, expressive performances is essential for professional music production.

Key Points

MIDI velocity variation is the single most important factor in creating realistic performances

Humanization (slight timing variations, note-length variations) separates human from mechanical performances

MIDI controllers (CC data) allow real-time parameter modulation and expression

Note timing and length are editable after recording, allowing perfect correction while maintaining performance feel

Different instruments require different MIDI programming approaches (strings vs. drums vs. synths require different humanization)

Swing and shuffle timing create groove and pocket rather than strict quantization

MIDI editing tools (tools for batch velocity editing, micro-timing adjustments, etc.) dramatically speed up workflow

Detailed Guide

Understanding MIDI Basics

MIDI data consists of several components: Note On/Off Events: Define when a note starts and stops

Pitch: Which note is being played (C3, D#4, G5, etc.)

Velocity: How hard the note is hit (0-127, where 0 is note-off, 1 is barely audible, 127 is maximum)

Timing: When the note occurs in the timeline

Duration: How long the note sustains

Controller Data (CC): Continuous parameters that change over time

CC1 (Modulation): Controls vibrato, brightness, or other parameters on synthesizers

CC7 (Volume): Controls the volume of a track

CC11 (Expression): Controls the dynamic expression of an instrument

CC64 (Sustain Pedal): Controls sustain on keyboards

CC74 (Filter Cutoff): Controls filter cutoff on synthesizers

Custom CCs allow control of any synthesizer parameter

Pitch Bend: Subtle pitch shifting, often used for expression Aftertouch: Pressure applied after striking a key Understanding these components is foundational to creating expressive MIDI performances.

Velocity Variation: The Most Important Humanization Technique

Velocity—how hard a note is struck—is the single most important factor in creating realistic MIDI performances. Human performers never hit keys with identical force. Varying velocity creates:

Realistic dynamics

Musical emphasis

Expressive variation

Appropriate stress on important notes

Typical velocity patterns (as percentages of maximum, 127): For melodic instruments (strings, brass, vocals):

Notes at phrase beginnings: 85-100% (emphasized)

Notes in middle of phrases: 70-85% (moderate)

Final notes of phrases: 60-75% (tapering off)

This creates natural phrasing that mimics breathing

For rhythmic instruments (drums, percussion):

Main beats (1 and 3): 95-100% (strong)

Secondary beats (2 and 4): 80-90% (moderate)

Off-beats/ghost notes: 50-70% (light)

This creates pocket and groove

For pads and sustained notes:

Often consistent velocity (90-100%) since the sound isn't dynamic

Variations can add expression when deliberately programmed

Practical workflow for adding velocity variation:

First, program all notes at identical velocity (e.g., 100)

Quantize timing to make notes rhythmically accurate

Now adjust velocities to create musicality

Identify the "important" notes (downbeats, melodic peaks, phrase starts)

Increase velocity on important notes to 90-100%

Reduce velocity on less important notes to 70-85%

Further reduce velocity on ghost notes or ornaments

Many DAWs allow velocity range adjustments across multiple notes simultaneously, speeding this process significantly.

Timing Humanization: Creating Groove Through Micro-Timing

While proper quantization is important for clarity, absolutely perfect quantization sounds mechanical. Subtle timing imperfections create groove. Types of timing variations: Swing and Shuffle: Intentional, consistent timing shifts that create groove

Traditional swing: Offbeat notes (e.g., the "and" of beats) are delayed by 15-30%

Shuffle: Similar but often with more dramatic offsets (40-60%)

Most DAWs have swing/shuffle parameters that apply this globally

Example in a drum pattern:

Straight quantization: Eighth-note hi-hats hit exactly on 0, 50, 100, 150, 200, 250, 300, 350 (millisecond timeline)

With 30% swing: Eighth-note hi-hats hit on 0, 70, 100, 170, 200, 270, 300, 370 (offbeats delayed by 20ms)

This creates a relaxed, groovy feel

Random micro-timing: Slight random variations that prevent mechanical feeling

Apply ±10-30 ms random timing variations to notes

Usually reduced for important notes, increased for texture notes

Creates human imperfection without obvious randomness

Intentional timing shifts: Some notes are slightly early or late for expression

A note rushed slightly (5-10 ms early) sounds anxious, urgent

A note delayed slightly (10-20 ms late) sounds relaxed, behind the beat

Used intentionally on specific notes creates character

Practical swing application:

Quantize all notes to the grid first (ensures clarity)

Apply global swing parameter (usually 50-70%)

Listen to the groove—does it feel natural?

Adjust swing percentage until it feels right

For some tracks, apply random micro-timing in addition to swing

Note Length and Sustain Variation

Beyond velocity and timing, how long notes sustain matters significantly. Staccato vs. Legato:

Staccato notes: Short duration (typically 50-70% of the note value)

Legato notes: Longer duration (typically 90-100% of the note value)

Mixing these creates expressive variation

Example with half notes:

Staccato half note: Sustains for 25% of the half note duration (short, punchy)

Normal half note: Sustains for 75% of the half note duration

Legato half note: Sustains fully until the next note starts

Using different note lengths in a melody creates interest

Practical workflow:

Program all notes with consistent length (e.g., 90% of note value)

Identify articulation opportunities

Reduce length on staccato notes to 50-60%

Extend length on legato passages to full note duration

Create emphasis through note-length variation

Sustain pedal data: For piano or organ recordings, sustain pedal data (CC64) is crucial. Program sustain on held chords, release sustain before new chords. This creates realistic piano behavior.

MIDI Controller Automation for Expression

Beyond note data, MIDI controllers allow continuous parameter modulation creating expressive, evolving performances. Common controller uses: Modulation (CC1) on string instruments:

Start at 0 for the first 100 ms (no vibrato)

Gradually increase to 60-80 over the duration of the note

This creates realistic vibrato that develops over time

Expression (CC11) for dynamic evolution:

Start at 40-50 at note beginning

Gradually increase to 80-100 over the note duration

Creates a swelling, expressive performance

Filter Cutoff (CC74) on synthesizers:

Program filter to sweep open during pad sustains

Or decrease during release for darkening effect

Creates animation and movement in static sounds

Breath CC (CC2) on wind instruments:

Start high at note attack

Decrease slightly during sustain

Increase again at release

Mimics natural breath control of wind players

Practical implementation:

Identify which controller(s) serve your instrument

Create CC automation lane in your DAW

Draw CC data curves that create expression:

- For strings: modulation increasing over time - For pads: filter cutoff opening gradually - For wind: breath decreasing then increasing

Use smooth curves (not stepped values) for musical expression

Humanization by Instrument Type

Different instruments require different humanization approaches: #### Drums and Percussion Kick drum:

Tight quantization (no timing variation)

Consistent velocity on main kicks

Slight velocity variation on swing kicks or ghost kicks

No note length variation (percussion doesn't sustain)

Snare drum:

Tight quantization on main snare hits

±5-10 ms timing variation on ghost snares

Main snares: 90-100% velocity

Ghost snares: 30-50% velocity

Short note duration (10-20% of note value, drums cut off quickly)

Hi-hats:

Swing/shuffle on closed hi-hats

Open hi-hats often delayed slightly (10-20 ms late) for swing effect

Velocity: 80-90% for main hits, 60-75% for ghost notes

Note duration: Very short (5-15% of note value)

#### Strings and Pads Legato articulation:

Notes overlap (one note's release overlaps next note's attack)

Slight timing delays (10-30 ms) between notes create legato feel

CC1 (modulation) automation creating vibrato

Expression automation (CC11) creating dynamic swell

Long note duration (100-110% of notated value)

Pizzicato (plucked):

Tighter quantization than legato

Short note duration (40-60% of notated value)

Lower velocity overall (70-85%)

Less modulation automation

#### Melodic Instruments (Brass, Woodwinds, Lead Synths) Expressive approach:

Slight timing variations reflecting phrasing

Velocity emphasis on melodic peaks

CC1 (modulation) for vibrato development

CC2 (breath) or CC11 (expression) for dynamic shaping

Note length variation reflecting articulation (staccato vs. legato)

#### Bass Pocket feel:

Slight timing variations (+5 to -15 ms) on certain notes to sit behind or ahead of the beat

Consistent velocity on the root notes

Velocity variations on passing notes and fills

Note length: mostly consistent but occasionally staccato for articulation

Advanced MIDI Programming Techniques

#### Swing Curves and Complex Timing Beyond simple swing, some producers use complex swing curves:

Different swing amounts for different note values (swing 16th notes at 40%, eighth notes at 30%)

Swing that changes over the course of the song (less swing in verses, more swing in choruses)

Intentional mis-quantization creating specific pockets

#### Arpeggio Programming Rather than playing chords as simultaneous notes, program them as arpeggio patterns:

Notes of a chord spread across 100-500 ms

Each note at slightly different velocity (lower velocity for earlier notes, higher for later)

Creates shimmer and movement in pad patterns

#### Polyrhythmic Layering Program multiple instruments with different swing/timing:

Drums in straight time (swing 0%)

Strings with 40% swing

Pads with 20% swing

Bass slightly behind the beat

Creates complex, evolving rhythm

#### Conditional Processing Use MIDI rules or tools to batch-adjust velocities based on criteria:

Reduce all velocities below a threshold by a percentage

Increase all first notes of phrases by a certain amount

Invert velocity (high velocities become low, vice versa)

These tools (common in advanced DAWs) speed up humanization dramatically

Quantization: Getting the Balance Right

Quantization is snapping notes to the grid. The challenge is quantizing enough for clarity while maintaining human feel. Full quantization (100%):

Notes snap completely to the grid

Tight, precise timing

Can sound mechanical if not humanized

Good for: electronic music, heavily sequenced parts, specific stylistic choices

Soft quantization (50-75%):

Notes move partially toward the grid

Maintains some original timing variation

Sounds more human while staying mostly tight

Good for: most organic-sounding productions

No quantization (0%):

Original recorded/programmed timing preserved

Requires careful recording to be usable

Most human-sounding but riskier

Good for: capturing feel from live recording or intended timing imperfection

Workflow: Most producers use soft quantization (70-80%) as a middle ground—correcting obvious mistakes while preserving performance feel.

Common MIDI Programming Mistakes

All notes same velocity: The most obvious indicator of poor MIDI programming. Always vary velocity based on musicality. No swing on drums: Perfectly quantized drums sound stiff and unmusical. Almost all drum programming benefits from swing or shuffle. Too much humanization: Random micro-timing variations everywhere creates chaos. Reserve humanization for organic instruments; keep drums and electronic elements tighter. Ignoring note sustain/length: All notes held the same duration sounds unmusical. Vary note length based on articulation. Not using MIDI controllers: CC automation makes the difference between mechanical and expressive performances. Program modulation, expression, and other controllers intentionally. Over-quantizing everything: Tight quantization on every note removes all feel. Balance tight quantization on rhythm with looser humanization on melody. Forgetting to humanize the humanization: Even your humanization variations should have variation—not a consistent ±10 ms on every note, but 5 ms here, 15 ms there.

MIDI Editing Tools and Workflow

Modern DAWs include powerful MIDI editing tools: Piano Roll: Visual representation of MIDI notes allowing point-and-click editing of pitch, velocity, and timing. List Editor: Text-based MIDI editing for precise control. MIDI Quantize Tools: Batch quantization with soft/hard quantization options. Humanize Tools: Automatic humanization applying velocity and timing variations. Transpose/Transpose by Scale: Change pitch of notes while respecting musical scale. Select by: Select notes based on criteria (pitch, velocity range, timing) for batch operations. Velocity Ramp: Create velocity curves (gradually increasing or decreasing) across multiple notes. Time Shift: Move selected notes forward or backward in time. Effective workflow:

Record or program basic MIDI notes

Quantize to the grid (soft quantization, 70-80%)

Adjust pitches and durations to be musically correct

Apply global humanization (humanize tool) as starting point

Manually refine velocities based on musicality

Add swing/shuffle to drums and rhythmic elements

Program MIDI controller automation for expression

Compare to reference performances—adjust as needed

Recommendations for Professional MIDI Programming

Study MIDI of professional tracks: Export MIDI from professionally sequenced parts and study their velocity variations, timing, and controller data. Learn from how professionals approach humanization.

Record real performances when possible: Playing parts in real-time often produces more natural MIDI than careful programming. Combine live recording with manual refinement.

Use scale/key filters: Modern DAWs can restrict MIDI to specific scales. This prevents accidental wrong notes while allowing more expressive, less rigid programming.

Create custom humanization templates: Build humanization patterns (velocity curves, swing amounts, controller shapes) for different instrument types and save them for reuse.

Listen on multiple systems: MIDI expression that sounds good on headphones might be different on monitors. Verify your humanization decisions on multiple playback systems.

Compare constantly: Reference your MIDI parts to professional recordings of the same instruments. Are your velocity variations similar? Is your swing similar? Use these comparisons to refine your approach.

Document what works: Keep a journal of successful MIDI approaches for different instruments. Your own library of effective humanization becomes your reference.

---