Matchering

You've got a song that's almost there, and a track you wish yours sounded like. Feed both into this node and the first one comes out wearing the second one's coat. That's the whole pitch: Matchering takes two audio files, analyzes the "mastered-ness" of the reference, and reshapes your target's loudness and frequency balance to match it. No GPU, no model download, no API key - it's a wrapper around sergree/matchering, a mature open-source audio mastering library that does everything with DSP math on your CPU.

The honest framing: this is an assistant, not a mastering engineer. It can't fix a muddy mix or save a bad recording, but it's genuinely great at the boring parts of mastering - getting loudness, headroom, and tonal balance into the same ballpark as a commercial release. People also use it in ComfyUI pipelines to match a cover or demo to the original track, or to make a studio recording sit at the same level as a live bootleg. It's the kind of tool that turns "my mix sounds quiet and dull next to Spotify" into a solved problem.

How it works

Matchering runs a fixed chain of stages on your target, all referenced against the reference track:

1. Level matching - it measures the average loudness (RMS) of both files and adjusts the target's gain so the overall loudness matches, working in mid/side channels.
2. Frequency matching - it compares the spectral balance of the two files and applies an EQ curve to push the target's tone toward the reference's.
3. RMS correction - a few refinement passes so the EQ didn't wreck the loudness match.
4. A brickwall limiter - the final "make it loud without clipping" stage, tuned to the reference's peak level.

Internally it resamples everything to 44.1 kHz and auto-upconverts mono audio to stereo, so you don't have to babysit sample rates. The whole thing runs locally in a few seconds to a couple of minutes depending on track length.

The inputs and outputs that matter

Only two inputs, and they're both the ComfyUI AUDIO type - so whatever your audio loader node produces (native ComfyUI audio nodes or a video-pack's audio output both work):

• target - the track you want to remaster.
• reference - the track whose sound you're copying.

Three outputs come out the other side:

• Result - the full chain: matched, limited, and amplified to the reference's level. This is the one you save.
• Result (no limiter) - everything except the limiter, for when you want to add your own loudness stage.
• Result (no limiter, normalized) - the no-limiter version peak-normalized up to just below full scale, useful if you're feeding something that expects hot audio.

Wire Result into an audio save/playback node and you're done.

Installing it

ComfyUI Manager makes this painless: search "Matchering" in the Manager's install tab and hit install, then restart ComfyUI. Or clone it the manual way:

cd ComfyUI/custom_nodes
git clone https://github.com/MuziekMagie/ComfyUI-Matchering
# restart ComfyUI after this

The pack pulls in numpy, scipy, soundfile, resampy, and statsmodels - all auto-installed from requirements.txt. No model files, no weights, nothing to download. It also ships on the Comfy Registry, so Manager finds it by name.

Common issues

The usual failure modes come from the library's validation, and they're reasonably clear in the console log the node prints:

• "Number of channels" error - audio with more than two channels (e.g. 5.1) is rejected. Mono is fine (auto-upconverted); just avoid surround formats.
• "Length is too long" - the default cap is 15 minutes per file. A full DJ mix or podcast episode will trip this; that's exactly what the MatcheringAdvanced variant's max_length setting is for.
• "Target/reference are equal" error - if the two files are (nearly) identical, matchering has nothing to do and it refuses. Flip allow_equality in the Advanced node if you genuinely want it.
• Clipping warnings - if the input is already crushed to 0 dBFS it'll warn that the result will be limited hard. Feed it a mix with a little headroom and you'll get a better result.

The name is a bit of a tease - "matchering" sounds like some magical AI mastering thing, but it's really just "match + master" and it's refreshingly deterministic about it.