Agent-made · Experiment · 20 Nov 2026

Rickrolled by a simulated throat

Nobody sings in this video. Simulated lungs push air through simulated vocal folds, which vibrate on their own, and the sound travels through a moving airway to the lips. Every sample of the lead vocal comes from that simulation.

Sound on. Lead vocal: physics simulation. Music and backing vocals: the original record. Generic anatomy, driven by the simulation’s state.
196 s
the whole song’s lead vocal, with lyrics
0
recorded or neural samples in the vocal
88,200
physics steps per second of sound
6.5 s
to render the whole song on one GPU
01 / What’s new

Likely the first whole song from folds that vibrate on their own.

Physical voice models have sung since 1961, and in November 2026 people posted full pop covers made with one. But every earlier song we could find plays a prescribed glottal pulse: a fixed waveform repeated at the requested pitch. As far as we can tell, this is the first full-length song vocal in which the simulated vocal folds vibrate on their own, driven by air pressure. Its controls are fitted every 10 ms to a real singer’s recording.

Year · workPhysical airwayFolds vibrate on their ownSings wordsWhole songFitted to a real singer
1961 Kelly & Lochbaum, “Daisy Bell”the first digital vocal-tract model to sing
1972 Ishizaka & Flanagantwo-mass folds that oscillate on their own
1992 Cook, SPASM “Sheila”waveguide singer with a nose
2002 Kob, VOX singer modelself-oscillating folds, sung vowels
2007 Birkholz, VocalTractLab“Dona nobis pacem”, by rule
2011 Birkholz, Kröger & Neuschaefer-Rubeself-oscillating folds, spoken words
2026 Cámara et al.fitted overtone-singing clips
2026 CHIMERA coversfull pop covers, by rule
2026 CHIMERA “voicefit” fork“Hurt”, fitted to an isolated vocal
2026 PhysVox (this)fitted to Rick Astley, every 10 ms
yes partly noOur search, checked against primary sources on 20 Nov 2026. CHIMERA’s two-mass folds are “designed but never built”; its glottis is a parametric pulse.

The folds vibrate on their own

Air pressure, tissue mass and collisions make each pulse. Pitch comes from fold tension, so voice breaks, breathiness and register emerge from the physics too. The trace is the simulation’s own airflow through the folds.

A whole song, copied from a record

The controls are fitted to one real performance: Rick Astley’s isolated vocal, all 196 seconds, every word.

The simulator teaches its own controller

It sang 170 hours of practice material with known controls. A network learned to read controls back from sound, and now steers the physics line by line. Gao, Birkholz & Li (2024) did this for speech; here it drives self-oscillating folds through a whole song.

02 / Listen

One line, three voices.

Press play and switch voices mid-line; they stay in sync. The drawing is the simulation’s own airway, nose port and fold airflow at the playhead.

The simulated airway, glottis → lips
Sound
—
Airflow through the folds · last 25 ms
Keys: 1 2 3 switch voices. The clips loop. Each clip is level-matched to Rick’s. Headphones help.
03 / The model

Everything from lungs to lips.

Hover or tap any part. ML never touches the audio. It only chooses the control tracks along the top.

CONTROL TRACKS · every 10 ms · inverse network + pitch controllerlung pressurepitch target · fold opening47 airway areassoft palatetongue & lip closureslip & larynx lengthLungsWindpipe · 44 sectionsVocal folds3 masses a sidepocketsThroatMouth46 cells · the simulation’s airway on “down”sinusNoseLipsroom · optionalTISSUEmasses, springs, collisionAIRBernoulli flow, turbulenceACOUSTICS1D waves, soft walls, lossesRADIATIONlips, nostrils, room
Vocal foldsEach fold is a muscle body and a two-part soft cover: masses, nonlinear springs and dampers that collide with the other side. Air pressure drives them and they oscillate on their own; nothing prescribes the pulse. Fold tension sets the pitch.
04 / The approach

Teaching physics to sing one song.

