Before you release a 432 Hz version, confirm you have the rights, render once from the approved lossless master at the correct source reference, and run a real QC gate. Check runtime, pitch, clipping, true peak on the WAV and the encode, and loudness change. Re-time anything synced to the old runtime, label it clearly, describe it honestly, and archive everything.

The A/B went well. The artist wants the 432 version out. It's rendered, it sounds right in the car, and the distributor upload form is open in another tab. This is the moment where a good creative idea turns into a sloppy release. Not because anyone did anything wrong, but because "it sounds good" quietly stood in for a dozen smaller questions nobody asked.

This is the list I'd want taped to the monitor before an alternate version goes public. It's not homework. Most items take a minute. A few of them, like rights, the source reference, the true peak, and the words you use to describe it, are the difference between a version people trust and one that causes a takedown, a rejected upload, or an awkward correction. If you haven't built the alternate yet, start with A 432 alternate master should never cost you the original. This picks up where that leaves off.

1. Rights first, before anything technical

Only release an altered version of a recording you own or are authorized to alter. A private listening test on your own machine is one thing. Publishing a retuned copy of someone else's master is another, and pitch-shifting it doesn't make it yours. The U.S. Copyright Office's overview of musical works and sound recordings is a good reminder that the composition and the recording are separate rights, often held by different people. For collaborations, get explicit permission from whoever controls the master. A thumbs-up emoji in a group chat doesn't count.

Then name the purpose: deluxe bonus track, standalone listening edition, slowed companion, DJ tool, client request. The purpose decides everything else, including how long it can run, whether loudness should match the original, what the title says, and how you talk about it.

2. Start from the approved source, at the right reference

Use the best lossless master you have, the one that was actually signed off, not a download of the streaming version. Confirm what A4 reference it was made against. Most modern records are 440, but not all, and a file that was already retuned must never be retuned again. The ratio is always target over the real source; 432, 435, 442 and the reference pitch you actually started from covers why that matters. Render once, to a 24-bit WAV, and keep the original untouched beside it.

3. Run a real QC gate, not a vibe check

Here's a pre-release gate you can run. It builds a synthetic master, a pad with a held A4 and very bright hats, generated in code and deliberately mastered too hot, the way plenty of real records are. It renders the 432 version, makes an AAC delivery encode from it, and checks eleven things. Then it does it again with a documented gain trim applied before the resample.

#!/usr/bin/env python3
"""12_release_qc.py: a pre-release gate for a 432 alternate master and its delivery encode.
SYNTHETIC AUDIO ONLY: a deliberately hot synthetic master is generated below.
Needs: python3 + numpy, ffmpeg/ffprobe on PATH.  Usage: python3 12_release_qc.py [workdir]"""
import hashlib, json, math, os, re, shutil, subprocess, sys
import numpy as np

SR, SRC_HZ, TGT_HZ = 48000, 440, 432
RATIO = TGT_HZ / SRC_HZ
work = os.path.abspath(sys.argv[1] if len(sys.argv) > 1 else "release_qc")
shutil.rmtree(work, ignore_errors=True); os.makedirs(work)
CHAIN = (f"aresample={SRC_HZ*200}:resampler=soxr:precision=28,asetrate={TGT_HZ*200},"
         f"aresample={SR}:resampler=soxr:precision=28")

def sh(cmd, **kw): return subprocess.run(cmd, capture_output=True, **{"text": True, **kw})
def sha(p): return hashlib.sha256(open(p, "rb").read()).hexdigest()

def probe(p):
    j = json.loads(sh(["ffprobe", "-v", "error", "-show_streams", "-show_format", "-of", "json", p]).stdout)
    s = j["streams"][0]
    return dict(dur=float(j["format"]["duration"]), rate=int(s["sample_rate"]), ch=s["channels"],
                bits=s.get("bits_per_raw_sample") or s.get("bits_per_sample"), codec=s["codec_name"],
                title=j["format"].get("tags", {}).get("title", ""))

def loud(p):
    e = sh(["ffmpeg", "-nostats", "-hide_banner", "-i", p, "-af", "ebur128=peak=true:framelog=quiet",
            "-f", "null", "-"]).stderr
    s = e[e.rfind("Summary:"):]
    return float(re.search(r"I:\s+(-?[\d.]+) LUFS", s).group(1)), float(re.search(r"Peak:\s+(-?[\d.]+) dBFS", s).group(1))

