MIDI, Virtual Instruments, and the Art of Programming Realistic (or Intentionally Unreal) Performances

The Ghost in the Grid

Tuesday, 11:40 p.m. Jaylen Cole's monitoring is finally calibrated — the nail-polish mark on the headphone knob from Chapter 8, the lies list taped to the wall — and for the first time in this book he's about to make actual music through it.

He opens FL Studio, loads the template he built in Chapter 6, and pulls up a piano. The plan is simple: a chord progression and a top-line melody, the harmonic bed for the track he's been circling for weeks. He doesn't play piano, so he does what every bedroom producer does. He clicks the notes in. Four chords, one bar each. A melody floating on top. He checks every note against the chords twice. The notes are right. He knows the notes are right.

He hits play.

It sounds like a doorbell. Not a bad doorbell — an expensive one, maybe, in a house with good taste. But a doorbell. The chords arrive like elevator floors. The melody sits on top with all the longing of a microwave announcing that the food is done. He A/Bs it against the reference track he's been studying — same kind of progression, same kind of patch — and the reference breathes. His version states. The reference plays. His version announces.

Here's the part that matters: the notes in the reference aren't better. Some of them are the same notes. Jaylen stares at his piano roll — that neat grid of identical gray rectangles, every note starting exactly on a line, every note the exact same loudness — and for once he asks the right question. Not "what notes am I missing?" but "what else is in a performance besides the notes?"

Twenty minutes later he has an answer, because twenty minutes is genuinely all it takes once you know where to look. He shapes the loudness of the notes into arcs — phrases that lean in and back off, melody notes louder than the chord tones under them. He drags chord notes a few milliseconds apart so each chord blooms bottom-to-top instead of detonating. He pulls the second hit of every bar slightly late, the way a player relaxes into a bar. He shortens some notes and lets others ring, so the line breathes between phrases instead of running on like a fire alarm. He adds one controller lane for the sustain pedal, because pianists have feet.

Same notes. Every single pitch identical to the doorbell version.

He hits play and the hair on his arms goes up, because there's somebody in there now. A player. A person with intentions, leaning on some notes and letting others go, rushing slightly toward the chorus that doesn't exist yet. Jaylen didn't record a performance. He programmed one — note by note, decision by decision — and his ears can't tell the difference. At 2 a.m. he types a note into his phone, the place all his best thinking lands:

"the ghost in the grid. the notes are the skeleton. the performance is everything i did tonight."

That's this chapter. MIDI is the most powerful instrument you own precisely because it isn't sound at all — it's instructions, infinitely revisable, played by instruments that live in your computer and never need tuning, coffee, or a second take. The gap between MIDI that sounds like a ringtone and MIDI that sounds like a record is not talent and it's not money. It's a learnable set of moves — velocity, timing, note length, controller data — plus one big aesthetic decision about when you want the machine to hide and when you want it to show. By the end of this chapter you'll have the moves, and "Static Bloom" will have its first real notes.

🏃 Fast Track: Read "MIDI Is a Script, Not a Recording," then go straight to "Velocity: The Expression Channel," "Humanization That Mimics Intention," and the workflow in "The Practice." Do the Project Checkpoint — it's the first one where you make music — and take the common-mistakes table with you.

🔬 Deep Dive: Read in order, including the General MIDI sidebar (it explains forty years of "MIDI sounds bad" slander in five minutes). Then run the full DAW Lab in the exercises — the stiff-then-humanized drill is this chapter in your hands — and read both case studies: one dissects feel at the millisecond level, the other explains why fake orchestras make your skin crawl.

The Player Piano Already Knew

You've met MIDI's great-grandparent, probably in a movie saloon scene: the player piano. A real piano, hammers and strings and all, played by a roll of paper with holes punched in it. Each hole says this note, now, for this long. No sound lives on the paper. The paper is instructions. The piano is the instrument. Swap the roll, the same piano plays a different song; swap the piano, the same roll plays on different strings.

Here's the detail that makes player pianos the perfect teacher for this chapter. Early rolls were punched mechanically from sheet music — every note exact, every duration mathematical — and listeners reliably described them the way Jaylen described his doorbell: correct and dead. So manufacturers built reproducing pianos, systems designed to capture a real pianist's performance — the timing, and on the fancy systems even the dynamics — onto the roll. Famous pianists and composers of the era, George Gershwin among them, recorded rolls this way. And people could hear the difference between a punched roll and a played one. A century ago, with paper and pneumatics, the industry had already discovered this chapter's whole thesis: the notes are the smallest part of a performance. The life is in the deviations.

You re-run this experiment every day without noticing. A phone ringtone playing a pop melody is recognizably the song and recognizably not the record — instructions rendered by a polite little engine, no human in the loop. Old video game soundtracks lived the same way: cartridges were too small for recorded audio, so games shipped note lists that the console's sound chip performed live, every time, identically. Some of that music is glorious — hold that thought, because "identical every time" becomes an aesthetic later in this chapter — but nobody mistakes it for a band.

Your ear, in other words, already contains a precision instrument for detecting whether music was played or typed. This chapter teaches your hands what your ears already know.

The Science: Instructions, Not Audio

MIDI Is a Script, Not a Recording

MIDI — the Musical Instrument Digital Interface — is a language for describing musical actions. Not sound. Actions. A MIDI file or clip contains messages like press the 60th key, this hard, now and release it now and push the mod wheel halfway up. It's a script waiting for an actor, sheet music for machines, the player piano roll grown up and gone digital.

The history is short and unusually heartwarming for this industry. In the early 1980s, synthesizers were multiplying and none of them could talk to each other. Two competitors — Dave Smith of Sequential Circuits and Ikutaro Kakehashi of Roland — led an effort to fix that with a free, open standard rather than a proprietary land grab. At the NAMM trade show in January 1983, a Sequential Prophet-600 and a Roland Jupiter-6 were cabled together in public: play one, the other sounds. It worked. The MIDI 1.0 specification published that year conquered the entire industry and then barely changed for almost four decades — we'll get to why in this chapter's sidebar — and in 2013 Smith and Kakehashi shared a Technical Grammy for it. Every beat you've ever made in a DAW runs on their handshake.

What's actually in the messages? The vocabulary you'll touch every week is small:

The working MIDI vocabulary. Sixteen channels can carry independent streams of these messages down one cable or one track.