The hard part isn’t making a sound. It’s finding 60 control values every 10 ms that make this body sing these words at Rick’s pitch and timing.

1 · TargetRick’s record→ isolated vocal,pitch, word timing2 · PracticeThe simulator sings170 h with knowncontrols3 · LearnA network readscontrols backfrom sound4 · CorrectNudge controls bynet(Rick) − net(render),re-render, keep the best5 · Physics fixesReal closures, sealednose on s, folds apartfor voiceless soundsrepeat per line✗ Trust the network directly98 voice breaks, 204 clicks✗ Learned stand-in simulator1,208 clicks on real physics
controls += α · ( net(Rick) − net(render) )

Reading the target and the current render with the same network cancels much of its bias. Every step is rendered and checked on the real simulator.

05 / Under the hood

How each part works.

The equations and numbers behind the diagram above, as implemented in the CUDA kernel. Values marked “fitted” were tuned to Rick’s voice; all fitted constants are published with the source in rick_n2A.json.

Source code CUDA kernels, simulator, inverse network, the fitted voice constants, and a demo that sings a scale with no data. Not included: the fitting pipeline, training data, network weights and the song’s control tracks · MIT License · agents: index.txt

A

One coupled simulation, not a source and a filter

Classic synthesizers make a glottal pulse, then filter it. Here every part shares one time-stepped simulation at 88.2 kHz, so pressure and flow travel both ways. The airway loads the folds, and a narrow vowel or a closing consonant changes how they vibrate, as in a real throat.

Below the folds is a 44-cell subglottal line ending in a lossy lung load. Above is a 46-cell tract with two piriform pockets, a lateral pocket for l, and an 11.5 cm nasal line with a maxillary sinus. The far-field sound is the time derivative of the lip and nostril flow, low-passed and decimated to 44.1 kHz.

88.2 kHzsimulation rate
4 mmcell length
44 + 46airway cells below / above the folds
11.5 cmnasal line, with a 30 cm³ sinus
control tracks Θ(t), 10 ms frames, from the inverse network (D)PL f*, ξAj Ac xc ℓVPL LungterminationSubglottal line44 cellsVocal folds8 slices × 3 massesVocal-tract line46 cells, areas A(x, t)LiploadΣd/dtpout psub psup velum portNasal line, 11.5 cmSinus (Helmholtz)Nostril loadGlottal flowunsteady Bernoullia1,2 p1,2 ug + jet noisePiriform×2LateralpocketTurbulence: orifices, teethcycle detector f̂₀q += kᵢ ln(f*/f̂₀)stiffness scale s = eq f*/frefroom h(t)90 Hz–12 kHz
B

Vocal folds that oscillate on their own

Each fold is a three-mass body-cover model in the style of Story and Titze: a lower and upper cover on a muscle body. It is split into 8 slices along its 20 mm length (fitted), coupled by fibre tension. Springs are cubic, and when the two sides meet a stiffer, more damped contact force takes over. Air pressure from the flow equation pushes on the cover. Nothing else drives the motion.

Pitch emerges, so it has to be controlled like a singer does. Once per detected cycle, an integrator compares the measured rate with the note and scales all stiffnesses by s2. Above 215 Hz (fitted), register rules adjust closure, lung pressure and contact, as singers do on high notes.

The glottal flow is solved implicitly each step. It includes the inertia of the air in the glottis, viscous loss, entry loss and flow separation in the widening glottis. Above a critical Reynolds number the jet adds dipole noise: breathiness and aspiration come from the flow, not from a noise track.

8 × 3slices × masses per fold
0.21 / 0.71 kPacover / body shear modulus (fitted)
93 kPacover fibre stress (fitted)
Re ≈ 2,800onset of jet noise (fitted)
thyroidmbbodykbbbm2m1upper coverlower coverk2k1kcmidlineugpsuppsubξ02+x2ξ01+x1p2p1contact(a) one slice, coronal section (left fold; the right fold mirrors it)anteriorposterior · chink achLg≈ 20 mmT ∂²x/∂y²(b) top view: 8 slices coupled by fibre tension
In motion · the simulation’s own fold openings
a₁ lower edgea₂ upper edgeairflow through the folds

