/ˌpiː.diːˈsiː/
PDC is a DAW feature that automatically measures and compensates for the processing delay introduced by plugins, keeping all tracks time-aligned. Without it, latency-heavy plugins cause tracks to drift out of phase, ruining transient punch and stereo imaging.
You spent hours getting that snare to crack perfectly — then you inserted a linear-phase EQ on the master bus and the whole kit went sideways. That wasn't your ears lying to you. That was PDC failing you, and understanding it is the difference between a mix that hits and one that mysteriously doesn't.
Plugin Delay Compensation (PDC) is an automatic timing-correction system built into modern digital audio workstations that measures the latency introduced by each plugin in a session and delays every other signal path by a corresponding amount so all audio arrives at the mix bus simultaneously. Every digital signal-processing plugin — compressors, equalizers, pitch correctors, convolution reverbs, linear-phase filters, loudness analyzers — requires at least a handful of samples of processing time to do its work. Some require tens of thousands. Left unaddressed, these micro-delays stack and misalign tracks, smearing transients, collapsing stereo images, and creating phase cancellation that no amount of EQ can fix after the fact.
The term is sometimes used interchangeably with ADC (Automatic Delay Compensation), and the two acronyms describe the same underlying mechanism. PDC is more common in European and UK documentation (Steinberg coined it in the Nuendo/Cubase context), while ADC appears frequently in Avid Pro Tools literature. Regardless of label, the function is identical: the DAW queries each plugin's reported latency in samples, calculates the maximum latency across all parallel signal paths, and inserts invisible delay buffers on every path that falls short of that maximum so every path arrives at the summing point in lock-step.
PDC operates entirely in the digital domain and has no analogue equivalent. On a physical console, every channel travels through the same copper and transformer path at the same speed; latency is effectively zero and uniform. In a DAW, a channel strip might hold a transparent EQ with 0-sample latency sitting next to a mid-side linear-phase mastering EQ reporting 8,192 samples of lookahead delay — and both feed the same mix bus. Without compensation, the linear-phase channel arrives 8,192 samples late relative to its neighbor, which at 44.1 kHz equals roughly 185 milliseconds: easily audible and catastrophically phase-destructive on anything sharing low-frequency content.
Understanding PDC is non-negotiable for any producer working with parallel processing, sidechain routing, stem exports, or hardware inserts. It is also the first diagnostic question to ask whenever a mix that sounds correct during playback sounds different when rendered to a file, or when a live-monitored signal sounds different from the recorded result. The good news is that modern DAWs handle PDC transparently in the majority of scenarios. The bad news is that specific routing topologies — hardware inserts, external effects sends, certain sidechain configurations, and ReWire connections — routinely defeat automatic compensation and require the producer to understand and apply manual correction.
At its core, PDC works by exploiting the VST, AU, or AAX plugin API's latency-reporting mechanism. Every compliant plugin exposes a property — called initialDelay in the VST3 SDK, latency in the Audio Unit framework, and similarly named fields in AAX — that declares how many samples of delay the plugin introduces between its input and output. The DAW reads this value when the plugin is instantiated and again whenever the plugin reports a change (for example, when a convolution reverb loads a new impulse response, or when a pitch corrector switches between low-latency and high-quality modes). The DAW's audio engine maintains a running map of every plugin latency on every channel and uses this map to calculate the total latency of each signal path from source to the mix bus.
Once the maximum latency across all paths is known, the DAW inserts delay buffers — implemented as simple FIFO (first-in, first-out) sample queues — on every path whose total latency falls below the maximum. If the heaviest path reports 4,096 samples and a given channel has no plugins at all, that channel receives a 4,096-sample delay buffer. If a second channel has a plugin with 2,048 samples of latency, it receives a 2,048-sample delay buffer. Every path now contributes identical total delay before summing, preserving phase coherence. This arithmetic runs in real time and is recalculated whenever the plugin graph changes — when a plugin is inserted, removed, bypassed, or reports a new latency value.
The system has two well-documented failure points. First, plugins that do not accurately report their latency — either reporting zero when they introduce delay, or reporting an incorrect sample count — silently corrupt the compensation map. This was a significant problem with early VST2 plugins in the late 1990s and early 2000s and remains an occasional issue with poorly implemented third-party plugins. Second, PDC cannot compensate for latency that originates outside the plugin graph: audio traveling through a hardware insert must leave the audio interface's D/A converter, pass through outboard gear, and re-enter through the A/D converter, accumulating round-trip latency that the DAW has no way to measure automatically. This hardware-insert problem is covered in depth in the Common Contexts section below.
Buffer size interacts with PDC in a subtle but important way. The audio interface buffer — set by the producer in the DAW's audio preferences — determines the granularity at which the engine processes audio. Increasing buffer size reduces CPU strain but increases the system's base latency floor. PDC compensation values are always measured in samples and are independent of buffer size, but the perceptible timing relationship between input monitoring and playback is affected. Producers tracking live instruments should use low buffer sizes (64–256 samples) to minimize monitoring latency, accepting higher CPU load, and switch to larger buffers (512–2048 samples) during mixing when heavy PDC-compensated plugin chains are active and no real-time input monitoring is required.
In summary, PDC is a sample-accurate bookkeeping system: the DAW tallies every plugin's declared latency, finds the tallest stack, and silently pads every shorter stack to match. When it works — which is most of the time in a self-contained plugin-only session — the producer never needs to think about it. When it fails, the symptoms are consistent: transients that feel soft or smeared, bass frequencies that cancel between parallel paths, and stereo images that narrow or shift unpredictably. Knowing the mechanism makes diagnosing these symptoms straightforward.
Diagram — PDC: PDC signal flow diagram showing three parallel plugin chains with varying latency, delay buffer insertion, and aligned summing at the mix bus.
Every pdc — hardware or plugin — operates on the same core parameters. Know these and you can work with any implementation.
Each plugin reports this value to the DAW via its API (initialDelay in VST3, latency in AU). Values range from 0 samples for a simple gain plugin to 32,768+ samples for heavy convolution reverbs or linear-phase mastering processors. A mismatch between a plugin's reported and actual latency is the most common source of PDC failure.
Calculated as (maximum session latency) minus (this track's cumulative plugin latency). If the heaviest plugin chain reports 8,192 samples and a track has no plugins, that track receives an 8,192-sample buffer. This value is typically hidden from the user but is exposed in DAWs like Reaper and Pro Tools HD as a readable field, useful for debugging.
Measured in samples by the producer using a null-test or DAW measurement utility (e.g., Pro Tools's Automatic Delay Compensation with hardware offset, or Reaper's pin connector latency field). At 44.1 kHz with a typical USB interface, round-trip hardware insert latency ranges from 1.5 ms (≈66 samples) to over 15 ms (≈662 samples) and must be entered manually since the DAW cannot detect it automatically.
Lookahead allows a plugin to analyze upcoming audio before it arrives, enabling faster and more accurate gain reduction. Common values are 0.5 ms to 10 ms (22–441 samples at 44.1 kHz). A brickwall limiter with 2 ms lookahead on the master bus will push every track's PDC offset up by 2 ms, which is usually negligible — but if that same limiter is inserted mid-session it can disrupt a render already in progress.
The DAW calculates this by summing plugin latencies along every serial chain and selecting the highest total. In sessions with linear-phase mastering EQs or convolution reverbs on the master bus, this number often exceeds 16,384 samples (≈370 ms at 44.1 kHz). This is why heavily mastered session renders can appear offset at the start of the exported file — the DAW pre-rolls the equivalent number of silence samples to flush delay buffers before audio begins.
Session-ready starting points. Sample values assume 44.1 kHz; multiply by 1.088 for 48 kHz equivalents. Always verify plugin latency reports with a null-test when mixing phase-critical material.
| Parameter | General | Drums | Vocals | Bass / Keys | Bus / Master |
|---|---|---|---|---|---|
| Typical plugin latency (IIR EQ) | 0–4 smp | 0–4 smp | 0–4 smp | 0–4 smp | 0–4 smp |
| Linear-phase EQ latency | 512–16384 smp | Avoid on parallel | 512–2048 smp | 1024–4096 smp | 4096–16384 smp |
| Convolution reverb latency | 256–8192 smp | Low-lat mode only | 512–4096 smp | 256–2048 smp | N/A on bus |
| Lookahead limiter latency | 64–512 smp | 64–256 smp | 64–512 smp | 64–512 smp | 256–1024 smp |
| Pitch correction latency | 64–2048 smp | N/A | 64–512 smp (low-lat) | N/A | N/A |
| Hardware insert (USB interface) | 1.5–15 ms manual | Measure + enter manually | Measure + enter manually | Measure + enter manually | Measure + enter manually |
| Max recommended session latency | <8192 smp | <2048 smp | <4096 smp | <4096 smp | <16384 smp |
Sample values assume 44.1 kHz; multiply by 1.088 for 48 kHz equivalents. Always verify plugin latency reports with a null-test when mixing phase-critical material.
The problem PDC solves predates the term itself by nearly two decades. When Digidesign introduced Sound Designer in 1984 and Pro Tools in 1991, the plug-in ecosystem was minimal and latency was measured in hardware buffer sizes rather than plugin processing delay. As DSP-based TDM plugins proliferated through the mid-1990s — including early Waves bundles and Digidesign's own DINR noise reduction — engineers working on high-profile sessions at studios like The Hit Factory and Westlake Audio began reporting that parallel TDM chains would drift relative to one another in ways that couldn't be explained by buffer settings alone. The culprit was plugin processing latency, and at that time engineers were manually nudging tracks in the timeline to compensate.
Steinberg is widely credited with introducing the first systematic software-based PDC in Nuendo 1.0, released in 2000. The Nuendo architecture, designed from the ground up for post-production work where sample-accuracy is contractually mandated, included a mechanism for VST2 plugins to declare their latency via the getInitialDelay() callback, and for the host to pad shorter paths accordingly. The feature was backported to Cubase SX in 2002. Steinberg's VST3 SDK, published in 2008, formalized latency reporting as a mandatory field rather than an optional callback, significantly reducing the number of non-reporting plugins in the ecosystem.
Avid implemented Automatic Delay Compensation in Pro Tools HD 6.1 in 2003, a release that also introduced the concept of a user-configurable ADC limit — the maximum number of samples Pro Tools would compensate before displaying a warning. The ADC limit in early HD systems was capped at 4,095 samples per path, which caused problems with certain early convolution reverb plugins that reported latencies above that ceiling. Avid raised and eventually removed the practical limit in Pro Tools 8 and later, though the underlying architecture of TDM hardware imposed constraints that persisted until the shift to HDX DSP cards and eventually AAX native processing.
Apple introduced PDC in Logic Pro 7 in 2004, implementing it as part of a broader overhaul of the Logic audio engine that also brought 64-bit summing and flexible routing. Logic's implementation was notable for its transparency — Apple chose not to expose the per-channel delay values to the user, a design decision that simplified the interface but made debugging routing-related PDC failures more opaque than in competing DAWs. Ableton Live implemented PDC in version 6 (2006), a critical milestone given Live's role as both a studio DAW and a live performance environment — the company had to carefully balance automatic compensation with the need for predictable, low-latency monitoring during live sets, which is why Live still offers a per-track delay-compensation disable option that no other major DAW exposes so prominently.
In a standard mixing session composed entirely of software plugins, PDC is invisible: insert a linear-phase EQ on the master bus, and the DAW silently pads every other track's output to match. The producer experiences nothing unusual. The scenarios where PDC demands active management are parallel processing, hardware inserts, sidechain routing across groups of different latency, and hybrid DAW/hardware setups. Parallel compression is the most common battleground. When you duplicate a drum bus and insert a heavily compressed version alongside the unprocessed signal, the compressor's latency — even a fast-attack IIR design — can offset the two paths by dozens of samples. The result is a characteristic low-end cancellation that makes the kick feel hollow and the snare less present. The fix is to verify that PDC is enabled globally and that the compressor plugin correctly reports its latency; most do, and the problem resolves automatically.
Drums and percussion require special attention because human perception of timing is most acute in the transient-rich frequencies where kick, snare, and hat live. A misalignment of just 2–5 milliseconds between a close-miked snare and an overhead microphone — caused by a room-correcting linear-phase EQ on the overhead — is perceptible as a slightly softened attack or, in severe cases, flamming. Engineers recording live drums in hybrid sessions should run a null-test: route a click track through the problematic plugin chain and the unprocessed path, invert one, and sum. Perfect PDC yields silence. Any residual click indicates an uncompensated offset equal to the timing of the remaining transient.
Vocals and melodic instruments using pitch-correction plugins (Auto-Tune, Melodyne Bridge, Waves Tune) introduce latency that varies not only by plugin but by mode setting within the same plugin. Auto-Tune's Low Latency mode reports approximately 2 ms (88 samples at 44.1 kHz), while its standard mode can exceed 20 ms. Switching modes mid-session changes the reported latency value, which should trigger an automatic DAW recalculation — but some older DAW versions require a manual engine refresh (typically accomplished by toggling the plugin off and on) to register the new value. Always re-verify PDC alignment after changing a pitch corrector's quality mode.
Hardware inserts — routing audio out through an interface's analog output into an outboard compressor or EQ and back in — are the one scenario where PDC unambiguously cannot help itself. The DAW has no way to measure the round-trip time through external gear. The standard workflow is to measure this latency once per interface configuration using a null-test: send a transient (a single-sample click) simultaneously through the hardware path and an internal bypass path, record both returns, and measure the sample offset between the two transients. Enter this value manually as a negative track offset or as a plugin insert offset in DAWs that expose this field. In Pro Tools, the I/O Setup panel includes a hardware delay compensation field for exactly this purpose. In Reaper, the FX chain's pin connector dialog allows per-instance latency declaration for hardware routing.
One email a week. The techniques behind the terms — curated by working producers, not algorithms.
Abstract knowledge becomes practical when you can hear it in music you know. These tracks demonstrate pdc used intentionally, at specific moments, for specific purposes.
Mick Guzauski's mix of 'Get Lucky' is a frequently cited case study in hybrid analogue/digital routing where hardware insert latency management is critical. The session combined SSL analogue summing with Pro Tools HDX native processing, requiring manual hardware delay compensation entries for every outboard piece. The punchy, phase-coherent kick and bass relationship — audible in the first 30 seconds — reflects careful null-testing of each insert path. Notice how the kick retains its click attack even as the bass slides in below it: this clarity is the signature of correctly compensated parallel paths on the low end.
The opening piano stab and snare of 'HUMBLE.' are among the most analyzed transients in modern hip-hop production. Mike Will Made-It's use of heavy parallel compression on the drum bus demands precise PDC management — the unprocessed parallel path must arrive at the summing point within a handful of samples of the compressed path or the snare's attack smears. The crack audible in the first measure is a product of that phase coherence. Producers studying parallel drum compression should use this record as a benchmark null-test reference: import the track, layer your parallel chain, and compare the transient alignment to the original.
Produced entirely in Logic Pro on a MacBook by Finneas O'Connell in a bedroom setting, 'bad guy' demonstrates that PDC issues are not exclusive to large studio environments. The song's bass synth sits directly against a kick drum transient with no perceptible flamming — an alignment that in Logic requires trusting the DAW's invisible automatic compensation across a signal chain that included Flex Pitch (low-latency mode) on the vocal and multiple Vintage EQ instances on the bass. Finneas has discussed in interviews that he works entirely in the box with Logic's defaults, which means Logic's automatic PDC is doing all the heavy lifting. Producers working in Logic should take confidence from this: the default settings are production-validated.
The standard implementation found in all modern DAWs. The host queries each plugin's declared latency via the plugin API, calculates the maximum across all parallel paths, and inserts FIFO delay buffers automatically. Requires no user intervention in a software-only session and is accurate to the sample as long as all plugins correctly report their latency.
Applied when audio routes through outboard hardware that the DAW cannot query for latency. The producer measures round-trip delay using a null-test or a DAW measurement utility, then enters the value manually as a negative offset on the return track or in the DAW's hardware delay field. Must be re-measured if the interface, cable routing, or sample rate changes.
Many high-latency plugins offer a low-latency processing mode that reduces the reported latency value at the cost of some processing quality. The plugin switches its reported latency value when the mode changes, and the DAW recalculates compensation accordingly. This allows producers to track through pitch correctors and loudness meters without accumulating prohibitive monitoring delay, then switch to high-quality mode for the final mix render.
Applications connected via ReWire or ARA (Audio Random Access) introduce their own latency outside the host's plugin graph. ARA2 implementations like Melodyne Bridge in Logic and Studio One include latency reporting that integrates with the host PDC system. Legacy ReWire connections (Reason as ReWire slave into Live or Pro Tools) often require manual offset correction because the ReWire protocol predates modern PDC API conventions.
These MPW articles put pdc into practice — specific techniques, real tools, and applied workflows.