Notice the number 127 everywhere. MIDI 1.0 is a 7-bit language: every knob, key, and dynamic resolves to 128 steps. That's the spec from 1983 — designed to scream down a cable at 31,250 bits per second, which was quick then — and it is still, overwhelmingly, what your DAW speaks today. 128 steps of velocity turns out to be plenty for most music; 128 steps of a slow filter sweep can audibly stair-step, which is one of the things MIDI 2.0 finally fixes (sidebar, again).

Here's the diagram worth pinning to your mental wall — where MIDI lives in the signal chain you mapped in Chapter 3:

 YOUR HANDS                      THE SCRIPT                THE ACTOR              SOUND
┌────────────────┐   MIDI    ┌────────────────┐   MIDI   ┌──────────────────┐  ┌─────────────┐
│ controller     │ messages  │ MIDI track in  │ messages │ VIRTUAL          │  │ audio:      │
│ (keys / pads / ├──────────►│ your DAW       ├─────────►│ INSTRUMENT       ├─►│ to fader,   │
│ mouse clicks)  │  "C3 on,  │ (recorded or   │ (edited, │ (sampler/synth   │  │ bus, FX,    │
└────────────────┘  vel 92"  │ clicked in —   │  always) │ plugin) renders  │  │ 2-bus, ears │
                             │ NO SOUND HERE) │          │ notes → SOUND    │  └─────────────┘
                             └────────────────┘          └──────────────────┘
       ▲                            ▲                            ▲
   performance                 the editable               swap this freely —
   (optional!)                 part — velocity,           the script doesn't
                               timing, length,            care who performs it
                               CC all live here

MIDI signal flow: instructions travel left to right and only become audio inside the virtual instrument. Everything upstream of that box is editable forever.

This architecture is the tradeoff at the heart of the chapter — theme three, wearing its friendliest face. Because MIDI is instructions, nothing is committed. Wrong chord in the recorded take? Drag the note. Tempo needs to drop four BPM? The notes follow; audio would smear (the elastic-audio rescue comes in Chapter 15, with bills attached). Hate the piano sound entirely? Swap the instrument; the performance survives, untouched, because the performance was never in the sound. Jaylen will cash this exact check in the Project Checkpoint: the pad sound he uses tonight is a placeholder, and the real "static bloom" patch he designs in Chapter 14 will inherit every note and every nuance he programs now.

And the cost of all that freedom? Nothing is committed. The audio engineer's version of a blank page. A recorded vocal take is a fact — flawed, alive, finished. A MIDI clip is a permanent invitation to fiddle, and producers have died of fiddling. Part of this chapter's job is teaching you when to stop.

The Piano Roll: Learn to Read the Grid

The piano roll is where you'll spend more hours than any other screen in your DAW, so let's get genuinely fluent instead of merely familiar. The layout is universal across every DAW (Appendix E translates the button names): pitch runs vertical — a piano keyboard up the left edge — time runs horizontal, and each note is a rectangle whose left edge is when it starts, whose length is how long it holds, and whose lane on the keyboard is its pitch. Below or beside the notes lives at least one more lane: velocity, usually drawn as bars, plus lanes for CC data.

        │ bar 1                          │ bar 2
  C4    │        ▓▓▓▓▓▓▓▓                │           melody (top voice)
  B3    │                  ▓▓▓▓          │
  A3    │ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  │ ◄── chord tones
  E3    │ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  │     (the Am pad, held)
  C3    │ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  │
  A2    │                                │
  A1    │ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓▓   │ ◄── bass (the floor)
        ├────────┬────────┬────────┬─────┤
 VELOCITY  ██       █▓       ██      █     ◄── velocity lane: bar height =
        │  92       74       88      81       how hard each note speaks
        └─ 1 ────── 2 ────── 3 ────── 4 ──    (beats)

Piano-roll anatomy: pitch vertical, time horizontal, length = duration, and the velocity lane underneath — the part beginners scroll past and professionals live in.

Fluency means you stop seeing rectangles and start seeing music. A chord is a vertical stack — and you can see whether it's tight or muddy by how tightly the stack clusters at the bottom of the keyboard (low, close-packed notes fight in the mud zone you learned to hear in Chapter 4). A bassline is the floor of the building. A melody is a contour — does it arc somewhere, or flatline? Call-and-response between two parts is visible as alternating clusters. Dense traffic everywhere, all bars filled, no gaps? You're looking at a clarity problem before you've heard a note — the amateur adds, the professional subtracts, and the piano roll shows you which one you're being.

Two grid skills matter immediately. First, grid resolution: the vertical lines you snap to can be quarter notes, eighths, sixteenths, or triplet divisions — and programming a triplet feel against a sixteenth grid is the classic source of "why does this sound wrong, the notes are right." Match the grid to the rhythm you're writing, and learn the keystroke that toggles snap off entirely. Second, note ends are musical decisions. Beginners obsess over where notes start and let every note end wherever the rectangle happened to get drawn. A bassline of identical pitches goes from plodding to pocketed purely by note length — short-short-short-loooong reads as a phrase; four identical lengths read as a metronome with a hobby. We'll weaponize this in the idioms section.

🔄 Check Your Understanding

1. Your bandmate says "send me the MIDI so I can hear the song." What's wrong with that sentence, and what would they actually need?
2. In the signal-flow diagram, list two things you can change after recording a MIDI performance that a recorded audio take wouldn't let you change as cleanly.
3. Why does a chord voiced C2–E2–G2 look like trouble in the piano roll to a Chapter 4-trained eye?

Verify

1. MIDI contains no sound — it's instructions. They'd hear nothing without a virtual instrument to perform it, and on a different instrument it won't sound like your version. Send rendered audio to share a sound; send MIDI to share a performance.
2. Any of: the notes themselves (drag a wrong pitch), the tempo (notes follow the grid; audio would need warping), the instrument (swap the plugin entirely), velocity/timing/length of every note, CC data. The performance and the sound are separate layers.
3. Three notes packed close together that low live around 65–100 Hz and their harmonics pile into the 200–400 Hz mud zone — close-voiced low chords are a masking pileup you can see coming. Spread the voicing or raise it.

Velocity: The Expression Channel

If this chapter let you keep only one tool, it would be this one. Velocity is the number, 0–127, that rides along with every note you play or click, recording how hard the key was struck. Beginners read it as "volume knob per note." It is so much more than that, and the difference is the whole game.