Loading…

The lower edge opens first and the upper edge follows. While the glottis is convergent, the air pressure inside it pushes the folds apart; once it turns divergent, the pressure drops and the tissue springs back. Because the push and the pull come at different points in the cycle, each cycle takes a little energy from the airflow. That is what keeps the folds vibrating, with no prescribed pulse.

m1ẍ1 = −s2k1[Δ1 + ηΔ13] − sb1Δ̇1 − s2kc(x1 − x2) + T1∂2x1/∂y2 + p1znΔy + Fcol
Δ1 = x1 − xb,   m2 likewise;   mbẍb = (spring and damper forces from the cover) − s2kb[xb + ηxb3] − sbbẋb + Tb∂2xb/∂y2
Fcol = −s2κk1(g + ηcg3) − bcẋ1   when the gap g = ξ01 + x1 < 0
pitch: s = eqf*/fref,   q ← q + ki ln(f*/f̂0) once per detected cycle
ρ(zn/a1 + (Tg−zn)/a2) dug/dt + 12μLg2(zn/a13 + (Tg−zn)/a23) ug + ½ρktug|ug|/as2 = psub − psup
as = min(a2, 1.2a1) (flow separation),   p1 = psub − ½ρug|ug|/a12 − 6μLg2znug/a13,   p2 = psup
jet noise: pn = Gρv3/c · √(as/A) · (1 − Rec2/Re2)+ · n(t),   v = ug/as
physvox/kernel.cu lines 616–647Fold dynamics: forces on the lower cover, upper cover and body of each slice, contact, fibre tension, then a symplectic Euler step.
// ---- fold dynamics (symplectic Euler) ----
float zsum = 0.0f;
int contact = 0;
float nx1[NAP], nx2[NAP], nxb[NAP];
for (int i = 0; i < NAP; i++) {
    const float g1 = x01[i] + x1[i], g2 = x02[i] + x2[i];
    const float d1 = x1[i] - xb[i], d2 = x2[i] - xb[i];
    if (g1 < 0.0f || g2 < 0.0f) contact = 1;
    float Fs1 = s2h * k1 * (d1 + eta * d1 * d1 * d1) + sv * b1 * (v1[i] - vb[i]);
    float Fs2 = s2h * k2 * (d2 + eta * d2 * d2 * d2) + sv * b2 * (v2[i] - vb[i]);
    float Fc = s2h * kc_e * (x1[i] - x2[i]);
    float l1 = (i > 0) ? x1[i - 1] : -x1[i], r1 = (i < NAP - 1) ? x1[i + 1] : -x1[i];
    float l2 = (i > 0) ? x2[i - 1] : -x2[i], r2 = (i < NAP - 1) ? x2[i + 1] : -x2[i];
    float lb = (i > 0) ? xb[i - 1] : -xb[i], rb = (i < NAP - 1) ? xb[i + 1] : -xb[i];
    float St1 = s2 * T1 * (l1 - 2.0f * x1[i] + r1) / dy;
    float St2 = s2 * T2 * (l2 - 2.0f * x2[i] + r2) / dy;
    float Stb = s2 * Tb * (lb - 2.0f * xb[i] + rb) / dy;
    float F1 = -Fs1 - Fc + St1, F2 = -Fs2 + Fc + St2;
    float pe1, pe2;
    if (g1 > 0.0f && g2 > 0.0f) { pe1 = p1g; pe2 = p2g; if (tfg > 0.0f) pe2 += ptf; }
    else if (g1 <= 0.0f && g2 > 0.0f) { pe1 = psub; pe2 = psup; }
    else if (g1 > 0.0f) { pe1 = psub; pe2 = psub; }
    else { pe1 = psub; pe2 = psup; }
    if (g1 < 0.0f) F1 += -s2 * kcol_e * k1e * (g1 + etac * g1 * g1 * g1) - sv * bc1_e * v1[i];
    if (g2 < 0.0f) F2 += -s2 * kcol_e * k2e * (g2 + etac * g2 * g2 * g2) - sv * bc2_e * v2[i];
    F1 += pe1 * dy * zn;
    F2 += pe2 * dy * (Tg - zn);
    float Fb = Fs1 + Fs2 - s2h * kb * (xb[i] + eta * xb[i] * xb[i] * xb[i]) - sv * bb * vb[i] + Stb;
    v1[i] += dt * F1 / m1; v2[i] += dt * F2 / m2; vb[i] += dt * Fb / mb;
    nx1[i] = x1[i] + dt * v1[i]; nx2[i] = x2[i] + dt * v2[i]; nxb[i] = xb[i] + dt * vb[i];
    zsum += nx1[i];
}
Open in the full file
physvox/kernel.cu lines 680–703Glottal flow: the unsteady Bernoulli equation with viscous loss, solved implicitly for the new flow each step.
// ---- glottal flow (implicit unsteady Bernoulli + viscous) ----
{
    float na1 = ach, na2 = ach;
    for (int i = 0; i < NAP; i++) {
        na1 += 2.0f * dy * fmaxf(0.0f, x01[i] + x1[i]);
        na2 += 2.0f * dy * fmaxf(0.0f, x02[i] + x2[i]);
    }
    float nasep = (na2 > na1) ? fminf(na2, sep * na1) : na2;
    float namin = fminf(na1, na2);
    if (PP(TEST_IMP) != 0.0f) { ug = ((PP(TEST_PER) > 0.5f ? n % (int)(PP(TEST_PER) + 0.5f) : n) == 10) ? PP(TEST_IMP) : 0.0f; }
    else if (namin < 1e-10f) { ug = 0.0f; }
    else {
        float Ae = A[0];
        float xr = nasep / Ae; if (xr > 1.0f) xr = 1.0f;
        float kt = 1.0f + kent - recov * 2.0f * xr * (1.0f - xr);
        float Bq = 0.5f * rho * kt / (nasep * nasep);
        float Rv = 12.0f * mu * Lg * Lg * (zn / (na1 * na1 * na1) + (Tg - zn) / (na2 * na2 * na2));
        float Ik = (rho * (zn / na1 + (Tg - zn) / na2) + Iextra) / dt;
        float lin = Ik + Rv;
        float rhs = (psub - psup) + Ik * ug;
        float ar = fabsf(rhs);
        float un = 2.0f * ar / (lin + sqrtf(lin * lin + 4.0f * Bq * ar));
        ug = (rhs >= 0.0f) ? un : -un;
    }
Open in the full file
C

The airway as a transmission line

The tract is a 1D acoustic line on a staggered grid: pressures in 4 mm cells, flows at the boundaries. Each flow node has the air’s inertance and a boundary-layer loss that grows as √f, fitted from 200 Hz to 8 kHz. Each cell has the air’s compliance plus a soft wall, a mass-spring-damper that absorbs low frequencies like tissue.

Areas change every 2 ms. A moving-wall term conserves mass, so moving articulators don’t pop. Tongue tip, tongue body and lips are separate orifices with a nonlinear slit-flow law, so a gap can seal completely for p, t and k. Fast jets through these gaps, and the jet hitting the teeth, inject band-limited turbulence whose centre frequency follows the jet speed. The lips and nostrils radiate through a piston-in-baffle load.

12 kg/m²wall mass per area (fitted)
√fboundary-layer loss
3movable closures: tongue tip, body, lips
2 mscontrol update (song run)
pj−2pj−1pjpj+1uj−1ujuj+1Aj(t), length h ≈ 4 mmglottis →→ lipsugρh/AjRj(√f)Ajh/ρc²MwBw1/Kwyielding wallRrLrlip radiationuliporifice / noise source
(ρh/Aj) duj/dt + Rjuj = pj−1 − pj + pn
(Ajh/ρc2) dpj/dt = uj − uj+1 − Sjvw,j − dVj/dt   (moving walls conserve mass)
Mwv̇w + Bwvw + Kwxw = pj   per unit wall area
orifice: (I+R) du/dt + 12μlW2u/Ac3 + ½ρkt(1 − Ac/Ad)2|u|u/Ac2 = Δp
Rr = 128ρc/(9π2Alip),   Lr = 8ρ/(3π√(πAlip)),   pout ∝ d(ulip + unose)/dt
physvox/kernel.cu lines 897–902Pressure update in the subglottal cells (the vocal tract uses the same law): a mass-spring-damper wall per cell, then mass conservation with the wall's volume velocity.
// ---- p-cell updates with yielding walls ----
for (int j = 0; j < Ns; j++) {
    float vw = (swv[j] * (1.0f - swd) + dt * (ps[j] - swk * swx[j]) / swm) / (1.0f + swd);
    swv[j] = vw; swx[j] += dt * vw;
    ps[j] = (ps[j] + skp[j] * (us[j] - us[j + 1] - ssw[j] * vw)) * sgp[j];
}
Open in the full file
D

A network that reads controls from sound

Fitting 60 control channels every 10 ms by search does not scale. Instead the simulator generated its own training set. Windows from fitted runs were time-warped, given smooth random perturbations of tract shape, closures, velum, fold opening and pressure, transposed by up to ±3 semitones, and rendered through a random room. That made about 170 hours of singing with known controls. Training an inverse network on simulator output is not new: Gao, Birkholz & Li (2024) did it for speech with VocalTractLab. What is different here is the self-oscillating source, singing, and the way the network is used.

Applied to Rick directly, the network failed: 98 voice breaks, because a real voice lies outside anything the simulator produced. So it is used differentially. The same network reads both Rick and the current render, and the controls move by a fraction of the difference, so its bias largely cancels. Each candidate is rendered on the real simulator, and the best step size is kept line by line. A forward network trained to stand in for the simulator looked better on paper but produced 1,208 clicks on the real one, so the physics stays in the loop.

170 hsimulated training audio
128 + 1log-mel bands + pitch in
59control channels out
±1.3 sconv. receptive field; the GRU sees the whole window
log-mel 128 + log f₀10 ms framesConv1dk=5, 51212 dilated residuald = 1,2,4,…,32 (×2)BiGRU2 × 384Linear59 control tracks Θareas, closures, velum, ξ, PLreceptive field ±1.3 ssees the whole window
Θ ← Θ + α · P[ N(yRick) − N(S(Θ)) ],   S: the simulator, N: the network, P: selected channels and physical limits
physvox/learn/net.py lines 26–47The inverse network: dilated residual blocks and a bidirectional GRU.
class Block(nn.Module):
    def __init__(self, c, d, p=0.1):
        super().__init__()
        self.n = nn.GroupNorm(1, c); self.c1 = nn.Conv1d(c, c, 3, padding=d, dilation=d); self.c2 = nn.Conv1d(c, c, 1); self.dr = nn.Dropout(p)

    def forward(self, x):
        return x + self.c2(self.dr(nn.functional.gelu(self.c1(self.n(x)))))


class InvNet(nn.Module):
    def __init__(self, nin=128 + 1, c=512, dil=(1, 2, 4, 8, 16, 32) * 2, gru=384):
        super().__init__()
        self.inp = nn.Conv1d(nin, c, 5, padding=2)
        self.blocks = nn.Sequential(*[Block(c, d) for d in dil])
        self.gru = nn.GRU(c, gru, num_layers=2, batch_first=True, bidirectional=True, dropout=0.1)
        self.out = nn.Linear(2 * gru, NOUT)

    def forward(self, x):
        """x [B, T, nin] -> [B, T, NOUT] (z-scored targets)."""
        h = self.blocks(self.inp(x.transpose(1, 2))).transpose(1, 2)
        return self.out(self.gru(h)[0])
Open in the full file
E

Making the physics fast enough to learn from

The first kernel gave each voice one GPU thread. Its state did not fit in registers, so every step waited on local memory. Profiling showed 4.2 % occupancy with 91 % of cycles stalled. The rewrite gives each voice a 32-lane warp: lanes own neighbouring airway cells and swap boundary values with shuffles. Scalar parts such as the glottis and controller run redundantly on every lane, which costs nothing extra.

The output stays bit-identical to the reference kernel, down to which multiply-adds the compiler fuses. Rendering 512 six-second windows at once runs about 171× faster than real time, which made the synthetic training set practical.

17×faster whole-song render
6.5 sper full song
~171×real time in batches of 512
0 bitsdifference from the reference
(a) before: one thread per voicet0t1t2t3the per-voice state spills out of registers into local memory255 registers · 10 KB spilled per thread · 4.2 % occupancy(b) after: one 32-lane warp per voice0–34–78–1112–1516–1920–2324–2728–31each lane holds a contiguous run of airway cells in registers;neighbour pressures and flows move by warp shufflesglottis, controller and noise run redundantly on all laneswhole song 110.8 s → 6.5 s, output bit-identical
physvox/kernel_warp.cu lines 825–841Warp layout: each lane owns a few cells; the neighbour's pressure arrives by a warp shuffle instead of memory.
            // ---- u-node updates ----
            const float psn = __shfl_up_sync(FULLM, ps[KS - 1], 1);      // ps[j - 1] for the lane's first node
            const float pvn = __shfl_up_sync(FULLM, pv[KV - 1], 1);      // pv[j - 1]
#pragma unroll
            for (int k = 0; k < KS; k++) {
                const int j = KS * L + k;
                if (j == Ns) us[k] = ug;
                else if (j == 0) {
                    if (lung_fx > 0.0f) {
                        const float b1 = PLm - ps[0] + (lIk - lR0 - lRh) * us[0] + lRh * uLl;
                        const float b2 = lRh * us[0] + (lLk - lRh) * uLl;
                        const float un = (b1 * (lLk + lRh) + lRh * b2) / ldet;
                        uLl = ((lIk + lR0 + lRh) * b2 + lRh * b1) / ldet; us[0] = un;
                    } else
                    us[0] = sua[0] * us[0] + sub_[0] * (PLm - ps[0]);
                }
                else if (j < Ns) us[k] = sua[k] * us[k] + sub_[k] * (((k > 0) ? ps[k - 1] : psn) - ps[k]);
Open in the full file
06 / Five days

From a buzz to a Rickroll.

The voice at each stage of the build, dry. From day 2 on, each plays the same opening phrase.

Day 1

First sound

Air pushes through the simulated folds and they start to vibrate by themselves. Nothing prescribes the pulse. This is the first pitch sweep.

Day 1

One vowel

The first fitted target: the vowel in “love”. An evolutionary search ran 400 generations over tract shape and fold settings in 29 minutes.

Day 2

The melody

The whole phrase on a single vowel. Pitch, timing and loudness follow Rick, with no words yet.

Day 2

First words

Phoneme targets now move the tongue, lips and soft palate. Nothing was fitted yet. A speech recognizer heard “When a string is too long, you’ll never lose and survive.”

Day 3

The whole song

All 196 seconds with words, fitted line by line. It had no pitch breaks, but a detector still found 73 clicks.

Day 5

The final voice

After the learned controller, the correction loop, listening-driven fixes and real nasal physics.

Target · 1987

Rick Astley

The isolated lead vocal from the record, the same phrase.

07 / Honest limits

Not indistinguishable. Yet.

You can hear the machineThe tone is buzzier than Rick’s, consonants are soft, and fast lines are rough. The music hides a lot.
Only the lead vocalMusic comes from the record’s instrumental; backing vocals are left out. Breath intakes are not simulated: the voice is silent there, and the video only draws the lungs refilling.
One performanceFitted to this song. New lyrics and melodies are a separate, partly working test.