def decode(p):
    raw = sh(["ffmpeg", "-v", "error", "-i", p, "-f", "f32le", "-ac", "1", "-ar", str(SR), "-"], text=False).stdout
    return np.frombuffer(raw, np.float32).astype(np.float64)

def decode_stereo(p):
    raw = sh(["ffmpeg", "-v", "error", "-i", p, "-f", "f32le", "-"], text=False).stdout
    return np.frombuffer(raw, np.float32)

def a4(x):
    w = x[SR:SR * 5] * np.hanning(SR * 4)
    sp = np.abs(np.fft.rfft(w, 32 * len(w))); f = np.fft.rfftfreq(32 * len(w), 1 / SR)
    m = (f > 420) & (f < 460); return f[m][np.argmax(sp[m])]

def edges(x):
    db = lambda v: 20 * math.log10(max(v, 1e-9))
    lead = np.argmax(np.abs(x) > 10 ** (-60 / 20)) / SR
    tail = db(np.sqrt(np.mean(x[-SR // 10:] ** 2)))
    return lead, tail

# synthetic hot master: pad + held A4 + bright clicky hats, peak-normalized to -0.2 dBFS
t = np.arange(SR * 20) / SR
x = sum(a * np.sin(2 * np.pi * f * t) for f, a in ((110, .3), (220, .2), (440, .25), (554.37, .12)))
hat = np.zeros_like(t)
for n in range(80):
    i = int(n * 0.25 * SR); hat[i:i + 96] += np.sign(np.sin(np.arange(96) * 1.9)) * 0.6
x = (x + hat) * np.minimum(1, (20 - t) / 3)              # 3 s fade so the tail is musical
x = np.stack([x, x * 0.97], 1); x *= 10 ** (-0.2 / 20) / np.abs(x).max()
src = os.path.join(work, "Artist_Title_Master_440_48k_24b.wav")
subprocess.run(["ffmpeg", "-y", "-v", "error", "-f", "f32le", "-ar", str(SR), "-ac", "2", "-i", "-",
                "-c:a", "pcm_s24le", src], input=x.astype(np.float32).tobytes(), check=True)
src_hash = sha(src)

def build(tag, trim_db):
    wav = os.path.join(work, f"Artist_Title_432Master{tag}_48k_24b.wav")
    af = (f"volume={trim_db}dB," if trim_db else "") + CHAIN   # trim BEFORE the resample, never after a clip
    sh(["ffmpeg", "-y", "-v", "error", "-i", src, "-af", af, "-c:a", "pcm_s24le",
        "-metadata", "title=Title (432 Hz Alternate Master)", wav], check=True)
    aac = wav.replace("_48k_24b.wav", "_256k.m4a")
    sh(["ffmpeg", "-y", "-v", "error", "-i", wav, "-c:a", "aac", "-b:a", "256k", aac], check=True)
    return wav, aac

def gate(label, wav, aac):
    ps, pw, pa = probe(src), probe(wav), probe(aac)
    ls, lw, la = loud(src), loud(wav), loud(aac)
    xs, xw = decode(src), decode(wav)
    lead, tail = edges(xw)
    clipped = int((np.abs(decode_stereo(wav)) >= 0.99999).sum())
    checks = [
        ("Runtime = source / 0.981818 (±5 ms)", abs(pw["dur"] - ps["dur"] / RATIO) < .005,
         f'{ps["dur"]:.3f} -> {pw["dur"]:.3f} s (expect {ps["dur"] / RATIO:.3f})'),
        ("Format kept: rate, depth, channels", (pw["rate"], pw["bits"], pw["ch"]) == (ps["rate"], ps["bits"], ps["ch"]),
         f'{pw["rate"]} Hz / {pw["bits"]}-bit / {pw["ch"]} ch'),
        ("Held A4 measures 432 Hz (±0.05)", abs(a4(xw) - 432) < .05, f"{a4(xs):.2f} -> {a4(xw):.2f} Hz"),
        ("Starts on time (first audio within 50 ms)", lead <= .05, f"first audio at {lead * 1000:.1f} ms"),
        ("Tail decays, not cut (last 100 ms < -40 dBFS)", tail < -40, f"last 100 ms at {tail:.1f} dBFS"),
        ("No full-scale (clipped) samples in the WAV", clipped == 0, f"{clipped} samples at full scale"),
        ("Lossless true peak <= -1.0 dBTP", lw[1] <= -1.0, f"{lw[1]:+.1f} dBTP (source {ls[1]:+.1f})"),
        ("Encoded AAC true peak <= -1.0 dBTP", la[1] <= -1.0, f"{la[1]:+.1f} dBTP"),
        ("Loudness change documented", True, f"{ls[0]:.1f} -> {lw[0]:.1f} LUFS ({lw[0] - ls[0]:+.1f} LU)"),
        ("Version title says 432", "432" in pw["title"] and "432" in pa["title"], pa["title"]),
        ("Approved 440 master untouched", sha(src) == src_hash, "sha256 matches"),
    ]
    print(f"\n{label}")
    for name, ok, note in checks:
        print(f"  [{'PASS' if ok else 'FAIL'}] {name:46s} {note}")
    print(f"  => {sum(ok for _, ok, _ in checks)}/{len(checks)} passed")

gate("Render A: straight 432 render of the hot master", *build("", 0))
gate("Render B: documented -4.0 dB trim applied before the resample", *build("_trim-4dB", -4.0))

Real output from the box:

Render A: straight 432 render of the hot master
  [PASS] Runtime = source / 0.981818 (±5 ms)            20.000 -> 20.370 s (expect 20.370)
  [PASS] Format kept: rate, depth, channels             48000 Hz / 24-bit / 2 ch
  [PASS] Held A4 measures 432 Hz (±0.05)                440.00 -> 432.00 Hz
  [PASS] Starts on time (first audio within 50 ms)      first audio at 0.0 ms
  [PASS] Tail decays, not cut (last 100 ms < -40 dBFS)  last 100 ms at -43.8 dBFS
  [FAIL] No full-scale (clipped) samples in the WAV     323 samples at full scale
  [FAIL] Lossless true peak <= -1.0 dBTP                +1.0 dBTP (source +2.5)
  [FAIL] Encoded AAC true peak <= -1.0 dBTP             +1.0 dBTP
  [PASS] Loudness change documented                     -10.2 -> -10.3 LUFS (-0.1 LU)
  [PASS] Version title says 432                         Title (432 Hz Alternate Master)
  [PASS] Approved 440 master untouched                  sha256 matches
  => 8/11 passed

Render B: documented -4.0 dB trim applied before the resample
  [PASS] Runtime = source / 0.981818 (±5 ms)            20.000 -> 20.370 s (expect 20.370)
  [PASS] Format kept: rate, depth, channels             48000 Hz / 24-bit / 2 ch
  [PASS] Held A4 measures 432 Hz (±0.05)                440.00 -> 432.00 Hz
  [PASS] Starts on time (first audio within 50 ms)      first audio at 0.0 ms
  [PASS] Tail decays, not cut (last 100 ms < -40 dBFS)  last 100 ms at -47.8 dBFS
  [PASS] No full-scale (clipped) samples in the WAV     0 samples at full scale
  [PASS] Lossless true peak <= -1.0 dBTP                -1.7 dBTP (source +2.5)
  [PASS] Encoded AAC true peak <= -1.0 dBTP             -1.7 dBTP
  [PASS] Loudness change documented                     -10.2 -> -14.3 LUFS (-4.1 LU)
  [PASS] Version title says 432                         Title (432 Hz Alternate Master)
  [PASS] Approved 440 master untouched                  sha256 matches
  => 11/11 passed

What that gate caught

Most of the list passed on the first try, and that's normal. The ratio, runtime, format, pitch, head, tail, title, and untouched source were all fine. The interesting part is the three failures, because they show something people don't expect.

The source master was already illegal. Its sample peak sat at −0.2 dBFS, which looks fine on a basic meter, but its true peak read +2.5 dBTP. The bright, clicky hats create big peaks between the samples, which is exactly what true peak is what codecs clip is about. The alternate inherited that problem. Retuning doesn't create headroom.

The resample clipped 323 samples. A resample rebuilds the waveform between the original sample points. Some of those intersample peaks became real samples above full scale, and a 24-bit WAV can't store anything above full scale, so they were flattened. That's why Render A's true peak reads +1.0 instead of the source's +2.5. It isn't better. The tops were cut off. A lower true-peak number caused by clipping is a warning, not a win.

The fix went in before the resample, not after. Render B applied a −4.0 dB trim first, then converted. No clipped samples, true peak at −1.7 dBTP on both the WAV and the AAC encode, all eleven checks passing. The cost is honest and visible: 4.1 LU quieter than the original master. On a streaming service that normalizes playback, that may not matter much. On a platform that doesn't, the alternate will sound quieter than the original, and the real fix is to go back to the master and give it some peak headroom, not to hit the alternate with a limiter and call it the same record. Whatever you choose, write it in the notes and in the file name, as the script does with _trim-4dB.

The ceiling here, −1.0 dBTP, is the maximum true peak the EBU R 128 loudness recommendation sets for broadcast programmes, and a sensible default for music delivery that will be encoded downstream.

4. The checklist, in one place

5. Fix everything that was timed against the old runtime

A classic 432 render runs about 1.85% longer, so every time-based asset built for the original is now slightly wrong. Lyric videos and visualizers drift a little more each bar. Synced lyrics on streaming platforms land early. Album transitions and gapless sequences shift. Live cues fire ahead of the music. Re-time them to the new file, or if picture must stay locked, render with a time-preserving pitch shift instead and audition the percussion, reverb tails, and stereo effects for artifacts. And re-check the identifier question with your distributor. The ISRC rules around length changes are covered in the alternate-master essay linked above.

6. Listen to the actual encoded file

Not the WAV, not the session: the encoded file the platform will receive. Start to finish, on headphones, on speakers, on a phone, and once at low volume in a quiet room. That last one reveals more than people expect. Then do a short synchronized A/B against the original at matched level, on a passage you know cold. You're not trying to prove anything. You're confirming the version going out is the version that won the room.

7. Describe it like a professional

The title should be unambiguous: Title (432 Hz Alternate Master), or another clear version name. Don't call it a remaster unless remastering happened. The description can say exactly what changed, and that's more persuasive than any promise. Something like this:

"An alternate version of [Title], retuned from the original A=440 reference to A=432. The whole recording sits about a third of a semitone lower and, because it was resampled like tape, runs about 1.85% longer. No other mixing or mastering changes. Same song, heavier and a little more suspended. Listen to both and see which one you live with."

What you leave out matters just as much. Don't promise healing, guaranteed calm, DNA repair, or "natural" tuning. Don't imply the standard version is harmful. None of it is supported, it invites exactly the wrong kind of attention, and it cheapens a version that can stand on how it sounds. Lower, warmer, heavier, slower, more suspended are all fair as artistic description, because they describe intent, not physiology. If anyone wants the math, What 432 Hz actually changes in a finished master is there.

A clear release note also does something quieter. It gives writers, curators, and fans a real reason to talk about the version. "The artist wanted a heavier companion to the single" is a story. "Frequency of the universe" is a slogan, and people can tell the difference.

8. Archive enough to rebuild it

Put it all in one folder: the approved source and its hash, the 432 render, every encode, the notes (source and target reference, ratio, render mode, any trim, loudness and true-peak readings, tool and version, date, who did it), the artwork, the metadata as submitted, and the permissions. If the file ever has to be replaced, this is what tells a correction apart from an accidental new master. Keep the delivery copies stripped of internal tags, and keep the archive copy complete. The privacy side of that is in Keeping an unreleased master on your own machine, honestly.

Then do the last check that matters: confirm the original 440 master is still there, still the approved file, still the primary release. The alternate is a companion. It shouldn't replace anything by accident.

If you want a second set of eyes before upload, run the final WAV through CoProducer's Analyze for a true-peak and loudness readout against the same delivery gates, the way a release checklist that matches the meter describes.

Can I release a 432 Hz version of someone else's song?

Only with permission from whoever controls the recording, and the composition rights still apply. Retuning a recording does not make it yours. Private listening tests and public releases are different things.

Does retuning to 432 Hz change the true peak?

It can. A resample rebuilds the waveform, so intersample peaks can become real samples. In our synthetic test, a hot master clipped 323 samples during a straight 432 render. Trim the gain before the resample and re-measure both the WAV and the encoded file.

What should I call a 432 Hz version on streaming platforms?

Use a clear version name such as Title (432 Hz Alternate Master). Don't call it a remaster unless remastering happened, and keep the original 440 release as the primary version.

What can I honestly say about a 432 Hz release?

State the facts: retuned from A=440 to A=432, about a third of a semitone lower, and about 1.85% longer if resampled. Describe the creative intent in words like heavier or warmer. Don't promise healing, relaxation, or natural tuning.

Do I need to update lyrics and videos for a 432 Hz version?

Yes, if it was made with classic resampling. It runs about 1.85% longer, so synced lyrics, videos, visualizers, cues, and gapless transitions drift unless you re-time them or use a time-preserving pitch shift.