Think back to Chapter 1: timbre is the recipe of harmonics, and on real instruments that recipe changes with effort. Strike a piano key gently and you get a round, dark tone — the fundamental and a few polite overtones. Strike it hard and the hammer felt compresses, the string's motion goes nonlinear, and the sound gets brighter, not just louder — more upper harmonics, sharper attack transient, a different animal. Same with a plucked bass string, a struck drum, a brass player pushing air. Loudness and brightness travel together in nature. Your ear has spent your whole life learning that correlation, which is why a "louder" note that doesn't also change character reads instantly as fake — it's the sonic equivalent of a photo where the shadows don't match the light.

Good virtual instruments honor this: velocity doesn't just turn notes up, it selects different recordings or different synthesis behavior — darker samples at low velocity, brighter and snappier ones up high (the mechanics arrive two sections from now). Which means a velocity lane full of identical values isn't merely "flat dynamics." It's one single timbre, stamped over and over, the sonic texture of a rubber stamp. Flat velocity is the loudest amateur tell in all of programming — louder than wrong notes, because wrong notes at least sound like a person failing, while flat 100s sound like nobody at all.

Here's the same two bars of melody, before and after a velocity pass:

 BEFORE — the rubber stamp                AFTER — a phrase with a spine
 127┤                                     127┤
    │                                        │
 100┤ █  █  █  █  █  █  █  █             100┤          █
    │ █  █  █  █  █  █  █  █                │       ▓  █  ▓
  75┤ █  █  █  █  █  █  █  █              75┤    ▓  ▓  █  ▓  ▓
    │ █  █  █  █  █  █  █  █                │ ▓  ▓  ▓  █  ▓  ▓  ░
  50┤ █  █  █  █  █  █  █  █              50┤ ▓  ▓  ▓  █  ▓  ▓  ░  ░
    └─┴──┴──┴──┴──┴──┴──┴──┴─               └─┴──┴──┴──┴──┴──┴──┴──┴─
      1  &  2  &  3  &  4  &                  1  &  2  &  3  &  4  &
      every note identical                    rises toward the peak on
      = announcement                          beat 2&, falls away to a
                                              whisper = INTENTION

The velocity lane before and after shaping. The "after" isn't random variety — it's an arc: the phrase leans toward its peak and exhales after. That shape is what reads as a player.

The craft of the velocity pass comes down to a few reliable shapes, learned once and applied forever:

Velocity recipes. Numbers are anchors, not laws — your ears, through your Chapter 8-calibrated monitoring, make the final call.

A practical note on range: most musical programming lives roughly between velocity 50 and 110. Pinned at 127 everything is shouting (and many instruments sound strained there by design); below 40, good libraries get whispery and soft in ways that vanish under other tracks. And one habit to install tonight: when you record from a controller, your velocities arrive already alive — imperfect, human, shaped by your actual hands. Don't flatten them in a fit of tidiness. Half of humanization is just not deleting the humanity you captured for free.

🔄 Check Your Understanding

1. Velocity changes two things on a well-made virtual instrument, not one. Name both, and connect the second to Chapter 1's timbre concept.
2. A chord sounds "blocky" even though its velocities aren't all identical — they're random values between 80 and 100. What's missing?
3. What's the cheapest way to build tension across eight bars without adding a single note?

Verify

1. Loudness and timbre: real instruments get brighter (more upper harmonics, sharper transients) when struck harder, so good instruments switch to brighter samples or behavior at higher velocities. Velocity is a timbre selector wearing a volume costume.
2. Structure. Random variety isn't expression — the chord needs a hierarchy: top (melody) note loudest, inner voices tucked, the relationship consistent chord to chord. Intention, not jitter.
3. A slow velocity creep upward across the section — more energy, more brightness, no new parts, no new clutter.

Quantize With Taste

Quantize is the command that snaps notes to the grid. It is simultaneously the most useful and most abused button in your DAW, and the difference is one slider most beginners never touch.

The naive use: record a part, hit quantize, every note teleports to the nearest gridline, the timing is now "perfect." And the part is now dead — you've heard this corpse already, in Jaylen's doorbell and the punched piano rolls. Perfect timing reads as no one home. But the opposite extreme is no better: a sloppily played part left raw doesn't sound human, it sounds bad, and "I left it loose for the feel" is the producer's version of "the dog ate it." The craft lives between the extremes, and it has three controls:

Quantize strength (sometimes "amount" or "iterative quantize") moves notes partway to the grid — 50% strength moves a note half the distance to its gridline. This is the single most valuable setting in the section. A take quantized at 100% is gridlocked; at 50–80%, the take keeps its push and pull, just less of it — the player's intentions, tidied. Working habit: record your part, quantize around 50%, listen, repeat once more if needed. You're sneaking up on tight instead of teleporting to dead.

Swing delays every other subdivision — typically the offbeat eighths or sixteenths — by a percentage, turning straight time into shuffle. At 50% (or "0," depending on the DAW's labeling) the offbeats sit exactly halfway between beats: straight. Push toward the mid-50s and beyond, and the offbeats lean late; the part starts to strut. You can hear swing in two seconds: count "1-and-2-and" with even "ands," then again with the "ands" arriving fashionably late. That lean is swing. For now, treat it as a seasoning you apply by ear and in small amounts — the full groove vocabulary, swing percentages by genre, hat languages, and why a certain drum machine's shuffle changed music — all of that is Chapter 13's deep work, and I'd rather you arrive there with curiosity than with half-learned numbers.

Off-grid pockets is the hand-tool version: deliberately placing or nudging specific notes ahead of or behind the grid, on purpose, unevenly. The chord that lands a hair late feels relaxed; the bass note that arrives a hair early feels eager. Sustained pads often want to start before the gridline so their slow attacks bloom on it — a move you'll use tonight in the checkpoint. These micro-placements are where feel actually lives, and Chapter 13 builds a whole groove language out of them. Here, learn the principle: the grid is a reference, not a residence.

The quantize menu, with prices. The slider between "tight" and "alive" is yours to set — the crime is not knowing it exists.

One workflow rule ties this together: quantize note starts, almost never note ends. Snapped endings create robotic gaps and clipped releases; real notes end where the phrase breathes, not where the ruler says. And when a part is built from clicked-in notes rather than a played take, quantize has nothing to humanize — which is exactly why the next section exists.

🧩 Productive Struggle

Before reading on: here's a four-chord pad progression, clicked in — every note starts exactly on bar lines, every velocity is 100, every chord holds exactly four beats, all notes in each chord start simultaneously. It sounds like Jaylen's doorbell. You now know velocity shapes and off-grid placement exist. Write down, specifically, five edits you'd make to this clip to convince a listener a human played it. Pitches may not change. Think like a player: what do hands, ears, and intentions actually do that a grid doesn't? Commit to your five before the next section gives you its answer key.

Humanization That Mimics Intention, Not Randomness

Humanization is any technique that puts performance deviations back into programmed music. Your DAW has a button with this name. The button is mostly a lie, and understanding why will teach you more about performance than the button ever will.

The button's offer: add random jitter — shift every note's timing by a random amount within a range, wobble every velocity randomly. The hidden assumption: human deviation is noise. But listen to any player you love. Their deviations aren't noise — they're correlated with the music. A pianist rolls a chord bottom-to-top, the same direction nearly every time, wider when the moment is tender. A bassist sits behind the beat all verse — consistently behind, that's the point — then pushes ahead into the chorus. The deviations have direction, pattern, meaning. They are the performance. Randomize a grid and you don't get a musician; you get a machine with a tremor. Listeners can't always articulate the difference, but they feel it instantly: intention reads as a ghost in the grid; randomness reads as a malfunction.

So here is the answer key to the struggle above — the five families of structured humanization, in the order of audible payoff:

1. Velocity follows phrase shape. Arcs, accents, hierarchy — everything from the velocity section. This is half the magic on its own.
2. Chords roll. Offset the notes of each chord by a few milliseconds — engineers commonly use something like five to twenty — usually bottom-to-top like a hand falling. Wider rolls read as expressive, tighter as confident. Direction consistent; width varying with the moment.
3. Timing deviations are consistent per voice. The bass sits a touch late all the way through; the pad blooms early every bar. A voice that wanders randomly around the grid sounds drunk; a voice that leans one way sounds like it means it. (This is the seed of groove — Chapter 13 grows it into a tree.)
4. Note lengths breathe. Phrases need exits: shorten the last note before a gap, let the arrival note ring. Legato where the line flows, detached where it speaks. The silence between notes is a musical event, not an absence — the amateur fills space, the professional shapes it.
5. Repetition never repeats exactly. Second verse a hair softer than the first; the fourth identical chord hit slightly different from the third. Real players can't repeat themselves perfectly. That inability is what "alive" means.

 BEFORE: clicked in, all on grid          AFTER: structured humanization
 grid:  │........│........│....          grid:  │........│........│....
 pad:   █████████                         pad:  ████████▓            ◄ starts 20 ms EARLY —
 (C3)   │                                      ─┤                      slow attack blooms ON the beat
 pad:   █████████                         pad:   ▓████████           ◄ +6 ms — chord rolls
 (E3)   │                                       ├─                     bottom to top
 pad:   █████████                         pad:    ▓███████▓          ◄ +14 ms — top note last,
 (A3)   │                                        ├──                   and loudest (vel hierarchy)
 bass:  █████████                         bass:    ████████          ◄ +9 ms LATE, every bar —
 (A1)   │                                        ──┤                   consistent lean = pocket
        on the line = no one home                deviations small, DIRECTIONAL, repeatable
                                                 = somebody's playing

Humanization before/after. Every offset is small (5–20 ms), every offset has a reason, and each voice leans the same way it leaned last bar. Pattern, not noise.

How much is too much? Rules of thumb, hedged as always, by ear as always: offsets under about ten milliseconds read as tight ensemble; ten to twenty as relaxed and human; past thirty the parts start to audibly flam and smear, especially against anything percussive. But the real test isn't a number, it's the question from Chapter 4: listen with your brain. Does the part sound like it has somewhere it's going? Intention is the product. Milliseconds are just the packaging.

🔍 Why Does This Work?

Why does your ear care about deviations this small? Because your brain is a prediction machine. Psychologists call your ability to lock onto a beat entrainment — within a couple of bars you've built a model of where the next hit will land, and you're not just hearing the music, you're forecasting it. Deviations from the forecast are information. When the deviations correlate with musical structure — leaning into the chorus, relaxing on the resolution, melody louder than accompaniment — your brain reads them the way it reads body language: as evidence of an agent with intentions. When deviations are absent, the forecast is always exactly right, and the prediction machinery files the music under "mechanical, no agent present." When deviations are random, the forecasts fail without pattern, which reads as incompetence rather than expression. Performance research has documented for decades that skilled players systematically stretch and compress timing and dynamics with the shape of the phrase — expression isn't sloppiness, it's structured deviation. (The companion volume, The Physics of Music, digs into the perception science in its Chapter 5.) Your job in the piano roll is to fake that structure — and the wonderful, slightly unsettling news of Jaylen's 2 a.m. discovery is that faked intention, done with care, is indistinguishable from the real thing.

🔄 Check Your Understanding

1. Your DAW's humanize button adds ±15 ms of random timing to every note. Why does this usually sound worse than the gridlocked version, not better?
2. Name three deviation patterns from a real player that are directional rather than random.
3. The "ghost in the grid" is which ingredient, in one word?

Verify

1. Random jitter has no correlation with the music — no lean, no phrase shape, no consistency per voice. Listeners read patterned deviation as intention and unpatterned deviation as malfunction; the grid at least sounds deliberate.
2. Any three of: chords rolled consistently bottom-to-top; a bass sitting consistently behind the beat; rushing into a chorus / relaxing on a resolution; melody consistently louder than inner voices; repeated notes alternating in a hand-motion pattern; final notes of phrases shortened for breath.
3. Intention. (Accept: agency, a player. The deviations are how it gets into the file.)

Virtual Instruments: Recorded Truth and Generated Possibility

Time to meet the actors who perform your scripts. A virtual instrument is a plugin — Chapter 6's "DSP in a box," but one that generates audio from MIDI rather than processing audio that already exists. You insert it on an instrument track, feed it notes, and it hands your DAW sound. Every virtual instrument you'll ever use descends from one of two philosophies, and knowing which one you're holding tells you what it'll be good at before you play a note.

Samplers are recorded truth. A sampler plays back recordings — real piano notes, real violin bows, real drum hits, captured in a real room through real mics (every Chapter 7 lesson happened on someone else's budget, baked into the product). When you press C3, a recording of an actual C3 plays. The strength is obvious: that is a piano, with all the complexity of felt and string and wood that no equation fully captures. The weakness is the flip side: you get what was recorded. The dynamics that were captured, the articulations that were captured, the room that was captured. Ask a sampled piano to do something the session never recorded, and the illusion creaks — which is why the depth of the sampling matters so much that it gets its own section, next.

Synths are generated possibility. A synthesizer builds sound from scratch — oscillators making raw waveforms, filters carving them, envelopes shaping them in time. (Recognize the vocabulary from Chapter 1? Sine, saw, square, harmonics — synthesis is that chapter with knobs on. The full guided tour, oscillator to patch, is Chapter 14, and I'll leave the deep teaching there.) A synth has no realism obligation and no realism ceiling-problem: it isn't pretending to be anything, so it can't fail at it. Pads wider than rooms, basses lower than instruments, sounds with no acoustic ancestor. The weakness mirrors the sampler's: a synth will never be a piano, and the "piano" preset on a cheap synth is a category error wearing a tuxedo.

Between them live romplers — preset-driven sample-playback instruments, the descendants of the workstation keyboards: big libraries of pre-made sounds, fast to use, shallow to edit. No shame in them; speed is a real currency.

Two philosophies. The professional move isn't picking a side — it's knowing which job calls for truth and which calls for possibility.

The practical decision is usually easy once you frame it this way. Need a believable piano under a singer? Sampler — realism is the job. Need the harmonic bed of an electronic-pop track to feel like weather? Synth — no real instrument is being imitated, so generated possibility wins. Need both? Layer them; nobody's checking IDs. The one decision to make consciously is the one this chapter's title flags: is this part pretending to be played, or proudly machine-made? Samplers default to the first, synths to the second, and your programming style — everything above — should match the pretense you picked.

Why Good Libraries Breathe: Multisampling, Velocity Layers, Round-Robins

Here's the section that explains where the gigabytes go — and why your velocity pass from earlier is the key that unlocks them.

A naive sampler would record one note and re-pitch it across the keyboard. You've heard the result in budget instruments and old toys: notes far from the original recording turn chipmunky and false, because re-pitching a recording shifts everything — including the parts of the timbre that shouldn't move (more on that phenomenon when formants come up with vocals, in Chapter 29's territory). The fix is multisampling: record every note, or at worst every two or three semitones, so no key is ever far from a real recording.

But one recording per note still flattens the dimension your ear cares most about. Remember the physics from the velocity section — real instruments change timbre with effort. So serious libraries record velocity layers: the same note captured at multiple dynamics — soft, medium, hard, harder — and your incoming velocity selects which recording plays, often crossfading between adjacent layers. This is why flat velocity 100 sounds so dead on an expensive library: you paid for eight dynamic layers and you're playing exactly one of them, over and over. The library can breathe. Your programming is holding its nose shut.

Third dimension: round-robins. Strike the same drum twice and the two hits differ — microscopically different stick position, head behavior, room excitement. A sampler replaying one identical recording on every repeat produces the infamous machine-gun effect: that fake, stuttering sameness on rolls and repeated notes that your ear flags instantly (it's the "repetition never repeats" humanization rule, violated at the sample level). So libraries record each note several times at each dynamic and rotate through the takes — round-robin — restoring the micro-variety of reality.

Do the arithmetic and the gigabytes explain themselves: 88 keys × 6 velocity layers × 4 round-robins is over two thousand recordings for one piano patch — before sustain-pedal-up and pedal-down variants, before release samples (the tiny sound of a note ending, which cheap instruments omit and your ear misses without knowing why). "Deep sampling" means deep in exactly these dimensions.

Two working lessons. First, when auditioning any sampled instrument, test the dimensions, not the demo: play one note at velocity 30, 60, 90, 120 — does the character change, or just the level? Repeat one note eight times — machine gun, or life? Those two tests sort the catalog faster than any review. Second — and this is the chapter's quiet thesis returning — a library's realism is rented through your MIDI. Velocity layers, round-robins, release samples: all of it is triggered by the data you program. The most expensive orchestra in the world, fed flat 100s on the grid, sounds exactly like the doorbell. The instrument doesn't breathe. The performance breathes, and you're the one writing it.

🔄 Check Your Understanding

1. A free piano instrument sounds increasingly fake as you play further from middle C. Which sampling dimension is it missing?
2. Why do velocity layers make the velocity pass (not just the velocity knob) matter more on expensive libraries, not less?
3. What's the machine-gun effect, and which library feature kills it?

Verify

1. Multisampling — it's re-pitching one (or few) recordings across the whole range, shifting timbre unnaturally as it goes.
2. Because velocity now selects between genuinely different recordings — different timbres. Flat velocities waste every layer but one; shaped velocities are what make the library audibly "deep." The better the library, the more your MIDI craft shows.
3. Identical repeated samples on consecutive hits — a stuttering, obviously artificial sameness on rolls and repeats. Round-robins (rotating alternate takes of each note) restore the natural variation.

Programming Idioms: Think Like the Player You're Faking

Here's the master rule for realistic programming, worth the price of the chapter: learn what the real instrument can't do, and stop doing it. Realism fails less from missing nuance than from casual impossibility — parts no human could physically play, written by a mouse that doesn't know it has no hands. Every instrument has an idiom: a set of physical truths that shape what comes out of it. Program inside the idiom and the listener's brain relaxes; violate it and they smell synthesis, even if they can't say why.

Keys. A pianist has two hands, each spanning roughly an octave comfortably. Voice your chords like that: a bass note or interval down low (left hand), three or four notes clustered in the middle (right hand) — not an eleven-note skyscraper from C1 to C6. Melody note on top, voiced louder (your velocity hierarchy). Roll the chords; hands fall, they don't detonate. Add the sustain pedal — CC64, down after the chord lands, up just as the next one arrives (that slightly-late pedal change is what makes piano lines connect; pianists call it legato pedaling). And let the left hand lead the right by a few milliseconds; it usually does.

Strings (sampled, sustained). Strings are the uncanny valley's favorite residents and Case Study 2's whole subject, so here's the short form. Real string lines connect — bow carries note into note — so use the library's legato patch and let consecutive notes slightly overlap, which is how most legato patches know to play a transition rather than a restart. Phrase like breath: lines, not stabs; a bow is finite, so eternal unbroken sustains read false. And the big one: on sustained instruments, velocity is the wrong expression channel — dynamics live in CC (next section). Writing strings with velocity alone is like steering a car with the door handle.

Bass. One note at a time. Real bassists are monophonic ninety-something percent of the time, and nothing screams "mouse" like sustained polyphonic bass chords rumbling in the mud zone. The expressive dimension of programmed bass is note length — this is the pocket secret. Short detached eighths drive; notes that ring into each other flow; that little gap before beat three is the funk. Take one bassline and render it three ways — staccato, legato, mixed — and you have three different grooves with identical pitches. Add occasional slides (pitch bend or the library's slide articulation) and ghosted soft notes between the main hits, and the line starts walking like a person. Where the bass sits against the kick — the most important relationship in your low end — is Chapter 13's centerpiece, and the kick doesn't exist yet in your project. Sketch now, marry later.

Drums get one sentence here and a whole chapter later: every principle above — velocity hierarchy, structured timing, round-robin awareness, idiomatic limits (two hands, two feet) — applies double, and Chapter 13 builds the complete groove language on this chapter's foundation.

Idiom cheat sheet. None of this requires playing the instrument — it requires respecting the body of the player you're impersonating.

The beautiful corollary: when you don't want realism — when the part is proudly synthetic — these rules become a style menu you're free to raid or ignore. A synth pad can hold a ten-note voicing forever precisely because no one's lungs are involved. Just choose on purpose.

CC Automation: Phrasing on the Third Axis

Notes, velocity… and then the dimension that separates programmers from players-by-proxy: continuous controller (CC) data, the stream of knob-and-pedal messages from the MIDI table. Velocity is decided once, at the strike. CC moves during the note — and for any sustained sound, during the note is where the music happens.

Listen to any sustained instrument in the real world: nothing holds still. A violinist's bow pressure swells and eases; a singer leans into the middle of a long note; a horn section blooms across a held chord. Every sustained tone is going somewhere — crescendo or decay, always in motion. Now listen to a programmed pad with no CC: a held note at constant everything, the audio equivalent of a stare. This is the other half of why fake strings sound fake (Case Study 2 cashes this out in full), and the fix is two lanes:

CC1 (mod wheel) is, by convention in most orchestral and many synth libraries, mapped to dynamics — which velocity layer you're hearing, crossfaded smoothly. Riding CC1 during a note literally morphs the timbre from soft-and-dark recordings to loud-and-bright ones, the same physics velocity gave you, now under continuous control. CC11 (expression) is finer volume within that timbre — micro-phrasing, the lean and the exhale. The working doctrine on sustained patches: CC1 sets the dynamic story of the phrase, CC11 breathes inside it. (And CC64 — sustain pedal — you've already met.)

The habit that changes everything: the hairpin rule. Every held note gets a shape — a swell into it, a bloom through it, or a decay out of it. Draw the curves with the pencil tool if you must, but better: grab the actual mod wheel on your controller, hit record, and perform the lane while the part plays. Recorded CC has the wobble and hesitation of a hand; drawn CC has the geometry of a ruler. (Tradeoff, as ever: drawn is precise and editable, performed is alive and messy. Record it, then tidy — same philosophy as quantize strength.) One pass of performed CC1 on a static pad is the single biggest before/after this chapter can offer besides the velocity pass — and on the "Static Bloom" pad tonight, it's the difference between a chord that sits there and a chord that arrives.

Controllers: Hands Beat Mouse (Mostly)

Speaking of hands: you don't need to play piano to benefit enormously from a MIDI controller — any device that generates MIDI when you touch it. Jaylen's Novation Launchkey Mini, twenty-five small keys and some pads, costs about as much as two plugin sales and earns it back the first week. Here's why, and what actually matters when buying.

Why hands win: everything this chapter teaches — velocity shape, micro-timing, structured deviation — happens automatically when a human performs, even badly. Record a part with one finger, slowly, and your timing leans and your velocities arc without a single thought, because you're a person and it leaks out of you. The honest old trick: drop the session tempo to half, record the part at granny speed with full attention to feel, restore tempo. MIDI doesn't care — instructions, not audio; nothing chipmunks. Loop-record several passes and keep the best (full comping craft arrives in Chapter 15). Then quantize at partial strength, and most of your humanization pass is already done — you played it.

What to look for, in order of audible payoff: keys you don't hate (action quality beats key count); pads if you'll program drums (Chapter 13 will thank you); mod and pitch wheels — your CC performance tools — present and reachable. Aftertouch (pressure on held keys as another CC stream) is a genuine nice-to-have. Beyond that lies the land of diminishing returns and Chapter 8's budget lesson in new clothing: don't buy expression you won't program. An MPE controller — MIDI Polyphonic Expression, the 2018 extension that gives every finger its own pitch/pressure/timbre dimensions — is a wondrous thing in the hands of someone who'll learn it, and a $700 way to play C-major chords for everyone else. Mouse-only programming, for the record, remains completely legitimate: every technique in this chapter works clicked-in. It's just slower to fake what hands do for free.

🔄 Check Your Understanding

1. Why is velocity "the wrong expression channel" for a sustained string patch, and what replaces it?
2. What does the half-tempo recording trick exploit about MIDI that wouldn't work with audio?
3. Your held pad note sounds like a stare. Which two CC lanes are the standard fix, and what does each control?

Verify

1. Velocity fires once at note-on, but sustained instruments live or die by what happens during the note. CC1 (dynamics — crossfading dynamic layers/timbre) and CC11 (expression — fine volume phrasing) provide continuous in-note control.
2. MIDI is instructions: change the tempo and notes simply replay at the new speed, pitch and sound untouched. Audio slowed or sped changes pitch/character (or requires warping with artifacts — Chapter 15).
3. CC1: dynamic layer/timbre morph (the big story of the phrase). CC11: expression, fine volume inside that timbre (the breathing). Hairpin rule: every held note gets a shape.

When Stiff Is the Point

Everything so far has chased realism. Now the title's other half: intentionally unreal — because some of the best music of the last fifty years is great because it's gridlocked, not despite it.

Kraftwerk built an aesthetic — arguably built several genres — on machine precision as meaning: music about technology that sounds like technology, robots singing as robots. Quantizing them "humanly" would be vandalism. Chiptune turned hardware constraint into a genre: those game soundtracks from the everyday-phenomenon section couldn't humanize — the chips played exact instructions with exact timing — and a generation fell in love with that crystalline rigidity, then kept it long after the constraint vanished. House and techno run on the unwavering grid; the machine pulse is the contract, the floor's heartbeat, and listeners entrain to its relentlessness — that's the high. And hyperpop took it furthest: hyper-quantized, hyper-tuned, velocity-pinned maximalism — 100 gecs and the SOPHIE school polishing the grid until it becomes chrome. The stiffness isn't a failure to humanize. It's the subject.

This is theme three with the mask off: stiff versus human isn't a quality axis, it's an aesthetic axis — and every position on it is a tradeoff you should choose on purpose. Machine-tight buys impact, hypnosis, modernity, that chrome sheen; it costs warmth, intimacy, the sense of a body in the room. Humanized buys breath and presence; it costs the laser-lock that makes a club drop hit like architecture. Neither is free. Neither is right. Genres are bundles of these choices that audiences have learned as expectations — country expects bodies, techno expects machines, pop expects machines impersonating bodies impersonating machines — and Chapter 18 maps those contracts in full.

The working doctrine: commit per part, on purpose. The crime isn't stiffness; it's accidental stiffness — the doorbell that thinks it's a pianist. Decide for each part which world it lives in, and program accordingly: maybe gridlocked drums under a humanized piano (a beloved modern combination — the machine and the ghost dancing), maybe everything rigid, maybe nothing. Write the decision down in your session notes. The mixed cases are where taste lives, and your track's identity is, in real part, this exact set of choices.

⚙️ Advanced Sidebar: General MIDI's Ghost and Why MIDI 2.0 Took 40 Years

If you grew up hearing "MIDI" used as an insult — "it sounds so MIDI" — you were hearing the ghost of General MIDI, and it's worth five minutes to exorcise it properly.

MIDI files contain no sound; play one and you hear whatever instrument renders it. Chaos, commercially: the same file sounded glorious on a studio synth and like a kazoo orchestra on a home computer. So in 1991 the industry standardized General MIDI (GM): 128 numbered program slots with fixed meanings — program 1 is always Acoustic Grand Piano, 57 is always Trumpet — plus drums fixed on channel 10. Now any GM file played "correctly" anywhere: karaoke machines, soundcards, keyboards, eventually phone ringtones. The catch: correctly meant the right instrument names, rendered by whatever cheap playback engine lived in the device. The thin, boxy "MIDI sound" a generation learned to mock was never MIDI — it was budget 1990s sample playback wearing MIDI's name tag. The protocol carrying those notes is the same one carrying every note of every record produced in a DAW today. Blaming MIDI for GM soundcards is blaming the alphabet for a bad novel.

Meanwhile, the 1983 spec just… kept working. Seven-bit values, 31,250 bits per second, one-way traffic — limits that mattered more every year (128 steps audibly stair-steps on slow filter sweeps; instruments couldn't tell hosts what they could do) — and yet MIDI 1.0 outlived its creators' wildest scoping because of a network effect with no exit: everything spoke it, so anything new had to, so everything kept speaking it. Breaking compatibility meant breaking every studio on Earth, and nothing was ever quite broken enough. The industry's answer was decades of clever workarounds inside the old spec — most importantly MPE (MIDI Polyphonic Expression, ratified 2018), which cleverly spends the 16 channels to give each finger its own expressive dimensions.

MIDI 2.0, ratified in early 2020 — thirty-seven years after 1.0, call it forty for the poetry — finally rebuilds the protocol: 16-bit velocity (65,536 levels instead of 128), 32-bit controllers (smooth sweeps, no stairs), per-note controllers as a native feature, and — the deep change — bidirectional conversation, where instruments and hosts negotiate capabilities instead of shouting blind. And it's backwards-compatible by design, because the lesson of the forty years was: you don't replace a universal language, you extend it. As of this writing, adoption is the usual slow tide — your DAW and OS likely already speak some of it; your habits won't need to change so much as your ceilings will rise. The craft in this chapter transfers untouched: more resolution makes structured intention smoother. It doesn't supply the intention. That remains your job.

🔄 Check Your Understanding

1. A friend says their new track "sounds too MIDI." Translate the complaint into this chapter's accurate vocabulary — what's actually wrong, since MIDI has no sound?
2. Why did MIDI 1.0 last nearly four decades despite known limits?
3. Which MIDI 2.0 improvement most directly addresses the stair-stepping of slow filter sweeps, and why?

Verify

1. The rendering and programming are weak, not the protocol: likely cheap/GM-style sounds and flat-velocity gridlocked performance data. The fix list: better virtual instruments and this chapter's velocity/timing/CC passes.
2. Network effects plus sacred backwards compatibility: universal adoption made any breaking change cost more than the limits did, and workarounds (like MPE) relieved the worst pressure.
3. 32-bit controllers — CC resolution jumps from 128 steps to effectively continuous, so slow parameter sweeps no longer audibly step.

The Practice: Programming a Part That Breathes

Everything above compresses into one repeatable workflow. Run it on every programmed part for a month and it becomes reflex — this is the chapter as a checklist:

1. Cast the actor honestly. Realism job → sampler; invention job → synth; speed job → rompler. Decide stiff-or-human now, out loud, in your session notes.
2. Get the notes in, alive if possible. Play it from a controller — half-tempo, loop-record, one finger, whatever it takes — because performed data arrives pre-humanized. No controller? Click in the skeleton and budget five extra minutes for step 4.
3. Quantize at partial strength. Start around 50%, listen, repeat once if needed. Starts, not ends. If the part is meant to be machine-stiff: 100% and proudly skip to step 5.
4. Velocity pass. Phrase arcs, top-note hierarchy in chords, accent pattern, no two repeats identical. Thirty seconds per part of pure rubber-stamp removal.
5. Length and articulation pass. Where does the phrase breathe? Shorten exits, let arrivals ring, overlap legato lines, gap the funk. Bass especially: length is the groove.
6. CC pass. CC64 pedal on keys; CC1/CC11 hairpins on anything sustained — performed from the wheel if you can. Every held note gets a shape.
7. Zoom out and subtract. Play the part in context, at your Chapter 8 reference level, eyes off the grid. Then the theme-two question: what can leave? Thin the chord that's fighting the mud zone, drop the doubled octave nobody hears, delete the clever fill that steps on the (future) vocal. The piano roll makes adding frictionless, which is exactly why the professionals you admire treat it as a place to remove things. Less, played better, is the entire recipe.

Common Mistakes and 60-Second Fixes

The emergency table. Notice how many fixes are subtraction — and that not one of them costs money.

Project Checkpoint: Building "Static Bloom"

Where we left off: Chapter 8's checkpoint ended with calibrated monitoring — marked listening level, headphone lies documented, gain structure audited. The session skeleton from Chapter 6 is waiting: 6-bus routing, color code, naming convention. Tonight it gets its first music.

Jaylen builds the harmonic bed exactly as the hook foreshadowed. Tempo check: 96 BPM, A minor, per the manifesto from Chapter 5. On a new instrument track routed to the SYNTHS bus, he loads a stock warm analog-style pad preset and names the track for the role, not the preset: PAD — bed (placeholder — Ch 14 patch). He knows the real "static bloom" sound gets designed from scratch in Chapter 14 — and because MIDI is instructions, every nuance he programs tonight will survive the swap untouched. The progression: Am – F – C – G, one bar each, ninths folded into the voicings, voiced like hands — roots low, three-note clusters mid, nothing crowding the mud zone. Each chord rolled bottom-to-top about 15 ms; each pad note starting ~20 ms early so the slow attack blooms on the downbeat; velocities arcing 64→84 across the four bars with top notes riding +8; one performed CC1 lane swelling into bars two and four. Quantize: 100% strength first — then the manual nudges. Stiff drums will eventually sit under a breathing pad: that contrast is a Static Bloom signature decision, logged in the session notes.

Then the bass sketch on the BASS bus: a simple sampled-electric patch (also a placeholder — the sub gets designed later), strictly monophonic roots with a passing octave walk into the G, velocities steady around 90, sitting consistently ~8 ms late. The groove secret is the lengths: each note released a sixteenth before the next bar — daylight before every downbeat, saving room for a kick that won't exist until Chapter 13. Twenty-five minutes total. Two tracks, eight bars, looped — and through calibrated monitoring it already sounds like weather coming. Saved as static-bloom_v0.3_harmonic-bed per Chapter 2's hygiene.

Your assignment, on your track, this week:

1. Program your chord bed: 4–8 bars, voiced like hands, rolled chords, velocity arcs, one CC lane minimum (CC64 on keys, CC1 hairpins on pads). Name the track for its role.
2. Sketch your bass: monophonic, roots first, note-length pass before any note gets added. Leave space where the kick will live.
3. Commit in writing: one session note per part — "stiff on purpose" or "humanized" — and three specific deviations you programmed (not randomized).

Genre adaptations. Hip-hop/trap: your bed might be a dark keys loop or pad — keep voicings sparse (two–three notes); sketch the bass as the future 808's dummy: roots and lengths only, tuning and glide come with sound design; commit drums-stiff-keys-loose now if that's your lane. Rock/band: program the keys/pad bed even if everything else will be tracked live — a humanized scratch bed guides every Chapter 12 overdub better than a click alone; bass sketch can be the DI guide your bassist replaces. Electronic/pop: this checkpoint is your genre's native craft — commit hardest to the stiff-vs-human map per part, and resist designing sounds tonight (Chapter 14 is soon); program performances, not patches.

Next checkpoint, Chapter 10: before recording a single microphone take, you'll clap-test and mirror-trick your room, run a budget treatment pass, and re-listen to your Chapter 4 references in a room that finally tells you the truth.

Cross-Chapter Connections

Looking back. This chapter ran on Chapter 6's chassis: instrument tracks, plugins, buses, and the template that gave tonight's notes somewhere organized to land. Chapter 2's instructions-vs-audio distinction did quiet load-bearing work — MIDI has no sample rate, no clipping, no dBFS; those concerns begin the instant a virtual instrument renders to audio, at your session's settings. Chapter 1's harmonics explained why velocity changes timbre and not just level; Chapter 4's brain-first listening explained why your ear detects intention in milliseconds; and Chapter 8's calibration is the reason tonight's velocity-balance judgments can be trusted at all. Even Chapter 5 cameoed — the player piano was MIDI rehearsing, a century early.

Looking ahead. Chapter 13 takes this chapter's groove seeds — partial quantize, swing, structured leans — and builds the full drum-programming language: pocket, hat dynamics, the 808-kick marriage. Chapter 14 opens the synth you used tonight and teaches you to design the actual "static bloom" patch from an init preset, oscillator by envelope. Chapter 15 brings editing craft to performances both recorded and programmed; Chapter 16 arranges the parts you're now stacking up. And when mixing begins in Chapter 20, your programmed tracks arrive with a hidden gift: consistent, intentional levels — the gain-staging and compression work of Chapters 21 and 23 goes easier on performances that were designed.

Spaced Review

Three questions reaching back. Answer before peeking.

1. (Chapter 8) You're about to spend an evening making fine velocity-balance judgments between a pad and a bass sketch on headphones. Name two specific calibration habits from Chapter 8 that protect those judgments, and the failure mode each prevents.
2. (Chapter 7) A friend wants to record soft acoustic guitar in a small echoey kitchen with the two mics from the workhorse list: a cardioid dynamic and a cardioid condenser. Which placement dial matters most for taming the room sound, and how do the two mics differ in how much room they'll drink?
3. (Chapter 5) The Beatles built Sgt. Pepper on four-track machines by bouncing submixes down to open up tracks. Name the creative upside and the technical downside of that constraint — and the modern descendant of the downside that you, with unlimited tracks, are still vulnerable to.

What's Next

Your session finally contains music — programmed, humanized (or proudly not), and trustworthy through calibrated monitoring. Chapter 10 turns to the last component standing between you and the truth: the room itself. The clap test, the mirror trick, why your 808s vanish at your desk but boom on the couch, and the $80 treatment pass that outperforms a folder of plugins — your room is lying to you, and next chapter you catch it in the act.

Before you go: the exercises' stiff-then-humanized drill is this chapter installed in your hands — twenty minutes that will change every part you ever program. Do it, take the quiz, and bring your humanized harmonic bed to Chapter 10. It's about to sound different in a room that's stopped editorializing.