diff --git a/website/src/repl/components/panel/remix-projects.mjs b/website/src/repl/components/panel/remix-projects.mjs index 13057a82..033648c8 100644 --- a/website/src/repl/components/panel/remix-projects.mjs +++ b/website/src/repl/components/panel/remix-projects.mjs @@ -1,12 +1,16 @@ // Remixes retro (80s/90s/2000s) para la pestaña Projects. // GENERADO desde my-patterns/RETRO-TECHNO-REMIXES/*.strudel — edita alli y regenera. +// Regenera con: node my-patterns/RETRO-TECHNO-REMIXES/_generate.mjs export const RETRO_REMIXES = [ { name: "01 · blue monday 909 — new order (1983)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 01 · BLUE MONDAY 909 — New Order (1983) → Peak-Time Techno Remix -// 132 BPM · Dm · TR-909 · sidechain + acid en el 2º drop +// 132 BPM · Dm (i·i·VII·v = Dm·Dm·C·Am) · TR-909 + sub-boom afinado +// PRODUCCIÓN PRO: kick en 2 capas (click 909 + boom con envolvente de +// tono), bajo que SIGUE las fundamentales del acorde, groove con swing + +// ghost notes, armonía con 7as/9as, capa de aire, separacion de frecuencias. // Estructura: intro→build→drop A→break→acid drop→coda (144 compases ≈ 4:22) // ════════════════════════════════════════════════════════════════ setcps(132/60/4) @@ -19,63 +23,113 @@ const hook = note("d5 ~ d5 ~ f5 ~ e5 ~ d5 ~ c5 d5 ~ a4 ~ ~") const hookOctava = hook.add(note(12)).gain(.35).lpf(3200).orbit(2) -// ── EL BAJO SECUENCIADO (16avos icónicos de Blue Monday) ── -const bajo = note("d2!7 d3 d2!4 f2 f2 e2 e2") - .s("sawtooth").lpf(perlin.slow(4).range(500, 1200)).lpq(8) +// ── LEAD LIMPIO (la melodía, nítida y al frente) ── +const leadLimpio = note("d5 ~ d5 ~ f5 ~ e5 ~ d5 ~ c5 d5 ~ a4 ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.58).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Dm9·Dm9·Cadd9·Am7) ── +// voicings extendidos + voice-leading (notas comunes) = color "deep", no triada seca +const stab = note("<[d3,f3,a3,e4] [d3,f3,a3,e4] [c3,e3,g3,d4] [a2,c3,e3,g3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(180).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.3).pan(.62).orbit(3) + +// ── EL BAJO SECUENCIADO (16avos de Blue Monday, AHORA sigue el acorde) ── +// el riff icónico transpuesto a la fundamental de cada compás: D·D·C·A +// (teoría techno nº1: el bajo sale de las fundamentales de los acordes) +const bajo = note("<[d2!7 d3 d2!4 f2 f2 e2 e2] [d2!7 d3 d2!4 f2 f2 e2 e2] [c2!7 c3 c2!4 e2 e2 d2 d2] [a1!7 a2 a1!4 c2 c2 b1 b1]>") + .s("sawtooth").lpf(perlin.slow(4).range(600, 1300)).lpq(8) .attack(.001).decay(.15).sustain(.3).release(.05) - .shape(.3).gain(.9).orbit(1) + .shape(.34).coarse(1).gain(.88).orbit(1) -const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.2) - .gain(.7).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica total) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04) + .gain(.72).orbit(1) -// ── BATERÍA 909 (el kick lanza el sidechain sobre bajo y lead) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) - .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) - .duck("1:2").duckattack(.12).duckdepth(.7).orbit(0) -const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y" entre kicks) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (cuerpo) ── +// el boom es una sine con envolvente de TONO que cae 28 semitonos en 55ms +// = el "thump" analógico. Esto es lo que mata el sonido de sonajero. +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.32).gain(.9) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).distort(1.1).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + +const clap = s("~ cp ~ cp").bank("RolandTR909").room(.28).rsize(4).hpf(300).gain(.72).orbit(0) +// hats con SWING + velocity humanizada (groove, no rejilla plana) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).pan(.45).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.35).orbit(0) +// ghost snare (redoble con dinamica de velocity que sube) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) // ── CAPA ACID (para el segundo drop) ── -const acid = note("d2 [~ d2] a2 [d2 d3] c3 [~ d2] [eb2 e2] d2") +const acid = note("<[d2 [~ d2] a2 [d2 d3] c3 [~ d2] [eb2 e2] d2] [c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [d2 eb2] c2] [a1 [~ a1] e2 [a1 a2] g2 [~ a1] [bb1 b1] a1]>") .s("sawtooth").ftype("ladder") .lpf(sine.slow(16).range(150, 2800)).lpq(sine.slow(7).range(8, 22)) .lpenv(3).lpattack(.005).lpdecay(.12) - .shape(.4).gain(.75).rarely(x=>x.add(note(12))) + .shape(.4).gain(.72).rarely(x=>x.add(note(12))) .delay(.25).delaytime(.1875).delayfeedback(.35).orbit(3) -// ── ATMÓSFERA / PADS ── -const pad = note("<[d3,f3,a3] [d3,f3,a3] [c3,e3,g3] [a2,c3,e3]>") - .s("sawtooth").lpf(700).attack(.8).release(1.5) - .room(.7).rsize(8).gain(.4).orbit(4) - +// ── ATMÓSFERA / PADS (2 capas + separacion de frecuencias) ── +// pad cálido grave (hi-pass a 150 para dejar el sub-bajo libre) +const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3] [a2,c3,e3,g3]>") + .s("sawtooth").lpf(sine.slow(24).range(500,1100)).lpq(3) + .hpf(150).attack(.8).release(1.5) + .room(.7).rsize(8).gain(.36).orbit(4) +// capa de AIRE: supersaw ancho, muy reverberado, arriba (profundidad estéreo) +const aire = note("").s("supersaw").unison(5).spread(.8) + .lpf(sine.slow(32).range(600,2600)).hpf(400).attack(1.2).release(2) + .room(.85).rsize(9).gain(.2).pan(sine.slow(12).range(.2,.8)).orbit(4) const cuerdas = note("").s("supersaw").unison(5).spread(.7) - .lpf(sine.slow(32).range(400,2200)).attack(.5).release(.8) - .room(.6).gain(.35).orbit(4) + .lpf(sine.slow(32).range(400,2200)).hpf(200).attack(.5).release(.8) + .room(.6).gain(.32).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.5).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── -const intro = stack(kick, hats, bajoSub.gain(.4)) -const introB = stack(kick, hats, hatsOpen, clap.gain(.4), bajo.lpf(400).gain(.6)) -const build = stack(kick, hats16, clap, bajo, pad, +const intro = stack(kickBoom.gain(.9), hats, bajoSub.gain(.4), pad.gain(.25)) +const introB = stack(kick, hats, hatsOpen, clap.gain(.4), bajo.lpf(500).gain(.6), pad.gain(.3)) +const build = stack(kick, hats16, clap, ghost, bajo, bajoSub, pad, hook.lpf(saw.slow(16).range(300,1800)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, hook.gain(.65)) -const dropA = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, hook, hookOctava) -const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, - bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, cuerdas) -const breakdown = stack(pad, cuerdas, hook.gain(.6).room(.8), - hats.gain(.3), bajoSub.gain(.3)) -const breakBuild = stack(pad, cuerdas, hook, rodillo, hats16.gain(.4)) -const dropAcid = stack(kickHard, hats16, hatsOpen, clap, acid, bajoSub, hook.gain(.6)) -const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, ride, acid, - bajoSub, hook, hookOctava, cuerdas.gain(.25)) -const coda = stack(kick, hats, bajo.lpf(600).gain(.7), hook.gain(.45).room(.7), pad) -const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.9).delayfeedback(.7), pad.gain(.3)) +const buildFin = stack(kickHard, rodillo, riser, bajo, bajoSub, hook.gain(.65), leadLimpio.gain(.5), stab) +const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajo, bajoSub, hook, hookOctava, leadLimpio, stab, pad.gain(.28)) +const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ghost, ride, + bajo, bajoSub, bajoOff, hook, hookOctava, cuerdas, leadLimpio, stab, contra, aire) +const breakdown = stack(pad, aire, cuerdas, hook.gain(.6).room(.8), + hats.gain(.3), bajoSub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, cuerdas, riser, hook, rodillo, hats16.gain(.4), leadLimpio.gain(.5)) +const dropAcid = stack(kickHard, hats16, hatsOpen, clap, ghost, acid, bajoSub, hook.gain(.6), leadLimpio, stab) +const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, ghost, ride, acid, + bajoSub, bajoOff, hook, hookOctava, cuerdas.gain(.25), leadLimpio, stab, contra, aire) +const coda = stack(kick, hats, bajo.lpf(600).gain(.7), bajoSub.gain(.5), hook.gain(.45).room(.7), pad, leadLimpio.gain(.4)) +const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.9).delayfeedback(.7), pad.gain(.3), aire.gain(.25)) // ── ARREGLO (144 compases) ── arrange( @@ -92,14 +146,17 @@ arrange( [16, dropAvar], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "02 · take on me hard trance — a-ha (1985)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 02 · TAKE ON ME HARD TRANCE — a-ha (1985) → Hard Trance Techno Remix -// 140 BPM · F#m/A · TR-909 · supersaw masivo + rodillos largos + break de piano +// 140 BPM · F#m (F#m·D·A·E) · TR-909 · supersaw masivo + rodillos largos + break de piano +// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes +// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser // Estructura: intro→build→drop A→break piano→drop B→coda (140 compases ≈ 4:00) // ════════════════════════════════════════════════════════════════ setcps(140/60/4) @@ -122,27 +179,61 @@ const riffPiano = melodia.slow(2).add(note(-12)).s("piano") .room(.85).rsize(8).delay(.45).delaytime(.375).delayfeedback(.5) .gain(.8).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("<[fs5 fs5 d5 b4 ~ b4 ~ e5 ~ e5 ~ e5 gs5 gs5 a5 b5] [a5 a5 a5 e5 ~ d5 ~ fs5 ~ fs5 ~ fs5 e5 e5 fs5 e5]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (F#m·D·A·E) + contramelodía ── +const stab = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,e4] [a3,cs4,e4,b4] [e3,gs3,b3,ds4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── BAJO ROLLING (16avos en fs; en el drop B sigue F#m→D→A→E) ── const bajo = note("fs1 fs1 fs1 fs2 fs1 fs1 fs2 fs1 fs1 fs1 fs2 fs1 fs1 fs2 fs1 fs2") - .s("sawtooth").lpf(perlin.slow(5).range(420, 1100)).lpq(7) + .s("sawtooth").lpf(perlin.slow(5).range(420, 1100)).lpq(8) .attack(.001).decay(.11).sustain(.2).release(.03) - .shape(.35).gain(.92).orbit(1) + .shape(.35).coarse(1).gain(.92).orbit(1) const bajoProg = bajo.add(note("<0 -4 3 -2>")) -const sub = note("fs1*4").s("sine").decay(.28).sustain(.25).gain(.65).orbit(1) +// SUB afinado que SIGUE la fundamental de cada compas (F#m·D·A·E) +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.68).orbit(1) -// ── BATERÍA 909 (el kick lanza el sidechain sobre bajo y lead) ── -const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05) - .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1) - .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0) +// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 909: KICK EN 2 CAPAS (click 909 + boom afinado que sigue las raices) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.45).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.1).gain(1.0) + .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.55).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.55).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.3,.7)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.4).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) // rodillo LARGO de 8 compases, marca de la casa hard trance const rodilloLargo = s("sd*16").bank("RolandTR909") .gain(saw.slow(8).range(.15, .9)).hpf(saw.slow(8).range(300, 2400)) @@ -151,27 +242,30 @@ const rodilloCorto = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.25, .95)).ply("<1 1 1 2>").orbit(0) // ── PADS ÉPICOS (F#m → D → A → E) ── -const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>") +const pad = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,e4] [a3,cs4,e4,b4] [e3,gs3,b3,ds4]>") .s("sawtooth").lpf(800).attack(.7).release(1.4) - .room(.7).rsize(8).gain(.4).orbit(4) + .hpf(150).room(.7).rsize(8).gain(.4).orbit(4) +// riser de ruido filtrado para transiciones/subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introB = stack(kick, hats, open, clap.gain(.45), bajo.lpf(420).gain(.65)) -const build = stack(kick, hats16, clap, bajo, pad, +const build = stack(kick, hats16, clap, bajo, sub, pad, riser, riff.lpf(saw.slow(16).range(400, 2600)).gain(.55)) -const buildFin = stack(kickHard, rodilloLargo, bajo, riff.gain(.7)) -const dropA = stack(kickHard, hats16, open, clap, bajo, sub, riff, riffCuerpo) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, - riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, pad.gain(.3)) -const breakPiano = stack(riffPiano, pad, hats.gain(.25), sub.gain(.3)) +const buildFin = stack(kickHard, rodilloLargo, riser, ghost, bajo, sub, riff.gain(.7)) +const dropA = stack(kickHard, hats16, open, clap, ghost, bajo, sub, riff, riffCuerpo, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, pad.gain(.3), leadLimpio, stab, contra) +const breakPiano = stack(riffPiano, pad, hats.gain(.25), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(riffPiano.gain(.6), pad, rodilloLargo, hats16.gain(.35), kick.degradeBy(.5)) -const dropB = stack(kickHard, hats16, open, clap, bajoProg, sub, riff, riffCuerpo) -const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ride, - bajoProg, sub, riff, riffCuerpo, pad.gain(.35)) +const dropB = stack(kickHard, hats16, open, clap, ghost, bajoProg, sub, riff, riffCuerpo, leadLimpio, stab) +const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ride, ghost, + bajoProg, sub, bajoOff, riff, riffCuerpo, pad.gain(.35), leadLimpio, stab, contra) const coda = stack(kick, hats, clap.gain(.4), bajo.lpf(600).gain(.7), - riff.gain(.4).room(.7)) + riff.gain(.4).room(.7), leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.35), riffPiano.gain(.5).room(.9).delayfeedback(.7), pad.gain(.3)) @@ -189,29 +283,38 @@ arrange( [16, dropBFull], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "03 · sweet dreams warehouse — eurythmics (1983)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 03 · SWEET DREAMS WAREHOUSE — Eurythmics (1983) → Dark Warehouse Techno Remix -// 128 BPM · Cm · TR-808 · bajo icónico con shape + hats industriales + hpf +// 128 BPM · Cm (Cm·Cm·Ab·G) · TR-808 · bajo icónico con shape + hats industriales + hpf +// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes +// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser // Estructura: intro→bajo solo→build→drop A→break→drop B→coda (140 compases ≈ 4:22) // ════════════════════════════════════════════════════════════════ setcps(128/60/4) // ── EL BAJO ICÓNICO (octavas Cm; progresión Cm→Cm→Ab→G por secciones) ── const bajo = note("<[c2 c3 g2 ab2 c2 c3 g2 ab2]!2 [ab1 ab2 eb2 c2 ab1 ab2 eb2 c2] [g1 g2 d2 b1 g1 g2 d2 b1]>") - .s("sawtooth").lpf(perlin.slow(6).range(500, 950)).lpq(6) + .s("sawtooth").lpf(perlin.slow(6).range(500, 950)).lpq(7) .attack(.002).decay(.18).sustain(.35).release(.05) - .shape(.45).gain(.95).orbit(1) + .shape(.45).coarse(1).gain(.95).orbit(1) +// SUB afinado que SIGUE la fundamental (Cm·Cm·Ab·G) const sub = note("").struct("x*4").s("sine") - .decay(.3).sustain(.2).gain(.6).orbit(1) + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1) -// ── HOOK VOCAL (interpretación sintética del estribillo) ── -const voz = note("g4 g4 eb4 g4 c5 ~ bb4 g4") +// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── HOOK VOCAL (melodía real: "sweet dreams are made of this / who am I to disagree") ── +const voz = note("<[g4 g4 g4 eb4 c4 ~ ~ ~] [c4 c4 d4 eb4 c4 bb3 c4 ~]>") .s("sawtooth").lpf(1500).lpq(5).attack(.01).release(.2) .vowel("").room(.5).rsize(6) .delay(.35).delaytime(.375).delayfeedback(.45) @@ -219,26 +322,51 @@ const voz = note("g4 g4 eb4 g4 c5 ~ bb4 g4") const vozEco = voz.off(.125, x=>x.add(note(12)).gain(.35).lpf(2400)) -// ── BATERÍA 808 (percusión pasada por hpf, carácter industrial) ── -const kick = s("bd bd bd ").bank("RolandTR808").shape(.5).gain(1.05) +// ── LEAD LIMPIO (la misma melodía real, nítida y al frente) ── +const leadLimpio = note("<[g4 g4 g4 eb4 c4 ~ ~ ~] [c4 c4 d4 eb4 c4 bb3 c4 ~]>") + .s("triangle").lpf(5200).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (Cm·Ab·G) + contramelodía de respuesta ── +const stab = note("<[c3,eb3,g3,bb3]!2 [ab2,c3,eb3,g3] [g2,b2,d3,f3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BATERÍA 808: KICK EN 2 CAPAS (click 808 + boom afinado que sigue las raices) ── +const kickClick = s("bd bd bd ").bank("RolandTR808").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickHard = s("bd bd bd ").bank("RolandTR808") - .shape(.6).distort(1.1).gain(1.1) +const kickBoom = note("").struct("x x x ").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.02).orbit(0) +const kickHardClick = s("bd bd bd ").bank("RolandTR808").hpf(38).shape(.6).distort(1.1).gain(1.0) .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR808").hpf(500).room(.3).gain(.7).orbit(0) -const hats = s("hh*8").bank("RolandTR808").hpf(6000).gain("[.5 .28]*4") +const hats = s("hh*8").bank("RolandTR808").hpf(6000).swingBy(1/24,8).gain("[.5 .28]*4") .pan(sine.slow(5).range(.35,.65)).orbit(0) const industria = s("metal*8").n(irand(8)).hpf(2800).crush(8) .gain("[.3 .12 .2 .12]*2").pan(rand.range(.25,.75)).orbit(0) const ghost = s("[~ sd]*4").bank("RolandTR808").degradeBy(.55) - .hpf(400).gain(.28).orbit(0) + .hpf(400).gain(rand.range(.1,.28)).orbit(0) const tomsBuild = s("lt lt mt lt ht mt lt mt").bank("RolandTR808") .gain(saw.slow(4).range(.3, .75)).speed(saw.slow(4).range(1, 1.3)).orbit(0) const riser = s("white").clip(1).hpf(saw.slow(8).range(300, 5000)) .gain(saw.slow(8).range(.05, .3)).room(.5).orbit(3) // ── PADS MENORES TENSOS ── -const pad = note("<[c3,eb3,g3]!2 [ab2,c3,eb3] [g2,b2,d3]>") +const pad = note("<[c3,eb3,g3,bb3]!2 [ab2,c3,eb3,g3] [g2,b2,d3,f3]>") .s("sawtooth").lpf(sine.slow(24).range(400, 900)).attack(.9).release(1.6) .hpf(150).room(.7).rsize(8).gain(.4).orbit(4) @@ -252,18 +380,18 @@ const introB = stack(kick, hats, ghost, clap.gain(.4), sub) const bajoSolo = stack(kick, hats, clap, bajo, ghost) const build = stack(kick, hats, industria.gain(.2), clap, bajo, pad, riser, voz.lpf(saw.slow(8).range(300, 1600)).gain(.5)) -const dropA = stack(kickHard, hats, industria, clap, bajo, sub, voz) -const dropAvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub, - vozEco, cuerdas) +const dropA = stack(kickHard, hats, industria, clap, ghost, bajo, sub, voz, leadLimpio, stab) +const dropAvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub, bajoOff, + vozEco, cuerdas, leadLimpio, stab, contra) const breakdown = stack(pad, cuerdas, voz.gain(.55).room(.8), - hats.gain(.25), sub.gain(.3)) + hats.gain(.25), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(pad, cuerdas, voz.gain(.65), tomsBuild, riser, hats.gain(.35)) const dropB = stack(kickHard, hats, industria, clap, ghost, - bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.55)), sub, vozEco) -const dropBvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub, - vozEco, cuerdas, pad.gain(.28)) -const punchFinal = stack(kickHard, hats, clap, bajo, sub, voz.gain(.6)) + bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.55)), sub, vozEco, leadLimpio, stab) +const dropBvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub, bajoOff, + vozEco, cuerdas, pad.gain(.28), leadLimpio, stab, contra) +const punchFinal = stack(kickHard, hats, clap, bajo, sub, voz.gain(.6), leadLimpio, stab) const coda = stack(kick, hats.gain(.35), bajo.lpf(550).gain(.7), voz.gain(.4).room(.7), pad) const codaFin = stack(hats.gain(.25), voz.gain(.3).room(.9).delayfeedback(.7), @@ -284,14 +412,17 @@ arrange( [8, punchFinal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "04 · billie jean tech house — michael jackson (1983)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 04 · BILLIE JEAN TECH HOUSE — Michael Jackson (1983) → Tech House Remix -// 126 BPM · F#m · LinnDrum · groove shuffleado + stabs F#m-B + bajo sine+saw +// 126 BPM · F#m (F#m·F#m·Bm·C#m) · LinnDrum · groove shuffleado + stabs F#m-B + bajo sine+saw +// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes +// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser // Estructura: intro→groove→build→drop A→break→drop B→coda (136 compases ≈ 4:19) // ════════════════════════════════════════════════════════════════ setcps(126/60/4) @@ -304,6 +435,17 @@ const bajoSaw = note(linea).swingBy(1/6, 8).s("sawtooth") .lpf(650).lpq(4).attack(.002).decay(.15).sustain(.3).release(.05) .shape(.2).gain(.55).orbit(1) const bajo = stack(bajoSine, bajoSaw) +// variante por compas transpuesta a la raiz de cada acorde (F#m·F#m·Bm·C#m) +const bajoProg = bajo.add(note("<0 0 5 -5>")) + +// SUB afinado que SIGUE la fundamental (coherencia armonica total) +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.68).orbit(1) + +// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) // ── CONTRAMELODÍA DE STRINGS (interpretación) ── const cuerdas = note("cs5 ~ b4 ~ a4 ~ gs4 fs4") @@ -314,17 +456,33 @@ const cuerdas = note("cs5 ~ b4 ~ a4 ~ gs4 fs4") const cuerdasAlto = cuerdas.add(note(12)).gain(.3).lpf(3000).orbit(2) +// ── VOZ PRINCIPAL (el estribillo real: "Billie Jean is not my lover…") ── +const voz = note("<[cs5 cs5 cs5 cs5 d5 cs5 b4 ~] [a4 ~ fs4 a4 b4 a4 fs4 ~]>") + .s("triangle").lpf(4800).lpq(1) + .attack(.005).decay(.18).sustain(.5).release(.15) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.66).pan(.5).orbit(2) + // ── STABS DE ACORDE (F#m alternando con B, muy tech house) ── -const stabs = note("~ [fs3,a3,cs4] ~ <[fs3,a3,cs4] [b3,ds4,fs4]>") +const stabs = note("~ [fs3,a3,cs4,e4] ~ <[fs3,a3,cs4,e4] [b3,ds4,fs4,cs5]>") .s("sawtooth").lpf(1900).lpq(6) .attack(.004).decay(.13).sustain(0).release(.08) - .phaser(.6).phaserdepth(.5).room(.35) - .gain(.7).orbit(3) + .phaser(.6).phaserdepth(.5).hpf(160).room(.35) + .gain(.68).orbit(3) -// ── BATERÍA LINNDRUM (crujiente, todo shuffleado) ── -const kick = s("bd*4").bank("LinnDrum").shape(.3).gain(1.05) - .duck("1:3").duckattack(.1).duckdepth(.5).orbit(0) +// ── BATERÍA LINNDRUM: KICK EN 2 CAPAS (click + boom afinado que sigue las raices) ── +const kickClick = s("bd*4").bank("LinnDrum").hpf(38).shape(.4).gain(.95) + .duck("1:3").duckattack(.11).duckdepth(.5).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.0).orbit(0) +const kickHardClick = s("bd*4").bank("LinnDrum").hpf(38).shape(.55).distort(1.05).gain(1.0) + .duck("1:3").duckattack(.11).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.03)) const clap = s("~ cp ~ cp").bank("LinnDrum").room(.25).gain(.8).orbit(0) +const ghost = s("~ ~ [~ rim] ~ ~ ~ [rim ~] ~").bank("LinnDrum").gain(rand.range(.1,.24)).hpf(400).orbit(0) const snare = s("~ ~ ~ [~ sd]").bank("LinnDrum").gain(.4).orbit(0) const hats = s("hh*8").bank("LinnDrum").swingBy(1/6, 8) .gain("[.55 .3]*4").pan(.6).orbit(0) @@ -337,27 +495,30 @@ const rodillo = s("sd*16").bank("LinnDrum") .gain(saw.slow(4).range(.2, .8)).speed(saw.slow(4).range(1, 1.35)).orbit(0) // ── PAD SUAVE DE FONDO ── -const pad = note("<[fs3,a3,cs4] [fs3,a3,cs4] [b2,d3,fs3] [cs3,e3,gs3]>") +const pad = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [b2,d3,fs3,a3] [cs3,e3,gs3,b3]>") .s("sawtooth").lpf(750).attack(.8).release(1.4) - .room(.6).rsize(7).gain(.35).orbit(4) + .hpf(150).room(.6).rsize(7).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones/subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, rimGhost) const introB = stack(kick, hats, open, clap.gain(.5), bajoSine.gain(.5)) const grooveA = stack(kick, hats, open, clap, rimGhost, bajo) -const build = stack(kick, hats16, clap, rimGhost, bajo, stabs, pad, - cuerdas.lpf(saw.slow(8).range(400, 2000)).gain(.45)) -const dropA = stack(kick, hats, open, clap, snare, rimGhost, bajo, stabs, cuerdas) -const dropAvar = stack(kick, hats16, open, clap, snare, bajo, stabs, - cuerdas, cuerdasAlto) +const build = stack(kick, hats16, clap, rimGhost, bajo, bajoSub, stabs, pad, riser, + cuerdas.lpf(saw.slow(8).range(400, 2000)).gain(.45), voz.gain(.5)) +const dropA = stack(kickHard, hats, open, clap, snare, rimGhost, ghost, bajo, bajoSub, stabs, cuerdas, voz) +const dropAvar = stack(kickHard, hats16, open, clap, snare, ghost, bajo, bajoSub, bajoOff, stabs, + cuerdas, cuerdasAlto, voz) const breakdown = stack(pad, cuerdas.gain(.55).room(.75), - bajoSine.gain(.45), hats.gain(.3), rimGhost.gain(.2)) -const breakBuild = stack(pad, cuerdas.gain(.65), bajo, rodillo, hats16.gain(.3)) -const dropB = stack(kick, hats, open, clap, snare, rimGhost, - bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), stabs, cuerdas) -const dropBvar = stack(kick, hats16, open, clap, snare, bajo, - stabs.every(4, x=>x.iter(4)), cuerdas, cuerdasAlto, pad.gain(.25)) -const coda = stack(kick, hats, clap.gain(.5), bajo, cuerdas.gain(.4).room(.7)) + bajoSine.gain(.45), hats.gain(.3), rimGhost.gain(.2), voz.gain(.5).room(.6)) +const breakBuild = stack(pad, cuerdas.gain(.65), bajo, rodillo, riser, hats16.gain(.3)) +const dropB = stack(kickHard, hats, open, clap, snare, rimGhost, ghost, + bajoProg.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, stabs, cuerdas, voz) +const dropBvar = stack(kickHard, hats16, open, clap, snare, ghost, bajoProg, bajoSub, bajoOff, + stabs.every(4, x=>x.iter(4)), cuerdas, cuerdasAlto, pad.gain(.25), voz) +const coda = stack(kick, hats, clap.gain(.5), bajo, cuerdas.gain(.4).room(.7), voz.gain(.45)) const codaFin = stack(hats.gain(.3), bajoSine.gain(.4), cuerdas.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3)) @@ -375,20 +536,23 @@ arrange( [16, dropBvar], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "05 · just can't get enough acid — depeche mode (1981)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 05 · JUST CAN'T GET ENOUGH ACID — Depeche Mode (1981) → Acid Techno Remix -// 135 BPM · G · TR-606 + 303 · línea acid protagonista + hook cuadrado naïf +// 135 BPM · G (G·G·C·D) · TR-606 + 303 · línea acid protagonista + hook cuadrado naïf +// PRO: kick 2 capas (click+boom afinado que sigue las raices) · acid/sub siguen acordes +// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser // Estructura: intro→acid solo→build→drop A→break→drop B→acid final→coda (144 compases ≈ 4:16) // ════════════════════════════════════════════════════════════════ setcps(135/60/4) // ── EL HOOK (interpretación: frase y respuesta alternadas, sinte naïf) ── -const hook = note("<[g4 b4 d5 b4 e5 d5 b4 g4] [c5 e5 g5 e5 d5 b4 a4 g4]>") +const hook = note("<[d5 ~ d5 d5 e5 d5 b4 ~ g4 ~ b4 d5 e5 d5 b4 ~] [d5 ~ d5 d5 e5 d5 b4 ~ a4 ~ b4 d5 e5 d5 ~ ~]>") .s("square").lpf(2300).lpq(3) .attack(.004).decay(.14).sustain(.15).release(.08) .room(.35).rsize(4).delay(.3).delaytime(.375).delayfeedback(.35) @@ -396,8 +560,29 @@ const hook = note("<[g4 b4 d5 b4 e5 d5 b4 g4] [c5 e5 g5 e5 d5 b4 a4 g4]>") const hookOctava = hook.add(note(12)).gain(.3).lpf(3600).orbit(2) +// ── LEAD LIMPIO (la misma frase vocal, nítida y al frente) ── +const leadLimpio = note("<[d5 ~ d5 d5 e5 d5 b4 ~ g4 ~ b4 d5 e5 d5 b4 ~] [d5 ~ d5 d5 e5 d5 b4 ~ a4 ~ b4 d5 e5 d5 ~ ~]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (G·C·D) + contramelodía ── +const stab = note("<[g2,b2,d3,a3] [g2,b2,d3,a3] [c3,e3,g3,d4] [d3,fs3,a3,c4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("2:3").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ d4 ~ b3 ~ g3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ e4 ~ c4 ~ g3 ~] [~ ~ fs4 ~ d4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── LA 303 (protagonista absoluta: lpf modulado lento + lpq alto) ── -const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1") +// el riff acid transpuesto a la fundamental de cada compas (G·G·C·D) +const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1").add(note("<0 0 5 7>")) .s("sawtooth").ftype("ladder") .lpf(sine.slow(24).range(140, 3200)).lpq(sine.slow(9).range(10, 24)) .lpenv(4).lpattack(.003).lpdecay(.14) @@ -407,46 +592,62 @@ const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1") const acidFuria = acid.lpf(sine.slow(6).range(300, 3600)) .lpq(sine.slow(3).range(14, 26)).sometimesBy(.3, x=>x.ply(2)) -// ── SUB DE APOYO ── -const sub = note("g1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1) +// ── SUB DE APOYO (afinado, SIGUE la fundamental G·G·C·D) ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1) -// ── BATERÍA 606 (seca, sin room, puro garaje) ── -const kick = s("bd*4").bank("RolandTR606").shape(.45).gain(1.1) +// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 606: KICK EN 2 CAPAS (click 606 + boom afinado que sigue las raices) ── +const kickClick = s("bd*4").bank("RolandTR606").hpf(38).shape(.45).gain(1.0) .duck("2:3").duckattack(.09).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR606").shape(.6).distort(1.1).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR606").hpf(38).shape(.6).distort(1.1).gain(1.05) .duck("2:3").duckattack(.09).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const snare = s("~ sd ~ sd").bank("RolandTR606").gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR606").gain(.55).pan(.58).orbit(0) -const hats16 = s("hh*16").bank("RolandTR606") - .gain("[.5 .2 .3 .2]*4").pan(rand.range(.35,.65)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandTR606").gain(.45).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR606").swingBy(1/24,8).gain(.55).pan(.58).orbit(0) +const hats16 = s("hh*16").bank("RolandTR606").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR606").nudge(.004).gain(.45).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR606").gain(rand.range(.1,.28)).hpf(400).orbit(0) const rodillo = s("sd*16").bank("RolandTR606") .gain(saw.slow(4).range(.2, .85)).speed(saw.slow(4).range(1, 1.5)).orbit(0) // ── PAD MÍNIMO (solo para el break) ── -const pad = note("<[g2,b2,d3] [g2,b2,d3] [c3,e3,g3] [d3,fs3,a3]>") +const pad = note("<[g2,b2,d3,a3] [g2,b2,d3,a3] [c3,e3,g3,d4] [d3,fs3,a3,c4]>") .s("sawtooth").lpf(700).attack(.8).release(1.5) - .room(.65).rsize(7).gain(.35).orbit(4) + .hpf(150).room(.65).rsize(7).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones/subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introB = stack(kick, hats, open, snare.gain(.4), sub) const acidSolo = stack(kick, hats, snare, acid.gain(.65), sub.gain(.4)) -const build = stack(kick, hats16, snare, acid, sub, pad.gain(.25), - hook.lpf(saw.slow(8).range(400, 2400)).gain(.5)) -const dropA = stack(kickHard, hats16, open, snare, acid, sub, hook) -const dropAvar = stack(kickHard, hats16, open, snare, acid, sub, - hook, hookOctava) +const build = stack(kick, hats16, snare, ghost, acid, sub, pad.gain(.25), riser, + hook.lpf(saw.slow(8).range(400, 2400)).gain(.5), leadLimpio.gain(.5), stab) +const dropA = stack(kickHard, hats16, open, snare, ghost, acid, sub, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, snare, ghost, acid, sub, bajoOff, + hook, hookOctava, leadLimpio, stab, contra) const breakdown = stack(pad, hook.gain(.55).room(.7).delayfeedback(.55), - hats.gain(.3), acid.gain(.4).lpf(500)) -const breakBuild = stack(pad, hook.gain(.65), rodillo, hats16.gain(.35), + hats.gain(.3), acid.gain(.4).lpf(500), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, hook.gain(.65), rodillo, riser, hats16.gain(.35), acid.gain(.6)) -const dropB = stack(kickHard, hats16, open, snare, acidFuria, sub, hook) -const dropBvar = stack(kickHard, hats16, open, snare, acidFuria, sub, - hook.every(4, x=>x.rev()), hookOctava) +const dropB = stack(kickHard, hats16, open, snare, ghost, acidFuria, sub, hook, leadLimpio, stab) +const dropBvar = stack(kickHard, hats16, open, snare, ghost, acidFuria, sub, bajoOff, + hook.every(4, x=>x.rev()), hookOctava, leadLimpio, stab, contra) const acidFinal = stack(kickHard, hats, snare, acidFuria, sub) const coda = stack(kick, hats, snare.gain(.4), acid.gain(.55).lpf(800), - hook.gain(.45).room(.6), sub.gain(.4)) + hook.gain(.45).room(.6), sub.gain(.4), leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.3), hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) @@ -465,14 +666,17 @@ arrange( [8, acidFinal], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "06 · tainted love ebm — soft cell (1981)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 06 · TAINTED LOVE EBM — Soft Cell (1981) → EBM / Electro Techno Remix -// 130 BPM · Dm · TR-808 · bajo EBM distorsionado + "ding ding" + coros vowel +// 130 BPM · Dm (Dm·Dm·Bb·A) · TR-808 · bajo EBM distorsionado + "ding ding" + coros vowel +// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes +// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser // Estructura: intro→ding→build→drop A→break coros→drop B→coda (140 compases ≈ 4:18) // ════════════════════════════════════════════════════════════════ setcps(130/60/4) @@ -497,6 +701,20 @@ const voz = note("d4 f4 d4 c4 a3 c4 d4 ~") const vozOctava = voz.add(note(12)).gain(.3).orbit(2) +// ── LEAD LIMPIO (la voz una octava arriba, nítida y al frente) ── +const leadLimpio = note("d5 f5 d5 c5 a4 c5 d5 ~") + .s("triangle").lpf(4800).lpq(1) + .attack(.005).decay(.18).sustain(.5).release(.15) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.22) + .gain(.58).pan(.5).orbit(2) + +// ── PAD CÁLIDO (colchón Dm·Bb·A que llena la zona media) ── +const padCalido = note("<[d3,f3,a3,c4]!2 [bb2,d3,f3,a3] [a2,cs3,e3,g3]>") + .s("sawtooth").lpf(sine.slow(24).range(500, 1100)).lpq(3) + .attack(.7).release(1.4).shape(.15).hpf(150) + .room(.55).rsize(7).gain(.34).pan(.45) + .duck("1:2").duckdepth(.35).orbit(4) + // ── BAJO EBM (16avos machacones con distorsión) ── const bajo = note("[d2 d2 d3 d2]*4").s("sawtooth") .lpf(750).lpq(7).attack(.001).decay(.1).sustain(.25).release(.03) @@ -507,18 +725,32 @@ const bajoProg = note("<[d2 d2 d3 d2]!2 [bb1 bb1 bb2 bb1] [a1 a1 a2 a1]>*4") .attack(.001).decay(.1).sustain(.25).release(.03) .shape(.5).distort(1.05).gain(.8).orbit(1) -const sub = note("d1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1) +// SUB afinado que SIGUE la fundamental (Dm·Dm·Bb·A) +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1) -// ── BATERÍA 808 (snare seca, marcial) ── -const kick = s("bd*4").bank("RolandTR808").shape(.5).gain(1.05) +// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 808: KICK EN 2 CAPAS (click 808 + boom afinado que sigue las raices) ── +const kickClick = s("bd*4").bank("RolandTR808").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) -const kickVar = s("bd bd bd [bd bd]").bank("RolandTR808") - .shape(.6).distort(1.05).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.02).orbit(0) +const kickVarClick = s("bd bd bd [bd bd]").bank("RolandTR808").hpf(38) + .shape(.6).distort(1.05).gain(1.0) .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickVar = stack(kickVarClick, kickBoom.gain(1.05)) const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.85).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR808") - .gain("[.45 .2 .3 .2]*4").pan(rand.range(.4,.6)).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR808").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR808").swingBy(1/24,16) + .gain(perlin.range(.2,.48)).pan(rand.range(.4,.6)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0) const rimInd = s("rim*8").bank("RolandTR808").crush(6) .gain("[.35 .18]*4").hpf(900).pan(.35).orbit(0) const tomsFill = s("~ ~ ~ [lt mt ht mt]").bank("RolandTR808") @@ -527,31 +759,34 @@ const rodillo = s("sd*16").bank("RolandTR808") .gain(saw.slow(4).range(.2, .9)).speed(saw.slow(4).range(1, 1.4)).orbit(0) // ── COROS SINTÉTICOS (Dm → Bb → A con formantes) ── -const coros = note("<[d3,f3,a3]!2 [bb2,d3,f3] [a2,cs3,e3]>") - .s("sawtooth").vowel("o").lpf(1200) +const coros = note("<[d3,f3,a3,c4]!2 [bb2,d3,f3,a3] [a2,cs3,e3,g3]>") + .s("sawtooth").vowel("o").lpf(1200).hpf(150) .attack(.6).release(1.2).room(.65).rsize(7) .gain(.45).orbit(4) +// riser de ruido filtrado para transiciones/subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introDing = stack(kick, hats, snare.gain(.4), ding, sub) -const build = stack(kick, hats16, snare, bajo, ding, coros.gain(.3), - voz.lpf(saw.slow(8).range(400, 1900)).gain(.5)) -const buildFin = stack(kickVar, rodillo, bajo, ding, voz.gain(.65)) -const dropA = stack(kickVar, hats16, snare, rimInd, bajo, sub, ding, voz) -const dropAvar = stack(kickVar, hats16, snare, rimInd, tomsFill, bajo, sub, - ding, dingRespuesta, voz, vozOctava) +const build = stack(kick, hats16, snare, ghost, bajo, sub, ding, coros.gain(.3), riser, + voz.lpf(saw.slow(8).range(400, 1900)).gain(.5), leadLimpio.gain(.5), padCalido.gain(.25)) +const buildFin = stack(kickVar, rodillo, riser, ghost, bajo, sub, ding, voz.gain(.65), leadLimpio.gain(.55)) +const dropA = stack(kickVar, hats16, snare, rimInd, ghost, bajo, sub, ding, voz, leadLimpio, padCalido) +const dropAvar = stack(kickVar, hats16, snare, rimInd, tomsFill, ghost, bajo, sub, bajoOff, + ding, dingRespuesta, voz, vozOctava, leadLimpio, padCalido) const breakCoros = stack(coros, voz.gain(.55).room(.75), ding.gain(.5), - hats.gain(.25), sub.gain(.3)) + hats.gain(.25), sub.gain(.3), leadLimpio.gain(.45).room(.7)) const breakBuild = stack(coros, voz.gain(.65), rodillo, hats16.gain(.3), ding.gain(.6)) -const dropB = stack(kickVar, hats16, snare, rimInd, bajoProg, sub, ding, - voz, coros.gain(.3)) -const dropBvar = stack(kickVar, hats16, snare, rimInd, tomsFill, bajoProg, sub, - ding, dingRespuesta, voz, vozOctava, coros.gain(.35)) -const marcha = stack(kick, hats, snare, bajo, sub, ding.gain(.6), voz.gain(.6)) +const dropB = stack(kickVar, hats16, snare, rimInd, ghost, bajoProg, sub, ding, + voz, coros.gain(.3), leadLimpio, padCalido.gain(.28)) +const dropBvar = stack(kickVar, hats16, snare, rimInd, tomsFill, ghost, bajoProg, sub, bajoOff, + ding, dingRespuesta, voz, vozOctava, coros.gain(.35), leadLimpio, padCalido.gain(.3)) +const marcha = stack(kick, hats, snare, bajo, sub, ding.gain(.6), voz.gain(.6), leadLimpio.gain(.5)) const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.6), - voz.gain(.45).room(.7), coros.gain(.35)) + voz.gain(.45).room(.7), coros.gain(.35), leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.3), ding.gain(.4).delayfeedback(.7), coros.gain(.3)) @@ -570,14 +805,17 @@ arrange( [8, marcha], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "07 · axel f detroit — harold faltermeyer (1984)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 07 · AXEL F DETROIT — Harold Faltermeyer (1984) → Detroit Techno Remix -// 128 BPM · Fm · TR-909 · chords stab Fm7 en offbeat + hats rápidos + bajo walking +// 128 BPM · Fm (Fm·Fm·Db·Eb) · TR-909 · chords stab Fm7 en offbeat + hats rápidos + bajo walking +// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes +// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser // Estructura: intro→stabs→build→drop A→break→drop B→drop C→coda (144 compases ≈ 4:30) // ════════════════════════════════════════════════════════════════ setcps(128/60/4) @@ -593,45 +831,86 @@ const lead = melodia.s("sawtooth").lpf(2000).lpq(5) const leadOctava = melodia.add(note(12)).s("square") .lpf(3400).attack(.004).release(.1).gain(.3).pan(.65).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("<[f4 ~ ~ ab4 ~ ~ f4 ~ f4 bb4 ~ f4 ~ eb4 ~ ~] [f4 ~ ~ c5 ~ ~ f4 ~ f4 db5 ~ c5 ~ ab4 ~ ~] [f4 c5 ~ f5 ~ f4 eb4 ~ eb4 c4 ~ g4 f4 ~ ~ ~]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (Fm·Db·Eb) + contramelodía ── +// (se llama stabArm porque ya existe un const stab de chords Detroit) +const stabArm = note("<[f3,ab3,c4,eb4] [f3,ab3,c4,eb4] [db3,f3,ab3,c4] [eb3,g3,bb3,db4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ ab4 ~ f4 ~ db4 ~] [~ ~ bb4 ~ g4 ~ eb4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── CHORDS STAB DETROIT (Fm7 en offbeat, con phaser) ── const stab = note("~ [f3,ab3,c4,eb4] ~ [f3,ab3,c4,eb4]") .s("sawtooth").lpf(2100).lpq(5) .attack(.003).decay(.15).sustain(0).release(.1) - .phaser(2).phaserdepth(.6).room(.4).rsize(5) + .phaser(2).phaserdepth(.6).hpf(160).room(.4).rsize(5) .gain(.7).orbit(3) const stabVar = note("~ [f3,ab3,c4,eb4] ~ <[f3,ab3,c4,eb4] [ab3,c4,eb4,g4]>") .s("sawtooth").lpf(2400).lpq(5) .attack(.003).decay(.15).sustain(0).release(.1) - .phaser(2).phaserdepth(.6).room(.4).rsize(5) + .phaser(2).phaserdepth(.6).hpf(160).room(.4).rsize(5) .gain(.7).every(4, x=>x.iter(4)).orbit(3) // ── BAJO WALKING (corcheas que caminan por Fm) ── const bajo = note("f1 f2 eb2 c2 f1 ab1 bb1 c2") - .s("sawtooth").lpf(perlin.slow(5).range(450, 900)).lpq(5) + .s("sawtooth").lpf(perlin.slow(5).range(450, 900)).lpq(6) .attack(.002).decay(.16).sustain(.3).release(.05) - .shape(.3).gain(.9).orbit(1) + .shape(.3).coarse(1).gain(.9).orbit(1) -const sub = note("f1*4").s("sine").decay(.28).sustain(.2).gain(.6).orbit(1) +// el walking transpuesto a la fundamental de cada compas (Fm·Fm·Db·Eb) +const bajoProg = bajo.add(note("<0 0 -4 -2>")) -// ── BATERÍA 909 (hats rápidos, ride Detroit) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// SUB afinado que SIGUE la fundamental (Fm·Fm·Db·Eb) +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) + +// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 909: KICK EN 2 CAPAS (click 909 + boom afinado que sigue las raices) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.4).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.05).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(28).pattack(.001).pdecay(.055).pcurve(0) + .attack(.001).decay(.32).sustain(0).release(.04) + .shape(.26).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).distort(1.05).gain(1.0) .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .22 .35 .22]*4").pan(rand.range(.3,.7)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.3,.7)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.4).room(.5).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2, .85)).speed(saw.slow(4).range(1, 1.4)).orbit(0) // ── PADS / STRINGS DETROIT ── -const pad = note("<[f3,ab3,c4] [f3,ab3,c4] [db3,f3,ab3] [eb3,g3,bb3]>") +const pad = note("<[f3,ab3,c4,eb4] [f3,ab3,c4,eb4] [db3,f3,ab3,c4] [eb3,g3,bb3,db4]>") .s("sawtooth").lpf(sine.slow(24).range(450, 1000)).attack(.8).release(1.5) - .room(.7).rsize(8).gain(.4).orbit(4) + .hpf(150).room(.7).rsize(8).gain(.4).orbit(4) +// riser de ruido filtrado para transiciones/subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) const cuerdas = note("").s("supersaw").unison(5).spread(.7) .lpf(sine.slow(32).range(400, 2000)).attack(.5).release(.9) @@ -640,24 +919,24 @@ const cuerdas = note("").s("supersaw").unison(5).spread(.7) // ── SECCIONES ── const intro = stack(kick, hats16.gain(.25), sub.gain(.4)) const introStabs = stack(kick, hats16.gain(.35), open, stab.gain(.5), sub) -const build = stack(kick, hats16, clap, bajo, stab, pad.gain(.3), +const build = stack(kick, hats16, clap, ghost, bajo, sub, stab, pad.gain(.3), riser, melodia.s("sawtooth").lpf(saw.slow(16).range(300, 2000)).gain(.5).orbit(2)) -const buildFin = stack(kickHard, rodillo, bajo, stab, lead.gain(.7)) -const dropA = stack(kickHard, hats16, open, clap, bajo, sub, stab, lead) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, - stabVar, lead, leadOctava) +const buildFin = stack(kickHard, rodillo, riser, ghost, bajo, sub, stab, lead.gain(.7)) +const dropA = stack(kickHard, hats16, open, clap, ghost, bajo, sub, stab, lead, leadLimpio, stabArm) +const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + stabVar, lead, leadOctava, leadLimpio, stabArm, contra) const breakdown = stack(pad, cuerdas, lead.gain(.55).room(.75), - hats16.gain(.2), sub.gain(.3)) -const breakBuild = stack(pad, cuerdas, lead.gain(.65), rodillo, + hats16.gain(.2), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, cuerdas, lead.gain(.65), rodillo, riser, hats16.gain(.3), stab.gain(.4)) -const dropB = stack(kickHard, hats16, open, clap, crash, bajo, sub, - stabVar, lead, leadOctava) -const dropBFull = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub, - stabVar, lead, leadOctava, cuerdas.gain(.25)) +const dropB = stack(kickHard, hats16, open, clap, crash, ghost, bajoProg, sub, + stabVar, lead, leadOctava, leadLimpio, stabArm) +const dropBFull = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajoProg, sub, bajoOff, + stabVar, lead, leadOctava, cuerdas.gain(.25), leadLimpio, stabArm, contra) const grooveOut = stack(kick, hats16, open, clap, bajo, sub, stab, - lead.sometimesBy(.3, x=>x.add(note(12)).gain(.5))) + lead.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), leadLimpio, stabArm) const coda = stack(kick, hats16.gain(.35), bajo.lpf(550).gain(.7), - lead.gain(.4).room(.7), pad) + lead.gain(.4).room(.7), pad, leadLimpio.gain(.4)) // ── ARREGLO (144 compases) ── arrange( @@ -673,14 +952,16 @@ arrange( [16, dropBFull], [16, grooveOut], [8, coda] -)`, +) +`, }, { name: "08 · the final countdown schranz — europe (1986)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 08 · THE FINAL COUNTDOWN SCHRANZ — Europe (1986) → Schranz / Hard Techno Remix -// 145 BPM · F#m · TR-909 distorsionado · kick implacable + metal loops + supersaw solo en drops +// 145 BPM · F#m (F#m·F#m·D·E) · TR-909 distorsionado · PRO: kick 2 capas + +// boom afinado que sigue las fundamentales + reese/sub siguen acordes + groove // Estructura: intro→máquina→build→drop A→break→drop B→schranz total→coda (148 compases ≈ 4:05) // ════════════════════════════════════════════════════════════════ setcps(145/60/4) @@ -702,22 +983,54 @@ const riffBreak = melodia.slow(2).s("sawtooth") .room(.85).rsize(9).delay(.5).delaytime(.375).delayfeedback(.55) .gain(.7).orbit(2) -// ── BAJO REESE (muro grave con detune, sostenido) ── -const reese = note("fs1").s("supersaw").unison(3).detune(.7) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("<[cs5 b4 cs5 ~ fs4 ~ ~ ~] [d5 cs5 d5 cs5 b4 ~ ~ ~] [d5 cs5 d5 ~ fs4 ~ ~ ~] [b4 a4 b4 a4 gs4 fs4 gs4 ~]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (F#m7·F#m7·Dadd9·E7) + hi-pass ── +const stab = note("<[fs2,a2,cs3,e3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(180).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BAJO REESE que SIGUE las fundamentales (F#·F#·D·E) ── +const reese = note("").s("supersaw").unison(3).detune(.7) .lpf(sine.slow(8).range(200, 600)).lpq(4) .attack(.01).sustain(.8).release(.2).clip(1) - .shape(.3).gain(.7).orbit(1) + .shape(.34).coarse(1).gain(.7).orbit(1) -const sub = note("fs1*4").s("sine").decay(.22).sustain(.2).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica) ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) -// ── BATERÍA 909 DESTROZADA (kick distorsionado implacable) ── -const kick = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 909 DESTROZADA: kick en 2 capas (click 909 + BOOM afinado) ── +// el boom es una sine con envolvente de tono que sigue las fundamentales +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.1).gain(1) .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0) -const kickSchranz = s("bd*4").bank("RolandTR909").ply("<1 1 1 2>") - .shape(.7).distort(1.15).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0) +const kickClickHard = s("bd*4").bank("RolandTR909").hpf(38).shape(.7).distort(1.15).gain(1) .duck("1:2").duckattack(.08).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickSchranz = stack(kickClickHard.ply("<1 1 1 2>"), kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").hpf(400).room(.25).gain(.7).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) .gain("[.45 .2 .3 .2]*4").hpf(4000).pan(rand.range(.35,.65)).orbit(0) const metalLoop = s("metal*8").n(irand(8)).crush(6).hpf(2200) .gain("[.35 .15 .25 .15]*2").pan(rand.range(.25,.75)).orbit(0) @@ -726,35 +1039,37 @@ const rimLoop = s("rim*16").bank("RolandTR909").crush(5).hpf(1200) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.25, .95)).speed(saw.slow(4).range(1, 1.6)) .hpf(saw.slow(4).range(200, 1800)).orbit(0) +// ghost snare sincopado (dinámica de velocity, entra en los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) const riser = s("white").clip(1).hpf(saw.slow(8).range(400, 6000)) .gain(saw.slow(8).range(.05, .32)).room(.4).orbit(3) -// ── PAD OSCURO (solo respira en el break) ── -const pad = note("<[fs2,a2,cs3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>") +// ── PAD OSCURO con 7as/9as (solo respira en el break) + hi-pass ── +const pad = note("<[fs2,a2,cs3,e3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>") .s("sawtooth").lpf(600).attack(1).release(1.8) - .room(.75).rsize(9).gain(.38).orbit(4) + .hpf(150).room(.75).rsize(9).gain(.38).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats16.gain(.25), sub.gain(.4)) const maquina = stack(kick, hats16, clap.gain(.5), rimLoop.gain(.25), reese.gain(.5)) const build = stack(kick, hats16, clap, metalLoop.gain(.2), reese, sub, riser, riffCuerpo.lpf(saw.slow(8).range(300, 1400)).gain(.5)) -const buildFin = stack(kickSchranz, rodillo, reese, riffCuerpo.gain(.55)) -const dropA = stack(kick, hats16, clap, metalLoop, reese, sub, riff, riffCuerpo) -const dropAvar = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, reese, sub, - riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo) -const breakdown = stack(pad, riffBreak, hats16.gain(.15), sub.gain(.3)) +const buildFin = stack(kickSchranz, rodillo, reese, sub, riser, riffCuerpo.gain(.55)) +const dropA = stack(kick, hats16, clap, metalLoop, ghost, reese, sub, riff, riffCuerpo, leadLimpio, stab) +const dropAvar = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, ghost, reese, sub, bajoOff, + riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, leadLimpio, stab, contra) +const breakdown = stack(pad, riffBreak, hats16.gain(.15), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(pad, riffBreak.gain(.6), rodillo, riser, hats16.gain(.3), kick.degradeBy(.5)) -const dropB = stack(kickSchranz, hats16, clap, metalLoop, reese, sub, - riff, riffCuerpo) -const dropBFull = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, reese, - sub, riff, riffCuerpo, pad.gain(.25)) -const schranzTotal = stack(kickSchranz, rimLoop, metalLoop, clap, - reese.lpf(sine.slow(4).range(250, 800)), sub, - riff.every(4, x=>x.rev())) +const dropB = stack(kickSchranz, hats16, clap, metalLoop, ghost, reese, sub, + riff, riffCuerpo, leadLimpio, stab) +const dropBFull = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, ghost, reese, + sub, bajoOff, riff, riffCuerpo, pad.gain(.25), leadLimpio, stab, contra) +const schranzTotal = stack(kickSchranz, rimLoop, metalLoop, clap, ghost, + reese.lpf(sine.slow(4).range(250, 800)), sub, bajoOff, + riff.every(4, x=>x.rev()), leadLimpio, stab) const coda = stack(kick, hats16.gain(.3), clap.gain(.4), reese.gain(.5), - riffBreak.gain(.5)) + riffBreak.gain(.5), leadLimpio.gain(.4)) const codaFin = stack(hats16.gain(.2), riffBreak.gain(.4).delayfeedback(.7), pad.gain(.3)) @@ -773,14 +1088,16 @@ arrange( [16, schranzTotal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "09 · africa melodic — toto (1982)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 09 · AFRICA MELODIC — Toto (1982) → Melodic Techno Remix -// 122 BPM · A/F#m · TR-707 · kalimba casio + toms tribales + breakdown con viento +// 122 BPM · A/F#m (A·F#m·D·E) · TR-707 · PRO: kick 2 capas + boom afinado +// que sigue las fundamentales + bajoSub sigue acordes + groove con swing // Estructura: intro→kalimba→build→drop A→break amplio→drop B→coda (136 compases ≈ 4:27) // ════════════════════════════════════════════════════════════════ setcps(122/60/4) @@ -794,6 +1111,26 @@ const hook = note("cs5 b4 a4 b4 cs5 ~ b4 a4 fs4 ~ a4 b4 a4 ~ ~ ~") const hookSuave = hook.lpf(1100).gain(.55).room(.8) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("cs5 b4 a4 b4 cs5 ~ b4 a4 fs4 ~ a4 b4 a4 ~ ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Aadd9·F#m7·Dadd9·E7) + hi-pass ── +const stab = note("<[a2,cs3,e3,b3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── ARPEGIO KALIMBA (seisillos con casio, la marimba del remix) ── const kalimba = note("a3 cs4 e4 a4 e4 cs4").s("casio") .attack(.001).decay(.18).sustain(0).release(.08) @@ -813,23 +1150,44 @@ const bajo = note("<[a1 ~ a1 [~ a1]] [fs1 ~ fs1 [~ fs1]] [d2 ~ d2 [~ d2]] [e2 ~ const bajoArm = bajo.add(note(12)).s("triangle").gain(.3).lpf(900).orbit(1) -// ── BATERÍA 707 (suave, con toms tribales) ── -const kick = s("bd*4").bank("RolandTR707").shape(.3).gain(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (A·F#m·D·E) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.55).orbit(1) + +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── BATERÍA 707: kick en 2 capas (click 707 + BOOM afinado que sigue raíces) ── +const kickClick = s("bd*4").bank("RolandTR707").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickClickHard = s("bd*4").bank("RolandTR707").hpf(38).shape(.6).distort(1.15).gain(.95) + .duck("1:2").duckattack(.13).duckdepth(.55).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickClickHard, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR707").room(.35).gain(.6).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR707").gain(.45).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR707") +const hats = s("[~ hh]*4").bank("RolandTR707").swingBy(1/24,8).gain(.45).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR707").swingBy(1/24,16) .gain(rand.range(.12, .42)).pan(rand.range(.35,.65)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandTR707").gain(.35).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR707").nudge(.004).gain(.35).orbit(0) const toms = s("~ mt ~ [~ lt] ~ ht ~ lt").bank("RolandTR707") .gain(.5).pan("<.35 .65 .5 .4>").room(.3).orbit(0) const tomsTribal = s("mt lt [mt mt] lt ht [~ mt] lt [ht lt]").bank("RolandTR707") .gain(saw.slow(4).range(.3, .7)).room(.3).orbit(0) +// ghost snare sincopado (entra en los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR707").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PADS LARGOS Y VIENTO ── -const pad = note("<[a2,cs3,e3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>") +// ── PADS LARGOS con 7as/9as (hi-pass) Y VIENTO ── +const pad = note("<[a2,cs3,e3,b3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>") .s("sawtooth").lpf(sine.slow(32).range(500, 1300)).attack(1.2).release(2) - .room(.75).rsize(9).gain(.42).orbit(4) + .hpf(150).room(.75).rsize(9).gain(.42).orbit(4) const viento = s("wind").n(irand(4)).slow(4).clip(1) .gain(.3).room(.9).rsize(9).hpf(300).orbit(4) @@ -837,22 +1195,22 @@ const viento = s("wind").n(irand(4)).slow(4).clip(1) // ── SECCIONES ── const intro = stack(kick, hats, bajo.gain(.5)) const introKalimba = stack(kick, hats, open, kalimba.gain(.45), bajo) -const build = stack(kick, hats16, clap, bajo, bajoArm, kalimba, pad.gain(.3), +const build = stack(kick, hats16, clap, ghost, bajo, bajoArm, bajoSub, kalimba, pad.gain(.3), riser, hook.lpf(saw.slow(16).range(300, 1700)).gain(.5)) -const buildFin = stack(kick, tomsTribal, bajo, kalimba, hook.gain(.65)) -const dropA = stack(kick, hats16, open, clap, toms, bajo, bajoArm, kalimba, hook) -const dropAvar = stack(kick, hats16, open, clap, toms, bajo, bajoArm, - kalimbaVar, hook, pad.gain(.3)) +const buildFin = stack(kickHard, tomsTribal, riser, bajo, bajoSub, kalimba, hook.gain(.65)) +const dropA = stack(kick, hats16, open, clap, toms, ghost, bajo, bajoArm, bajoSub, kalimba, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, toms, ghost, bajo, bajoArm, bajoSub, bajoOff, + kalimbaVar, hook, pad.gain(.3), leadLimpio, stab, contra) const breakAmplio = stack(pad, viento, hookSuave, kalimba.gain(.4), - bajo.gain(.4)) -const breakBuild = stack(pad, viento.gain(.2), hook.gain(.65), kalimba, + bajo.gain(.4), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, viento.gain(.2), riser, hook.gain(.65), kalimba, tomsTribal, hats16.gain(.3)) -const dropB = stack(kick, hats16, open, clap, toms, bajo, bajoArm, - kalimba, hook.sometimesBy(.25, x=>x.add(note(12)).gain(.5))) -const dropBFull = stack(kick, hats16, open, clap, toms, tomsTribal.gain(.3), - bajo, bajoArm, kalimbaVar, hook, pad.gain(.35)) +const dropB = stack(kick, hats16, open, clap, toms, ghost, bajo, bajoArm, bajoSub, + kalimba, hook.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), leadLimpio, stab) +const dropBFull = stack(kickHard, hats16, open, clap, toms, tomsTribal.gain(.3), ghost, + bajo, bajoArm, bajoSub, bajoOff, kalimbaVar, hook, pad.gain(.35), leadLimpio, stab, contra) const coda = stack(kick, hats, clap.gain(.4), bajo.gain(.6), - kalimba.gain(.45), hookSuave.gain(.4), pad) + kalimba.gain(.45), hookSuave.gain(.4), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.25), kalimba.gain(.35).delayfeedback(.6), viento, pad.gain(.3)) @@ -870,14 +1228,16 @@ arrange( [16, dropBFull], [4, coda], [4, codaFin] -)`, +) +`, }, { name: "10 · jump big room — van halen (1984)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 10 · JUMP BIG ROOM — Van Halen (1984) → Big Room Techno Remix -// 132 BPM · C · TR-909 · sidechain profundo (duckdepth .8) + sub en c1 + builds con rodillo +// 132 BPM · C (C·C·F·G) · TR-909 · PRO: kick 2 capas + sub/boom siguen los +// acordes + bajo offbeat + groove con swing · sidechain profundo (duckdepth .8) // Estructura: intro→stabs→build→drop A→break→build 2→drop B→coda (144 compases ≈ 4:22) // ════════════════════════════════════════════════════════════════ setcps(132/60/4) @@ -897,24 +1257,43 @@ const stabsCuerpo = note("[g3,c4,e4] ~ [g3,c4,e4] [a3,c4,f4] ~ [g3,c4,e4] ~ [g3, const stabsBreak = stabs.slow(2).lpf(1000).room(.85).rsize(9) .delayfeedback(.55).gain(.65) -// ── EL SUB POTENTE (pedal en c1) + bajo offbeat ── -const sub = note("c1*4").s("sine").decay(.35).sustain(.35).release(.05) - .gain(.8).orbit(1) +// ── LEAD LIMPIO (la melodía superior del riff, nítida y al frente) ── +const leadLimpio = note("e5 ~ e5 f5 ~ e5 ~ d5") + .s("triangle").lpf(5200).lpq(1) + .attack(.005).decay(.2).sustain(.45).release(.16) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.6).pan(.5).orbit(2) -const bajoOff = note("[~ c2]*4").s("sawtooth") +// ── CONTRAMELODÍA (zona media, notas de C·F·G) ── +const contra = note("<[~ ~ g4 ~ e4 ~ c4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ a4 ~ f4 ~ c4 ~] [~ ~ b4 ~ g4 ~ d4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── EL SUB que SIGUE los acordes (C·C·F·G) + bajo offbeat ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.35).sustain(.35).release(.05).gain(.8).orbit(1) + +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") .lpf(700).lpq(5).attack(.001).decay(.14).sustain(.2).release(.04) .shape(.3).gain(.7).orbit(1) -// ── BATERÍA 909 ENORME (el kick hunde TODO con duckdepth .8) ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1) +// ── BATERÍA 909 ENORME: kick en 2 capas (hunde TODO con duckdepth .8) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(1) .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.05).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.15).gain(1) .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.1)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.4).rsize(5).gain(.8).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.55).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.55).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.45).room(.5).orbit(0) // rodillo + hpf que sube: la rampa big room const rodillo = s("sd*16").bank("RolandTR909") @@ -922,36 +1301,41 @@ const rodillo = s("sd*16").bank("RolandTR909") .hpf(saw.slow(8).range(150, 2500)).orbit(0) const rodilloCorto = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.3, .95)).ply("<1 1 2 2>").orbit(0) +// ghost snare sincopado (entra en los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PAD ESTADIO ── -const pad = note("<[c3,e3,g3] [c3,e3,g3] [f3,a3,c4] [g3,b3,d4]>") +// ── PAD ESTADIO con 7as/9as (hi-pass) ── +const pad = note("<[c3,e3,g3,d4] [c3,e3,g3,d4] [f3,a3,c4,e4] [g3,b3,d4,f4]>") .s("supersaw").unison(5).spread(.7) .lpf(sine.slow(32).range(450, 1400)).attack(.9).release(1.8) - .room(.75).rsize(9).gain(.4).orbit(4) + .hpf(150).room(.75).rsize(9).gain(.4).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introStabs = stack(kick, hats, open, clap.gain(.5), stabs.lpf(900).gain(.5), sub.gain(.5)) -const build = stack(kick, hats16, clap, bajoOff, pad.gain(.3), - stabs.hpf(saw.slow(16).range(50, 2500)).gain(.6), sub.gain(.5)) -const buildFin = stack(kickHard, rodillo, bajoOff, - stabs.hpf(saw.slow(8).range(100, 4000)).gain(.7)) -const dropA = stack(kickHard, hats16, open, clap, crash, sub, bajoOff, - stabs, stabsCuerpo) -const dropAvar = stack(kickHard, hats16, open, clap, sub, bajoOff, - stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.6)), stabsCuerpo, pad.gain(.3)) -const breakdown = stack(pad, stabsBreak, hats.gain(.25), sub.gain(.35)) -const build2 = stack(pad, stabsBreak.gain(.5), rodillo, hats16.gain(.35), +const build = stack(kick, hats16, clap, ghost, bajoOff, pad.gain(.3), riser, + stabs.hpf(saw.slow(16).range(50, 2500)).gain(.6), sub.gain(.5), leadLimpio.gain(.5)) +const buildFin = stack(kickHard, rodillo, riser, bajoOff, + stabs.hpf(saw.slow(8).range(100, 4000)).gain(.7), leadLimpio.gain(.55)) +const dropA = stack(kickHard, hats16, open, clap, crash, ghost, sub, bajoOff, + stabs, stabsCuerpo, leadLimpio, contra) +const dropAvar = stack(kickHard, hats16, open, clap, ghost, sub, bajoOff, + stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.6)), stabsCuerpo, pad.gain(.3), leadLimpio, contra) +const breakdown = stack(pad, stabsBreak, hats.gain(.25), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const build2 = stack(pad, stabsBreak.gain(.5), rodillo, riser, hats16.gain(.35), kick.degradeBy(.5), sub.gain(.4)) -const dropB = stack(kickHard, hats16, open, clap, crash, sub, bajoOff, - stabs, stabsCuerpo, pad.gain(.3)) -const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, sub, - bajoOff, stabs, stabsCuerpo, pad.gain(.35)) -const grooveOut = stack(kick, hats16, open, clap, sub, bajoOff, - stabs.gain(.7)) +const dropB = stack(kickHard, hats16, open, clap, crash, ghost, sub, bajoOff, + stabs, stabsCuerpo, pad.gain(.3), leadLimpio, contra) +const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ghost, sub, + bajoOff, stabs, stabsCuerpo, pad.gain(.35), leadLimpio, contra) +const grooveOut = stack(kick, hats16, open, clap, ghost, sub, bajoOff, + stabs.gain(.7), leadLimpio) const coda = stack(kick, hats, clap.gain(.5), sub.gain(.5), - stabsBreak.gain(.5), pad.gain(.3)) + stabsBreak.gain(.5), pad.gain(.3), leadLimpio.gain(.4)) // ── ARREGLO (144 compases) ── arrange( @@ -967,14 +1351,16 @@ arrange( [16, dropBFull], [16, grooveOut], [8, coda] -)`, +) +`, }, { name: "11 · rule the world dub — tears for fears (1985)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 11 · RULE THE WORLD DUB — Tears for Fears (1985) → Dub Techno Remix -// 118 BPM · D · Roland CR-78 · chords dub con delay infinito + bajo sine + shuffle hipnótico +// 118 BPM · D (D·D·G·A) · Roland CR-78 · PRO: kick 2 capas + boom afinado y +// bajo/sub que siguen los acordes + chords con 7as/9as + groove shuffle // Estructura: intro→chords→riff→drop A→break→drop B→dub final→coda (140 compases ≈ 4:45) // ════════════════════════════════════════════════════════════════ setcps(118/60/4) @@ -989,8 +1375,28 @@ const riff = note("<[d4 e4 fs4 a4 fs4 e4 d4 ~] [d4 e4 fs4 b4 a4 fs4 e4 ~]>") const riffLejos = riff.add(note(12)).gain(.28).lpf(2200).room(.85) -// ── CHORDS DUB (el corazón del track: delay largo + feedback alto) ── -const chords = note("~ <[d3,fs3,a3] [d3,fs3,a3] [g3,b3,d4] [a3,cs4,e4]> ~ ~") +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("<[d4 e4 fs4 a4 fs4 e4 d4 ~] [d4 e4 fs4 b4 a4 fs4 e4 ~]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Dadd9·Dadd9·Gmaj7·A7) + hi-pass ── +const stab = note("<[d3,fs3,a3,e4] [d3,fs3,a3,e4] [g2,b2,d3,fs3] [a2,cs3,e3,g3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ e4 ~ cs4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── CHORDS DUB con 7as/9as (delay largo + feedback alto) ── +const chords = note("~ <[d3,fs3,a3,e4] [d3,fs3,a3,e4] [g3,b3,d4,fs4] [a3,cs4,e4,g4]> ~ ~") .s("sawtooth").lpf(1100).lpq(3).hpf(250) .attack(.01).decay(.4).sustain(0).release(.3) .phaser(.7).phaserdepth(.5) @@ -999,18 +1405,31 @@ const chords = note("~ <[d3,fs3,a3] [d3,fs3,a3] [g3,b3,d4] [a3,cs4,e4]> ~ ~") const chordsEco = chords.late(.5).gain(.35).lpf(800) -// ── BAJO REDONDO (sine profundo, respirado) ── -const bajo = note("<[d1 ~ [~ d1] ~] [d1 ~ [~ d1] [~ a1]]>") +// ── BAJO REDONDO (sine profundo, ahora sigue D·D·G·A) ── +const bajo = note("<[d1 ~ [~ d1] ~] [d1 ~ [~ d1] ~] [g1 ~ [~ g1] ~] [a1 ~ [~ a1] [~ e1]]>") .s("sine").decay(.4).sustain(.55).release(.1) .gain(.9).orbit(1) const bajoArm = bajo.add(note(12)).s("triangle").lpf(700).gain(.25).orbit(1) -// ── BATERÍA CR-78 (suave, vintage, hipnótica) ── -const kick = s("bd*4").bank("RolandCR78").shape(.35).gain(1.05) +// ── SUB-BAJO afinado que SIGUE la fundamental (D·D·G·A) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.5).orbit(1) + +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.35).duck("1").orbit(1) + +// ── BATERÍA CR-78: kick en 2 capas (click vintage + BOOM afinado) ── +const kickClick = s("bd*4").bank("RolandCR78").hpf(38).shape(.45).gain(.98) .duck("2:3").duckattack(.15).duckdepth(.45).orbit(0) -const kickIntro = s("bd*4").bank("RolandCR78").degradeBy(.15).shape(.3).gain(1) - .duck("2:3").duckattack(.15).duckdepth(.4).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickIntro = stack(s("bd*4").bank("RolandCR78").degradeBy(.15).hpf(38).shape(.3).gain(.9) + .duck("2:3").duckattack(.15).duckdepth(.4).orbit(0), kickBoom.gain(.85)) const hats = s("[~ hh]*4").bank("RolandCR78").swingBy(1/6, 8) .gain(.4).pan(.6).orbit(0) const shaker = s("hh*16").bank("RolandCR78").swingBy(1/6, 16) @@ -1020,40 +1439,45 @@ const rimDub = s("~ rim ~ [~ rim]").bank("RolandCR78") .room(.6).gain(.45).pan(.4).orbit(0) const snareDub = s("~ sd ~ ~").bank("RolandCR78") .room(.6).rsize(7).gain(.5).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandCR78").gain(.3).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandCR78").nudge(.004).gain(.3).orbit(0) +// ghost sincopado (entra en los drops) +const ghost = s("~ ~ [~ rim] ~ ~ ~ [rim ~] ~").bank("RolandCR78").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── ATMÓSFERA (pads inmensos + textura) ── -const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [g2,b2,d3] [a2,cs3,e3]>") +// ── ATMÓSFERA (pads inmensos con 7as/9as + textura) ── +const pad = note("<[d3,fs3,a3,e4] [d3,fs3,a3,e4] [g2,b2,d3,fs3] [a2,cs3,e3,g3]>") .s("sawtooth").lpf(sine.slow(48).range(400, 900)).attack(1.5).release(2.5) .hpf(120).room(.85).rsize(9).gain(.4).orbit(4) const espacio = s("space").n(irand(4)).slow(8).clip(1) .gain(.25).room(.9).rsize(9).hpf(250).orbit(4) +// riser de ruido para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kickIntro, hats, bajo.gain(.5)) const introChords = stack(kickIntro, hats, chords.gain(.5), bajo) const grooveRiff = stack(kick, hats, shaker.gain(.15), rimDub.gain(.3), chords, bajo, riff.gain(.5).lpf(900)) -const build = stack(kick, hats, shaker, rimDub, chords, bajo, bajoArm, - pad.gain(.3), riff.lpf(saw.slow(16).range(500, 1600)).gain(.6)) -const dropA = stack(kick, hats, shaker, open, rimDub, snareDub, - chords, bajo, bajoArm, riff) -const dropAvar = stack(kick, hats, shaker, open, rimDub, snareDub, - chords, chordsEco, bajo, bajoArm, riff, riffLejos) +const build = stack(kick, hats, shaker, rimDub, chords, bajo, bajoArm, bajoSub, + pad.gain(.3), riser, riff.lpf(saw.slow(16).range(500, 1600)).gain(.6)) +const dropA = stack(kick, hats, shaker, open, rimDub, snareDub, ghost, + chords, bajo, bajoArm, riff, leadLimpio, stab) +const dropAvar = stack(kick, hats, shaker, open, rimDub, snareDub, ghost, + chords, chordsEco, bajo, bajoArm, bajoSub, bajoOff, riff, riffLejos, leadLimpio, stab, contra) const breakdown = stack(pad, espacio, chords.gain(.55).delayfeedback(.72), - riff.gain(.45).room(.85), bajo.gain(.45)) -const breakBuild = stack(pad, espacio.gain(.15), chords, riff.gain(.6), + riff.gain(.45).room(.85), bajo.gain(.45), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, espacio.gain(.15), riser, chords, riff.gain(.6), shaker.gain(.25), rimDub, bajo) -const dropB = stack(kick, hats, shaker, open, rimDub, snareDub, chords, +const dropB = stack(kick, hats, shaker, open, rimDub, snareDub, ghost, chords, bajo, bajoArm, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)), - pad.gain(.25)) -const dropBFull = stack(kick, hats, shaker, open, rimDub, snareDub, - chords, chordsEco, bajo, bajoArm, riff, riffLejos, pad.gain(.3)) -const dubFinal = stack(kick, hats, rimDub, chords.delayfeedback(.72), - bajo, riff.gain(.5).room(.9)) + pad.gain(.25), leadLimpio, stab) +const dropBFull = stack(kick, hats, shaker, open, rimDub, snareDub, ghost, + chords, chordsEco, bajo, bajoArm, bajoSub, bajoOff, riff, riffLejos, pad.gain(.3), leadLimpio, stab, contra) +const dubFinal = stack(kick, hats, rimDub, ghost, chords.delayfeedback(.72), + bajo, bajoSub, riff.gain(.5).room(.9), leadLimpio, stab) const coda = stack(kickIntro, hats.gain(.3), - chords.gain(.45).delayfeedback(.75), bajo.gain(.5), pad.gain(.3)) + chords.gain(.45).delayfeedback(.75), bajo.gain(.5), pad.gain(.3), leadLimpio.gain(.4)) const codaFin = stack(chords.gain(.3).delayfeedback(.78), espacio, pad.gain(.3)) @@ -1072,14 +1496,16 @@ arrange( [8, dubFinal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "12 · the model minimal — kraftwerk (1978)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 12 · THE MODEL MINIMAL — Kraftwerk (1978) → Minimal Electro Remix -// 126 BPM · Cm · TR-606 · square robótico + crush suave · ultra seco +// 126 BPM · Cm (Cm·Cm·Ab·G) · TR-606 · PRO: kick 2 capas + boom afinado y +// bajo/sub que siguen los acordes + groove con swing · square robótico, seco // Estructura: intro→groove→drop A→break robot→drop B→coda (136 compases ≈ 4:19) // ════════════════════════════════════════════════════════════════ setcps(126/60/4) @@ -1093,33 +1519,73 @@ const hook = note("c5 ~ b4 c5 g4 ~ eb4 g4 f4 ~ d4 f4 c4 ~ ~ ~") const hookEco = hook.add(note(-12)).late(.5).gain(.3).lpf(1400).orbit(3) -// ── BAJO ROBÓTICO (pulso de máquina en Cm) ── -const bajo = note("c2 c2 g1 c2").s("square") +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("c5 ~ b4 c5 g4 ~ eb4 g4 f4 ~ d4 f4 c4 ~ ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Cm7·Cm7·Abmaj7·G7) + hi-pass ── +const stab = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [g2,b2,d3,f3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BAJO ROBÓTICO (pulso de máquina, ahora sigue Cm·Cm·Ab·G) ── +const bajo = note("<[c2 c2 g1 c2] [c2 c2 g1 c2] [ab1 ab1 eb1 ab1] [g1 g1 d1 g1]>").s("square") .lpf(850).lpq(5).attack(.001).decay(.11).sustain(.3).release(.03) .shape(.2).gain(.9).orbit(1) const bajoOcho = bajo.ply(2).gain(.85) -const bajoDrop = note("c2 [~ c2] g1 [c2 c2] c2 [~ c2] bb1 g1") +const bajoDrop = note("<[c2 [~ c2] g1 [c2 c2] c2 [~ c2] bb1 g1] [c2 [~ c2] g1 [c2 c2] c2 [~ c2] bb1 g1] [ab1 [~ ab1] eb1 [ab1 ab1] ab1 [~ ab1] gb1 eb1] [g1 [~ g1] d1 [g1 g1] g1 [~ g1] f1 d1]>") .s("square").lpf(1000).lpq(6) .attack(.001).decay(.1).sustain(.2).release(.03) .shape(.25).gain(.9).orbit(1) -const sub = note("c1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (Cm·Cm·Ab·G) ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.25).sustain(.2).gain(.6).orbit(1) -// ── BATERÍA 606 (seca, sin reverb, precisión maquinal) ── -const kick = s("bd*4").bank("RolandTR606").shape(.35).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── BATERÍA 606: kick en 2 capas (click seco + BOOM afinado) ── +const kickClick = s("bd*4").bank("RolandTR606").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) -const kickElectro = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR606") - .shape(.4).gain(1.05).duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickElectroClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR606").hpf(38).shape(.4).gain(.95) + .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) +const kickElectroBoom = note("").struct("x ~ ~ x ~ ~ x ~").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0) +const kickElectro = stack(kickElectroClick, kickElectroBoom) const clap = s("~ cp ~ cp").bank("RolandTR606").gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR606").gain(.5).pan(.55).orbit(0) -const hats16 = s("hh*16").bank("RolandTR606") +const hats = s("[~ hh]*4").bank("RolandTR606").swingBy(1/24,8).gain(.5).pan(.55).orbit(0) +const hats16 = s("hh*16").bank("RolandTR606").swingBy(1/24,16) .gain("[.45 .2 .3 .2]*4").pan(.45).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR606").gain(.45).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR606").nudge(.004).gain(.45).orbit(0) const rim = s("[~ rim]*2").bank("RolandTR606").gain(.4).pan(.65).orbit(0) const rodillo = s("sd*16").bank("RolandTR606") .gain(saw.slow(4).range(.15,.7)).speed(saw.slow(4).range(1,1.3)).orbit(0) +// ghost snare sincopado (entra en los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR606").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── BLIPS DE ORDENADOR (textura minimal, aleatoria y fría) ── const blips = note("c6 ~ ~ g5 ~ ~ eb6 ~").s("square") @@ -1127,27 +1593,27 @@ const blips = note("c6 ~ ~ g5 ~ ~ eb6 ~").s("square") .degradeBy(.4).gain(.35).pan(rand.range(.3,.7)) .delay(.2).delaytime(.25).delayfeedback(.3).orbit(3) -// ── PAD MÍNIMO (frío, casi inaudible, solo da contexto) ── -const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [g2,b2,d3]>") +// ── PAD MÍNIMO con 7as (frío, da contexto) + hi-pass ── +const pad = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [g2,b2,d3,f3]>") .s("triangle").lpf(600).attack(1).release(1.5) - .room(.3).gain(.35).orbit(4) + .hpf(150).room(.3).gain(.35).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats) const introB = stack(kick, hats, rim, bajo.lpf(400).gain(.7)) const groove = stack(kick, hats, hatsOpen, clap, bajo, sub.gain(.4)) -const build = stack(kick, hats16, clap, rim, bajo, +const build = stack(kick, hats16, clap, rim, ghost, bajo, riser, hook.lpf(saw.slow(8).range(400,2600)).gain(.55)) -const buildFin = stack(kick, rodillo, bajoOcho, hook.gain(.7)) -const dropA = stack(kick, hats16, hatsOpen, clap, bajoOcho, sub, hook) -const dropAvar = stack(kick, hats16, hatsOpen, clap, rim, bajoOcho, sub, - hook.every(4, x=>x.iter(4)), hookEco, blips) -const breakRobot = stack(bajo.gain(.6), blips, hook.gain(.5), pad, hats.gain(.3)) -const breakBuild = stack(bajo, blips, hook.gain(.6), pad, rodillo, hats16.gain(.35)) -const dropB = stack(kickElectro, hats16, hatsOpen, clap, bajoDrop, sub, hook, hookEco) -const dropBvar = stack(kick, hats16, hatsOpen, clap, rim, bajoDrop, sub, - hook.sometimesBy(.25, x=>x.add(note(12)).gain(.6)), hookEco, blips) -const coda = stack(kick, hats, bajo.gain(.7), hook.gain(.45), pad) +const buildFin = stack(kick, rodillo, riser, bajoOcho, hook.gain(.7)) +const dropA = stack(kick, hats16, hatsOpen, clap, ghost, bajoOcho, sub, hook, leadLimpio, stab) +const dropAvar = stack(kick, hats16, hatsOpen, clap, rim, ghost, bajoOcho, sub, bajoOff, + hook.every(4, x=>x.iter(4)), hookEco, blips, leadLimpio, stab, contra) +const breakRobot = stack(bajo.gain(.6), blips, hook.gain(.5), pad, hats.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(bajo, blips, riser, hook.gain(.6), pad, rodillo, hats16.gain(.35)) +const dropB = stack(kickElectro, hats16, hatsOpen, clap, ghost, bajoDrop, sub, hook, hookEco, leadLimpio, stab) +const dropBvar = stack(kick, hats16, hatsOpen, clap, rim, ghost, bajoDrop, sub, bajoOff, + hook.sometimesBy(.25, x=>x.add(note(12)).gain(.6)), hookEco, blips, leadLimpio, stab, contra) +const coda = stack(kick, hats, bajo.gain(.7), hook.gain(.45), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.35), hook.gain(.3).delayfeedback(.5), blips.gain(.25), pad.gain(.25)) @@ -1166,14 +1632,16 @@ arrange( [16, dropBvar], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "13 · girls fun breakbeat — cyndi lauper (1983)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 13 · GIRLS FUN BREAKBEAT — Cyndi Lauper (1983) → Breakbeat Rave Remix -// 138 BPM · G · OberheimDMX · breaks + stabs rave + sirenas + hoover +// 138 BPM · G (G·Em·C·D) · OberheimDMX · PRO: kick 2 capas + boom afinado y +// bajo/sub que siguen los acordes + stabs con 7as/9as + groove con swing // Estructura: intro→build→drop A→sirenas→break→drop hoover→coda (152 compases ≈ 4:24) // ════════════════════════════════════════════════════════════════ setcps(138/60/4) @@ -1187,6 +1655,26 @@ const hook = note("g4 g4 fs4 g4 e4 e4 d4 e4 g4 g4 a4 g4 e4 ~ d4 ~") const hookAlta = hook.add(note(12)).gain(.35).lpf(3500).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("g4 g4 fs4 g4 e4 e4 d4 e4 g4 g4 a4 g4 e4 ~ d4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Gadd9·Em7·Cmaj7·D7) + hi-pass ── +const stab = note("<[g3,b3,d4,a4] [e3,g3,b3,d4] [c3,e3,g3,b3] [d3,fs3,a3,c4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ d4 ~ b3 ~ g3 ~] [~ ~ b3 ~ g3 ~ e3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ a4 ~ fs4 ~ d4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── STABS RAVE (acorde de G, cada 4 compases se aceleran con hurry) ── const stabs = note("[g4,b4,d5] ~ ~ [g4,b4,d5] ~ [g4,b4,d5] ~ ~") .s("sawtooth").lpf(3000).attack(.001).decay(.15).sustain(0) @@ -1206,56 +1694,72 @@ const hoover = note("g2 ~ g2 g2 ~ e2 ~ [f2 fs2]") .attack(.01).decay(.2).sustain(.4).release(.1) .gain(.7).orbit(3) -// ── BAJO RAVE (punchy, con sub de refuerzo) ── -const bajo = note("g1 ~ [~ g1] g1 ~ g1 [~ e1] [f1 fs1]") +// ── BAJO RAVE que SIGUE los acordes (G·Em·C·D), con sub de refuerzo ── +const bajo = note("<[g1 ~ [~ g1] g1 ~ g1 [~ d1] [fs1 f1]] [e1 ~ [~ e1] e1 ~ e1 [~ b1] [a1 b1]] [c1 ~ [~ c1] c1 ~ c1 [~ g1] [e1 eb1]] [d1 ~ [~ d1] d1 ~ d1 [~ a1] [f1 fs1]]>") .s("sawtooth").lpf(700).lpq(6) .attack(.001).decay(.12).sustain(.35).release(.04) .shape(.3).gain(.9).orbit(1) -const sub = note("g1 ~ ~ g1 ~ ~ g1 ~").s("sine") +const sub = note("<[g1 ~ ~ g1 ~ ~ g1 ~] [e1 ~ ~ e1 ~ ~ e1 ~] [c1 ~ ~ c1 ~ ~ c1 ~] [d1 ~ ~ d1 ~ ~ d1 ~]>").s("sine") .decay(.3).sustain(.3).gain(.65).orbit(1) -// ── BATERÍA DMX (breakbeat con snares desplazadas y fantasma) ── -const kick = s("bd ~ [~ bd] bd").bank("OberheimDMX").shape(.35).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.38).duck("1").orbit(1) + +// ── BATERÍA DMX: kick en 2 capas (breakbeat + BOOM afinado que sigue raíces) ── +const kickClick = s("bd ~ [~ bd] bd").bank("OberheimDMX").hpf(38).shape(.45).gain(1) .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) -const kick4 = s("bd*4").bank("OberheimDMX").shape(.4).gain(1.05) +const kickBoom = note("").struct("x ~ [~ x] x").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kick = stack(kickClick, kickBoom) +const kick4Click = s("bd*4").bank("OberheimDMX").hpf(38).shape(.5).gain(1) .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0) +const kick4Boom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.03).orbit(0) +const kick4 = stack(kick4Click, kick4Boom) const snare = s("~ sd ~ [~ sd]").bank("OberheimDMX").room(.25).gain(.8).orbit(0) const ghost = s("sd*8").bank("OberheimDMX") .degradeBy(.65).gain(.22).pan(.6).orbit(0) -const hats = s("[~ hh]*4").bank("OberheimDMX").gain(.55).pan(.4).orbit(0) -const hats16 = s("hh*16").bank("OberheimDMX") +const hats = s("[~ hh]*4").bank("OberheimDMX").swingBy(1/24,8).gain(.55).pan(.4).orbit(0) +const hats16 = s("hh*16").bank("OberheimDMX").swingBy(1/24,16) .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("OberheimDMX").gain(.5).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("OberheimDMX").nudge(.004).gain(.5).orbit(0) const clap = s("~ cp ~ cp").bank("OberheimDMX").room(.3).gain(.7).orbit(0) const rodillo = s("sd*16").bank("OberheimDMX") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.5)).orbit(0) +// riser de ruido para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PAD (colchón alegre G-Em-C-D) ── -const pad = note("<[g3,b3,d4] [e3,g3,b3] [c3,e3,g3] [d3,fs3,a3]>") +// ── PAD con 7as/9as (colchón G-Em-C-D) + hi-pass ── +const pad = note("<[g3,b3,d4,a4] [e3,g3,b3,d4] [c3,e3,g3,b3] [d3,fs3,a3,c4]>") .s("supersaw").unison(4).spread(.6).lpf(900) - .attack(.7).release(1.2).room(.6).rsize(7).gain(.35).orbit(4) + .hpf(150).attack(.7).release(1.2).room(.6).rsize(7).gain(.35).orbit(4) // ── SECCIONES ── const intro = stack(kick4, hats) const introB = stack(kick4, hats, clap, ghost, bajo.lpf(400).gain(.7)) -const build = stack(kick4, hats16, clap, bajo, pad, +const build = stack(kick4, hats16, clap, bajo, pad, riser, hook.lpf(saw.slow(16).range(400,2200)).gain(.5), stabs.gain(.4)) -const buildFin = stack(kick4, rodillo, bajo, hook.gain(.65), sirena) -const dropA = stack(kick, snare, ghost, hats16, open, bajo, sub, hook, stabs) -const dropAvar = stack(kick, snare, ghost, hats16, open, bajo, sub, - hook, hookAlta, stabs, sirena) +const buildFin = stack(kick4, rodillo, riser, bajo, hook.gain(.65), sirena) +const dropA = stack(kick, snare, ghost, hats16, open, bajo, sub, hook, stabs, leadLimpio, stab) +const dropAvar = stack(kick, snare, ghost, hats16, open, bajo, sub, bajoOff, + hook, hookAlta, stabs, sirena, leadLimpio, stab, contra) const breakdown = stack(pad, sirena, hook.gain(.55).room(.7), - hats.gain(.3), sub.gain(.35)) -const breakBuild = stack(pad, hook.gain(.65), stabs.gain(.5), + hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, riser, hook.gain(.65), stabs.gain(.5), rodillo, hats16.gain(.4), sirena) const dropHoover = stack(kick, snare, hats16, open, hoover, sub, - hook.gain(.6), ghost) -const dropFull = stack(kick, snare, ghost, hats16, open, hoover, sub, - hook, hookAlta, stabs.gain(.5), sirena) -const dropUltimo = stack(kick, snare, ghost, hats16, open, bajo, sub, - hook.sometimesBy(.2, x=>x.add(note(12))), hookAlta, stabs, pad.gain(.25)) -const coda = stack(kick4, hats, clap, bajo.gain(.7), hook.gain(.45).room(.6), pad) + hook.gain(.6), ghost, leadLimpio, stab) +const dropFull = stack(kick, snare, ghost, hats16, open, hoover, sub, bajoOff, + hook, hookAlta, stabs.gain(.5), sirena, leadLimpio, stab, contra) +const dropUltimo = stack(kick, snare, ghost, hats16, open, bajo, sub, bajoOff, + hook.sometimesBy(.2, x=>x.add(note(12))), hookAlta, stabs, pad.gain(.25), leadLimpio, stab, contra) +const coda = stack(kick4, hats, clap, bajo.gain(.7), hook.gain(.45).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.8).delayfeedback(.6), sirena.gain(.2), pad.gain(.3)) @@ -1274,29 +1778,41 @@ arrange( [16, dropUltimo], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "14 · bites the dust tribal — queen (1980)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 14 · BITES THE DUST TRIBAL — Queen (1980) → Tribal Tech House Remix -// 125 BPM · Em · TR-808 · toms euclidianos + bajo funk exacto · groove seco +// 125 BPM · Em (Em·Em·Am·Bm = i·i·iv·v) · TR-808 · toms euclidianos + groove seco +// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado que sigue las +// fundamentales), sub/bajo siguen los acordes, bajo offbeat, groove con +// swing + ghost + velocity humanizada, armonía con 7as/9as e hi-pass, riser +// de ruido en subidas. Carácter peak-time duro (saturación, poco aire). // Estructura: intro→percusión→groove→drop A→break tribal→drop B→coda (140 compases ≈ 4:29) // ════════════════════════════════════════════════════════════════ setcps(125/60/4) -// ── EL BAJO (la línea exacta de John Deacon, 16 pasos) ── -const bajo = note("e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~") - .s("sawtooth").lpf(750).lpq(7) +// ── EL BAJO (la línea de John Deacon, AHORA sigue el acorde: Em·Em·Am·Bm) ── +// mismo groove de 16 pasos, transpuesto a la fundamental de cada compás +const bajo = note("<[e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~] [e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~] [a1 ~ ~ a1 a1 ~ a1 ~ [c2 a1] d2 ~ ~ ~ ~ ~ ~] [b1 ~ ~ b1 b1 ~ b1 ~ [d2 b1] e2 ~ ~ ~ ~ ~ ~]>") + .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8) .attack(.001).decay(.14).sustain(.35).release(.05) - .shape(.3).gain(.95).orbit(1) + .shape(.34).coarse(1).gain(.95).orbit(1) -const sub = note("e1 ~ ~ e1 e1 ~ e1 ~ ~ a1 ~ ~ ~ ~ ~ ~") - .s("sine").decay(.25).sustain(.3).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica) ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) -// ── STABS MÍNIMOS (acorde Em seco, casi percusivo) ── -const stab = note("~ ~ [e3,g3,b3] ~ ~ [e3,g3,b3] ~ ~") +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y" entre kicks) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── STABS MÍNIMOS (Em7 seco, casi percusivo) ── +const stab = note("~ ~ [e3,g3,b3,d4] ~ ~ [e3,g3,b3,d4] ~ ~") .s("sawtooth").lpf(1600).hpf(300) .attack(.001).decay(.09).sustain(0) .gain(.55).pan(.6).orbit(3) @@ -1308,15 +1824,45 @@ const riff = note("e4 ~ ~ g4 ~ e4 d4 ~ ~ e4 ~ ~ a4 g4 ~ ~") .delay(.2).delaytime(.1875).delayfeedback(.3) .gain(.6).pan(.4).orbit(2) -// ── BATERÍA 808 (bombo seco con swing + claps a contratiempo) ── -const kick = s("bd*4").bank("RolandTR808").shape(.3).gain(1.05) +// ── LEAD LIMPIO (la melodía real del riff, nítida y al frente) ── +const leadLimpio = note("e4 ~ ~ g4 ~ e4 d4 ~ ~ e4 ~ ~ a4 g4 ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Em7·Em7·Am7·Bm7) + contramelodía ── +// voicings extendidos + voice-leading (notas comunes) + hi-pass = color, no triada seca +const stabPad = note("<[e2,g2,b2,d3] [e2,g2,b2,d3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ b3 ~ g3 ~ e3 ~] [~ ~ b3 ~ g3 ~ e3 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado que sigue raíces ── +// el boom es una sine con envolvente de TONO que cae 26 semitonos = "thump" +const kickClick = s("bd*4").bank("RolandTR808").hpf(38).shape(.5).distort(1.05).gain(.9) .duck("1:2").duckattack(.09).duckdepth(.45).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04) + .shape(.3).gain(1).orbit(0) +const kick = stack(kickClick, kickBoom) + const clap = s("[~ cp]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0) const clapDos = s("~ cp ~ cp").bank("RolandTR808").gain(.65).orbit(0) +// hats con SWING (groove, no rejilla plana) const hats = s("[~ hh]*4").bank("RolandTR808").gain(.5).pan(.35) - .swingBy(1/8, 4).orbit(0) -const shaker = s("hh*16").bank("RolandTR808") - .gain("[.4 .18 .28 .18]*4").speed(rand.range(1.4,1.8)) + .swingBy(1/24, 8).orbit(0) +// shaker con SWING + velocity humanizada (perlin) +const shaker = s("hh*16").bank("RolandTR808").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).speed(rand.range(1.4,1.8)) .pan(rand.range(.3,.7)).orbit(0) // ── TOMS TRIBALES (euclidianos, el corazón del remix) ── @@ -1333,11 +1879,16 @@ const congas = s("[~ mt]*4").bank("RolandTR808") .pan(rand.range(.25,.75)).orbit(0) const rodillo = s("lt*8").bank("RolandTR808") .gain(saw.slow(4).range(.25,.8)).speed(saw.slow(4).range(.8,1.3)).orbit(0) +// ghost snare (percusión sincopada muy baja, groove anti-4x4) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD OSCURO (mínimo, solo en las pausas) ── -const pad = note("<[e2,g2,b2] [e2,g2,b2] [a2,c3,e3] [b2,d3,fs3]>") - .s("triangle").lpf(550).attack(1.2).release(1.8) +// ── PAD OSCURO con 7as (mínimo, solo en las pausas; hi-pass para el sub) ── +const pad = note("<[e2,g2,b2,d3] [e2,g2,b2,d3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>") + .s("triangle").lpf(550).hpf(150).attack(1.2).release(1.8) .room(.5).rsize(5).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats) @@ -1345,22 +1896,22 @@ const percusion = stack(kick, hats, clap, congas) const grooveBajo = stack(kick, hats, clap, clapDos.gain(.4), bajo, sub.gain(.4)) const build = stack(kick, hats, shaker, clap, bajo, sub, tomAlto, riff.lpf(saw.slow(16).range(400,1900)).gain(.45)) -const buildFin = stack(kick, rodillo, bajo, tomAlto, tomMedio, riff.gain(.55)) -const dropA = stack(kick, clap, clapDos.gain(.4), shaker, bajo, sub, - stab, riff, congas) -const dropAtoms = stack(kick, clap, shaker, bajo, sub, stab, riff, - tomAlto, tomMedio, tomBajo, congas) +const buildFin = stack(kick, rodillo, riser, bajo, tomAlto, tomMedio, riff.gain(.55)) +const dropA = stack(kick, clap, clapDos.gain(.4), shaker, ghost, bajo, sub, + stab, riff, congas, leadLimpio, stabPad) +const dropAtoms = stack(kick, clap, shaker, ghost, bajo, sub, bajoOff, stab, riff, + tomAlto, tomMedio, tomBajo, congas, leadLimpio, stabPad, contra) const breakTribal = stack(tomAlto, tomMedio, tomBajo, congas, shaker, - bajo.gain(.6), sub.gain(.4), pad) -const breakBuild = stack(tomAlto, tomMedio, tomBajo, congas, rodillo, + bajo.gain(.6), sub.gain(.4), pad, contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(tomAlto, tomMedio, tomBajo, congas, rodillo, riser, bajo, riff.gain(.5), pad) -const dropB = stack(kick, clap, clapDos.gain(.4), shaker, bajo, sub, +const dropB = stack(kick, clap, clapDos.gain(.4), shaker, ghost, bajo, sub, stab, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)), - tomAlto, congas) -const dropBvar = stack(kick, clap, shaker, bajo, sub, stab, - riff, tomAlto, tomMedio, tomBajo, congas.gain(.55)) + tomAlto, congas, leadLimpio, stabPad) +const dropBvar = stack(kick, clap, shaker, ghost, bajo, sub, bajoOff, stab, + riff, tomAlto, tomMedio, tomBajo, congas.gain(.55), leadLimpio, stabPad, contra) const coda = stack(kick, hats, clap, bajo.gain(.7), congas.gain(.35), - riff.gain(.4), pad) + riff.gain(.4), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.35), congas.gain(.3), sub.gain(.35), riff.gain(.25).room(.7).delayfeedback(.55), pad.gain(.3)) @@ -1379,14 +1930,19 @@ arrange( [16, dropBvar], [12, coda], [4, codaFin] -)`, +) +`, }, { name: "15 · forever young trance — alphaville (1984)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 15 · FOREVER YOUNG TRANCE — Alphaville (1984) → Trance Techno Remix -// 138 BPM · C/Am · TR-909 · supersaw nostálgico + piano + arpegio perpetuo +// 138 BPM · C/Am (C·Am·F·G) · TR-909 · supersaw + piano + arpegio perpetuo +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las +// fundamentales C·Am·F·G), sub/bajo siguen los acordes, bajo offbeat, groove +// con swing + ghost + velocity humanizada, armonía con 7as/9as e hi-pass, +// riser de ruido en subidas. Carácter peak-time duro (saturación, poco aire). // Estructura: intro→arpegio→build→drop A→breakdown piano→drop B→coda (160 compases ≈ 4:38) // ════════════════════════════════════════════════════════════════ setcps(138/60/4) @@ -1400,13 +1956,33 @@ const hook = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~") const hookAlta = hook.add(note(12)).gain(.3).lpf(4000).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Cadd9·Am7·Fmaj7·G7) + contramelodía ── +const stab = note("<[c3,e3,g3,d4] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── PIANO EMOTIVO (protagonista del breakdown) ── const piano = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~") .s("piano").slow(2).room(.8).rsize(8) .delay(.4).delaytime(.375).delayfeedback(.45) .gain(.9).orbit(2) -const pianoAcordes = note("<[c3,e3,g3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>") +const pianoAcordes = note("<[c3,e3,g3,b3] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") .s("piano").room(.8).rsize(8).gain(.7).orbit(4) // ── ARPEGIO PERPETUO (el motor del track) ── @@ -1422,57 +1998,75 @@ const arpegio16 = note("[c3 e3 g3 c4]*4") .delay(.25).delaytime(.1875).delayfeedback(.3) .gain(.55).pan(sine.slow(3).range(.3,.7)).orbit(3) -// ── BAJO ROLLING (16avos, progresión C·Am·F·G) ── +// ── BAJO ROLLING (16avos, progresión C·Am·F·G — sigue las fundamentales) ── const bajo = note("").struct("x*16") - .s("sawtooth").lpf(650).lpq(6) + .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8) .attack(.001).decay(.1).sustain(.25).release(.03) - .gain("[.9 .55 .7 .55]*4").shape(.25).orbit(1) + .gain("[.9 .55 .7 .55]*4").shape(.34).coarse(1).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental ── const sub = note("").struct("x*4") - .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1) + .s("sine").attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) -// ── BATERÍA 909 ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 909 EN 2 CAPAS (click + boom afinado) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04) + .shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.15).gain(.95) .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0) const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +// ghost snare (percusión sincopada muy baja, groove anti-4x4) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── CUERDAS / PADS (el gran room trance) ── -const cuerdas = note("<[c3,e3,g3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>") - .s("supersaw").unison(4).spread(.8).lpf(1000) +// ── CUERDAS / PADS con 7as (el gran room trance; hi-pass para el sub) ── +const cuerdas = note("<[c3,e3,g3,d4] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .s("supersaw").unison(4).spread(.8).lpf(1000).hpf(160) .attack(.9).release(1.8).room(.75).rsize(8).gain(.4).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introArp = stack(kick, hats, open, arpegio, sub.gain(.5)) const build = stack(kick, hats16, clap, bajo, arpegio, cuerdas.gain(.3), hook.lpf(saw.slow(16).range(400,2400)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, arpegio16, hook.gain(.65)) -const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub, - arpegio16, hook) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, - arpegio16, hook, hookAlta, cuerdas.gain(.3)) -const breakPiano = stack(piano, pianoAcordes, cuerdas, sub.gain(.3)) +const buildFin = stack(kickHard, rodillo, riser, bajo, arpegio16, hook.gain(.65)) +const dropA = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, + arpegio16, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + arpegio16, hook, hookAlta, cuerdas.gain(.3), leadLimpio, stab, contra) +const breakPiano = stack(piano, pianoAcordes, cuerdas, sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(piano.gain(.7), pianoAcordes.gain(.5), cuerdas, - arpegio, rodillo, hats16.gain(.4)) -const dropB = stack(kickHard, hats16, open, clap, crash, bajo, sub, - arpegio16, hook, hookAlta) -const dropBvar = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub, + arpegio, rodillo, riser, hats16.gain(.4)) +const dropB = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, + arpegio16, hook, hookAlta, leadLimpio, stab) +const dropBvar = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajo, sub, bajoOff, arpegio16, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), - hookAlta, cuerdas.gain(.3)) -const dropFinal = stack(kickHard, hats16, open, clap, ride, bajo, sub, - arpegio16, hook, hookAlta, cuerdas.gain(.35), pianoAcordes.gain(.35)) + hookAlta, cuerdas.gain(.3), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + arpegio16, hook, hookAlta, cuerdas.gain(.35), pianoAcordes.gain(.35), leadLimpio, stab) const coda = stack(kick, hats, bajo.gain(.6), arpegio, hook.gain(.4).room(.7), - cuerdas.gain(.3)) + cuerdas.gain(.3), leadLimpio.gain(.4)) const codaFin = stack(piano.gain(.6), cuerdas.gain(.3), arpegio.gain(.3).delayfeedback(.6)) @@ -1491,29 +2085,40 @@ arrange( [16, dropFinal], [12, coda], [8, codaFin] -)`, +) +`, }, { name: "16 · west end girls deep — pet shop boys (1985)", folder: "remixes 80s", code: `// ════════════════════════════════════════════════════════════════ // 16 · WEST END GIRLS DEEP — Pet Shop Boys (1985) → Deep Techno Remix -// 124 BPM · Dm · LinnDrum · chords deep con phaser + sub redondo + eco dub +// 124 BPM · Dm (Dm·Dm·C·Bb) · LinnDrum · chords deep con phaser + eco dub +// PRODUCCIÓN PRO: kick 2 capas (click Linn + boom afinado que sigue las +// fundamentales Dm·Dm·C·Bb), sub/bajo siguen los acordes, bajo offbeat, +// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass, +// riser de ruido en subidas. Carácter peak-time (saturación, menos aire). // Estructura: intro→sub→chords→drop A→break urbano→drop B→coda (136 compases ≈ 4:23) // ════════════════════════════════════════════════════════════════ setcps(124/60/4) -// ── EL BAJO (la línea del original, redonda y profunda) ── -const bajo = note("d2 d2 c2 d2 f2 d2 g2 f2") - .s("triangle").lpf(500) +// ── EL BAJO (la línea del original, AHORA sigue el acorde: Dm·Dm·C·Bb) ── +const bajo = note("<[d2 d2 c2 d2 f2 d2 g2 f2] [d2 d2 c2 d2 f2 d2 g2 f2] [c2 c2 bb1 c2 e2 c2 g2 e2] [bb1 bb1 ab1 bb1 d2 bb1 f2 d2]>") + .s("sawtooth").lpf(perlin.slow(4).range(500,1000)).lpq(6) .attack(.002).decay(.18).sustain(.5).release(.08) - .shape(.15).gain(.95).orbit(1) + .shape(.3).coarse(1).gain(.95).orbit(1) -const sub = note("d1 ~ ~ d1 ~ ~ d1 ~").s("sine") - .decay(.35).sustain(.35).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) -// ── ECO DUB DEL BAJO (delay largo, flotando por detrás) ── -const bajoDub = note("d2 ~ ~ ~ f2 ~ ~ ~") +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── ECO DUB DEL BAJO (delay largo, sigue el acorde, flotando por detrás) ── +const bajoDub = note("<[d2 ~ ~ ~ f2 ~ ~ ~] [d2 ~ ~ ~ f2 ~ ~ ~] [c2 ~ ~ ~ e2 ~ ~ ~] [bb1 ~ ~ ~ d2 ~ ~ ~]>") .s("triangle").hpf(200).lpf(900) .delay(.5).delaytime(.5625).delayfeedback(.55) .gain(.4).pan(.65).orbit(3) @@ -1527,35 +2132,65 @@ const lead = note("a4 ~ g4 f4 g4 ~ f4 ~ e4 d4 ~ ~") const leadEco = lead.add(note(12)).late(.25).gain(.25).lpf(2600).orbit(2) -// ── CHORDS DEEP (Dm7 con phaser, sofisticación urbana) ── +// ── LEAD LIMPIO (la melodía real, nítida y al frente, a doble compás) ── +const leadLimpio = note("a4 ~ g4 f4 g4 ~ f4 ~ e4 d4 ~ ~") + .slow(2).s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Dm7·Dm7·C7·Bbmaj7) + contramelodía ── +const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ f4 ~ d4 ~ bb3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── CHORDS DEEP (Dm7·Dm7·C7·Bbmaj7 con phaser; hi-pass para el sub) ── const chords = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>") .struct("~ x ~ [~ x]") - .s("sawtooth").lpf(1100).lpq(2) + .s("sawtooth").lpf(1100).hpf(160).lpq(2) .attack(.01).decay(.3).sustain(.2).release(.15) .phaser(.5).phaserdepth(.7) .room(.45).rsize(4).gain(.6).pan(.45).orbit(4) -// ── BATERÍA LINNDRUM (suave, elegante, ochentera) ── -const kick = s("bd*4").bank("LinnDrum").shape(.2).gain(1) +// ── BATERÍA LINNDRUM EN 2 CAPAS (click + boom afinado) ── +const kickClick = s("bd*4").bank("LinnDrum").hpf(38).shape(.4).gain(.9) .duck("1:2").duckattack(.1).duckdepth(.4).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04) + .shape(.3).gain(1).orbit(0) +const kick = stack(kickClick, kickBoom) + const clap = s("~ cp ~ cp").bank("LinnDrum").room(.3).gain(.6).orbit(0) -const hats = s("[~ hh]*4").bank("LinnDrum").gain(.45).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("LinnDrum") - .gain("[.4 .18 .28 .18]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("LinnDrum").gain(.4).orbit(0) +const hats = s("[~ hh]*4").bank("LinnDrum").swingBy(1/24,8).gain(.45).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("LinnDrum").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("LinnDrum").nudge(.004).gain(.4).orbit(0) const rim = s("~ [~ rim] ~ rim").bank("LinnDrum").gain(.4).pan(.35).orbit(0) -const ghost = s("sd*8").bank("LinnDrum").degradeBy(.7).gain(.18).pan(.55).orbit(0) +// ghost snare (percusión sincopada muy baja, groove anti-4x4) +const ghost = s("sd*8").bank("LinnDrum").degradeBy(.7).gain(.18).pan(.55).hpf(400).orbit(0) const rodillo = s("sd*16").bank("LinnDrum") .gain(saw.slow(4).range(.15,.65)).speed(saw.slow(4).range(1,1.3)).orbit(0) -// ── ATMÓSFERA URBANA (textura espacial, muy al fondo) ── +// ── ATMÓSFERA URBANA (textura espacial, muy al fondo; peak-time = poco aire) ── const niebla = s("space").slow(8).lpf(1200).room(.8).rsize(8) - .gain(.25).pan(sine.slow(16).range(.3,.7)).orbit(4) + .gain(.18).pan(sine.slow(16).range(.3,.7)).orbit(4) -// ── PAD NOCTURNO ── -const pad = note("<[d3,f3,a3] [d3,f3,a3] [c3,e3,g3] [bb2,d3,f3]>") - .s("triangle").lpf(700).attack(1).release(2) +// ── PAD NOCTURNO con 7as (hi-pass para dejar libre el sub) ── +const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>") + .s("triangle").lpf(700).hpf(150).attack(1).release(2) .room(.6).rsize(6).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, niebla) @@ -1563,21 +2198,21 @@ const introSub = stack(kick, hats, rim, sub, bajo.lpf(300).gain(.7)) const grooveChords = stack(kick, hats, open, clap, bajo, sub, chords.gain(.45)) const build = stack(kick, hats16, clap, rim, bajo, sub, chords, lead.lpf(saw.slow(16).range(300,1600)).gain(.45)) -const buildFin = stack(kick, rodillo, bajo, chords, lead.gain(.6)) -const dropA = stack(kick, hats16, open, clap, ghost, bajo, sub, chords, lead) -const dropAvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub, - bajoDub, chords, lead, leadEco) +const buildFin = stack(kick, rodillo, riser, bajo, chords, lead.gain(.6)) +const dropA = stack(kick, hats16, open, clap, ghost, bajo, sub, chords, lead, leadLimpio, stab) +const dropAvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub, bajoOff, + bajoDub, chords, lead, leadEco, leadLimpio, stab, contra) const breakUrbano = stack(pad, niebla, chords.gain(.4), lead.gain(.5).room(.7), - bajoDub, hats.gain(.25)) -const breakBuild = stack(pad, chords.gain(.5), lead.gain(.6), rodillo, + bajoDub, hats.gain(.25), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, chords.gain(.5), lead.gain(.6), rodillo, riser, hats16.gain(.35), sub.gain(.4)) const dropB = stack(kick, hats16, open, clap, ghost, bajo, sub, bajoDub, - chords.every(4, x=>x.iter(4)), lead, leadEco) -const dropBvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub, + chords.every(4, x=>x.iter(4)), lead, leadEco, leadLimpio, stab) +const dropBvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub, bajoOff, bajoDub, chords, lead.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), - leadEco, niebla) + leadEco, niebla, leadLimpio, stab, contra) const coda = stack(kick, hats, bajo.gain(.7), chords.gain(.4), - lead.gain(.4).room(.7), pad) + lead.gain(.4).room(.7), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.3), bajoDub.gain(.3), lead.gain(.25).room(.85).delayfeedback(.65), pad.gain(.3), niebla) @@ -1596,14 +2231,19 @@ arrange( [16, dropBvar], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "17 · what is love hard house — haddaway (1993)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 17 · WHAT IS LOVE HARD HOUSE — Haddaway (1993) → Hard House Remix -// 134 BPM · Dm · TR-909 · stabs offbeat con vowel + bajo offbeat · segundo drop en octava +// 134 BPM · Dm (Dm·Dm·Bb·C) · TR-909 · stabs offbeat con vowel + bajo offbeat +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las +// fundamentales Dm·Dm·Bb·C), sub/bajo siguen los acordes, bajo offbeat, +// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass, +// riser de ruido en subidas. Carácter peak-time duro (saturación). // Estructura: intro→stabs→build→drop A→break vocal→drop octava→coda (148 compases ≈ 4:25) // ════════════════════════════════════════════════════════════════ setcps(134/60/4) @@ -1617,6 +2257,26 @@ const hook = note("a4 c5 d5 c5 a4 g4 a4 ~ f4 g4 a4 g4 f4 ~ e4 ~") const hookOctava = hook.add(note(12)).gain(.85).lpf(3200).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("a4 c5 d5 c5 a4 g4 a4 ~ f4 g4 a4 g4 f4 ~ e4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Dm7·Dm7·Bbmaj7·C7) + contramelodía ── +const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [bb2,d3,f3,a3] [c3,e3,g3,bb3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ f4 ~ d4 ~ bb3 ~] [~ ~ g4 ~ e4 ~ c4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── STABS OFFBEAT (los acordes exactos del género, con vocal sintética) ── const stabs = note("~ [d4,f4,a4] ~ [c4,f4,a4]").fast(2) .s("sawtooth").lpf(2400).lpq(3) @@ -1624,63 +2284,82 @@ const stabs = note("~ [d4,f4,a4] ~ [c4,f4,a4]").fast(2) .vowel("a e").shape(.25) .room(.3).gain(.75).pan(.55).orbit(3) -// ── BAJO OFFBEAT (bombeo clásico hard house) ── -const bajo = note("[~ d2]*4") - .s("sawtooth").lpf(800).lpq(7) +// ── BAJO OFFBEAT (bombeo clásico hard house, AHORA sigue el acorde) ── +const bajo = note("<[~ d2]*4 [~ d2]*4 [~ bb1]*4 [~ c2]*4>") + .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(7) .attack(.001).decay(.13).sustain(.3).release(.04) - .shape(.35).gain(.9).orbit(1) + .shape(.35).coarse(1).gain(.9).orbit(1) -const bajoVar = note("[~ d2]!3 [~ [c2 e2]]") - .s("sawtooth").lpf(850).lpq(7) +const bajoVar = note("<[[~ d2]!3 [~ [c2 e2]]] [[~ d2]!3 [~ [c2 e2]]] [[~ bb1]!3 [~ [ab1 c2]]] [[~ c2]!3 [~ [bb1 d2]]]>") + .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(7) .attack(.001).decay(.13).sustain(.3).release(.04) - .shape(.35).gain(.9).orbit(1) + .shape(.35).coarse(1).gain(.9).orbit(1) -const sub = note("d1*4").s("sine").decay(.28).sustain(.2).gain(.65).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.65).orbit(1) -// ── BATERÍA 909 (dura y directa) ── -const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05) +// ── BAJO OFFBEAT EXTRA (sub-octava para el clímax) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── BATERÍA 909 EN 2 CAPAS (dura y directa) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04) + .shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0) const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) const rodilloCorto = s("sd*8").bank("RolandTR909") .gain(saw.slow(2).range(.3,.8)).orbit(0) +// ghost snare (percusión sincopada muy baja, groove anti-4x4) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD (colchón menor dramático) ── -const pad = note("<[d3,f3,a3] [d3,f3,a3] [bb2,d3,f3] [c3,e3,g3]>") - .s("supersaw").unison(4).spread(.7).lpf(900) +// ── PAD con 7as (colchón menor dramático; hi-pass para el sub) ── +const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [bb2,d3,f3,a3] [c3,e3,g3,bb3]>") + .s("supersaw").unison(4).spread(.7).lpf(900).hpf(150) .attack(.8).release(1.5).room(.65).rsize(7).gain(.38).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introStabs = stack(kick, hats, open, stabs.gain(.45), sub.gain(.5)) const build = stack(kick, hats16, clap, bajo, stabs, pad.gain(.3), hook.lpf(saw.slow(16).range(400,2000)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, stabs, hook.gain(.65)) -const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub, stabs, hook) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajoVar, sub, - stabs, hook, pad.gain(.25)) +const buildFin = stack(kickHard, rodillo, riser, bajo, stabs, hook.gain(.65)) +const dropA = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, stabs, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajoVar, sub, + stabs, hook, pad.gain(.25), leadLimpio, stab, contra) const breakVocal = stack(pad, stabs.gain(.4).room(.6), - hook.gain(.55).room(.7), hats.gain(.3), sub.gain(.35)) + hook.gain(.55).room(.7), hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(pad, stabs.gain(.5), hook.gain(.65), - rodilloCorto, hats16.gain(.4)) -const dropOctava = stack(kickHard, hats16, open, clap, crash, bajo, sub, - stabs, hookOctava) -const dropOctavaVar = stack(kickHard, hats16, open, clap, ride, bajoVar, sub, + rodilloCorto, riser, hats16.gain(.4)) +const dropOctava = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, + stabs, hookOctava, leadLimpio, stab) +const dropOctavaVar = stack(kickHard, hats16, open, clap, ride, ghost, bajoVar, sub, stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), - hookOctava, hook.gain(.4), pad.gain(.25)) -const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, bajoVar, - sub, stabs, hook, hookOctava.gain(.5)) + hookOctava, hook.gain(.4), pad.gain(.25), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajoVar, + sub, bajoOff, stabs, hook, hookOctava.gain(.5), leadLimpio, stab) const coda = stack(kick, hats, clap, bajo.gain(.7), stabs.gain(.4), - hook.gain(.45).room(.6), pad) + hook.gain(.45).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), stabs.gain(.25).room(.8), hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) @@ -1699,14 +2378,19 @@ arrange( [16, dropFinal], [12, coda], [4, codaFin] -)`, +) +`, }, { name: "18 · rhythm is a dancer rave — snap! (1992)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 18 · RHYTHM IS A DANCER RAVE — Snap! (1992) → Rave Techno Remix -// 140 BPM · Gm · TR-909 · piano rave offbeat + hoover + euforia noventera +// 140 BPM · Gm (Gm·Gm·Eb·F) · TR-909 · piano rave offbeat + hoover +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las +// fundamentales Gm·Gm·Eb·F), sub/bajo/hoover siguen los acordes, bajo offbeat, +// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass, +// riser de ruido en subidas. Carácter peak-time duro (saturación). // Estructura: intro→piano→build→drop A→break oh→drop hoover→coda (152 compases ≈ 4:21) // ════════════════════════════════════════════════════════════════ setcps(140/60/4) @@ -1720,48 +2404,86 @@ const hook = note("g4 ~ bb4 g4 c5 ~ bb4 g4 d5 ~ c5 bb4 g4 ~ f4 g4") const hookAlta = hook.add(note(12)).gain(.3).lpf(3600).orbit(2) -// ── PIANO RAVE (el acorde en offbeat, pura euforia) ── -const pianoRave = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>") +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("g4 ~ bb4 g4 c5 ~ bb4 g4 d5 ~ c5 bb4 g4 ~ f4 g4") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Gm7·Gm7·Ebmaj7·F7) + contramelodía ── +const stab = note("<[g2,bb2,d3,f3] [g2,bb2,d3,f3] [eb2,g2,bb2,d3] [f2,a2,c3,eb3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ bb3 ~ g3 ~ eb3 ~] [~ ~ c4 ~ a3 ~ f3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── PIANO RAVE con 7as (el acorde en offbeat, pura euforia) ── +const pianoRave = note("<[g3,bb3,d4,f4] [g3,bb3,d4,f4] [eb3,g3,bb3,d4] [f3,a3,c4,eb4]>") .struct("[~ x]*4") .s("piano").room(.45).rsize(4) .gain(.8).pan(.55).orbit(3) -// ── HOOVER (supersaw rugiente, el terror de 1992) ── -const hoover = note("g2 g2 ~ g2 ~ bb2 ~ c3") +// ── HOOVER (supersaw rugiente, AHORA sigue el acorde: Gm·Gm·Eb·F) ── +const hoover = note("<[g2 g2 ~ g2 ~ bb2 ~ c3] [g2 g2 ~ g2 ~ bb2 ~ c3] [eb2 eb2 ~ eb2 ~ g2 ~ ab2] [f2 f2 ~ f2 ~ a2 ~ bb2]>") .s("supersaw").unison(6).detune(.9).spread(.85) .lpf(1500).distort(.9) .attack(.01).decay(.2).sustain(.45).release(.12) .gain(.7).orbit(3) -// ── BAJO (el motor: negras que empujan + sub) ── -const bajo = note("g1 g1 bb1 c2").ply(2) - .s("sawtooth").lpf(700).lpq(6) +// ── BAJO (el motor: negras que empujan, AHORA sigue el acorde) ── +const bajo = note("<[g1 g1 bb1 c2] [g1 g1 bb1 c2] [eb1 eb1 g1 ab1] [f1 f1 a1 bb1]>").ply(2) + .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8) .attack(.001).decay(.12).sustain(.35).release(.04) - .shape(.3).gain(.9).orbit(1) + .shape(.34).coarse(1).gain(.9).orbit(1) -const sub = note("g1 ~ g1 ~ bb1 ~ c2 ~").s("sine") - .decay(.3).sustain(.25).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) -// ── BATERÍA 909 (con fills doblados cada 8 compases) ── -const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 909 EN 2 CAPAS (con fills doblados cada 8 compases) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04) + .shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.1).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.65) - .every(8, x=>x.ply(2).gain(.95)).orbit(0) + .every(8, x=>x.ply(2).gain(.85)).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const openRave = s("[~ oh]*4").bank("RolandTR909").gain(.5).pan(.4).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const openRave = s("[~ oh]*4").bank("RolandTR909").nudge(.004).gain(.5).pan(.4).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0) const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) +// ghost snare (percusión sincopada muy baja, groove anti-4x4) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD (colchón Gm, grande) ── -const pad = note("<[g2,bb2,d3] [g2,bb2,d3] [eb2,g2,bb2] [f2,a2,c3]>") - .s("supersaw").unison(4).spread(.75).lpf(950) +// ── PAD con 7as (colchón Gm, grande; hi-pass para el sub) ── +const pad = note("<[g2,bb2,d3,f3] [g2,bb2,d3,f3] [eb2,g2,bb2,d3] [f2,a2,c3,eb3]>") + .s("supersaw").unison(4).spread(.75).lpf(950).hpf(150) .attack(.8).release(1.6).room(.7).rsize(8).gain(.38).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) @@ -1769,24 +2491,24 @@ const introPiano = stack(kick, hats, clap.gain(.4), pianoRave.gain(.5), bajo.lpf(400).gain(.65)) const build = stack(kick, hats16, clap, bajo, pianoRave, pad.gain(.3), hook.lpf(saw.slow(16).range(400,2300)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, pianoRave, hook.gain(.65)) -const dropA = stack(kickHard, hats16, openRave, clap, crash, bajo, sub, - pianoRave, hook) -const dropAvar = stack(kickHard, hats16, openRave, clap, ride, bajo, sub, - pianoRave, hook, hookAlta, pad.gain(.25)) +const buildFin = stack(kickHard, rodillo, riser, bajo, pianoRave, hook.gain(.65)) +const dropA = stack(kickHard, hats16, openRave, clap, crash, ghost, bajo, sub, + pianoRave, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, openRave, clap, ride, ghost, bajo, sub, bajoOff, + pianoRave, hook, hookAlta, pad.gain(.25), leadLimpio, stab, contra) const breakOh = stack(pad, pianoRave.gain(.5).room(.7), - hook.gain(.55).room(.75), openRave.gain(.35), sub.gain(.35)) + hook.gain(.55).room(.75), openRave.gain(.35), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(pad, pianoRave.gain(.6), hook.gain(.65), - rodillo, hats16.gain(.4), openRave.gain(.4)) -const dropHoover = stack(kickHard, hats16, openRave, clap, crash, hoover, - sub, hook.gain(.6), pianoRave.gain(.5)) -const dropHooverFull = stack(kickHard, hats16, openRave, clap, ride, hoover, - sub, hook, hookAlta, pianoRave.gain(.6)) -const dropFinal = stack(kickHard, hats16, openRave, clap, ride, crash, bajo, - sub, pianoRave, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), - hookAlta, pad.gain(.25)) + rodillo, riser, hats16.gain(.4), openRave.gain(.4)) +const dropHoover = stack(kickHard, hats16, openRave, clap, crash, ghost, hoover, + sub, hook.gain(.6), pianoRave.gain(.5), leadLimpio, stab) +const dropHooverFull = stack(kickHard, hats16, openRave, clap, ride, ghost, hoover, + sub, bajoOff, hook, hookAlta, pianoRave.gain(.6), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, openRave, clap, ride, crash, ghost, bajo, + sub, bajoOff, pianoRave, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), + hookAlta, pad.gain(.25), leadLimpio, stab) const coda = stack(kick, hats, clap, bajo.gain(.7), pianoRave.gain(.45), - hook.gain(.45).room(.6), pad) + hook.gain(.45).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), pianoRave.gain(.3).room(.8), hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) @@ -1805,19 +2527,24 @@ arrange( [16, dropFinal], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "19 · no limit hardcore — 2 unlimited (1993)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 19 · NO LIMIT HARDCORE — 2 Unlimited (1993) → Hardcore / Gabber suave Remix -// 150 BPM · Cm · TR-909 · kick distorsionado + riff square + rodillos dobles +// 150 BPM · Cm (Cm·Cm·Ab·Bb) · TR-909 · kick distorsionado + riff square +// PRODUCCIÓN PRO: kick 2 capas (click gabber + boom afinado que sigue las +// fundamentales Cm·Cm·Ab·Bb), sub/bajo/hoover siguen los acordes, bajo offbeat, +// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass, +// riser de ruido en subidas. Carácter peak-time gabber (saturación seria). // Estructura: intro→riff→build→drop A→break voces→drop gabber→coda (160 compases ≈ 4:16) // ════════════════════════════════════════════════════════════════ setcps(150/60/4) -// ── EL RIFF (square agresivo, martillo de Cm) ── +// ── EL RIFF (square agresivo, martillo de Cm — la melodía, notas intactas) ── const riff = note("c4 ~ c4 c4 eb4 c4 f4 eb4") .s("square").lpf(2200).lpq(6) .attack(.001).decay(.12).sustain(.25).release(.05) @@ -1826,8 +2553,28 @@ const riff = note("c4 ~ c4 c4 eb4 c4 f4 eb4") const riffAlta = riff.add(note(12)).gain(.35).lpf(3400).coarse(0).orbit(2) -// ── HOOVER (stabs supersaw, el rugido rave) ── -const hoover = note("c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]") +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("c4 ~ c4 c4 eb4 c4 f4 eb4") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Cm7·Cm7·Abmaj7·Bb7) + contramelodía ── +const stab = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ f4 ~ d4 ~ bb3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── HOOVER (stabs supersaw, AHORA sigue el acorde: Cm·Cm·Ab·Bb) ── +const hoover = note("<[c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]] [c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]] [ab2 ~ ~ ab2 ~ c3 ~ [eb3 c3]] [bb2 ~ ~ bb2 ~ d3 ~ [f3 d3]]>") .s("supersaw").unison(6).detune(.9).spread(.85) .lpf(1600).distort(.9) .attack(.01).decay(.18).sustain(.4).release(.1) @@ -1838,37 +2585,61 @@ const voz = s("numbers:0 numbers:0 numbers:0 ~") .speed(1.3).crush(6).hpf(300) .gain(.5).pan(.6).orbit(3) -// ── BAJO (sub duro pegado al kick) ── -const bajo = note("c2 c2 c2 [c2 eb2]") - .s("sawtooth").lpf(600).lpq(6) +// ── BAJO (sub duro pegado al kick, AHORA sigue el acorde) ── +const bajo = note("<[c2 c2 c2 [c2 eb2]] [c2 c2 c2 [c2 eb2]] [ab1 ab1 ab1 [ab1 c2]] [bb1 bb1 bb1 [bb1 d2]]>") + .s("sawtooth").lpf(perlin.slow(4).range(500,1100)).lpq(6) .attack(.001).decay(.11).sustain(.35).release(.03) - .shape(.4).gain(.9).orbit(1) + .shape(.4).coarse(1).gain(.9).orbit(1) -const sub = note("c1*4").s("sine").decay(.22).sustain(.2).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental ── +const sub = note("").struct("x*4").s("sine") + .attack(.002).decay(.22).sustain(.2).release(.04).gain(.6).orbit(1) -// ── BATERÍA 909 GABBER (bombo con distorsión seria) ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).distort(1.2).gain(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── BATERÍA 909 GABBER EN 2 CAPAS (click distorsionado + boom afinado) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).distort(1.2).gain(.9) .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) -const kickGabber = s("bd*4").bank("RolandTR909").shape(.6).distort(1.5).gain(1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04) + .shape(.3).gain(1).orbit(0) +const kickGabberClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.5).gain(.9) .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0) -const kickDoble = s("bd*8").bank("RolandTR909").shape(.55).distort(1.3).gain(.9) +const kickDobleClick = s("bd*8").bank("RolandTR909").hpf(38).shape(.55).distort(1.3).gain(.85) .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0) +const kickBoomDoble = note("").struct("x*8").s("sine") + .penv(26).pattack(.001).pdecay(.04).pcurve(0) + .attack(.001).decay(.16).sustain(0).release(.03) + .shape(.3).gain(.9).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickGabber = stack(kickGabberClick, kickBoom.gain(1.05)) +const kickDoble = stack(kickDobleClick, kickBoomDoble) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.2).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.6).pan(.6).orbit(0) -const hatsMachaca = s("hh*8").bank("RolandTR909") +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.6).pan(.6).orbit(0) +const hatsMachaca = s("hh*8").bank("RolandTR909").swingBy(1/24,8) .gain("[.55 .35]*4").pan(.45).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.35).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) const rodilloDoble = s("sd*32").bank("RolandTR909") .gain(saw.slow(2).range(.3,.95)).speed(saw.slow(2).range(1.1,1.7)) .pan(sine.fast(2).range(.3,.7)).orbit(0) +// ghost snare (percusión sincopada muy baja, groove anti-4x4) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD OSCURO (tensión entre drops) ── -const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [bb2,d3,f3]>") - .s("supersaw").unison(4).spread(.7).lpf(850) +// ── PAD OSCURO con 7as (tensión entre drops; hi-pass para el sub) ── +const pad = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>") + .s("supersaw").unison(4).spread(.7).lpf(850).hpf(150) .attack(.7).release(1.4).room(.6).rsize(7).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) @@ -1876,24 +2647,24 @@ const introRiff = stack(kick, hats, clap.gain(.4), riff.lpf(800).gain(.55), sub.gain(.5)) const build = stack(kick, hatsMachaca, clap, bajo, pad.gain(.25), riff.lpf(saw.slow(16).range(500,2200)).gain(.6)) -const buildFin = stack(kickGabber, rodillo, bajo, riff.gain(.7), voz.gain(.4)) -const dropA = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub, - riff, hoover.gain(.5)) -const dropAvar = stack(kickGabber, hatsMachaca, open, clap, bajo, sub, - riff, riffAlta, voz, hoover.gain(.55)) +const buildFin = stack(kickGabber, rodillo, riser, bajo, riff.gain(.7), voz.gain(.4)) +const dropA = stack(kickGabber, hatsMachaca, open, clap, crash, ghost, bajo, sub, + riff, hoover.gain(.5), leadLimpio, stab) +const dropAvar = stack(kickGabber, hatsMachaca, open, clap, ghost, bajo, sub, bajoOff, + riff, riffAlta, voz, hoover.gain(.55), leadLimpio, stab, contra) const breakVoces = stack(pad, voz, riff.gain(.5).room(.5), - hats.gain(.3), sub.gain(.35)) -const breakBuild = stack(pad, voz, riff.gain(.65), rodilloDoble, + hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, voz, riff.gain(.65), rodilloDoble, riser, hatsMachaca.gain(.4)) -const dropGabber = stack(kickGabber, hatsMachaca, open, clap, crash, sub, - hoover, riff, voz.gain(.4)) -const dropGabberFull = stack(kickDoble, hatsMachaca, clap, sub, - hoover, riff, riffAlta, voz) -const dropFinal = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub, +const dropGabber = stack(kickGabber, hatsMachaca, open, clap, crash, ghost, sub, + hoover, riff, voz.gain(.4), leadLimpio, stab) +const dropGabberFull = stack(kickDoble, hatsMachaca, clap, sub, bajoOff, + hoover, riff, riffAlta, voz, leadLimpio, stab, contra) +const dropFinal = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub, bajoOff, riff.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), riffAlta, - hoover.gain(.5), rodilloDoble.degradeBy(.5).gain(.3)) + hoover.gain(.5), rodilloDoble.degradeBy(.5).gain(.3), leadLimpio, stab) const coda = stack(kick, hats, clap, bajo.gain(.7), riff.gain(.45), - pad.gain(.3)) + pad.gain(.3), leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), voz.gain(.3), riff.gain(.25).room(.7), pad.gain(.3)) @@ -1912,14 +2683,18 @@ arrange( [16, dropFinal], [16, coda], [12, codaFin] -)`, +) +`, }, { name: "20 · rhythm of the night italo — corona (1993)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 20 · RHYTHM OF THE NIGHT ITALO — Corona (1993) → Italo Dance Techno Remix -// 130 BPM · Am · TR-909 · piano italo protagonista + bajo octavador · claps brillantes +// 130 BPM · Am (Am·F·C·G → raíces a·f·c·g) · TR-909 · piano italo + bajo octavador +// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales, +// bajo/sub que siguen los acordes, bajo offbeat, groove swing/ghost/velocity, +// armonía con 7as/9as e hi-pass, carácter duro peak-time, riser de ruido. // Estructura: intro→piano→build→drop A→break piano→drop supersaw→coda (144 compases ≈ 4:26) // ════════════════════════════════════════════════════════════════ setcps(130/60/4) @@ -1937,66 +2712,99 @@ const hookSaw = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~") .room(.5).rsize(6).delay(.3).delaytime(.375).delayfeedback(.4) .gain(.7).pan(sine.slow(8).range(.35,.65)).orbit(2) -// ── ACORDES ITALO (piano en offbeat, Am·F·C·G) ── -const acordes = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>") +// ── LEAD LIMPIO (el hook de piano, nítido y al frente) ── +const leadLimpio = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~") + .s("triangle").lpf(5200).lpq(1) + .attack(.005).decay(.2).sustain(.45).release(.16) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.55).pan(.5).orbit(2) + +// ── CONTRAMELODÍA (zona media, Am·F·C·G) ── +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ f4 ~ c4 ~ a3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.3).pan(.62).orbit(3) + +// ── ACORDES ITALO con 7as (Am7·Fmaj7·Cmaj7·G7, piano en offbeat + hi-pass) ── +const acordes = note("<[a3,c4,e4,g4] [f3,a3,c4,e4] [c4,e4,g4,b4] [g3,b3,d4,f4]>") .struct("[~ x]*4") - .s("piano").room(.4).rsize(4) + .s("piano").hpf(150).room(.4).rsize(4) .gain(.7).pan(.55).orbit(3) -// ── BAJO OCTAVADOR (corcheas saltando la octava) ── +// ── BAJO OCTAVADOR (corcheas saltando la octava, sigue las raíces a·f·c·g) ── const bajo = note("<[a1 a2 a1 a2 a1 a2 a1 a2] [f1 f2 f1 f2 f1 f2 f1 f2] [c2 c3 c2 c3 c2 c3 c2 c3] [g1 g2 g1 g2 g1 g2 g1 g2]>") - .s("sawtooth").lpf(750).lpq(6) + .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8) .attack(.001).decay(.12).sustain(.3).release(.04) - .shape(.3).gain(.9).orbit(1) + .shape(.34).coarse(1).gain(.9).orbit(1) +// ── SUB que SIGUE la fundamental (coherencia armónica total) ── const sub = note("").struct("x*4") .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1) -// ── BATERÍA 909 (brillante y bailonga) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) - .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1) - .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y", sigue las raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909") .hpf(300).room(.35).gain(.8).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0) +// hats con SWING + velocity humanizada +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0) const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +// ghost snare sincopado (dinámica de velocity aleatoria) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD MEDITERRÁNEO (colchón cálido) ── -const pad = note("<[a2,c3,e3] [f2,a2,c3] [c3,e3,g3] [g2,b2,d3]>") - .s("supersaw").unison(4).spread(.7).lpf(950) +// ── PAD MEDITERRÁNEO con 7as (colchón cálido + hi-pass) ── +const pad = note("<[a2,c3,e3,g3] [f2,a2,c3,e3] [c3,e3,g3,b3] [g2,b2,d3,f3]>") + .s("supersaw").unison(4).spread(.7).lpf(950).hpf(150) .attack(.8).release(1.6).room(.65).rsize(7).gain(.38).orbit(4) +// ── RISER de ruido filtrado para las subidas ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introPiano = stack(kick, hats, clap.gain(.4), acordes.gain(.45), bajo.lpf(400).gain(.65)) -const build = stack(kick, hats16, clap, bajo, acordes, pad.gain(.25), +const build = stack(kick, hats16, clap, ghost, bajo, acordes, pad.gain(.25), hookPiano.gain(.55)) -const buildFin = stack(kickHard, rodillo, bajo, acordes, hookPiano.gain(.75)) -const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub, - acordes, hookPiano) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, - acordes, hookPiano, pad.gain(.25)) +const buildFin = stack(kickHard, rodillo, riser, bajo, acordes, hookPiano.gain(.75)) +const dropA = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, + acordes, hookPiano, leadLimpio, contra) +const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + acordes, hookPiano, pad.gain(.25), leadLimpio, contra) const breakPiano = stack(pad, hookPiano.gain(.7).room(.75), - acordes.gain(.5).room(.6), sub.gain(.35)) + acordes.gain(.5).room(.6), sub.gain(.35), leadLimpio.gain(.42).room(.7)) const breakBuild = stack(pad, hookPiano.gain(.8), acordes.gain(.55), - rodillo, hats16.gain(.4)) -const dropSaw = stack(kickHard, hats16, open, clap, crash, bajo, sub, - acordes.gain(.5), hookSaw) -const dropSawFull = stack(kickHard, hats16, open, clap, ride, bajo, sub, - acordes, hookSaw, hookPiano.gain(.5), pad.gain(.25)) -const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub, + riser, rodillo, hats16.gain(.4)) +const dropSaw = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, + acordes.gain(.5), hookSaw, leadLimpio.gain(.45), contra) +const dropSawFull = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + acordes, hookSaw, hookPiano.gain(.5), pad.gain(.25), leadLimpio.gain(.45), contra) +const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajo, sub, bajoOff, acordes, hookPiano, hookSaw.sometimesBy(.2, x=>x.add(note(12)).gain(.4)).gain(.5)) const coda = stack(kick, hats, clap, bajo.gain(.7), acordes.gain(.45), - hookPiano.gain(.5).room(.6), pad) + hookPiano.gain(.5).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), hookPiano.gain(.4).room(.85).delayfeedback(.6), acordes.gain(.25).room(.8), pad.gain(.3)) @@ -2015,14 +2823,18 @@ arrange( [16, dropFinal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "21 · children dream — robert miles (1995)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 21 · CHILDREN DREAM — Robert Miles (1995) → Dream Trance Remix -// 137 BPM · Am · TR-909 + piano · LA joya dream: piano solo→drops elegantes→coda +// 137 BPM · Am (Am·F·C·G → raíces a·f·c·g) · TR-909 + piano +// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales, +// bajo/sub que siguen los acordes, bajo offbeat, groove swing/ghost/velocity, +// armonía con 7as/9as e hi-pass, carácter más duro, riser de ruido. // Estructura: piano solo→pads→build→drop A→break central→drop B→coda piano (168 compases ≈ 4:54) // ════════════════════════════════════════════════════════════════ setcps(137/60/4) @@ -2040,65 +2852,104 @@ const melodiaSinte = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ .room(.6).rsize(7).delay(.35).delaytime(.375).delayfeedback(.4) .gain(.55).pan(sine.slow(8).range(.35,.65)).orbit(2) -// ── ACORDES DE PIANO (Am·F·C·G, la mano izquierda del sueño) ── -const pianoAcordes = note("<[a2,e3,a3] [f2,c3,f3] [c3,g3,c4] [g2,d3,g3]>") - .s("piano").room(.8).rsize(8) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ ~ b4 ~ d5 ~ c5 b4 ~ a4 ~ ~]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (Am7·Fmaj7·Cmaj7·G7) + contramelodía + hi-pass ── +const stab = note("<[a2,c3,e3,g3] [f2,a2,c3,e3] [c3,e3,g3,b3] [g2,b2,d3,f3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── ACORDES DE PIANO con 7as (Am·F·C·G, la mano izquierda del sueño) ── +const pianoAcordes = note("<[a2,e3,g3,a3] [f2,c3,e3,f3] [c3,g3,b3,c4] [g2,d3,f3,g3]>") + .s("piano").hpf(120).room(.8).rsize(8) .gain(.7).pan(.45).orbit(4) -// ── BAJO ROLLING SUAVE (16avos redondos, progresión Am·F·C·G) ── +// ── BAJO ROLLING (16avos redondos, sigue las raíces a·f·c·g) ── const bajo = note("").struct("x*16") .s("sawtooth").lpf(500).lpq(4) .attack(.001).decay(.11).sustain(.25).release(.03) - .gain("[.8 .5 .6 .5]*4").shape(.2).orbit(1) + .gain("[.8 .5 .6 .5]*4").shape(.24).coarse(1).orbit(1) +// ── SUB que SIGUE la fundamental ── const sub = note("").struct("x*4") .s("sine").decay(.3).sustain(.3).gain(.6).orbit(1) -// ── BATERÍA 909 (elegante, nunca agresiva) ── -const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4, sigue las raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.48).gain(.92) .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.58).distort(1.2).gain(.95) + .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).gain(.65).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.45 .22 .32 .22]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.2,.45)).pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.4).orbit(0) const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.45).room(.5).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.15,.75)).speed(saw.slow(4).range(1,1.35)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.26)).hpf(400).orbit(0) -// ── CUERDAS (el colchón que llora detrás del piano) ── -const cuerdas = note("<[a2,c3,e3] [f2,a2,c3] [c3,e3,g3] [g2,b2,d3]>") - .s("supersaw").unison(5).spread(.8).lpf(sine.slow(32).range(500,1400)) +// ── CUERDAS con 7as (el colchón que llora detrás del piano) + hi-pass ── +const cuerdas = note("<[a2,c3,e3,g3] [f2,a2,c3,e3] [c3,e3,g3,b3] [g2,b2,d3,f3]>") + .s("supersaw").unison(5).spread(.8).lpf(sine.slow(32).range(500,1400)).hpf(150) .attack(1).release(2).room(.8).rsize(9).gain(.4).orbit(4) // ── VIENTO (textura del sueño, solo en el breakdown) ── const viento = s("wind").slow(8).lpf(1000).room(.9).rsize(9) .gain(.22).pan(sine.slow(16).range(.3,.7)).orbit(4) +// ── RISER de ruido filtrado para las subidas ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES ── const pianoSolo = stack(melodia, pianoAcordes) const pianoPads = stack(melodia, pianoAcordes, cuerdas.gain(.3), viento) const entraKick = stack(kick, hats, melodia.gain(.7), pianoAcordes.gain(.5), sub.gain(.4)) -const build = stack(kick, hats16, clap, bajo, melodia.gain(.75), +const build = stack(kick, hats16, clap, ghost, bajo, melodia.gain(.75), cuerdas.gain(.3), sub.gain(.5)) -const buildFin = stack(kick, rodillo, bajo, melodia.gain(.85), cuerdas.gain(.35)) -const dropA = stack(kick, hats16, open, clap, crash, bajo, sub, - melodia, melodiaSinte.gain(.4)) -const dropAvar = stack(kick, hats16, open, clap, ride, bajo, sub, - melodia, melodiaSinte, cuerdas.gain(.3)) -const breakCentral = stack(melodia, pianoAcordes, cuerdas, viento, sub.gain(.3)) +const buildFin = stack(kick, rodillo, riser, bajo, melodia.gain(.85), cuerdas.gain(.35)) +const dropA = stack(kick, hats16, open, clap, crash, ghost, bajo, sub, + melodia, melodiaSinte.gain(.4), leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, + melodia, melodiaSinte, cuerdas.gain(.3), leadLimpio, stab, contra) +const breakCentral = stack(melodia, pianoAcordes, cuerdas, viento, sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(melodia, pianoAcordes.gain(.5), cuerdas, - rodillo, hats16.gain(.35)) -const dropB = stack(kick, hats16, open, clap, crash, bajo, sub, - melodia, melodiaSinte, cuerdas.gain(.35)) -const dropBvar = stack(kick, hats16, open, clap, ride, bajo, sub, + riser, rodillo, hats16.gain(.35)) +const dropB = stack(kick, hats16, open, clap, crash, ghost, bajo, sub, + melodia, melodiaSinte, cuerdas.gain(.35), leadLimpio, stab) +const dropBvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff, melodia, melodiaSinte.sometimesBy(.2, x=>x.add(note(12)).gain(.35)), - cuerdas.gain(.4), pianoAcordes.gain(.4)) + cuerdas.gain(.4), pianoAcordes.gain(.4), leadLimpio, stab, contra) const bajada = stack(kick, hats, bajo.gain(.6), melodia.gain(.8), pianoAcordes.gain(.5), cuerdas.gain(.35)) -const codaPiano = stack(melodia, pianoAcordes, cuerdas.gain(.25)) +const codaPiano = stack(melodia, pianoAcordes, cuerdas.gain(.25), leadLimpio.gain(.4)) const codaFin = stack(melodia.gain(.7).room(.95).delayfeedback(.6), pianoAcordes.gain(.4), viento) @@ -2118,14 +2969,18 @@ arrange( [12, bajada], [8, codaPiano], [8, codaFin] -)`, +) +`, }, { name: "22 · insomnia — faithless (1995)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 22 · INSOMNIA — Faithless (1995) → Epic Techno Remix -// 130 BPM · F#m · TR-909 · el arpegio abre su filtro durante TODO el track +// 130 BPM · F#m (F#m·F#m·D·E → raíces fs·fs·d·e) · TR-909 +// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales, +// bajo/sub que siguen los acordes (el sub deja de ser nota fija), bajo offbeat, +// groove swing/ghost/velocity, armonía con 7as/9as e hi-pass, riser de ruido. // Estructura: intro→arpegio→build→drop A→breakdown→drop épico→coda (152 compases ≈ 4:41) // ════════════════════════════════════════════════════════════════ setcps(130/60/4) @@ -2147,55 +3002,93 @@ const hook = note("fs4 a4 gs4 fs4 cs4 ~ fs4 ~ a4 b4 a4 fs4 e4 ~ cs4 ~") const hookEco = hook.add(note(12)).gain(.26).lpf(4200).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("fs4 a4 gs4 fs4 cs4 ~ fs4 ~ a4 b4 a4 fs4 e4 ~ cs4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (F#m7·F#m7·Dmaj7·E7) + contramelodía + hi-pass ── +const stab = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [e3,gs3,b3,d4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a3 ~ fs3 ~ d3 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── BAJO (corcheas de raíz que siguen la armonía F#m→D→E) ── const bajo = note("fs1!8").add(note("<0 0 -4 -2>")) .s("sawtooth").lpf(perlin.slow(8).range(400, 900)).lpq(6) .attack(.001).decay(.18).sustain(.25).release(.05) - .shape(.3).gain(.85).orbit(1) + .shape(.32).coarse(1).gain(.85).orbit(1) -const bajoSub = note("fs1*4").s("sine").decay(.35).sustain(.2).gain(.7).orbit(1) +// ── SUB que ahora SIGUE la fundamental (fs·fs·d·e), ya no nota fija ── +const bajoSub = note("").struct("x*4") + .s("sine").decay(.35).sustain(.2).gain(.7).orbit(1) -// ── BATERÍA 909 (sidechain sobre bajo y lead) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4, sigue las raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PADS ÉPICOS ── -const pad = note("<[fs3,a3,cs4] [fs3,a3,cs4] [d3,fs3,a3] [e3,gs3,b3]>") - .s("sawtooth").lpf(750).attack(.9).release(1.6) +// ── PADS ÉPICOS con 7as + hi-pass ── +const pad = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [e3,gs3,b3,d4]>") + .s("sawtooth").lpf(750).hpf(150).attack(.9).release(1.6) .room(.8).rsize(8).gain(.4).orbit(4) const cuerdas = note("").s("supersaw").unison(6).spread(.8) - .lpf(sine.slow(32).range(500, 2400)).attack(.6).release(1) + .lpf(sine.slow(32).range(500, 2400)).hpf(200).attack(.6).release(1) .room(.7).gain(.32).orbit(4) +// ── RISER de ruido filtrado para las subidas ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introArp = stack(kick, hats, bajoSub.gain(.5), arpegio.gain(.6)) -const build = stack(kick, hats16, clap, bajoSub, arpegio, pad) -const buildFin = stack(kickHard, rodillo, arpegio, hook.gain(.5).lpf(1500)) -const dropA = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, arpegio, hook) -const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, arpegio, - hook, hookEco, cuerdas.gain(.24)) -const breakdown = stack(arpegio.gain(.65).room(.6), pad, cuerdas) -const breakBuild = stack(arpegio, arpegioAlto, pad, cuerdas, rodillo, hats16.gain(.4)) -const dropEpic = stack(kickHard, hats16, hatsOpen, clap, ride, bajo, bajoSub, - arpegio, arpegioAlto, hook) -const dropEpicFull = stack(kickHard, hats16, hatsOpen, clap, ride, bajo, bajoSub, - arpegio, arpegioAlto, hook, hookEco, cuerdas.gain(.26)) -const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride, - bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, - arpegio, hook, cuerdas.gain(.24)) -const coda = stack(kick, hats, arpegio.gain(.55), pad, hook.gain(.4).room(.8)) +const build = stack(kick, hats16, clap, ghost, bajoSub, arpegio, pad) +const buildFin = stack(kickHard, rodillo, riser, arpegio, hook.gain(.5).lpf(1500)) +const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajo, bajoSub, arpegio, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajo, bajoSub, bajoOff, arpegio, + hook, hookEco, cuerdas.gain(.24), leadLimpio, stab, contra) +const breakdown = stack(arpegio.gain(.65).room(.6), pad, cuerdas, contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(arpegio, arpegioAlto, pad, cuerdas, riser, rodillo, hats16.gain(.4)) +const dropEpic = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajo, bajoSub, + arpegio, arpegioAlto, hook, leadLimpio, stab) +const dropEpicFull = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajo, bajoSub, bajoOff, + arpegio, arpegioAlto, hook, hookEco, cuerdas.gain(.26), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, + bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + arpegio, hook, cuerdas.gain(.24), leadLimpio, stab) +const coda = stack(kick, hats, arpegio.gain(.55), pad, hook.gain(.4).room(.8), leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.35), arpegio.gain(.35).room(.85), pad.gain(.3)) // ── ARREGLO (152 compases) ── @@ -2213,14 +3106,18 @@ arrange( [16, dropFinal], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "23 · sandstorm — darude (1999)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 23 · SANDSTORM — Darude (1999) → Hard Trance Remix -// 138 BPM · Bm · TR-909 · pluck metralleta + bajo offbeat + doble drop con ride +// 138 BPM · Bm (Bm·G·A·Bm → raíces b·g·a·b) · TR-909 +// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales, +// bajo offbeat y sub que siguen los acordes (dejan de ser nota fija), +// groove swing/ghost/velocity, armonía con 7as/9as e hi-pass, carácter duro, riser. // Estructura: intro→build→drop A→break→drop B con ride→coda (136 compases ≈ 3:57) // ════════════════════════════════════════════════════════════════ setcps(138/60/4) @@ -2235,53 +3132,86 @@ const riff = note("b3 b3 b3 [b3 b3] e4 e4 e4 [e4 e4] d4 d4 d4 [d4 d4] a3 ~ b3 b3 const riffAlto = riff.add(note(12)).gain(.35).lpf(4200).orbit(2) const riffGrave = riff.add(note(-12)).lpf(saw.slow(16).range(400, 2200)).gain(.7).orbit(2) -// ── BAJO OFFBEAT (hard trance clásico) ── -const bajoOff = note("[~ b1]*4").s("sawtooth").lpf(760).lpq(5) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("b3 b3 b3 [b3 b3] e4 e4 e4 [e4 e4] d4 d4 d4 [d4 d4] a3 ~ b3 b3") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (Bm7·Gmaj7·A7·Bm7) + contramelodía + hi-pass ── +const stab = note("<[b2,d3,fs3,a3] [g2,b2,d3,fs3] [a2,cs3,e3,g3] [b2,d3,fs3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BAJO OFFBEAT (hard trance clásico, ahora sigue las raíces b·g·a·b) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(760).lpq(5) .attack(.001).decay(.16).sustain(.2).release(.04) - .shape(.35).gain(.9).orbit(1) + .shape(.35).coarse(1).gain(.9).orbit(1) -const bajoSub = note("b1*4").s("sine").decay(.3).sustain(.15).gain(.6).orbit(1) +// ── SUB que ahora SIGUE la fundamental (b·g·a·b), ya no nota fija ── +const bajoSub = note("").struct("x*4").s("sine") + .decay(.3).sustain(.15).gain(.6).orbit(1) -// ── BATERÍA 909 DURA ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1) +// ── KICK 909 DURO EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).gain(.94) .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.35).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.32).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.62).distort(1.4).gain(.96) .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.55 .25 .4 .25]*4").pan(rand.range(.3,.7)).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.32).pan(.35).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.25,.55)).pan(rand.range(.3,.7)).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.32).pan(.35).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) const rodilloLargo = s("sd*16").bank("RolandTR909") .gain(saw.slow(8).range(.15,.9)).speed(saw.slow(8).range(1,1.6)).orbit(0) const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.5).room(.4).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.3)).hpf(400).orbit(0) -// ── PAD DE FONDO (Bm→G→A) ── -const pad = note("<[b2,d3,fs3] [g2,b2,d3] [a2,cs3,e3] [b2,d3,fs3]>") - .s("sawtooth").lpf(700).attack(.8).release(1.4) +// ── PAD DE FONDO con 7as (Bm·G·A·Bm) + hi-pass ── +const pad = note("<[b2,d3,fs3,a3] [g2,b2,d3,fs3] [a2,cs3,e3,g3] [b2,d3,fs3,a3]>") + .s("sawtooth").lpf(700).hpf(150).attack(.8).release(1.4) .room(.6).rsize(6).gain(.38).orbit(4) +// ── RISER de ruido filtrado para las subidas ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introB = stack(kick, hats, hatsOpen, clap.gain(.5), bajoOff.lpf(450).gain(.7)) -const build = stack(kick, hats16, clap, bajoOff, riffGrave, pad.gain(.3)) -const buildFin = stack(kickHard, rodillo, bajoOff, riff.gain(.7)) -const dropA = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, riff) -const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, riff, - riffAlto, crash) -const breakdown = stack(pad, riff.gain(.55).room(.7).delayfeedback(.55), hats.gain(.3)) -const breakBuild = stack(pad, riff.gain(.75), rodilloLargo, hats16.gain(.4), +const build = stack(kick, hats16, clap, ghost, bajoOff, riffGrave, pad.gain(.3)) +const buildFin = stack(kickHard, rodillo, riser, bajoOff, riff.gain(.7)) +const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajoOff, bajoSub, riff, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoOff, bajoSub, riff, + riffAlto, crash, leadLimpio, stab, contra) +const breakdown = stack(pad, riff.gain(.55).room(.7).delayfeedback(.55), hats.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, riff.gain(.75), riser, rodilloLargo, hats16.gain(.4), bajoSub.gain(.4)) -const dropB = stack(kickHard, hats16, hatsOpen, clap, ride, bajoOff, bajoSub, - riff, riffAlto) -const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, crash, bajoOff, - bajoSub, riff, riffAlto, pad.gain(.25)) -const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride, - bajoOff.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), bajoSub, riff, riffAlto) -const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), riff.gain(.5).room(.6), pad) +const dropB = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoOff, bajoSub, + riff, riffAlto, leadLimpio, stab) +const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, crash, ghost, bajoOff, + bajoSub, riff, riffAlto, pad.gain(.25), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, + bajoOff.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), bajoSub, riff, riffAlto, leadLimpio, stab) +const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), riff.gain(.5).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), riff.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) @@ -2300,14 +3230,18 @@ arrange( [12, dropFinal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "24 · blue (da ba dee) — eiffel 65 (1998)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 24 · BLUE (DA BA DEE) — Eiffel 65 (1998) → Eurodance Techno Remix -// 133 BPM · Gm · TR-909 · lead vocoder con vowel + bajo octavado eurodance +// 133 BPM · Gm (Gm·Gm·Eb·F → raíces g·g·eb·f) · TR-909 +// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales, +// bajo/sub que siguen los acordes, bajo offbeat, groove swing/ghost/velocity, +// armonía con 7as/9as e hi-pass, carácter duro peak-time, riser de ruido. // Estructura: intro→build→drop A→break→drop B→coda (136 compases ≈ 4:05) // ════════════════════════════════════════════════════════════════ setcps(133/60/4) @@ -2321,60 +3255,97 @@ const hook = note("bb4 ~ g4 ~ f4 g4 bb4 g4 ~ f4 ~ d4 f4 g4 ~ ~") const hookOctava = hook.add(note(12)).gain(.3).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("bb4 ~ g4 ~ f4 g4 bb4 g4 ~ f4 ~ d4 f4 g4 ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (Gm7·Gm7·Ebmaj7·F7) + contramelodía + hi-pass ── +const stab = note("<[g3,bb3,d4,f4] [g3,bb3,d4,f4] [eb3,g3,bb3,d4] [f3,a3,c4,eb4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ bb3 ~ g3 ~ eb3 ~] [~ ~ c4 ~ a3 ~ f3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── RIFF SINTÉTICO (pluck de apoyo en corcheas) ── const riff = note("[g3 bb3 c4 d4]*2").s("square") .lpf(1900).attack(.001).decay(.1).sustain(.05).release(.05) .delay(.2).delaytime(.1875).delayfeedback(.3) .gain(.6).pan(.35).orbit(3) -// ── BAJO OCTAVADO EURODANCE (sigue Gm→Eb→F) ── +// ── BAJO OCTAVADO EURODANCE (sigue Gm→Eb→F, raíces g·g·eb·f) ── const bajo = note("[g1 g2 g1 g2]*2").add(note("<0 0 -4 -2>")) - .s("sawtooth").lpf(820).lpq(5) + .s("sawtooth").lpf(perlin.slow(4).range(600,1200)).lpq(5) .attack(.001).decay(.14).sustain(.3).release(.04) - .shape(.3).gain(.9).orbit(1) + .shape(.34).coarse(1).gain(.9).orbit(1) +// ── SUB que SIGUE la fundamental (g·g·eb·f) ── const bajoSub = note("g1*4").add(note("<0 0 -4 -2>")).s("sine") .decay(.3).sustain(.2).gain(.65).orbit(1) -// ── BATERÍA 909 (claps dobles, energía pop) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// ── BAJO OFFBEAT (rompe el 4x4, sigue las raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickDoble = s("<[bd*4] [bd*4] [bd*4] [bd bd bd [bd bd]]>").bank("RolandTR909") - .shape(.5).distort(1.1).gain(1.1) - .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickDobleClick = s("<[bd*4] [bd*4] [bd*4] [bd bd bd [bd bd]]>").bank("RolandTR909") + .hpf(38).shape(.6).distort(1.2).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickDoble = stack(kickDobleClick, kickBoom.gain(1.05)) + const clapDoble = s("~ cp ~ [cp cp]").bank("RolandTR909").room(.3).gain(.72).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .38 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.48).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PADS BRILLANTES ── -const pad = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>") +// ── PADS BRILLANTES con 7as + hi-pass ── +const pad = note("<[g3,bb3,d4,f4] [g3,bb3,d4,f4] [eb3,g3,bb3,d4] [f3,a3,c4,eb4]>") .s("supersaw").unison(5).spread(.7) - .lpf(sine.slow(16).range(600, 2200)).attack(.5).release(1) + .lpf(sine.slow(16).range(600, 2200)).hpf(150).attack(.5).release(1) .room(.6).rsize(6).gain(.35).orbit(4) +// ── RISER de ruido filtrado para las subidas ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introB = stack(kick, hats, hatsOpen, riff.gain(.4), bajo.lpf(400).gain(.6)) -const build = stack(kick, hats16, clapDoble, bajo, riff, +const build = stack(kick, hats16, clapDoble, ghost, bajo, riff, hook.lpf(saw.slow(16).range(400, 2600)).gain(.55)) -const buildFin = stack(kickDoble, rodillo, bajo, hook.gain(.65)) -const dropA = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub, hook, riff) -const dropAvar = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub, - hook, hookOctava, riff, pad.gain(.25)) -const breakdown = stack(pad, hook.gain(.6).room(.75), bajoSub.gain(.35), hats.gain(.3)) -const breakBuild = stack(pad, hook.gain(.75), riff.gain(.5), rodillo, hats16.gain(.4)) -const dropB = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub, - hook, hookOctava, riff) -const dropBfull = stack(kickDoble, hats16, hatsOpen, clapDoble, - bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, - hook, hookOctava, riff, pad.gain(.28)) -const dropFinal = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub, - hook, hookOctava, pad.gain(.25)) -const coda = stack(kick, hats, bajo.lpf(550).gain(.7), hook.gain(.45).room(.7), pad) +const buildFin = stack(kickDoble, rodillo, riser, bajo, hook.gain(.65)) +const dropA = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, hook, riff, leadLimpio, stab) +const dropAvar = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, bajoOff, + hook, hookOctava, riff, pad.gain(.25), leadLimpio, stab, contra) +const breakdown = stack(pad, hook.gain(.6).room(.75), bajoSub.gain(.35), hats.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, hook.gain(.75), riff.gain(.5), riser, rodillo, hats16.gain(.4)) +const dropB = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, + hook, hookOctava, riff, leadLimpio, stab) +const dropBfull = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, + bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + hook, hookOctava, riff, pad.gain(.28), leadLimpio, stab, contra) +const dropFinal = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, bajoOff, + hook, hookOctava, pad.gain(.25), leadLimpio, stab) +const coda = stack(kick, hats, bajo.lpf(550).gain(.7), hook.gain(.45).room(.7), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3)) @@ -2393,14 +3364,18 @@ arrange( [8, dropFinal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "25 · better off alone — alice deejay (1998)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 25 · BETTER OFF ALONE — Alice Deejay (1998) → Hands-Up Techno Remix -// 137 BPM · F#m · TR-909 · pluck ping-pong + pausas dramáticas + supersaw +// 137 BPM · F#m (F#m·D·A·E → raíces fs·d·a·e) · TR-909 +// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales, +// bajo offbeat/rolling y sub que siguen los acordes, groove swing/ghost/velocity, +// armonía con 7as/9as e hi-pass, carácter duro peak-time, riser de ruido. // Estructura: intro→pluck solo→build→PAUSA→drop A→break→PAUSA→drop B→coda (134 compases ≈ 3:55) // ════════════════════════════════════════════════════════════════ setcps(137/60/4) @@ -2426,53 +3401,85 @@ const superLead = note(melodia).s("supersaw").unison(6).spread(.8).detune(.18) .lpf(3400).attack(.005).decay(.2).sustain(.15).release(.15) .room(.5).rsize(5).gain(.55).orbit(3) -// ── BAJOS (offbeat en el drop A, rolling en el drop B; F#m→D→A→E) ── +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("cs5 ~ cs5 ~ fs5 ~ e5 ~ ~ cs5 ~ b4 ~ cs5 ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (F#m7·Dmaj7·Amaj7·E7) + contramelodía + hi-pass ── +const stab = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,d4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a3 ~ fs3 ~ d3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BAJOS (offbeat en el drop A, rolling en el drop B; siguen fs·d·a·e) ── const bajoOff = note("[~ fs1]*4").add(note("<0 -4 3 -2>")) .s("sawtooth").lpf(720).lpq(5) .attack(.001).decay(.15).sustain(.2).release(.04) - .shape(.35).gain(.88).orbit(1) + .shape(.35).coarse(1).gain(.88).orbit(1) const bajoRoll = note("fs1*16").add(note("<0 -4 3 -2>")) .s("sawtooth").lpf(850).lpq(6) .attack(.001).decay(.1).sustain(.15).release(.03) - .shape(.3).gain("[.85 .45 .6 .45]*4").orbit(1) + .shape(.3).coarse(1).gain("[.85 .45 .6 .45]*4").orbit(1) const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine") .decay(.3).sustain(.15).gain(.6).orbit(1) -// ── BATERÍA 909 ── -const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08) +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.52).gain(.94) .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.96) .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.52 .25 .38 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.52)).pan(rand.range(.35,.65)).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.48).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.88)).speed(saw.slow(4).range(1,1.45)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PADS ── -const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>") - .s("sawtooth").lpf(720).attack(.8).release(1.5) +// ── PADS con 7as + hi-pass ── +const pad = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,d4]>") + .s("sawtooth").lpf(720).hpf(150).attack(.8).release(1.5) .room(.7).rsize(7).gain(.38).orbit(4) +// ── RISER de ruido filtrado para las subidas ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES (la PAUSA deja el pluck solo, flotando antes del drop) ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introB = stack(kick, hats, hatsOpen, clap.gain(.5), bajoOff.lpf(420).gain(.65)) const pluckSolo = stack(pluck, kick.gain(.9), hats.gain(.4)) -const build = stack(kick, hats16, clap, bajoOff, pluck, pad.gain(.3)) +const build = stack(kick, hats16, clap, ghost, bajoOff, pluck, pad.gain(.3)) const pausa = stack(pluck.gain(.95).room(.7).delayfeedback(.6), silence) -const dropA = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, - pluck, pluckOctava) -const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, - pluck, pluckOctava, pad.gain(.25)) -const breakdown = stack(pad, pluck.gain(.6).room(.7), bajoSub.gain(.3), hats.gain(.3)) -const breakBuild = stack(pad, pluck, rodillo, hats16.gain(.4)) -const dropB = stack(kickHard, hats16, hatsOpen, clap, bajoRoll, bajoSub, - pluck, superLead) -const dropBfull = stack(kickHard, hats16, hatsOpen, clap, bajoRoll, bajoSub, - pluck, pluckOctava, superLead, pad.gain(.25)) -const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), pluck.gain(.5).room(.6), pad) +const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajoOff, bajoSub, + pluck, pluckOctava, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoOff, bajoSub, + pluck, pluckOctava, pad.gain(.25), leadLimpio, stab, contra) +const breakdown = stack(pad, pluck.gain(.6).room(.7), bajoSub.gain(.3), hats.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, pluck, riser, rodillo, hats16.gain(.4)) +const dropB = stack(kickHard, hats16, hatsOpen, clap, ghost, bajoRoll, bajoSub, + pluck, superLead, leadLimpio, stab) +const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoRoll, bajoSub, + pluck, pluckOctava, superLead, pad.gain(.25), leadLimpio, stab, contra) +const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), pluck.gain(.5).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), pluck.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) @@ -2492,14 +3499,18 @@ arrange( [16, dropBfull], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "26 · born slippy .nuxx — underworld (1995)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 26 · BORN SLIPPY .NUXX — Underworld (1995) → Progressive Techno Remix -// 140 BPM · E · TR-909 · lead celestial 16 compases → kick brutal SIN bajo + toms +// 140 BPM · E (i·i·IV·V = Em? -> E·E·A·B) · TR-909 · lead celestial +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue E-A-B), +// sub que sigue los acordes + bajo offbeat, groove swing/ghost/velocity, +// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido. // Estructura: lead solo→kick entra→toms→drop A→break→drop B→coda (140 compases ≈ 4:00) // ════════════════════════════════════════════════════════════════ setcps(140/60/4) @@ -2514,23 +3525,60 @@ const lead = note("e5 ~ gs5 e5 ~ fs5 e5 ~ b4 ~ cs5 ~ e5 ~ ~ ~") const leadOctava = lead.add(note(12)).gain(.28).lpf(4500).orbit(2) const leadGrave = lead.add(note(-12)).gain(.45).lpf(1400).orbit(2) -// ── PADS ELÉCTRICOS ENORMES (E→A→B) ── -const pad = note("<[e3,gs3,b3] [e3,gs3,b3] [a3,cs4,e4] [b3,ds4,fs4]>") +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("e5 ~ gs5 e5 ~ fs5 e5 ~ b4 ~ cs5 ~ e5 ~ ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Eadd9·Eadd9·Aadd9·B7) + hi-pass ── +const stab = note("<[e3,gs3,b3,fs4] [e3,gs3,b3,fs4] [a3,cs4,e4,b4] [b3,ds4,fs4,a4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("2:4").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ b3 ~ gs3 ~ e3 ~] [~ ~ b3 ~ gs3 ~ e3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ fs4 ~ ds4 ~ b3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── PADS ELÉCTRICOS ENORMES (E→A→B, 7as/9as + hi-pass para dejar respirar el sub) ── +const pad = note("<[e3,gs3,b3,fs4] [e3,gs3,b3,fs4] [a3,cs4,e4,b4] [b3,ds4,fs4,a4]>") .s("supersaw").unison(6).spread(.85) - .lpf(sine.slow(32).range(500, 2000)).attack(1).release(2) + .lpf(sine.slow(32).range(500, 2000)).hpf(150).attack(1).release(2) .room(.9).rsize(9).gain(.4).orbit(4) -// ── BATERÍA (distorsión creciente, toms marciales, SIN bajo: bombo+lead) ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1) +// ── SUB-BAJO que SIGUE la fundamental de cada acorde (E·E·A·B) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04) + .gain(.68).orbit(1) + +// ── BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") solo en los drops grandes ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("2").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue E-A-B ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("2:4").duckattack(.1).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.3).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("2:4").duckattack(.1).duckdepth(.6).orbit(0) -const kickBrutal = s("bd*4").bank("RolandTR909").shape(.65).distort(1.6).gain(1.1) +const kickBrutalClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.65).distort(1.6).gain(.97) .duck("2:4").duckattack(.1).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) +const kickBrutal = stack(kickBrutalClick, kickBoom.gain(1.08)) const snare = s("~ sd ~ sd").bank("RolandTR909").shape(.3).room(.3).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .22 .35 .22]*4").pan(rand.range(.3,.7)).orbit(0) +// hats con SWING + velocity humanizada +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.3,.7)).orbit(0) const tomsMarcial = s("ht mt ~ lt ~ mt ht lt").bank("RolandTR909") .shape(.25).gain(.62).pan(sine.fast(2).range(.3,.7)).orbit(0) const tomsFuria = s("[ht ht] mt [mt lt] lt [ht mt] lt [mt mt] [lt lt]").bank("RolandTR909") @@ -2538,22 +3586,27 @@ const tomsFuria = s("[ht ht] mt [mt lt] lt [ht mt] lt [mt mt] [lt lt]").bank("Ro const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.5).room(.4).orbit(0) +// ghost snare sincopada (dinámica de velocity aleatoria) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const leadSolo = stack(lead.gain(.85), silence) const leadCoro = stack(lead.gain(.85), leadOctava, pad.gain(.3)) -const kickEntra = stack(kick, lead.gain(.7), hats.gain(.35)) -const kickLead = stack(kick, hats, snare.gain(.5), lead, leadGrave.gain(.3)) -const tomsBuild = stack(kickHard, tomsMarcial, rodillo, lead.gain(.65)) -const dropA = stack(kickHard, hats16, snare, tomsMarcial, lead, leadGrave) -const dropAvar = stack(kickHard, hats16, snare, tomsMarcial, crash, - lead, leadOctava, leadGrave) -const breakdown = stack(pad, lead.gain(.6), hats.gain(.25)) -const breakBuild = stack(pad, lead.gain(.8), leadOctava, rodillo, hats16.gain(.35)) -const dropB = stack(kickBrutal, hats16, snare, tomsFuria, lead, leadGrave) -const dropBfull = stack(kickBrutal, hats16, snare, tomsFuria, crash, - lead, leadOctava, leadGrave, pad.gain(.25)) -const coda = stack(kick, hats, lead.gain(.55).room(.9), pad) +const kickEntra = stack(kick, lead.gain(.7), hats.gain(.35), bajoSub.gain(.4)) +const kickLead = stack(kick, hats, snare.gain(.5), lead, leadGrave.gain(.3), bajoSub) +const tomsBuild = stack(kickHard, tomsMarcial, rodillo, riser, bajoSub, lead.gain(.65)) +const dropA = stack(kickHard, hats16, snare, tomsMarcial, ghost, bajoSub, lead, leadGrave, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, snare, tomsMarcial, crash, ghost, bajoSub, bajoOff, + lead, leadOctava, leadGrave, leadLimpio, stab, contra) +const breakdown = stack(pad, lead.gain(.6), hats.gain(.25), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, lead.gain(.8), leadOctava, rodillo, riser, hats16.gain(.35)) +const dropB = stack(kickBrutal, hats16, snare, tomsFuria, ghost, bajoSub, lead, leadGrave, leadLimpio, stab) +const dropBfull = stack(kickBrutal, hats16, snare, tomsFuria, crash, ghost, bajoSub, bajoOff, + lead, leadOctava, leadGrave, pad.gain(.25), leadLimpio, stab, contra) +const coda = stack(kick, hats, bajoSub, lead.gain(.55).room(.9), pad, leadLimpio.gain(.4)) const codaFin = stack(lead.gain(.4).room(.95).delayfeedback(.6), pad.gain(.3)) // ── ARREGLO (140 compases) ── @@ -2571,14 +3624,18 @@ arrange( [16, dropBfull], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "27 · mr. vain — culture beat (1993)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 27 · MR. VAIN — Culture Beat (1993) → Eurotechno Remix -// 133 BPM · Cm · TR-909 · stabs FM metálicos + corte hpf + acid suave al final +// 133 BPM · Cm (i·i·VI·VII = Cm·Cm·Ab·Bb) · TR-909 · stabs FM metálicos +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue C-Ab-Bb), +// bajo + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity, +// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido. // Estructura: intro→build→drop A→break hpf→drop acid→coda (136 compases ≈ 4:05) // ════════════════════════════════════════════════════════════════ setcps(133/60/4) @@ -2593,13 +3650,40 @@ const riff = note("c5 bb4 g4 bb4 c5 bb4 g4 f4") const riffHpf = riff.hpf(900).gain(.65).room(.5).orbit(2) const riffApoyo = riff.add(note(-12)).fm(5).gain(.4).orbit(2) -// ── EL BAJO (groove noventero exacto) ── -const bajo = note("c2 ~ c2 c2 ~ c2 eb2 f2") - .s("sawtooth").lpf(830).lpq(6) - .attack(.001).decay(.13).sustain(.2).release(.04) - .shape(.35).gain(.92).orbit(1) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("c5 bb4 g4 bb4 c5 bb4 g4 f4") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) -const bajoSub = note("c1*4").s("sine").decay(.3).sustain(.2).gain(.65).orbit(1) +// ── ZONA MEDIA: stab armónico con 7as/9as (Cm7·Cm7·Abmaj7·Bb7) + hi-pass ── +const stab = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ f4 ~ d4 ~ bb3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── EL BAJO (groove noventero, AHORA sigue el acorde: C·C·Ab·Bb) ── +const bajo = note("<[c2 ~ c2 c2 ~ c2 eb2 f2] [c2 ~ c2 c2 ~ c2 eb2 f2] [ab1 ~ ab1 ab1 ~ ab1 c2 eb2] [bb1 ~ bb1 bb1 ~ bb1 d2 f2]>") + .s("sawtooth").lpf(perlin.slow(4).range(600, 1300)).lpq(8) + .attack(.001).decay(.13).sustain(.2).release(.04) + .shape(.34).coarse(1).gain(.9).orbit(1) + +// ── SUB-BAJO afinado que SIGUE la fundamental (C·C·Ab·Bb) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.65).orbit(1) + +// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) // ── CAPA ACID SUAVE (segunda mitad) ── const acid = note("c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [f2 eb2] c2") @@ -2609,45 +3693,56 @@ const acid = note("c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [f2 eb2] c2") .shape(.3).gain(.68).rarely(x=>x.add(note(12))) .delay(.22).delaytime(.1875).delayfeedback(.3).orbit(3) -// ── BATERÍA 909 CON GROOVE (swing sutil + rim fantasma) ── -const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue C-Ab-Bb ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.42).gain(.92) .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).distort(1.2).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.28).gain(.72).orbit(0) const rim = s("[~ rim]*4").bank("RolandTR909").gain(rand.range(.2,.45)).pan(.3).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909").swingBy(.06, 8) - .gain("[.5 .25 .36 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0) +// hats con SWING + velocity humanizada +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.48).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +// ghost snare sincopada +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PAD (Cm→Ab→Bb) ── -const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [bb2,d3,f3]>") - .s("sawtooth").lpf(700).attack(.8).release(1.5) +// ── PAD (Cm→Ab→Bb, 7as/9as + hi-pass) ── +const pad = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>") + .s("sawtooth").lpf(700).hpf(150).attack(.8).release(1.5) .room(.65).rsize(6).gain(.38).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) -const introB = stack(kick, hats, hatsOpen, rim.gain(.3), bajo.lpf(420).gain(.65)) -const build = stack(kick, hats16, clap, bajo, riffApoyo, +const introB = stack(kick, hats, hatsOpen, rim.gain(.3), bajoSub.gain(.5), bajo.lpf(420).gain(.65)) +const build = stack(kick, hats16, clap, ghost, bajo, bajoSub, riffApoyo, riser, riff.lpf(saw.slow(16).range(400, 2500)).gain(.55)) -const buildFin = stack(kickHard, rodillo, bajo, riff.gain(.65)) -const dropA = stack(kickHard, hats16, hatsOpen, clap, rim, bajo, bajoSub, riff) -const dropAvar = stack(kickHard, hats16, hatsOpen, clap, rim, bajo, bajoSub, - riff, riffApoyo, pad.gain(.24)) -const breakHpf = stack(riffHpf, pad, hats.gain(.3), clap.gain(.4)) -const breakBuild = stack(riffHpf.gain(.75), pad, rodillo, hats16.gain(.4), +const buildFin = stack(kickHard, rodillo, riser, bajo, bajoSub, riff.gain(.65)) +const dropA = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, bajo, bajoSub, riff, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, bajo, bajoSub, bajoOff, + riff, riffApoyo, pad.gain(.24), leadLimpio, stab, contra) +const breakHpf = stack(riffHpf, pad, hats.gain(.3), clap.gain(.4), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(riffHpf.gain(.75), pad, rodillo, riser, hats16.gain(.4), bajoSub.gain(.4)) -const dropAcid = stack(kickHard, hats16, hatsOpen, clap, acid, bajoSub, - riff.gain(.6)) -const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, rim, acid, - bajo, bajoSub, riff, pad.gain(.24)) -const dropFinal = stack(kickHard, hats16, hatsOpen, clap, rim, - bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, - riff, riffApoyo, acid.gain(.5)) -const coda = stack(kick, hats, bajo.lpf(500).gain(.7), riff.gain(.5).room(.6), pad) +const dropAcid = stack(kickHard, hats16, hatsOpen, clap, ghost, acid, bajoSub, + riff.gain(.6), leadLimpio, stab) +const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, acid, + bajo, bajoSub, bajoOff, riff, pad.gain(.24), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, + bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + riff, riffApoyo, acid.gain(.5), leadLimpio, stab) +const coda = stack(kick, hats, bajo.lpf(500).gain(.7), bajoSub.gain(.5), riff.gain(.5).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.4), riff.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3)) @@ -2666,14 +3761,18 @@ arrange( [8, dropFinal], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "28 · smells like teen spirit — nirvana (1991)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 28 · SMELLS LIKE TEEN SPIRIT — Nirvana (1991) → Industrial Techno Remix -// 135 BPM · Fm · TR-909 · muro de power chords + snare metálica + reese +// 135 BPM · Fm (i·i·VI·bII = Fm·Fm·Ab·Db) · TR-909 · muro de power chords +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue F-Ab-Db), +// reese + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity, +// stabs con 7as/9as + hi-pass, carácter peak-time (distorsión) + riser de ruido. // Estructura: intro→build→drop A→break susurrado→drop B→coda (144 compases ≈ 4:16) // ════════════════════════════════════════════════════════════════ setcps(135/60/4) @@ -2696,55 +3795,92 @@ const voz = note("f4 ab4 f4 eb4 f4 ~ c4 ~") const vozOctava = voz.add(note(12)).gain(.25).orbit(2) -// ── REESE INDUSTRIAL (supersaw desafinado grave) ── +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("f4 ab4 f4 eb4 f4 ~ c4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Fm7·Fm7·Abmaj7·Dbmaj7) + hi-pass ── +const stab = note("<[f2,ab2,c3,eb3] [f2,ab2,c3,eb3] [ab2,c3,eb3,g3] [db3,f3,ab3,c4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ ab4 ~ f4 ~ db4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── REESE INDUSTRIAL que SIGUE las fundamentales (F·F·Ab·Db) ── const reese = note("") .s("supersaw").unison(3).detune(.5).spread(.9) .lpf(520).attack(.04).decay(.3).sustain(.75).release(.2) - .shape(.2).gain(.75).orbit(1) + .shape(.28).gain(.75).orbit(1) -const bajoSub = note("f1*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (F·F·Ab·Db) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1) -// ── BATERÍA INDUSTRIAL (kick distorsionado + snare de chatarra) ── -const kick = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1) +// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── BATERÍA INDUSTRIAL: kick 2 capas (click distorsionado + boom afinado) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).distort(1.1).gain(.95) .duck("1:3").duckattack(.1).duckdepth(.55).orbit(0) -const kickBrutal = s("<[bd*4] [bd*4] [bd [bd bd] bd bd] [bd*4]>").bank("RolandTR909") - .shape(.65).distort(1.45).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickBrutalClick = s("<[bd*4] [bd*4] [bd [bd bd] bd bd] [bd*4]>").bank("RolandTR909") + .hpf(38).shape(.65).distort(1.45).gain(.97) .duck("1:3").duckattack(.1).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickBrutal = stack(kickBrutalClick, kickBoom.gain(1.05)) const snareMetal = s("~ metal ~ metal").speed(1.8).hpf(900) .shape(.3).room(.3).gain(.55).orbit(0) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.6).orbit(0) -const hatsInd = s("hh*8").bank("RolandTR909").crush(6) +const hatsInd = s("hh*8").bank("RolandTR909").crush(6).swingBy(1/24,8) .gain("[.5 .28]*4").pan(rand.range(.3,.7)).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909").crush(8) - .gain("[.5 .22 .35 .22]*4").orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").crush(8).swingBy(1/24,16) + .gain(perlin.range(.22,.5)).orbit(0) const rodillo = s("sd*16").bank("RolandTR909").shape(.3) .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) +// ghost snare sincopada +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PAD OSCURO ── -const pad = note("<[f2,ab2,c3] [f2,ab2,c3] [ab2,c3,eb3] [db3,f3,ab3]>") - .s("sawtooth").lpf(600).attack(1).release(1.8) +// ── PAD OSCURO (7as/9as + hi-pass) ── +const pad = note("<[f2,ab2,c3,eb3] [f2,ab2,c3,eb3] [ab2,c3,eb3,g3] [db3,f3,ab3,c4]>") + .s("sawtooth").lpf(600).hpf(150).attack(1).release(1.8) .room(.8).rsize(8).gain(.35).orbit(4) // ── SECCIONES ── const intro = stack(kick, hatsInd.gain(.35), bajoSub.gain(.4)) -const introB = stack(kick, hatsInd, clap.gain(.45), chords.lpf(500).gain(.55)) -const build = stack(kick, hats16, clap, reese, +const introB = stack(kick, hatsInd, clap.gain(.45), bajoSub.gain(.5), chords.lpf(500).gain(.55)) +const build = stack(kick, hats16, clap, ghost, reese, bajoSub, riser, chords.lpf(saw.slow(16).range(500, 2400))) -const buildFin = stack(kickBrutal, rodillo, reese, chords) -const dropA = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub, chords) -const dropAvar = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub, - chords, chordsAlto, voz.gain(.4)) -const breakSusurro = stack(pad, voz, vozOctava, bajoSub.gain(.3), hatsInd.gain(.25)) -const breakBuild = stack(pad, voz, chords.gain(.55).lpf(1200), rodillo, +const buildFin = stack(kickBrutal, rodillo, riser, reese, bajoSub, chords) +const dropA = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, chords, leadLimpio, stab) +const dropAvar = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, bajoOff, + chords, chordsAlto, voz.gain(.4), leadLimpio, stab, contra) +const breakSusurro = stack(pad, voz, vozOctava, bajoSub.gain(.3), hatsInd.gain(.25), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, voz, chords.gain(.55).lpf(1200), rodillo, riser, hats16.gain(.35)) -const dropB = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub, - chords, voz.gain(.5)) -const dropBfull = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub, - chords, chordsAlto, voz, pad.gain(.25)) -const dropFinal = stack(kickBrutal, hats16, snareMetal, clap, - reese.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, - chords, chordsAlto) -const coda = stack(kick, hatsInd, chords.gain(.5).lpf(900), voz.gain(.5), pad) +const dropB = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, + chords, voz.gain(.5), leadLimpio, stab) +const dropBfull = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, bajoOff, + chords, chordsAlto, voz, pad.gain(.25), leadLimpio, stab, contra) +const dropFinal = stack(kickBrutal, hats16, snareMetal, clap, ghost, + reese.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + chords, chordsAlto, leadLimpio, stab) +const coda = stack(kick, hatsInd, chords.gain(.5).lpf(900), voz.gain(.5), pad, leadLimpio.gain(.4)) const codaFin = stack(voz.gain(.4).room(.9), pad.gain(.3), hatsInd.gain(.3)) // ── ARREGLO (144 compases) ── @@ -2762,14 +3898,18 @@ arrange( [8, dropFinal], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "29 · your woman — white town (1997)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 29 · YOUR WOMAN — White Town (1997) → Minimal Electro Remix -// 125 BPM · Dm · TR-808 · trompeta telefónica (square+crush) + electro roto +// 125 BPM · Dm (i·i·VI·V = Dm·Dm·Bb·A) · TR-808 · trompeta telefónica +// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado que sigue D-Bb-A, +// respetando el patrón roto), bajo + sub que siguen las fundamentales + bajo +// offbeat, groove swing/ghost/velocity, pad con 7as/9as + hi-pass, riser de ruido. // Estructura: intro→build→drop A→break robótico→drop B→coda (132 compases ≈ 4:13) // ════════════════════════════════════════════════════════════════ setcps(125/60/4) @@ -2783,18 +3923,39 @@ const trompeta = note("d5 ~ d5 d5 cs5 d5 a4 f4 e4 d4 ~ ~ ~ ~ ~ ~") const trompetaBaja = trompeta.add(note(-12)).gain(.3).orbit(2) -// ── BAJO ELECTRO SINCOPADO ── -const bajo = note("d2 ~ [~ d2] a1") - .s("sawtooth").coarse(2).lpf(700).lpq(5) - .attack(.001).decay(.14).sustain(.2).release(.04) - .shape(.3).gain(.9).orbit(1) +// ── LEAD LIMPIO (la trompeta "your woman", nítida y al frente) ── +const leadLimpio = note("d5 ~ d5 d5 cs5 d5 a4 f4 e4 d4 ~ ~ ~ ~ ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.005).decay(.2).sustain(.45).release(.16) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.55).pan(.5).orbit(2) -const bajoVar = note("d2 ~ [~ d2] [a1 c2]") - .s("sawtooth").coarse(2).lpf(750).lpq(5) - .attack(.001).decay(.14).sustain(.2).release(.04) - .shape(.3).gain(.9).orbit(1) +// ── CONTRAMELODÍA (zona media, Dm·Dm·Bb·A) ── +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ bb4 ~ f4 ~ d4 ~] [~ ~ a4 ~ e4 ~ cs4 ~]>") + .s("triangle").lpf(2700).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.3).pan(.62).orbit(3) -const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.18).gain(.55).orbit(1) +// ── BAJO ELECTRO SINCOPADO (AHORA sigue el acorde: D·D·Bb·A) ── +const bajo = note("<[d2 ~ [~ d2] a1] [d2 ~ [~ d2] a1] [bb1 ~ [~ bb1] f1] [a1 ~ [~ a1] e1]>") + .s("sawtooth").coarse(2).lpf(perlin.slow(4).range(600, 1100)).lpq(6) + .attack(.001).decay(.14).sustain(.2).release(.04) + .shape(.32).gain(.9).orbit(1) + +const bajoVar = note("<[d2 ~ [~ d2] [a1 c2]] [d2 ~ [~ d2] [a1 c2]] [bb1 ~ [~ bb1] [f1 a1]] [a1 ~ [~ a1] [e1 g1]]>") + .s("sawtooth").coarse(2).lpf(perlin.slow(4).range(650, 1150)).lpq(6) + .attack(.001).decay(.14).sustain(.2).release(.04) + .shape(.32).gain(.9).orbit(1) + +// ── SUB-BAJO afinado que SIGUE la fundamental (D·D·Bb·A) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.18).release(.04).gain(.55).orbit(1) + +// ── BAJO OFFBEAT (rompe el patrón) solo en los drops grandes ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.36).duck("1").orbit(1) // ── VOZ ROBÓTICA (números hablados triturados) ── const robot = s("numbers").n("<0 1 2 3>").crush(6).lpf(2000) @@ -2804,41 +3965,50 @@ const robot = s("numbers").n("<0 1 2 3>").crush(6).lpf(2000) const piano = note("[d3,f3,a3] ~ [c3,e3,g3] ~").slow(2).s("piano") .crush(8).room(.5).gain(.5).orbit(3) -// ── BATERÍA ELECTRO 808 (patrón roto, nada de 4x4) ── -const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").shape(.35).gain(1.05) +// ── BATERÍA ELECTRO 808: kick 2 capas (click 808 + boom afinado), patrón roto ── +const kickClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").hpf(38).shape(.35).gain(.92) .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0) +const kickBoom = note("").struct("x ~ ~ x ~ ~ x ~").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kick = stack(kickClick, kickBoom) const snare = s("~ ~ sd ~ ~ ~ sd ~").bank("RolandTR808").gain(.8).orbit(0) const rimGhost = s("[~ rim]*4").bank("RolandTR808") .gain(rand.range(.15,.4)).pan(rand.range(.3,.7)).orbit(0) -const hats = s("hh*8").bank("RolandTR808").gain("[.5 .25]*4").crush(8).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR808") - .gain("[.45 .2 .3 .2]*4").crush(8).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0) +const hats = s("hh*8").bank("RolandTR808").swingBy(1/24,8).gain("[.5 .25]*4").crush(8).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR808").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).crush(8).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR808").nudge(.004).gain(.4).orbit(0) const toms = s("~ ~ ~ ~ ~ ~ [mt lt] ~").bank("RolandTR808").gain(.55).pan(.35).orbit(0) +// ghost snare sincopada +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PAD MINIMAL ── -const pad = note("<[d3,f3,a3] [d3,f3,a3] [bb2,d3,f3] [a2,c3,e3]>") - .s("sawtooth").lpf(550).attack(1).release(1.6) +// ── PAD MINIMAL (7as/9as + hi-pass) ── +const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [bb2,d3,f3,a3] [a2,c3,e3,g3]>") + .s("sawtooth").lpf(550).hpf(150).attack(1).release(1.6) .room(.6).rsize(6).gain(.32).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) -const introB = stack(kick, snare.gain(.5), hats, bajo.lpf(400).gain(.6)) -const build = stack(kick, snare, hats16, rimGhost, bajo, - trompeta.lpf(saw.slow(16).range(500, 2100)).gain(.55)) -const dropA = stack(kick, snare, hats, hatsOpen, rimGhost, bajo, bajoSub, trompeta) -const dropAvar = stack(kick, snare, hats16, hatsOpen, rimGhost, toms, - bajoVar, bajoSub, trompeta, trompetaBaja) +const introB = stack(kick, snare.gain(.5), hats, bajoSub.gain(.5), bajo.lpf(400).gain(.6)) +const build = stack(kick, snare, hats16, rimGhost, ghost, bajo, bajoSub, riser, + trompeta.lpf(saw.slow(16).range(500, 2100)).gain(.55), leadLimpio.gain(.45)) +const dropA = stack(kick, snare, hats, hatsOpen, rimGhost, ghost, bajo, bajoSub, trompeta, leadLimpio, contra) +const dropAvar = stack(kick, snare, hats16, hatsOpen, rimGhost, ghost, toms, + bajoVar, bajoSub, bajoOff, trompeta, trompetaBaja, leadLimpio, contra) const breakRobot = stack(pad, robot, piano, trompeta.gain(.5).room(.6), - hats.gain(.25)) -const breakBuild = stack(pad, trompeta.gain(.7), robot, hats16.gain(.35), + hats.gain(.25), leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, trompeta.gain(.7), robot, riser, hats16.gain(.35), bajo.gain(.6)) -const dropB = stack(kick, snare, hats16, hatsOpen, rimGhost, toms, - bajo, bajoSub, trompeta, robot.gain(.35)) -const dropBfull = stack(kick, snare, hats16, hatsOpen, rimGhost, toms, - bajoVar, bajoSub, trompeta, trompetaBaja, piano.gain(.3)) +const dropB = stack(kick, snare, hats16, hatsOpen, rimGhost, ghost, toms, + bajo, bajoSub, trompeta, robot.gain(.35), leadLimpio, contra) +const dropBfull = stack(kick, snare, hats16, hatsOpen, rimGhost, ghost, toms, + bajoVar, bajoSub, bajoOff, trompeta, trompetaBaja, piano.gain(.3), leadLimpio, contra) const coda = stack(kick, hats, bajo.lpf(450).gain(.65), - trompeta.gain(.45).room(.6), pad) + trompeta.gain(.45).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.3), trompeta.gain(.3).room(.8).delayfeedback(.6), pad.gain(.25)) @@ -2855,25 +4025,36 @@ arrange( [16, dropBfull], [12, coda], [8, codaFin] -)`, +) +`, }, { name: "30 · around the world — daft punk (1997)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 30 · AROUND THE WORLD — Daft Punk (1997) → French Techno Remix -// 121 BPM · Am · TR-909 · el bajo es el rey · todo respira con el filtro lento +// 121 BPM · Am (i·VII·VI·VII = Am·G·F·G) · TR-909 · el bajo es el rey +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue A-G-F), +// bajo rey + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity, +// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido. // Estructura: intro→build→drop A→break filtrado→drop B→coda (144 compases ≈ 4:46) // ════════════════════════════════════════════════════════════════ setcps(121/60/4) -// ── EL BAJO REY (línea exacta, filter house francés) ── -const bajo = note("a1 a2 g2 a2 e2 g2 a1 ~") +// ── EL BAJO REY (groove filter-house, AHORA sigue el acorde: Am·G·F·G) ── +const bajo = note("<[a1 a2 g2 a2 e2 g2 a1 ~] [g1 g2 f2 g2 d2 f2 g1 ~] [f1 f2 e2 f2 c2 e2 f1 ~] [g1 g2 f2 g2 d2 f2 g1 ~]>") .s("sawtooth").lpf(sine.slow(32).range(320, 1700)).lpq(6) .attack(.001).decay(.2).sustain(.35).release(.05) - .shape(.3).gain(.95).orbit(1) + .shape(.32).coarse(1).gain(.95).orbit(1) -const bajoSub = note("a1*4").s("sine").decay(.3).sustain(.2).gain(.55).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (A·G·F·G) ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.2).release(.04).gain(.55).orbit(1) + +// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) // ── EL VOCODER (interpretación, vocales sintéticas que respiran) ── const vocoder = note("e4 e4 d4 c4 d4 e4 ~ ~") @@ -2885,54 +4066,84 @@ const vocoder = note("e4 e4 d4 c4 d4 e4 ~ ~") const vocoderAlto = vocoder.add(note(12)).gain(.28).orbit(2) -// ── STAB FUNKY (acorde filtrado, discoteca francesa) ── +// ── LEAD LIMPIO (la melodía real -vocoder-, nítida y al frente) ── +const leadLimpio = note("e4 e4 d4 c4 d4 e4 ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (Am7·G7·Fmaj7·G7) + hi-pass ── +const stabArm = note("<[a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── STAB FUNKY (acorde filtrado, discoteca francesa) + hi-pass ── const stab = note("~ [a3,c4,e4] ~ [a3,c4,e4] ~ ~ [g3,b3,d4] ~") - .s("sawtooth").lpf(sine.slow(16).range(500, 2200)).lpq(7) + .s("sawtooth").lpf(sine.slow(16).range(500, 2200)).lpq(7).hpf(160) .attack(.002).decay(.14).sustain(.05).release(.05) .phaser(2).phaserdepth(.5) .gain(.55).pan(.4).orbit(3) -// ── BATERÍA FRANCESA (hats con phaser, groove disco) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// ── BATERÍA FRANCESA: kick 2 capas (click 909 + boom afinado que sigue A-G-F) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.4).gain(.92) .duck("1:2").duckattack(.13).duckdepth(.6).orbit(0) -const kickFuerte = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.08) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickFuerteClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).distort(1.1).gain(.95) .duck("1:2").duckattack(.13).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickFuerte = stack(kickFuerteClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.7).orbit(0) -const hatsPhaser = s("[~ hh]*4").bank("RolandTR909") +const hatsPhaser = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8) .phaser(4).phaserdepth(.7).gain(.55).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .38 .25]*4").phaser(2).phaserdepth(.5) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).phaser(2).phaserdepth(.5) .pan(rand.range(.35,.65)).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.8)).speed(saw.slow(4).range(1,1.35)).orbit(0) +// ghost snare sincopada +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PAD QUE RESPIRA (Am→G→F→G) ── -const pad = note("<[a2,c3,e3] [g2,b2,d3] [f2,a2,c3] [g2,b2,d3]>") - .s("sawtooth").lpf(sine.slow(32).range(400, 1200)).attack(.9).release(1.6) +// ── PAD QUE RESPIRA (Am→G→F→G, 7as/9as + hi-pass) ── +const pad = note("<[a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .s("sawtooth").lpf(sine.slow(32).range(400, 1200)).hpf(150).attack(.9).release(1.6) .room(.6).rsize(6).gain(.36).orbit(4) // ── SECCIONES ── const intro = stack(kick, hatsPhaser, bajoSub.gain(.4)) -const introB = stack(kick, hatsPhaser, hatsOpen, clap.gain(.5), +const introB = stack(kick, hatsPhaser, hatsOpen, clap.gain(.5), bajoSub.gain(.5), bajo.lpf(sine.slow(32).range(250, 700)).gain(.7)) -const build = stack(kick, hats16, clap, bajo, stab.gain(.4), +const build = stack(kick, hats16, clap, ghost, bajo, bajoSub, stab.gain(.4), riser, vocoder.lpf(saw.slow(16).range(400, 2200)).gain(.5)) -const buildFin = stack(kickFuerte, rodillo, bajo, vocoder.gain(.6)) -const dropA = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub, vocoder, stab) -const dropAvar = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub, - vocoder, vocoderAlto, stab, pad.gain(.24)) +const buildFin = stack(kickFuerte, rodillo, riser, bajo, bajoSub, vocoder.gain(.6)) +const dropA = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, vocoder, stab, leadLimpio, stabArm) +const dropAvar = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, bajoOff, + vocoder, vocoderAlto, stab, pad.gain(.24), leadLimpio, stabArm, contra) const breakFiltro = stack(bajo.lpf(sine.slow(8).range(200, 900)).gain(.85), - vocoder.gain(.55).room(.6), pad, hatsPhaser.gain(.3)) -const breakBuild = stack(bajo, vocoder.gain(.7), pad, rodillo, hats16.gain(.4)) -const dropB = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub, - vocoder, vocoderAlto, stab) -const dropBfull = stack(kickFuerte, hats16, hatsOpen, clap, + vocoder.gain(.55).room(.6), pad, hatsPhaser.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(bajo, vocoder.gain(.7), pad, rodillo, riser, hats16.gain(.4)) +const dropB = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, + vocoder, vocoderAlto, stab, leadLimpio, stabArm) +const dropBfull = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajoOff, bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, - vocoder, vocoderAlto, stab, pad.gain(.26)) -const dropFinal = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub, - vocoder, stab, pad.gain(.24)) -const coda = stack(kick, hatsPhaser, bajo.gain(.8), vocoder.gain(.45).room(.7), pad) + vocoder, vocoderAlto, stab, pad.gain(.26), leadLimpio, stabArm, contra) +const dropFinal = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, bajoOff, + vocoder, stab, pad.gain(.24), leadLimpio, stabArm) +const coda = stack(kick, hatsPhaser, bajo.gain(.8), bajoSub.gain(.5), vocoder.gain(.45).room(.7), pad, leadLimpio.gain(.4)) const codaFin = stack(hatsPhaser.gain(.35), bajo.lpf(400).gain(.6), vocoder.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3)) @@ -2951,14 +4162,18 @@ arrange( [12, dropFinal], [8, coda], [8, codaFin] -)`, +) +`, }, { name: "31 · 9pm (till i come) — atb (1998)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 31 · 9PM (TILL I COME) — ATB (1998) → Progressive Trance Remix -// 132 BPM · F#m · TR-909 · pluck-guitarra con pitch bend (penv) + bajo rolling +// 132 BPM · F#m (i·VI·III·VII = F#m·D·A·E) · TR-909 · pluck-guitarra con pitch bend +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue F#-D-A-E), +// bajo rolling + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity, +// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido. // Estructura: intro→hook→build→drop A→break flotante→drop B→coda (152 compases ≈ 4:36) // ════════════════════════════════════════════════════════════════ setcps(132/60/4) @@ -2973,34 +4188,70 @@ const hook = note("cs5 ~ d5 cs5 ~ b4 cs5 ~ e5 ~ cs5 ~ b4 ~ a4 b4") const hookGrave = hook.add(note(-12)).gain(.3).lpf(1800).orbit(2) const hookFlotante = hook.slow(2).gain(.6).room(.85).rsize(8).delayfeedback(.6).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("cs5 ~ d5 cs5 ~ b4 cs5 ~ e5 ~ cs5 ~ b4 ~ a4 b4") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as/9as (F#m7·Dmaj7·Amaj7·Eadd9) + hi-pass ── +const stab = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,fs4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ b4 ~ gs4 ~ e4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── BAJO ROLLING SUAVE (16avos, sigue F#m→D→A→E) ── const bajo = note("fs1*16").add(note("<0 -4 3 -2>")) - .s("sawtooth").lpf(820).lpq(5) + .s("sawtooth").lpf(perlin.slow(4).range(600, 1100)).lpq(5) .attack(.001).decay(.09).sustain(.15).release(.03) - .shape(.25).gain("[.8 .42 .58 .42]*4").orbit(1) + .shape(.34).coarse(1).gain("[.8 .42 .58 .42]*4").orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (F#·D·A·E) ── const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine") - .decay(.3).sustain(.18).gain(.6).orbit(1) + .attack(.002).decay(.26).sustain(.18).release(.04).gain(.6).orbit(1) -// ── BATERÍA 909 ELEGANTE (shaker agudo con pan aleatorio) ── -const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02) +// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── BATERÍA 909 ELEGANTE: kick 2 capas (click 909 + boom afinado que sigue F#-D-A-E) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.35).gain(.9) .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0) -const kickDrop = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickDropClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickDrop = stack(kickDropClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.68).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.48 .22 .34 .22]*4").pan(rand.range(.35,.65)).orbit(0) -const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) const shaker = s("hh*16").bank("RolandTR909").speed(1.8).hpf(7000) .gain(rand.range(.15,.38)).pan(rand.range(.25,.75)).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.18,.8)).speed(saw.slow(4).range(1,1.4)).orbit(0) +// ghost snare sincopada +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) -// ── PADS FLOTANTES ── -const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>") +// ── PADS FLOTANTES (7as/9as + hi-pass) ── +const pad = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,fs4]>") .s("supersaw").unison(5).spread(.8) - .lpf(sine.slow(32).range(500, 1900)).attack(.8).release(1.8) + .lpf(sine.slow(32).range(500, 1900)).hpf(150).attack(.8).release(1.8) .room(.8).rsize(8).gain(.36).orbit(4) const colchon = note("").s("sine").attack(1).release(2) @@ -3008,23 +4259,23 @@ const colchon = note("").s("sine").attack(1).release(2) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) -const introB = stack(kick, hats, hatsOpen, clap.gain(.45), bajo.lpf(400).gain(.6)) +const introB = stack(kick, hats, hatsOpen, clap.gain(.45), bajoSub.gain(.5), bajo.lpf(400).gain(.6)) const hookIntro = stack(kick, hats, bajoSub.gain(.5), hook.lpf(saw.slow(8).range(600, 3200)).gain(.6)) -const build = stack(kick, hats16, clap, shaker.gain(.2), bajo, hook, pad.gain(.28)) -const buildFin = stack(kickDrop, rodillo, bajo, hook.gain(.65)) -const dropA = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub, hook) -const dropAvar = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub, - hook, hookGrave, pad.gain(.26)) +const build = stack(kick, hats16, clap, shaker.gain(.2), ghost, bajo, bajoSub, riser, hook, pad.gain(.28)) +const buildFin = stack(kickDrop, rodillo, riser, bajo, bajoSub, hook.gain(.65)) +const dropA = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajo, bajoSub, hook, leadLimpio, stab) +const dropAvar = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajo, bajoSub, bajoOff, + hook, hookGrave, pad.gain(.26), leadLimpio, stab, contra) const breakFlotante = stack(pad, colchon, hookFlotante, bajoSub.gain(.3), - hats.gain(.25)) -const breakBuild = stack(pad, colchon, hook.gain(.75), rodillo, hats16.gain(.38)) -const dropB = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub, - hook, hookGrave) -const dropBfull = stack(kickDrop, hats16, hatsOpen, clap, shaker, + hats.gain(.25), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, colchon, hook.gain(.75), rodillo, riser, hats16.gain(.38)) +const dropB = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajo, bajoSub, + hook, hookGrave, leadLimpio, stab) +const dropBfull = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajoOff, bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.45)), bajoSub, - hook, hookGrave, pad.gain(.28), colchon.gain(.22)) -const coda = stack(kick, hats, bajo.lpf(500).gain(.65), hook.gain(.5).room(.7), pad) + hook, hookGrave, pad.gain(.28), colchon.gain(.22), leadLimpio, stab, contra) +const coda = stack(kick, hats, bajo.lpf(500).gain(.65), bajoSub.gain(.5), hook.gain(.5).room(.7), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.35), hookFlotante.gain(.4), pad.gain(.3), colchon.gain(.25)) @@ -3043,14 +4294,16 @@ arrange( [16, dropBfull], [16, coda], [8, codaFin] -)`, +) +`, }, { name: "32 · encore une fois — sash! (1996)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 32 · ENCORE UNE FOIS — Sash! (1996) → Happy Hard Techno Remix -// 140 BPM · Am · TR-909 · piano offbeat + supersaw eufórica + doble clap +// 140 BPM · Am (Am·F·C·G = raices a f c g) · TR-909 · piano offbeat euforico +// PRO: kick 2 capas + boom afinado (a f c g) · bajo sigue acordes · groove swing/ghost · 7as/9as · riser // Estructura: intro→build→PAUSA→drop A→break piano→PAUSA→drop B→coda (134 compases ≈ 3:50) // ════════════════════════════════════════════════════════════════ setcps(140/60/4) @@ -3064,6 +4317,26 @@ const hook = note("a4 ~ a4 g4 a4 c5 a4 g4 a4 e4 ~ ~ g4 a4 g4 ~") const hookOctava = hook.add(note(12)).gain(.3).lpf(4200).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("a4 ~ a4 g4 a4 c5 a4 g4 a4 e4 ~ ~ g4 a4 g4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (Am·F·C·G) + contramelodía ── +const stab = note("<[a3,c4,e4,g4] [f3,a3,c4,e4] [c4,e4,g4,b4] [g3,b3,d4,f4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── PIANO OFFBEAT (el rebote eufórico del happy hard, Am F C G) ── const piano = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>") .struct("~ x ~ x ~ x ~ x").s("piano").clip(.6) @@ -3075,47 +4348,62 @@ const bajo = note("~ a1 ~ a1 ~ a1 ~ a1").add(note("<0 -4 3 -2>")) .attack(.001).decay(.18).sustain(.15).release(.05) .shape(.35).gain(.9).orbit(1) -const bajoSub = note("").s("sine") +const bajoSub = note("").s("sine") .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1) -// ── BATERÍA 909 (kick duro, DOBLE clap, rodillos constantes) ── -const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05) - .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1) - .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y", sigue el acorde) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) + +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue el acorde ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) +// ── DOBLE clap + rodillos ── const dobleClap = s("~ [cp cp] ~ [cp cp]").bank("RolandTR909") .room(.3).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.55).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.55 .25 .4 .25]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.45).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.55).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0) const rodilloCorto = s("sd*16").bank("RolandTR909") .gain(saw.slow(2).range(.3,.95)).hpf(250).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) // ── PAD (colchón mayor eufórico) ── -const pad = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>") - .s("sawtooth").lpf(800).attack(.6).release(1.2) +const pad = note("<[a3,c4,e4,g4] [f3,a3,c4,e4] [c4,e4,g4,b4] [g3,b3,d4,f4]>") + .s("sawtooth").lpf(800).hpf(150).attack(.6).release(1.2) .room(.7).rsize(7).gain(.4).orbit(4) +// riser de ruido filtrado para las subidas +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.35)) const introB = stack(kick, hats, open, dobleClap.gain(.4), bajo.lpf(500).gain(.7)) -const build = stack(kick, hats16, dobleClap, bajo, piano, +const build = stack(kick, hats16, dobleClap, ghost, bajo, piano, hook.lpf(saw.slow(16).range(400,2600)).gain(.55)) -const buildFin = stack(kickHard, rodillo, bajo, piano, hook.gain(.7)) -const dropA = stack(kickHard, hats16, open, dobleClap, bajo, bajoSub, piano, hook, hookOctava) -const dropAvar = stack(kickHard, hats16, open, dobleClap, ride, bajo, bajoSub, piano, - hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3)) +const buildFin = stack(kickHard, rodillo, riser, bajo, piano, hook.gain(.7)) +const dropA = stack(kickHard, hats16, open, dobleClap, ghost, bajo, bajoSub, piano, hook, hookOctava, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, dobleClap, ghost, ride, bajo, bajoSub, bajoOff, piano, + hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), leadLimpio, stab, contra) const breakPiano = stack(piano.gain(.85).room(.6), pad, hook.gain(.5).room(.75), - hats.gain(.3), bajoSub.gain(.35)) -const breakBuild = stack(piano, pad, hook.gain(.7), rodilloCorto, kick.gain(.95), bajo) -const dropB = stack(kickHard, hats16, open, dobleClap, bajo, bajoSub, piano, hook, hookOctava, ride) -const dropBFull = stack(kickHard, hats16, open, dobleClap, ride, bajo, bajoSub, - piano, hook, hookOctava, pad.gain(.35), rodillo.gain(.35)) -const coda = stack(kick, hats, dobleClap.gain(.5), piano.gain(.6), hook.gain(.45).room(.7), pad) + hats.gain(.3), bajoSub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(piano, pad, hook.gain(.7), rodilloCorto, riser, kick.gain(.95), bajo) +const dropB = stack(kickHard, hats16, open, dobleClap, ghost, bajo, bajoSub, piano, hook, hookOctava, ride, leadLimpio, stab) +const dropBFull = stack(kickHard, hats16, open, dobleClap, ghost, ride, bajo, bajoSub, bajoOff, + piano, hook, hookOctava, pad.gain(.35), rodillo.gain(.35), leadLimpio, stab, contra) +const coda = stack(kick, hats, dobleClap.gain(.5), piano.gain(.6), hook.gain(.45).room(.7), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.35), hook.gain(.3).room(.9).delayfeedback(.65), pad.gain(.35)) // ── ARREGLO (134 compases, con las dos PAUSAS de silencio total) ── @@ -3134,14 +4422,16 @@ arrange( [16, dropBFull], [12, coda], [4, codaFin] -)`, +) +`, }, { name: "33 · flat beat — mr. oizo (1999)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 33 · FLAT BEAT — Mr. Oizo (1999) → Electro Bass Remix -// 128 BPM · Fm · TR-808 · el bajo wah ES el track · groove roto y funky +// 128 BPM · Fm (Fm·Fm·Fm·Eb = raices f f f eb) · TR-808 · el bajo wah ES el track +// PRO: kick 2 capas + boom afinado que sigue el kick roto (f/eb) · sub sigue acordes · Fm9 · riser // Estructura: intro→bajo wah→groove→stabs FM→solo bajo→contramelodía→groove final (132 compases ≈ 4:07) // ════════════════════════════════════════════════════════════════ setcps(128/60/4) @@ -3155,16 +4445,26 @@ const bajo = note("f1 f1 ~ f1 ~ f1 eb1 f1") const bajoOctava = bajo.add(note(12)).gain(.28) .lpf(sine.slow(2).range(300,1600)).orbit(3) -const sub = note("f1").s("sine").attack(.02).decay(.6).sustain(.35) +const sub = note("").s("sine").attack(.02).decay(.6).sustain(.35) .gain(.4).orbit(1) +// ── BAJO OFFBEAT (textura sintetica en las "y", sigue el acorde) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.32).duck("1").orbit(1) + // ── PERCUSIÓN 808 (mínima pero groovy: kick roto con huecos) ── -const kick = s("bd ~ [~ bd] ~ bd ~ ~ ~").bank("RolandTR808") - .shape(.4).gain(1.05).duck("2:3").duckattack(.08).duckdepth(.4).orbit(0) +// KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado que sigue el kick roto +const kickClick = s("bd ~ [~ bd] ~ bd ~ ~ ~").bank("RolandTR808") + .hpf(38).shape(.5).gain(.95).duck("2:3").duckattack(.08).duckdepth(.4).orbit(0) +const kickBoom = note("").struct("x ~ [~ x] ~ x ~ ~ ~").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(.92).orbit(0) +const kick = stack(kickClick, kickBoom) const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.7).orbit(0) const ghost = s("[~ sd]*4").bank("RolandTR808").degradeBy(.7).gain(.25).hpf(300).orbit(0) const hats = s("[~ hh] [hh ~] [~ hh] [hh hh]").bank("RolandTR808") - .gain(.5).pan(.6).orbit(0) + .swingBy(1/24,8).gain(.5).pan(.6).orbit(0) const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0) const rim = s("~ ~ rim ~ ~ rim ~ ~").bank("RolandTR808").gain(.4).pan(.35).orbit(0) const toms = s("~ ~ ~ ~ ~ ~ [mt lt] ~").bank("RolandTR808") @@ -3182,21 +4482,31 @@ const contra = note("c4 ~ ab3 bb3").s("triangle") .delay(.3).delaytime(.375).delayfeedback(.4) .room(.4).gain(.7).orbit(2) +// ── PAD CÁLIDO (colchón Fm·Eb sutil que llena la zona media sin romper el funk) ── +const padCalido = note("<[f2,ab2,c3,g3]!3 [eb2,g2,bb2,f3]>") + .s("sawtooth").lpf(sine.slow(24).range(400, 950)).lpq(3) + .attack(.9).release(1.6).shape(.12).hpf(160) + .room(.6).rsize(7).gain(.28).pan(.5) + .duck("2:3").duckdepth(.35).orbit(4) +// riser de ruido filtrado para las transiciones +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) + // ── SECCIONES ── const intro = stack(kick, hats) const introB = stack(kick, hats, snare, rim) const bajoIn = stack(kick, hats, snare, bajo.lpf(sine.slow(4).range(80,500)).gain(.85)) -const grooveA = stack(kick, hats, open, snare, ghost, bajo, sub) -const grooveStabs = stack(kick, hats, open, snare, ghost, rim, bajo, sub, stabs) +const grooveA = stack(kick, hats, open, snare, ghost, bajo, sub, padCalido.gain(.2)) +const grooveStabs = stack(kick, hats, open, snare, ghost, rim, bajo, sub, stabs, padCalido.gain(.22)) const soloBajo = stack(bajo.lpf(sine.slow(1).range(100,1400)).gain(1), hats.gain(.25), toms, sub) -const grooveB = stack(kick, hats, open, snare, ghost, bajo, sub, contra) +const grooveB = stack(kick, hats, open, snare, ghost, bajo, sub, contra, padCalido.gain(.22)) const grooveBFull = stack(kick, hats, open, snare, ghost, rim, toms, - bajo, bajoOctava, sub, contra, stabs) -const breakFm = stack(stabs.gain(.7), contra.gain(.5).room(.7), hats.gain(.3), sub) -const grooveFinal = stack(kick, hats, open, snare, ghost, rim, bajo, bajoOctava, sub, - contra.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), stabs) -const coda = stack(kick, hats, bajo.gain(.8), sub) + bajo, bajoOctava, bajoOff, sub, contra, stabs, padCalido.gain(.25)) +const breakFm = stack(stabs.gain(.7), contra.gain(.5).room(.7), hats.gain(.3), riser, sub, padCalido.gain(.3)) +const grooveFinal = stack(kick, hats, open, snare, ghost, rim, bajo, bajoOctava, bajoOff, sub, + contra.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), stabs, padCalido.gain(.25)) +const coda = stack(kick, hats, bajo.gain(.8), sub, padCalido.gain(.22)) const fin = stack(bajo.lpf(300).gain(.7), hats.gain(.25)) // ── ARREGLO (132 compases) ── @@ -3213,14 +4523,16 @@ arrange( [16, grooveFinal], [8, coda], [4, fin] -)`, +) +`, }, { name: "34 · kernkraft 400 — zombie nation (1999)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 34 · KERNKRAFT 400 — Zombie Nation (1999) → Rave Techno Remix -// 140 BPM · Em · TR-909 · el himno de estadio · multitud de ruido blanco +// 140 BPM · Em (Em·C·Am·Bm = raices e c a b) · TR-909 · himno de estadio +// PRO: kick 2 capas + boom afinado (e c a b) · bajo/sub siguen acordes · groove swing/ghost · 7as · riser // Estructura: intro→build→drop A→break piano→drop B→drop final→coda (152 compases ≈ 4:21) // ════════════════════════════════════════════════════════════════ setcps(140/60/4) @@ -3238,16 +4550,40 @@ const leadSaw = melodia.s("sawtooth").lpf(2200) const leadOctava = melodia.add(note(12)).s("square").crush(7).lpf(4200) .gain(.3).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("<[e4 g4 e4 d4 e4 c4 d4 b3] [e4 g4 e4 a4 g4 e4 d4 c4]>") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (Em·C·Am·Bm) + contramelodía ── +const stab = note("<[e3,g3,b3,d4] [c3,e3,g3,b3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ b4 ~ g4 ~ e4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── PIANO (para el breakdown de estadio) ── const piano = melodia.s("piano").clip(.9).lpf(3000) .room(.6).rsize(6).gain(.85).orbit(3) // ── BAJO (corcheas motrices en Em) ── -const bajo = note("e1!8").s("sawtooth") +const bajo = note("").s("sawtooth") .lpf(perlin.slow(4).range(400,1000)).lpq(6) .attack(.001).decay(.12).sustain(.25).release(.04) .shape(.35).gain("[.95 .7]*4").orbit(1) -const sub = note("e1*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1) +const sub = note("").struct("x*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) // ── LA MULTITUD (ruido blanco con vocales = coros de estadio) ── const multitud = s("white").struct("~ x ~ x").vowel("a") @@ -3257,43 +4593,51 @@ const estadio = s("white").vowel("").attack(.8).release(1) .lpf(1800).hpf(200).gain(.25).room(.8).rsize(8).orbit(4) // ── BATERÍA 909 (kick ENORME) ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) -const kickEnorme = s("bd*4").bank("RolandTR909").shape(.65).distort(1.3).gain(1.12) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickEnormeClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.65).distort(1.3).gain(.95) .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickEnorme = stack(kickEnormeClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.55 .25 .4 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.45).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0) const tomsRave = s("~ ~ ~ [ht mt lt lt]").bank("RolandTR909") .gain(.6).mask("<0 0 0 1>").orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.4)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD (Em C Am B) ── -const pad = note("<[e3,g3,b3] [c3,e3,g3] [a2,c3,e3] [b2,d3,fs3]>") - .s("sawtooth").lpf(700).attack(.7).release(1.4) +// ── PAD (Em C Am B con 7as) ── +const pad = note("<[e3,g3,b3,d4] [c3,e3,g3,b3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>") + .s("sawtooth").lpf(700).hpf(150).attack(.7).release(1.4) .room(.7).rsize(8).gain(.4).orbit(4) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.4)) const introB = stack(kick, hats, clap, bajo.lpf(450).gain(.7)) -const build = stack(kick, hats16, clap, bajo, +const build = stack(kick, hats16, clap, ghost, bajo, leadSq.lpf(saw.slow(16).range(350,2800)).gain(.55)) -const buildFin = stack(kickEnorme, rodillo, bajo, leadSq.gain(.75)) -const dropA = stack(kickEnorme, hats16, open, clap, bajo, sub, leadSq, leadSaw, multitud) -const dropAvar = stack(kickEnorme, hats16, open, clap, ride, tomsRave, - bajo, sub, leadSq, leadSaw, leadOctava, multitud) -const breakPiano = stack(piano, pad, estadio, hats.gain(.3), sub.gain(.35)) -const breakBuild = stack(piano, pad, rodillo, kick.gain(.95), bajo, estadio) -const dropB = stack(kickEnorme, hats16, open, clap, bajo, sub, leadSq, leadSaw, leadOctava) -const dropBFull = stack(kickEnorme, hats16, open, clap, ride, bajo, sub, - leadSq, leadSaw, leadOctava, multitud, estadio) -const dropFinal = stack(kickEnorme, hats16, open, clap, ride, tomsRave, bajo, sub, - leadSq.sometimesBy(.25, x=>x.add(note(12))), leadSaw, multitud, pad.gain(.3)) -const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(600).gain(.7), piano.gain(.5), pad) +const buildFin = stack(kickEnorme, rodillo, riser, bajo, leadSq.gain(.75)) +const dropA = stack(kickEnorme, hats16, open, clap, ghost, bajo, sub, leadSq, leadSaw, multitud, leadLimpio, stab) +const dropAvar = stack(kickEnorme, hats16, open, clap, ghost, ride, tomsRave, + bajo, sub, bajoOff, leadSq, leadSaw, leadOctava, multitud, leadLimpio, stab, contra) +const breakPiano = stack(piano, pad, estadio, hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(piano, pad, rodillo, riser, kick.gain(.95), bajo, estadio) +const dropB = stack(kickEnorme, hats16, open, clap, ghost, bajo, sub, leadSq, leadSaw, leadOctava, leadLimpio, stab) +const dropBFull = stack(kickEnorme, hats16, open, clap, ghost, ride, bajo, sub, bajoOff, + leadSq, leadSaw, leadOctava, multitud, estadio, leadLimpio, stab, contra) +const dropFinal = stack(kickEnorme, hats16, open, clap, ghost, ride, tomsRave, bajo, sub, bajoOff, + leadSq.sometimesBy(.25, x=>x.add(note(12))), leadSaw, multitud, pad.gain(.3), leadLimpio, stab) +const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(600).gain(.7), piano.gain(.5), pad, leadLimpio.gain(.4)) const fin = stack(hats.gain(.35), piano.gain(.4).room(.85), estadio.gain(.2)) // ── ARREGLO (152 compases) ── @@ -3311,14 +4655,16 @@ arrange( [16, dropFinal], [8, coda], [4, fin] -)`, +) +`, }, { name: "35 · café del mar — energy 52 (1993)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 35 · CAFÉ DEL MAR — Energy 52 (1993) → Classic Trance Remix -// 136 BPM · Am · TR-909 · la catedral trance · breakdown de 16 compases +// 136 BPM · Am (Am·Am·F·G = raices a a f g) · TR-909 · la catedral trance +// PRO: kick 2 capas + boom afinado (a a f g) · bajo/sub siguen acordes · groove swing/ghost · 7as · riser // Estructura: intro→arpegio→build→drop A→breakdown épico→drop B→coda (144 compases ≈ 4:14) // ════════════════════════════════════════════════════════════════ setcps(136/60/4) @@ -3342,6 +4688,26 @@ const melodiaEpica = melodia.s("supersaw").unison(7).spread(.8).detune(.2) .lpf(3500).gain(.8) const melodiaOctava = melodiaEpica.add(note(12)).gain(.3) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("e5 d5 c5 d5 e5 c5 a4 b4 c5 b4 a4 g4 a4 ~ ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (Am·F·G) + contramelodía ── +const stab = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── BAJO ROLLING (16avos con acentos, progresión Am Am F G) ── const bajo = note("a1!16").add(note("<0 0 -4 -2>")) .s("sawtooth").lpf(750).lpq(5) @@ -3349,46 +4715,58 @@ const bajo = note("a1!16").add(note("<0 0 -4 -2>")) .shape(.25).gain("[.9 .5 .65 .5]*4").orbit(1) const sub = note("").s("sine") .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) // ── BATERÍA 909 ── -const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05) - .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1) - .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .22 .38 .22]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.42).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.42).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.35).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.88)).speed(saw.slow(4).range(1,1.4)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── ATMÓSFERA (la catedral: reverbs enormes) ── -const pad = note("<[a2,c3,e3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>") - .s("sawtooth").lpf(650).attack(.9).release(1.8) +// ── ATMÓSFERA (la catedral: reverbs enormes, con 7as) ── +const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .s("sawtooth").lpf(650).hpf(150).attack(.9).release(1.8) .room(.8).rsize(9).gain(.4).orbit(4) const cuerdas = note("").s("supersaw").unison(5).spread(.6) .lpf(sine.slow(32).range(400,2000)).attack(.6).release(1) .room(.7).gain(.35).orbit(4) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.35)) const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(400).gain(.65)) const arpIn = stack(kick, hats, clap, bajo, arpegio.lpf(saw.slow(16).range(500,3200))) -const build = stack(kick, hats16, clap, bajo, arpegio, +const build = stack(kick, hats16, clap, ghost, bajo, arpegio, melodia.lpf(saw.slow(8).range(300,2000)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, arpegio, melodia.gain(.65)) -const dropA = stack(kickHard, hats16, open, clap, bajo, sub, arpegio, melodia) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, arpegio, melodia, cuerdas) +const buildFin = stack(kickHard, rodillo, riser, bajo, arpegio, melodia.gain(.65)) +const dropA = stack(kickHard, hats16, open, clap, ghost, bajo, sub, arpegio, melodia, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, ghost, ride, bajo, sub, bajoOff, arpegio, melodia, cuerdas, leadLimpio, stab, contra) const breakdown = stack(melodiaFlotante, pad, arpegio.gain(.5).room(.7), - cuerdas.gain(.3), sub.gain(.3)) -const breakBuild = stack(melodiaFlotante, pad, arpegio, rodillo, hats16.gain(.4)) -const dropB = stack(kickHard, hats16, open, clap, bajo, sub, arpegio, melodiaEpica, melodiaOctava) -const dropBFull = stack(kickHard, hats16, open, clap, ride, bajo, sub, arpegio, - melodiaEpica, melodiaOctava, cuerdas) + cuerdas.gain(.3), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(melodiaFlotante, pad, arpegio, rodillo, riser, hats16.gain(.4)) +const dropB = stack(kickHard, hats16, open, clap, ghost, bajo, sub, arpegio, melodiaEpica, melodiaOctava, leadLimpio, stab) +const dropBFull = stack(kickHard, hats16, open, clap, ghost, ride, bajo, sub, bajoOff, arpegio, + melodiaEpica, melodiaOctava, cuerdas, leadLimpio, stab, contra) const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(550).gain(.7), - arpegio.gain(.5), melodia.gain(.45).room(.75), pad) + arpegio.gain(.5), melodia.gain(.45).room(.75), pad, leadLimpio.gain(.4)) const fin = stack(hats.gain(.3), arpegio.gain(.35).delayfeedback(.7), pad.gain(.35)) // ── ARREGLO (144 compases) ── @@ -3406,14 +4784,16 @@ arrange( [16, dropBFull], [8, coda], [4, fin] -)`, +) +`, }, { name: "36 · l'amour toujours — gigi d'agostino (1999)", folder: "remixes 90s", code: `// ════════════════════════════════════════════════════════════════ // 36 · L'AMOUR TOUJOURS — Gigi D'Agostino (1999) → Italo Techno Remix -// 139 BPM · F · TR-909 · lead italo de sierra fina + piano marcato + optimismo total +// 139 BPM · F (F·Bb·F·C = raices f bb f c) · TR-909 · lead italo + piano marcato +// PRO: kick 2 capas + boom afinado (f bb f c) · bajo/sub siguen acordes · groove swing/ghost · 7as · riser // Estructura: intro→build→drop A→break piano→drop B→drop final→coda (144 compases ≈ 4:09) // ════════════════════════════════════════════════════════════════ setcps(139/60/4) @@ -3426,12 +4806,36 @@ const hook = note("a4 ~ bb4 a4 g4 f4 g4 ~ a4 ~ g4 f4 e4 f4 g4 ~") .room(.35).gain(.82).orbit(2) const hookOctava = hook.add(note(12)).gain(.28).lpf(4200).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("a4 ~ bb4 a4 g4 f4 g4 ~ a4 ~ g4 f4 e4 f4 g4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico (F·Bb·C) + contramelodía ── +const stab = note("<[f3,a3,c4,e4] [bb2,d3,f3,a3] [f3,a3,c4,e4] [c3,e3,g3,bb3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ c4 ~ a3 ~ f3 ~] [~ ~ f4 ~ d4 ~ bb3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ g4 ~ e4 ~ c4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── BAJO QUE BAILA (el salto de octava italo) ── -const bajo = note("f1 f2 c2 f1").s("sawtooth") +const bajo = note("<[f1 f2 c2 f1] [bb0 bb1 f1 bb0] [f1 f2 c2 f1] [c1 c2 g1 c1]>").s("sawtooth") .lpf(850).lpq(4).attack(.001).decay(.2).sustain(.2).release(.04) .shape(.3).gain(.95).orbit(1) const bajoBaile = bajo.ply(2).gain(.85) -const sub = note("f1*4").s("sine").decay(.3).sustain(.15).gain(.5).orbit(1) +const sub = note("").struct("x*4").s("sine").decay(.3).sustain(.15).gain(.5).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) // ── PIANO MARCATO (para los breaks, F Bb F C) ── const piano = note("<[f3,a3,c4] [f3,bb3,d4] [f3,a3,c4] [e3,g3,c4]>") @@ -3439,43 +4843,51 @@ const piano = note("<[f3,a3,c4] [f3,bb3,d4] [f3,a3,c4] [e3,g3,c4]>") .lpf(3200).room(.45).gain(.8).orbit(3) // ── BATERÍA 909 ── -const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05) - .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.58).distort(1.1).gain(1.1) - .duck("1:2").duckattack(.1).duckdepth(.62).orbit(0) +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.58).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.42).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.58).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) + .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.42).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.35)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD (colchón mayor optimista) ── -const pad = note("<[f3,a3,c4] [bb2,d3,f3] [f3,a3,c4] [c3,e3,g3]>") - .s("sawtooth").lpf(750).attack(.7).release(1.3) +// ── PAD (colchón mayor optimista, con 7as) ── +const pad = note("<[f3,a3,c4,e4] [bb2,d3,f3,a3] [f3,a3,c4,e4] [c3,e3,g3,bb3]>") + .s("sawtooth").lpf(750).hpf(150).attack(.7).release(1.3) .room(.65).rsize(7).gain(.38).orbit(4) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, sub.gain(.35)) const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(450).gain(.7)) -const build = stack(kick, hats16, clap, bajo, piano.gain(.55), +const build = stack(kick, hats16, clap, ghost, bajo, piano.gain(.55), hook.lpf(saw.slow(16).range(400,2600)).gain(.55)) -const buildFin = stack(kickHard, rodillo, bajoBaile, hook.gain(.72)) -const dropA = stack(kickHard, hats16, open, clap, bajoBaile, sub, hook, hookOctava) -const dropAvar = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub, - hook, hookOctava, pad.gain(.3)) +const buildFin = stack(kickHard, rodillo, riser, bajoBaile, hook.gain(.72)) +const dropA = stack(kickHard, hats16, open, clap, ghost, bajoBaile, sub, hook, hookOctava, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, open, clap, ghost, ride, bajoBaile, sub, bajoOff, + hook, hookOctava, pad.gain(.3), leadLimpio, stab, contra) const breakPiano = stack(piano, pad, hook.gain(.5).room(.7), - hats.gain(.3), sub.gain(.35)) -const breakBuild = stack(piano, pad, hook.gain(.7), rodillo, kick.gain(.95), bajo) -const dropB = stack(kickHard, hats16, open, clap, bajoBaile, sub, hook, hookOctava, piano.gain(.5)) -const dropBFull = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub, - hook, hookOctava, piano.gain(.55), pad.gain(.32)) -const dropFinal = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub, - hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), rodillo.gain(.3)) + hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(piano, pad, hook.gain(.7), rodillo, riser, kick.gain(.95), bajo) +const dropB = stack(kickHard, hats16, open, clap, ghost, bajoBaile, sub, hook, hookOctava, piano.gain(.5), leadLimpio, stab) +const dropBFull = stack(kickHard, hats16, open, clap, ghost, ride, bajoBaile, sub, bajoOff, + hook, hookOctava, piano.gain(.55), pad.gain(.32), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, open, clap, ghost, ride, bajoBaile, sub, bajoOff, + hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), rodillo.gain(.3), leadLimpio, stab) const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.8), piano.gain(.6), - hook.gain(.45).room(.7), pad) + hook.gain(.45).room(.7), pad, leadLimpio.gain(.4)) const fin = stack(hats.gain(.32), hook.gain(.3).room(.85).delayfeedback(.6), pad.gain(.35)) // ── ARREGLO (144 compases) ── @@ -3493,14 +4905,16 @@ arrange( [16, dropFinal], [8, coda], [4, fin] -)`, +) +`, }, { name: "37 · one more time — daft punk (2000)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 37 · ONE MORE TIME — Daft Punk (2000) → Filter House Techno Remix -// 123 BPM · D · TR-909 · todo el drop respira por lpf+hpf · hats con swing +// 123 BPM · D (D·D·Bm·A = raices d d b a) · TR-909 · el drop respira por lpf+hpf +// PRO: kick 2 capas + boom afinado (d d b a) · bajo/sub siguen acordes · ghost · pad 9as · riser // Estructura: intro→build→drop filtrado A→breakdown→drop B→coda (136 compases ≈ 4:25) // ════════════════════════════════════════════════════════════════ setcps(123/60/4) @@ -3514,6 +4928,20 @@ const brass = note("d5 d5 c5 d5 ~ f5 ~ d5 c5 a4 c5 d5 ~ ~ ~ ~") .lpf(2400).lpq(2).room(.5).rsize(4).gain(.82).orbit(2) const brassOctava = brass.add(note(12)).gain(.25).orbit(2) +// ── LEAD LIMPIO (la fanfarria, nítida y al frente, FUERA del filtro que respira) ── +const leadLimpio = note("d5 d5 c5 d5 ~ f5 ~ d5 c5 a4 c5 d5 ~ ~ ~ ~") + .s("triangle").lpf(5200).lpq(1) + .attack(.005).decay(.2).sustain(.45).release(.16) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.58).pan(.5).orbit(2) + +// ── CONTRAMELODÍA (zona media, D·Bm·A) ── +const contra = note("<[~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ e4 ~ cs4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── BAJO DISCO (con la subida de octava, progresión D D B A) ── const bajo = note("d2 ~ d2 d3").add(note("<0 0 -3 -5>")) .s("sawtooth").lpf(900).lpq(3) @@ -3521,45 +4949,57 @@ const bajo = note("d2 ~ d2 d3").add(note("<0 0 -3 -5>")) .shape(.3).gain(.9).orbit(1) const sub = note("").s("sine") .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) // ── BATERÍA 909 (hats con swing francés) ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) - .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.52).distort(1.08).gain(1.08) +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) + .duck("1:2").duckattack(.12).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0) const hatsSwing = s("hh*8").bank("RolandTR909").swingBy(1/6, 8) .gain("[.5 .3]*4").pan(.6).orbit(0) const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/8, 8) - .gain("[.5 .22 .36 .22]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.42).orbit(0) + .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.42).orbit(0) const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.3)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD CON PHASER (movimiento constante, D D Bm A) ── -const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [b2,d3,fs3] [a2,cs3,e3]>") - .s("sawtooth").lpf(900).attack(.5).release(1.2) +// ── PAD CON PHASER (movimiento constante, D D Bm A con 9as) ── +const pad = note("<[d3,fs3,a3,e4] [d3,fs3,a3,e4] [b2,d3,fs3,a3] [a2,cs3,e3,b3]>") + .s("sawtooth").lpf(900).hpf(150).attack(.5).release(1.2) .phaser(.5).phaserdepth(.75).room(.6).rsize(6).gain(.4).orbit(4) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hatsSwing, sub.gain(.35)) const introB = stack(kick, hatsSwing, clap, bajo.lpf(500).gain(.7)) -const build = stack(kick, hats16, clap, bajo, pad, - brass.lpf(saw.slow(16).range(400,2400)).gain(.55)) -const buildFin = stack(kickHard, rodillo, bajo, brass.gain(.7)) -const dropA = stack(kickHard, hats16, open, clap, sub, - respira(stack(bajo, brass, brassOctava))) -const dropAfiltro = stack(kickHard, hats16, open, clap, ride, sub, - respira(stack(bajo, brass, brassOctava, pad.gain(.3)))) -const breakdown = stack(pad, brass.gain(.55).room(.75), hatsSwing.gain(.3), sub.gain(.35)) -const breakBuild = stack(pad, brass.gain(.7), rodillo, hats16.gain(.4), bajo) -const dropB = stack(kickHard, hats16, open, clap, sub, - respira(stack(bajo, brass.sometimesBy(.2, x=>x.add(note(12))), brassOctava))) -const dropBFull = stack(kickHard, hats16, open, clap, ride, sub, - respira(stack(bajo, brass, brassOctava, pad.gain(.32))), rodillo.gain(.25)) +const build = stack(kick, hats16, clap, ghost, bajo, pad, + brass.lpf(saw.slow(16).range(400,2400)).gain(.55), leadLimpio.gain(.5)) +const buildFin = stack(kickHard, rodillo, riser, bajo, brass.gain(.7), leadLimpio.gain(.55)) +const dropA = stack(kickHard, hats16, open, clap, ghost, sub, + respira(stack(bajo, brass, brassOctava)), leadLimpio, contra) +const dropAfiltro = stack(kickHard, hats16, open, clap, ghost, ride, sub, bajoOff, + respira(stack(bajo, brass, brassOctava, pad.gain(.3))), leadLimpio, contra) +const breakdown = stack(pad, brass.gain(.55).room(.75), hatsSwing.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, brass.gain(.7), rodillo, riser, hats16.gain(.4), bajo) +const dropB = stack(kickHard, hats16, open, clap, ghost, sub, + respira(stack(bajo, brass.sometimesBy(.2, x=>x.add(note(12))), brassOctava)), leadLimpio, contra) +const dropBFull = stack(kickHard, hats16, open, clap, ghost, ride, sub, bajoOff, + respira(stack(bajo, brass, brassOctava, pad.gain(.32))), rodillo.gain(.25), leadLimpio, contra) const coda = stack(kick, hatsSwing, clap.gain(.5), bajo.lpf(600).gain(.7), - brass.gain(.45).room(.7), pad) + brass.gain(.45).room(.7), pad, leadLimpio.gain(.4)) const fin = stack(hatsSwing.gain(.3), brass.gain(.3).room(.85), pad.gain(.35)) // ── ARREGLO (136 compases) ── @@ -3576,14 +5016,18 @@ arrange( [16, dropBFull], [8, coda], [4, fin] -)`, +) +`, }, { name: "38 · harder better faster stronger — daft punk (2001)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 38 · HARDER BETTER FASTER STRONGER — Daft Punk (2001) → Electro Techno Remix -// 123 BPM · Em · TR-808 · vocoder con vowel secuenciado + kick 3-3-2 + cortes stut +// 123 BPM · Em (i·III·i·VII = Em·G·Em·D) · TR-808 · vocoder con vowel secuenciado +// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado que sigue las raíces +// e·g·e·d) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing + +// ghost + armonía con 7as/9as e hi-pass + carácter DURO peak-time + riser de ruido. // Estructura: intro→build→drop A→breakdown→drop stut→coda (128 compases ≈ 4:10) // ════════════════════════════════════════════════════════════════ setcps(123/60/4) @@ -3596,52 +5040,92 @@ const hook = note("e4 e4 ~ e4 d4 e4 g4 ~ e4 d4 e4 ~ b3 ~ d4 ~") const hookRobot = hook.add(note(12)).vowel("[i o a e]*2").gain(.32).orbit(2) const hookStut = hook.every(4, x=>x.stut(4,.55,.0625)) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("e4 e4 ~ e4 d4 e4 g4 ~ e4 d4 e4 ~ b3 ~ d4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as/9as (Em7·Gmaj7·Em7·D7) + hi-pass ── +const stab = note("<[e3,g3,b3,d4] [g3,b3,d4,fs4] [e3,g3,b3,d4] [d3,fs3,a3,c4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ b3 ~ g3 ~] [~ ~ g4 ~ d4 ~ b3 ~] [~ ~ e4 ~ b3 ~ g3 ~] [~ ~ fs4 ~ d4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── TALKBOX (FM + vibrato = la voz de goma) ── const talkbox = note("").s("sine").fm(5).fmh(1.98) .vib(5.5).vibmod(.5).attack(.05).release(.3) .lpf(1800).gain(.5).room(.4).orbit(3) -// ── BAJO ELECTRO PUNCHY (síncopa 3-3-2 pegada al kick) ── -const bajo = note("e1 ~ ~ e1 ~ ~ ~") +// ── BAJO ELECTRO PUNCHY (síncopa 3-3-2 AHORA sigue el acorde: E·G·E·D) ── +const bajo = note("<[e1 ~ ~ e1 ~ ~ g1 ~] [g1 ~ ~ g1 ~ ~ b1 ~] [e1 ~ ~ e1 ~ ~ g1 ~] [d1 ~ ~ d1 ~ ~ fs1 ~]>") .s("square").lpf(700).lpq(8) .attack(.001).decay(.15).sustain(.1).release(.03) - .shape(.4).gain(.95).orbit(1) -const sub = note("e1").s("sine").attack(.02).decay(.6).sustain(.3) + .shape(.4).coarse(1).gain(.95).orbit(1) +// ── SUB afinado que SIGUE la fundamental de cada compás ── +const sub = note("").s("sine").attack(.02).decay(.6).sustain(.3) .gain(.4).orbit(1) +// ── BAJO OFFBEAT (rompe el 3-3-2: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── BATERÍA 808 ELECTRO (kick 3-3-2, clave de rim, toms de máquina) ── -const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808") - .shape(.45).gain(1.06).duck("1:2").duckattack(.09).duckdepth(.5).orbit(0) -const kick4 = s("bd*4").bank("RolandTR808").shape(.5).gain(1.08) +// ── KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado que sigue las raíces ── +const kickClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").hpf(38).shape(.5).gain(.92) + .duck("1:2").duckattack(.09).duckdepth(.5).orbit(0) +const kickBoom = note("").struct("x ~ ~ x ~ ~ x ~").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickBoom4 = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kick4Click = s("bd*4").bank("RolandTR808").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("1:2").duckattack(.09).duckdepth(.55).orbit(0) +const kick = stack(kickClick, kickBoom) +const kick4 = stack(kick4Click, kickBoom4.gain(1.05)) + const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.72).orbit(0) const clave = s("[~ rim]*4").bank("RolandTR808").degradeBy(.4).gain(.4).pan(.3).orbit(0) -const hats = s("hh*8").bank("RolandTR808").gain("[.5 .25]*4").pan(.6).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0) +// hats con SWING + velocity patrón (groove, no rejilla plana) +const hats = s("hh*8").bank("RolandTR808").swingBy(1/24,8).gain("[.5 .25]*4").pan(.6).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").nudge(.004).gain(.4).orbit(0) const toms = s("~ ~ ~ ~ ~ ~ [ht mt] lt").bank("RolandTR808") .gain(.55).mask("<0 0 0 1>").orbit(0) +// ghost snare sincopada muy baja (para los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD LO-FI (coarse = circuito viejo) ── -const pad = note("<[e3,g3,b3] [g3,b3,d4] [e3,g3,b3] [d3,fs3,a3]>") +// ── PAD LO-FI con 7as + hi-pass (deja el sub libre) ── +const pad = note("<[e3,g3,b3,d4] [g3,b3,d4,fs4] [e3,g3,b3,d4] [d3,fs3,a3,c4]>") .s("sawtooth").lpf(800).coarse(3).attack(.5).release(1.1) - .room(.55).rsize(6).gain(.38).orbit(4) + .hpf(150).room(.55).rsize(6).gain(.38).orbit(4) +// riser de ruido filtrado para transiciones (barrido que sube) +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats) const introB = stack(kick, hats, snare, clave) -const build = stack(kick, hats, snare, bajo, +const build = stack(kick, hats, snare, bajo, riser, hook.lpf(saw.slow(16).range(400,2800)).gain(.55)) -const buildFin = stack(kick4, hats, snare, bajo, hook.gain(.7), toms) -const dropA = stack(kick, hats, open, snare, clave, bajo, sub, hook, talkbox) -const dropAvar = stack(kick, hats, open, snare, clave, toms, bajo, sub, - hook, hookRobot, talkbox) +const buildFin = stack(kick4, hats, snare, bajo, riser, hook.gain(.7), toms) +const dropA = stack(kick, hats, open, snare, clave, ghost, bajo, sub, hook, talkbox, leadLimpio, stab) +const dropAvar = stack(kick, hats, open, snare, clave, toms, ghost, bajo, sub, bajoOff, + hook, hookRobot, talkbox, leadLimpio, stab, contra) const breakdown = stack(pad, talkbox.gain(.6), hook.slow(2).gain(.5).room(.65), - hats.gain(.28), sub.gain(.35)) -const breakBuild = stack(pad, hook.gain(.7), hats, snare.gain(.5), bajo) -const dropStut = stack(kick4, hats, open, snare, bajo, sub, hookStut, talkbox) -const dropStutFull = stack(kick4, hats, open, snare, clave, toms, bajo, sub, - hookStut, hookRobot, talkbox, pad.gain(.3)) -const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.8), hook.gain(.5), sub) + hats.gain(.28), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, riser, hook.gain(.7), hats, snare.gain(.5), bajo) +const dropStut = stack(kick4, hats, open, snare, ghost, bajo, sub, hookStut, talkbox, leadLimpio, stab) +const dropStutFull = stack(kick4, hats, open, snare, clave, toms, ghost, bajo, sub, bajoOff, + hookStut, hookRobot, talkbox, pad.gain(.3), leadLimpio, stab, contra) +const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.8), hook.gain(.5), sub, leadLimpio.gain(.4)) const fin = stack(hats.gain(.3), hook.slow(2).gain(.35).room(.8), pad.gain(.3)) // ── ARREGLO (128 compases) ── @@ -3658,14 +5142,18 @@ arrange( [16, dropStutFull], [8, coda], [4, fin] -)`, +) +`, }, { name: "39 · can't get you out of my head — kylie minogue (2001)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 39 · CAN'T GET YOU OUT OF MY HEAD — Kylie Minogue (2001) → Dark Disco Techno Remix -// 126 BPM · Dm · TR-909 · la-la-la nocturno + bajo disco en octavas + cuerdas staccato +// 126 BPM · Dm (i·i·VI·VII = Dm·Dm·Bb·C) · TR-909 · la-la-la nocturno +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces +// d·d·bb·c) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing + +// ghost + cuerdas con 7as/9as e hi-pass + carácter DURO peak-time + riser de ruido. // Estructura: intro→groove→drop A→breakdown→drop B (tensión máxima)→coda (132 compases ≈ 4:11) // ════════════════════════════════════════════════════════════════ setcps(126/60/4) @@ -3678,57 +5166,88 @@ const lalala = note("d5 ~ d5 c5 a4 ~ c5 d5 c5 a4 g4 f4 g4 ~ ~ ~") .room(.5).rsize(5).gain(.8).pan(sine.slow(7).range(.35,.65)).orbit(2) const lalalaEco = lalala.add(note(12)).gain(.25).late(.0625).orbit(2) -// ── BAJO DISCO EN OCTAVAS (Dm Dm Bb C) ── +// ── LEAD LIMPIO (el "la la la", nítido y al frente) ── +const leadLimpio = note("d5 ~ d5 c5 a4 ~ c5 d5 c5 a4 g4 f4 g4 ~ ~ ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.005).decay(.2).sustain(.45).release(.16) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.55).pan(.5).orbit(2) + +// ── CONTRAMELODÍA (zona media, Dm·Bb·C) ── +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ bb4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~]>") + .s("triangle").lpf(2700).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.3).pan(.62).orbit(3) + +// ── BAJO DISCO EN OCTAVAS (SIGUE el acorde: Dm·Dm·Bb·C) ── const bajo = note("d2 d3 d2 d3 d2 d3 d2 d3").add(note("<0 0 -4 -2>")) .s("sawtooth").lpf(950).lpq(4) .attack(.001).decay(.14).sustain(.12).release(.03) - .shape(.3).gain(.9).orbit(1) -const sub = note("d1!2").add(note("<0 0 8 10>")).s("sine") + .shape(.3).coarse(1).gain(.9).orbit(1) +// ── SUB afinado que SIGUE la fundamental de cada compás ── +const sub = note("").s("sine") .attack(.02).decay(.5).sustain(.35).gain(.5).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── CUERDAS STACCATO (la elegancia oscura) ── -const cuerdas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>") +// ── CUERDAS STACCATO con 7as/9as (Dm7·Dm7·Bbmaj7·C7) + hi-pass ── +const cuerdas = note("<[d4,f4,a4,c5] [d4,f4,a4,c5] [bb3,d4,f4,a4] [c4,e4,g4,bb4]>") .struct("~ x ~ x ~ ~ x ~").s("sawtooth").clip(.25) .attack(.005).release(.08).lpf(3200).hpf(280) .room(.35).gain(.6).orbit(3) -const cuerdasLargas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>") - .s("sawtooth").lpf(1400).attack(.6).release(1.2) +const cuerdasLargas = note("<[d4,f4,a4,c5] [d4,f4,a4,c5] [bb3,d4,f4,a4] [c4,e4,g4,bb4]>") + .s("sawtooth").lpf(1400).hpf(160).attack(.6).release(1.2) .room(.7).rsize(7).gain(.35).orbit(4) -// ── BATERÍA 909 (hats franceses: hpf alto + iter) ── -const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue las raíces ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.08) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.48).pan(.58).orbit(0) -const hatsFr = s("hh*16").bank("RolandTR909").hpf(6000).iter(4) +// hats con SWING (groove francés, no rejilla plana) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.48).pan(.58).orbit(0) +const hatsFr = s("hh*16").bank("RolandTR909").hpf(6000).iter(4).swingBy(1/24,16) .gain("[.5 .2 .35 .2]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.4).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.38).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.4).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.26).pan(.38).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.35)).orbit(0) +// ghost snare sincopada muy baja (para los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +// riser de ruido filtrado para transiciones +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES (la tensión crece sección a sección) ── const intro = stack(kick, hats, sub.gain(.35)) const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(450).gain(.65)) const groove = stack(kick, hatsFr, clap, bajo, cuerdas.gain(.4)) -const build = stack(kick, hatsFr, clap, bajo, cuerdas, - lalala.lpf(saw.slow(8).range(400,2600)).gain(.55)) -const dropA = stack(kickHard, hatsFr, open, clap, bajo, sub, lalala, cuerdas) -const dropAvar = stack(kickHard, hatsFr, open, clap, ride, bajo, sub, - lalala, lalalaEco, cuerdas) +const build = stack(kick, hatsFr, clap, bajo, cuerdas, riser, + lalala.lpf(saw.slow(8).range(400,2600)).gain(.55), leadLimpio.gain(.5)) +const dropA = stack(kickHard, hatsFr, open, clap, ghost, bajo, sub, lalala, cuerdas, leadLimpio, contra) +const dropAvar = stack(kickHard, hatsFr, open, clap, ride, ghost, bajo, sub, bajoOff, + lalala, lalalaEco, cuerdas, leadLimpio, contra) const breakdown = stack(cuerdasLargas, lalala.slow(2).gain(.55).room(.75), - hats.gain(.28), sub.gain(.35)) -const breakBuild = stack(cuerdasLargas, lalala.gain(.7), rodillo, + hats.gain(.28), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(cuerdasLargas, lalala.gain(.7), rodillo, riser, hatsFr.gain(.35), bajo) -const dropB = stack(kickHard, hatsFr, open, clap, bajo, sub, lalala, lalalaEco, - cuerdas.hpf(saw.slow(32).range(280,1200))) -const dropBFull = stack(kickHard, hatsFr, open, clap, ride, bajo, sub, +const dropB = stack(kickHard, hatsFr, open, clap, ghost, bajo, sub, lalala, lalalaEco, + cuerdas.hpf(saw.slow(32).range(280,1200)), leadLimpio, contra) +const dropBFull = stack(kickHard, hatsFr, open, clap, ride, ghost, bajo, sub, bajoOff, lalala.sometimesBy(.2, x=>x.add(note(12))), lalalaEco, cuerdas, - cuerdasLargas.gain(.28), rodillo.gain(.25)) + cuerdasLargas.gain(.28), rodillo.gain(.25), leadLimpio, contra) const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.75), - lalala.gain(.45).room(.7), cuerdasLargas) + lalala.gain(.45).room(.7), cuerdasLargas, leadLimpio.gain(.4)) const fin = stack(hats.gain(.3), lalala.gain(.3).room(.9).delayfeedback(.65), cuerdasLargas.gain(.3)) @@ -3746,14 +5265,18 @@ arrange( [16, dropBFull], [8, coda], [4, fin] -)`, +) +`, }, { name: "40 · satisfaction — benny benassi (2002)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 40 · SATISFACTION — Benny Benassi (2002) → Electro House Remix -// 130 BPM · Cm · TR-909 · el zumbido serrado (crush+shape) + sidechain exagerado +// 130 BPM · Cm (vamp de un acorde, raíz C) · TR-909 · el zumbido serrado +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado en la raíz C) + sub que +// sigue la raíz + bajo offbeat + groove con swing + ghost + stab con 7as/9as e +// hi-pass + carácter DURO peak-time (crush+shape) + riser de ruido en subidas. // Estructura: intro→riff→build hpf→drop A→breakdown→drop B demoledor→coda (136 compases ≈ 4:11) // ════════════════════════════════════════════════════════════════ setcps(130/60/4) @@ -3767,44 +5290,80 @@ const riff = note("c3 ~ c3 eb3 ~ c3 f3 eb3") .gain(.9).orbit(2) const riffAlto = riff.add(note(12)).gain(.38).crush(8).orbit(3) -// ── SUB (la misma línea, una octava abajo en seno) ── +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("c3 ~ c3 eb3 ~ c3 f3 eb3") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as/9as (Cm9) + hi-pass ── +const stab = note("[c3,eb3,g3,bb3,d4]") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── SUB (la misma línea Benassi, una octava abajo en seno, centrada en C) ── const sub = note("c1 ~ c1 eb1 ~ c1 f1 eb1").s("sine") .decay(.25).sustain(.2).gain(.65).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y", raíz C) ── +const bajoOff = note("c2").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── BATERÍA 909 (sidechain exagerado: duckdepth .85) ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado en la raíz (sidechain exagerado) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).gain(.92) .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0) -const kickDemoledor = s("bd*4").bank("RolandTR909").shape(.65).distort(1.25).gain(1.12) +const kickBoom = note("c1").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickDemoledorClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.7).distort(1.35).gain(.95) .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickDemoledor = stack(kickDemoledorClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.48).pan(.58).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") +// hats con SWING + velocity patrón (groove, no rejilla plana) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.48).pan(.58).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0) -const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.42).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.42).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.45)).orbit(0) +// ghost snare sincopada muy baja (para los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD (respiro entre zumbidos) ── -const pad = note("[c3,eb3,g3]").s("supersaw").unison(5).spread(.6) - .lpf(sine.slow(32).range(350,1600)).attack(.6).release(1.2) +// ── PAD con 7as + hi-pass (respiro entre zumbidos) ── +const pad = note("[c3,eb3,g3,bb3]").s("supersaw").unison(5).spread(.6) + .lpf(sine.slow(32).range(350,1600)).hpf(150).attack(.6).release(1.2) .room(.6).rsize(6).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES (los builds suben con hpf, el drop lo suelta todo) ── const intro = stack(kick, hats, sub.gain(.35)) const introB = stack(kick, hats, clap.gain(.5), sub.gain(.5)) const riffIn = stack(kick, hats, clap, riff.lpf(sine.slow(8).range(200,900)).gain(.7)) -const build = stack(kick, hats16, clap, riff.hpf(saw.slow(8).range(60,2400)), sub) -const buildFin = stack(kickDemoledor, rodillo, +const build = stack(kick, hats16, clap, riff.hpf(saw.slow(8).range(60,2400)), sub, riser) +const buildFin = stack(kickDemoledor, rodillo, riser, riff.hpf(saw.slow(4).range(200,3000)).gain(.8)) -const dropA = stack(kickDemoledor, hats16, open, clap, riff, sub) -const dropAvar = stack(kickDemoledor, hats16, open, clap, riff, riffAlto, sub) -const breakdown = stack(pad, riff.lpf(500).gain(.55).room(.6), hats.gain(.3), sub.gain(.3)) +const dropA = stack(kickDemoledor, hats16, open, clap, ghost, riff, sub, leadLimpio, stab) +const dropAvar = stack(kickDemoledor, hats16, open, clap, ghost, riff, riffAlto, sub, bajoOff, leadLimpio, stab, contra) +const breakdown = stack(pad, riff.lpf(500).gain(.55).room(.6), hats.gain(.3), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(pad, riff.hpf(saw.slow(8).range(60,2800)).gain(.75), - rodillo, hats16.gain(.4)) -const dropB = stack(kickDemoledor, hats16, open, clap, riff, riffAlto, sub) -const dropBFull = stack(kickDemoledor, hats16, open, clap, - riff.sometimesBy(.2, x=>x.add(note(12))), riffAlto, sub, pad.gain(.3)) -const coda = stack(kick, hats, clap.gain(.5), riff.lpf(700).gain(.7), sub) + rodillo, riser, hats16.gain(.4)) +const dropB = stack(kickDemoledor, hats16, open, clap, ghost, riff, riffAlto, sub, leadLimpio, stab) +const dropBFull = stack(kickDemoledor, hats16, open, clap, ghost, bajoOff, + riff.sometimesBy(.2, x=>x.add(note(12))), riffAlto, sub, pad.gain(.3), leadLimpio, stab, contra) +const coda = stack(kick, hats, clap.gain(.5), riff.lpf(700).gain(.7), sub, leadLimpio.gain(.4)) const fin = stack(hats.gain(.3), riff.lpf(400).gain(.4).room(.7), pad.gain(.3)) // ── ARREGLO (136 compases) ── @@ -3822,14 +5381,18 @@ arrange( [16, dropBFull], [8, coda], [4, fin] -)`, +) +`, }, { name: "41 · call on me — eric prydz (2004)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 41 · CALL ON ME — Eric Prydz (2004) → Pump House Remix -// 128 BPM · Bm · TR-909 · sidechain EXTREMO (duckdepth .9): todo el track respira +// 128 BPM · Bm (i·i·VII·VI = Bm·Bm·A·G) · TR-909 · sidechain EXTREMO (duckdepth .9) +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces +// b·b·a·g) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing + +// ghost + stab con 7as e hi-pass + carácter DURO peak-time + riser de ruido. // Estructura: intro→build→drop A→breakdown→drop B→coda (128 compases ≈ 4:00) // ════════════════════════════════════════════════════════════════ setcps(128/60/4) @@ -3842,48 +5405,85 @@ const hook = note("fs4 ~ fs4 e4 d4 e4 fs4 ~ b4 ~ a4 fs4 e4 d4 e4 ~") const hookStab = hook.superimpose(x=>x.add(note(-12)).lpf(1300).gain(.6)) const hookOctava = hook.add(note(12)).gain(.28).orbit(2) -// ── BAJO PEGADO AL KICK (corcheas que el duck convierte en bomba) ── +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("fs4 ~ fs4 e4 d4 e4 fs4 ~ b4 ~ a4 fs4 e4 d4 e4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (Bm7·Bm7·A7·Gmaj7) + hi-pass ── +const stab = note("<[b2,d3,fs3,a3] [b2,d3,fs3,a3] [a2,cs3,e3,g3] [g2,b2,d3,fs3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BAJO PEGADO AL KICK (corcheas que SIGUEN el acorde: B·B·A·G) ── const bajo = note("b1!8").add(note("<0 0 -2 -4>")) .s("sawtooth").lpf(800).lpq(5) .attack(.001).decay(.2).sustain(.35).release(.04) - .shape(.4).gain(.95).orbit(1) + .shape(.4).coarse(1).gain(.95).orbit(1) +// ── SUB afinado que SIGUE la fundamental de cada compás ── const sub = note("").s("sine") .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── BATERÍA 909 (el kick manda: duckdepth .9, duckattack .2) ── -const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado (el kick manda: duckdepth .9) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).gain(.92) .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0) -const kickPump = s("bd*4").bank("RolandTR909").shape(.6).distort(1.15).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickPumpClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.7).distort(1.3).gain(.95) .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickPump = stack(kickPumpClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0) -const hatsMin = s("[~ hh]*4").bank("RolandTR909").gain(.32).pan(.55).orbit(0) -const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.3).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.22).pan(.4).orbit(0) +// hats con SWING (groove, no rejilla plana) +const hatsMin = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.32).pan(.55).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.3).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.22).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +// ghost snare sincopada muy baja (para los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── PAD CON PUMP FALSO (saw.fast(4) simula el sidechain en la órbita 4) ── -const pad = note("<[b2,d3,fs3] [b2,d3,fs3] [a2,cs3,e3] [g2,b2,d3]>") - .s("supersaw").unison(5).spread(.6).lpf(1000) +// ── PAD CON PUMP FALSO con 7as + hi-pass (saw.fast(4) simula el sidechain) ── +const pad = note("<[b2,d3,fs3,a3] [b2,d3,fs3,a3] [a2,cs3,e3,g3] [g2,b2,d3,fs3]>") + .s("supersaw").unison(5).spread(.6).lpf(1000).hpf(150) .attack(.05).release(.6) .gain(saw.fast(4).range(.12,.45)).room(.5).rsize(5).orbit(4) +// riser de ruido filtrado para transiciones +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hatsMin, sub.gain(.4)) const introB = stack(kick, hatsMin, clap.gain(.5), bajo.lpf(400).gain(.7)) -const build = stack(kick, hatsMin, clap, bajo, +const build = stack(kick, hatsMin, clap, bajo, riser, hookStab.lpf(saw.slow(16).range(400,2400)).gain(.6)) -const buildFin = stack(kickPump, rodillo, bajo, hookStab.gain(.75)) -const dropA = stack(kickPump, hatsMin, open, clap, bajo, sub, hookStab) -const dropAvar = stack(kickPump, hatsMin, open, clap, bajo, sub, - hookStab, hookOctava, pad) -const breakdown = stack(pad, hook.gain(.55).room(.7), hatsMin.gain(.25), sub.gain(.35)) -const breakBuild = stack(pad, hookStab.gain(.7), rodillo, kick.gain(.95), bajo) -const dropB = stack(kickPump, hatsMin, open, clap, bajo, sub, hookStab, hookOctava) -const dropBFull = stack(kickPump, hatsMin, open, clap, ride, bajo, sub, - hookStab.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad, rodillo.gain(.22)) +const buildFin = stack(kickPump, rodillo, riser, bajo, hookStab.gain(.75)) +const dropA = stack(kickPump, hatsMin, open, clap, ghost, bajo, sub, hookStab, leadLimpio, stab) +const dropAvar = stack(kickPump, hatsMin, open, clap, ghost, bajo, sub, bajoOff, + hookStab, hookOctava, pad, leadLimpio, stab, contra) +const breakdown = stack(pad, hook.gain(.55).room(.7), hatsMin.gain(.25), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, hookStab.gain(.7), rodillo, riser, kick.gain(.95), bajo) +const dropB = stack(kickPump, hatsMin, open, clap, ghost, bajo, sub, hookStab, hookOctava, leadLimpio, stab) +const dropBFull = stack(kickPump, hatsMin, open, clap, ride, ghost, bajo, sub, bajoOff, + hookStab.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad, rodillo.gain(.22), leadLimpio, stab, contra) const coda = stack(kick, hatsMin, clap.gain(.5), bajo.gain(.8), - hook.gain(.45).room(.6), pad.gain(.3)) + hook.gain(.45).room(.6), pad.gain(.3), leadLimpio.gain(.4)) const fin = stack(hatsMin.gain(.25), hook.gain(.3).room(.85), pad.gain(.28)) // ── ARREGLO (128 compases) ── @@ -3900,14 +5500,18 @@ arrange( [16, dropBFull], [8, coda], [4, fin] -)`, +) +`, }, { name: "42 · played-a-live tribal — safri duo (2000)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 42 · PLAYED-A-LIVE TRIBAL — Safri Duo (2000) → Tribal Techno Remix -// 138 BPM · Dm · TR-909 + east · los tambores SON el hook +// 138 BPM · Dm (i·i·VII·v = Dm·Dm·C·Am) · TR-909 + east · los tambores SON el hook +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces +// d·d·c·a) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing + +// ghost + stab con 7as e hi-pass + carácter DURO peak-time + riser de ruido. // Estructura: percusión sola→toms→drop tribal→melodía tardía→drop total→coda (144 compases ≈ 4:10) // ════════════════════════════════════════════════════════════════ setcps(138/60/4) @@ -3929,24 +5533,38 @@ const toms = s("~ ~ [ht mt] ~ ~ lt ~ [mt ht]").bank("RolandTR909") const tomsRodillo = s("lt lt mt mt ht ht mt lt mt ht ht mt lt mt ht ht").bank("RolandTR909") .gain(saw.slow(4).range(.4,.95)).speed(saw.slow(4).range(1,1.55)).orbit(0) -// ── BATERÍA 909 ── -const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05) +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las raíces ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.2).gain(.7).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") +// hats con SWING (groove, no rejilla plana) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) .gain("[.5 .22 .32 .22]*4").pan(rand.range(.35,.65)).orbit(0) const shaker = s("hh*16").bank("RolandCR78") .gain(rand.range(.15,.4)).hpf(6000).pan(rand.range(.2,.8)).orbit(0) +// ghost snare sincopada muy baja (para los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) -// ── BAJO PUNCHY (stabs sincopados, deja hueco a los tambores) ── -const bajo = note("d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~") +// ── BAJO PUNCHY (stabs sincopados que SIGUEN el acorde: D·D·C·A) ── +const bajo = note("<[d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~] [d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~] [c2 ~ ~ c2 ~ ~ c2 ~ c2 ~ ~ c2 ~ e2 d2 ~] [a1 ~ ~ a1 ~ ~ a1 ~ a1 ~ ~ a1 ~ c2 b1 ~]>") .s("sawtooth").lpf(900).lpq(7).attack(.002).decay(.14).sustain(.15).release(.04) - .shape(.35).gain(.9).orbit(1) -const bajoSub = note("d1 ~ d1 d1 ~ d1 ~ ~").s("sine") + .shape(.35).coarse(1).gain(.9).orbit(1) +// ── SUB afinado que SIGUE la fundamental de cada compás ── +const bajoSub = note("<[d1 ~ d1 d1 ~ d1 ~ ~] [d1 ~ d1 d1 ~ d1 ~ ~] [c1 ~ c1 c1 ~ c1 ~ ~] [a0 ~ a0 a0 ~ a0 ~ ~]>").s("sine") .decay(.25).sustain(.25).gain(.7).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) // ── LA MELODÍA (entra tarde, interpretación del hook de Safri Duo) ── const hook = note("d4 f4 g4 a4 g4 f4 d4 ~") @@ -3955,29 +5573,52 @@ const hook = note("d4 f4 g4 a4 g4 f4 d4 ~") .room(.35).rsize(4).gain(.75).pan(sine.slow(8).range(.35,.65)).orbit(2) const hookOctava = hook.add(note(12)).gain(.3).lpf(2800).orbit(2) -// ── TEXTURA / DRONE OSCURO ── -const drone = note("[d2,a2,d3]").s("sawtooth").lpf(500) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("d4 f4 g4 a4 g4 f4 d4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (Dm7·Dm7·Cmaj7·Am7) + hi-pass ── +const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3] [a2,c3,e3,g3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── TEXTURA / DRONE OSCURO (hi-pass para dejar el sub libre) ── +const drone = note("[d2,a2,d3]").s("sawtooth").lpf(500).hpf(120) .attack(1.2).release(2).room(.7).rsize(7).gain(.35).orbit(4) +// riser de ruido filtrado para transiciones +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const introPerc = stack(kick, taikoA, hats) const percDobla = stack(kick, taikoA, taikoB, hats, clap.gain(.45)) const tribalFull = stack(kick, taikoA, taikoB, taikoC, toms, hats16, clap) -const rodilloTom = stack(kickHard, tomsRodillo, taikoSolo.gain(.8)) -const dropPerc = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, bajo, bajoSub) -const dropMelodia = stack(kickHard, taikoA, taikoB, toms, hats16, clap, bajo, bajoSub, - hook.lpf(saw.slow(16).range(400,1800)).gain(.6)) -const breakTribal = stack(taikoSolo, toms.gain(.6), drone, bajoSub.gain(.35), shaker.gain(.5)) -const buildTribal = stack(taikoSolo, tomsRodillo, hats16.gain(.4), drone, +const rodilloTom = stack(kickHard, tomsRodillo, riser, taikoSolo.gain(.8)) +const dropPerc = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, ghost, bajo, bajoSub) +const dropMelodia = stack(kickHard, taikoA, taikoB, toms, hats16, clap, ghost, bajo, bajoSub, + hook.lpf(saw.slow(16).range(400,1800)).gain(.6), leadLimpio, stab) +const breakTribal = stack(taikoSolo, toms.gain(.6), drone, bajoSub.gain(.35), shaker.gain(.5), contra, leadLimpio.gain(.42).room(.7)) +const buildTribal = stack(taikoSolo, tomsRodillo, hats16.gain(.4), drone, riser, hook.gain(.5).room(.6)) -const dropTotal = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, - bajo, bajoSub, hook, hookOctava) +const dropTotal = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, ghost, + bajo, bajoSub, hook, hookOctava, leadLimpio, stab) const dropTotalVar = stack(kickHard, taikoA.sometimesBy(.25, x=>x.speed(1.3)), taikoB, taikoC, - toms.every(4, x=>x.fast(2)), hats16, clap, - bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, drone) + toms.every(4, x=>x.fast(2)), hats16, clap, ghost, bajoOff, + bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, drone, leadLimpio, stab, contra) const dropPercFin = stack(kickHard, taikoA, taikoB, taikoC, toms, - tomsRodillo.degradeBy(.5).gain(.5), hats16, shaker, clap, bajo, bajoSub) -const coda = stack(kick, taikoA, hats, hook.gain(.4).room(.6), bajoSub.gain(.4)) + tomsRodillo.degradeBy(.5).gain(.5), hats16, shaker, clap, ghost, bajo, bajoSub) +const coda = stack(kick, taikoA, hats, hook.gain(.4).room(.6), bajoSub.gain(.4), leadLimpio.gain(.4)) const codaFin = stack(taikoSolo.gain(.6).room(.7), drone.gain(.25), shaker.gain(.3)) // ── ARREGLO (144 compases) ── @@ -3995,14 +5636,18 @@ arrange( [16, dropPercFin], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "43 · resurection trance — ppk (2001)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 43 · RESURECTION TRANCE — PPK (2001) → Trance Techno Remix -// 138 BPM · Am · TR-909 · supersaw con portamento (penv) + FX espaciales +// 138 BPM · Am (i·i·VII·VI = Am·Am·G·F) · TR-909 · supersaw con portamento (penv) +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces +// a·a·g·f) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing + +// ghost + stab con 7as e hi-pass + carácter DURO peak-time + riser de ruido. // Estructura: intro→build→drop A→break cósmico→drop delay largo→coda (148 compases ≈ 4:17) // ════════════════════════════════════════════════════════════════ setcps(138/60/4) @@ -4018,58 +5663,95 @@ const riffOctava = riff.add(note(12)).gain(.28).lpf(3600).orbit(2) const riffCosmico = riff.delay(.55).delaytime(.5).delayfeedback(.65) .room(.8).rsize(9) -// ── BAJO ROLLING (16avos con acentos, progresión Am→G→F) ── +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("a4 b4 c5 d5 e5 ~ c5 e5 a5 ~ g5 e5 d5 c5 b4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab con 7as (Am7·Am7·G7·Fmaj7) + hi-pass ── +const stab = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ c4 ~ a3 ~ f3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── BAJO ROLLING (16avos con acentos, SIGUE el acorde: Am→Am→G→F) ── const bajo = note("a1*16").add(note("<0 0 -2 -4>")) .s("sawtooth").lpf(perlin.slow(8).range(450,1100)).lpq(9) .attack(.001).decay(.09).sustain(.2).release(.03) - .shape(.3).gain("[1 .55 .75 .55]*4").orbit(1) + .shape(.3).coarse(1).gain("[1 .55 .75 .55]*4").orbit(1) +// ── SUB afinado que SIGUE la fundamental de cada compás ── const bajoSub = note("").s("sine") .attack(.02).decay(.4).sustain(.5).gain(.6).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── BATERÍA 909 TRANCE ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las raíces ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0) -const hats = s("hh*8").bank("RolandTR909").gain(.4).pan(.6).orbit(0) -const hatsOff = s("[~ oh]*4").bank("RolandTR909").gain(.55).orbit(0) -const hats16 = s("hh*16").bank("RolandTR909") +// hats con SWING (groove, no rejilla plana) +const hats = s("hh*8").bank("RolandTR909").swingBy(1/24,8).gain(.4).pan(.6).orbit(0) +const hatsOff = s("[~ oh]*4").bank("RolandTR909").nudge(.004).gain(.55).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16) .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) +// ghost snare sincopada muy baja (para los drops) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) // ── ATMÓSFERA CÓSMICA ── const espacio = s("").slow(2) .gain(.4).room(.8).rsize(8).lpf(3000) .pan(sine.slow(16).range(.2,.8)).orbit(4) -const pad = note("<[a2,c3,e3] [a2,c3,e3] [g2,b2,d3] [f2,a2,c3]>") - .s("sawtooth").lpf(700).attack(.9).release(1.6) +const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>") + .s("sawtooth").lpf(700).hpf(150).attack(.9).release(1.6) .room(.7).rsize(7).gain(.4).orbit(4) +// riser de ruido filtrado para transiciones +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introB = stack(kick, hats, hatsOff, clap.gain(.45), bajo.lpf(400).gain(.6)) -const build = stack(kick, hats16, clap, bajo, pad, +const build = stack(kick, hats16, clap, bajo, pad, riser, riff.lpf(saw.slow(16).range(350,2200)).gain(.55)) -const buildFin = stack(kickHard, rodillo, bajo, riff.gain(.65)) -const dropA = stack(kickHard, hats16, hatsOff, clap, bajo, bajoSub, riff) -const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, bajo, bajoSub, - riff, riffOctava) +const buildFin = stack(kickHard, rodillo, riser, bajo, riff.gain(.65)) +const dropA = stack(kickHard, hats16, hatsOff, clap, ghost, bajo, bajoSub, riff, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, ghost, bajo, bajoSub, + riff, riffOctava, leadLimpio, stab, contra) const breakCosmos = stack(espacio, pad, riffCosmico.gain(.6), - bajoSub.gain(.35), hats.gain(.25)) + bajoSub.gain(.35), hats.gain(.25), contra, leadLimpio.gain(.42).room(.7)) const breakBuild = stack(espacio.gain(.3), pad, riffCosmico.gain(.7), - rodillo, hats16.gain(.4)) -const dropDelay = stack(kickHard, hats16, hatsOff, clap, bajo, bajoSub, - riffCosmico.gain(.75)) -const dropTotal = stack(kickHard, hats16, hatsOff, clap, ride, bajo, bajoSub, - riff, riffOctava, pad.gain(.3)) -const dropTotalVar = stack(kickHard, hats16, hatsOff, clap, ride, + rodillo, riser, hats16.gain(.4)) +const dropDelay = stack(kickHard, hats16, hatsOff, clap, ghost, bajo, bajoSub, + riffCosmico.gain(.75), leadLimpio, stab) +const dropTotal = stack(kickHard, hats16, hatsOff, clap, ride, ghost, bajo, bajoSub, + riff, riffOctava, pad.gain(.3), leadLimpio, stab) +const dropTotalVar = stack(kickHard, hats16, hatsOff, clap, ride, ghost, bajoOff, bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, - riff.every(4, x=>x.iter(4)), riffOctava, espacio.gain(.25)) + riff.every(4, x=>x.iter(4)), riffOctava, espacio.gain(.25), leadLimpio, stab, contra) const coda = stack(kick, hats, bajo.lpf(550).gain(.7), - riff.gain(.45).room(.7), pad) + riff.gain(.45).room(.7), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.3), espacio, riffCosmico.gain(.35).delayfeedback(.75), pad.gain(.3)) @@ -4088,14 +5770,18 @@ arrange( [16, dropTotalVar], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "44 · lady french touch — modjo (2000)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 44 · LADY FRENCH TOUCH — Modjo (2000) → French Touch Remix -// 122 BPM · F#m · TR-909 · filtros que respiran + swing suave y elegante +// 122 BPM · F#m (i·i·III·iv = F#m·F#m·A·Bm) · TR-909 · filtros que respiran +// PRODUCCIÓN PRO: kick 2 capas (click + boom afinado F#·F#·A·B) + bajo/sub +// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass +// + carácter peak-time (saturación) + riser de ruido. Estructura conservada. // Estructura: intro→groove→drop filtrado→break sedoso→drop abierto→coda (136 compases ≈ 4:28) // ════════════════════════════════════════════════════════════════ setcps(122/60/4) @@ -4109,60 +5795,100 @@ const riffRespira = riff.lpf(sine.slow(16).range(500,2400)) .hpf(sine.slow(23).range(40,500)) const riffOctava = riff.add(note(12)).gain(.3).lpf(2600).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("fs3 a3 b3 cs4 e4 cs4 b3 a3") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (F#m7·F#m7·Amaj7·Bm7) + hi-pass ── +const stab = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [a2,cs3,e3,gs3] [b2,d3,fs3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.24).room(.3).rsize(5).gain(.32).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── STABS DE ACORDE (a contratiempo, como el sample original) ── const stabs = note("~ [fs3,a3,cs4,e4] ~ [fs3,a3,cs4,e4]") .s("sawtooth").lpf(1500).attack(.005).decay(.15).sustain(0).release(.08) .hpf(300).room(.3).rsize(3).gain(.55) .phaser(.3).phaserdepth(.3).orbit(3) -// ── BAJO DISCO CON OCTAVAS (progresión F#m→F#m→A→B) ── +// ── BAJO DISCO CON OCTAVAS (sigue las fundamentales F#·F#·A·B) ── const bajo = note("fs1 [~ fs2] fs1 [~ fs2] fs1 [~ fs2] fs1 [~ fs2]") .add(note("<0 0 3 5>")) - .s("sawtooth").lpf(750).lpq(4).attack(.003).decay(.16).sustain(.3).release(.05) - .shape(.2).gain(.9).swingBy(.06, 8).orbit(1) + .s("sawtooth").lpf(perlin.slow(4).range(500,1200)).lpq(6).attack(.003).decay(.16).sustain(.3).release(.05) + .shape(.3).coarse(1).gain(.9).swingBy(.06, 8).orbit(1) +// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica) ── const bajoSub = note("").s("sine") .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── BATERÍA 909 CÁLIDA CON SWING ── -const kick = s("bd*4").bank("RolandTR909").shape(.25).gain(1) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95) + .duck("1:2").duckattack(.13).duckdepth(.55).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) + +// ── PERCUSIÓN CÁLIDA CON SWING + velocity humanizada + ghost ── const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).rsize(3).gain(.7).orbit(0) const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).swingBy(.08, 8).pan(.6).orbit(0) const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.4 .18 .28 .18]*4").swingBy(.08, 8).pan(rand.range(.4,.6)).orbit(0) -const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.4).orbit(0) + .gain(perlin.range(.22,.5)).swingBy(.08, 8).pan(rand.range(.4,.6)).orbit(0) +const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.4).orbit(0) const rimGroove = s("~ ~ rim ~ ~ rim ~ ~").bank("LinnDrum") .gain(.4).swingBy(.08, 8).pan(.35).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) +const rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) -// ── PAD SUAVE (strings de terciopelo) ── -const pad = note("[fs3,a3,cs4]").add(note("<0 0 3 5>")) +// ── PAD SUAVE (strings de terciopelo, 7as, hi-pass para dejar el sub libre) ── +const pad = note("[fs3,a3,cs4,e4]").add(note("<0 0 3 5>")) .s("supersaw").unison(4).spread(.5) - .lpf(sine.slow(24).range(400,1400)).attack(.7).release(1.2) - .room(.6).rsize(6).gain(.32).orbit(4) + .lpf(sine.slow(24).range(400,1400)).hpf(150).attack(.7).release(1.2) + .room(.6).rsize(6).gain(.3).orbit(4) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introB = stack(kick, hats, hatOpen, clap.gain(.4), bajo.lpf(450).gain(.65)) const groove = stack(kick, hats, hats16, clap, rimGroove, bajo, riffRespira.gain(.6)) -const grooveFin = stack(kick, hats16, clap, bajo, +const grooveFin = stack(kickHard, hats16, clap, rodillo, riser, bajo, riff.hpf(saw.slow(4).range(40,900)).gain(.7)) -const dropFiltrado = stack(kick, hats, hats16, hatOpen, clap, rimGroove, - bajo, bajoSub, riffRespira, stabs.gain(.4)) -const dropFunk = stack(kick, hats, hats16, hatOpen, clap, rimGroove, - bajo, bajoSub, riff, stabs, riffOctava) +const dropFiltrado = stack(kick, hats, hats16, hatOpen, clap, rimGroove, ghost, + bajo, bajoSub, riffRespira, stabs.gain(.4), leadLimpio, stab) +const dropFunk = stack(kickHard, hats, hats16, hatOpen, clap, rimGroove, ghost, + bajo, bajoSub, bajoOff, riff, stabs, riffOctava, leadLimpio, stab) const breakSedoso = stack(pad, riff.gain(.5).room(.6).lpf(900), - hats.gain(.3), bajoSub.gain(.35), rimGroove.gain(.25)) -const breakBuild = stack(pad, riffRespira.gain(.7), stabs.gain(.4), + hats.gain(.3), bajoSub.gain(.35), rimGroove.gain(.25), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, riffRespira.gain(.7), stabs.gain(.4), riser, hats16.gain(.35), bajo.lpf(500).gain(.6)) -const dropAbierto = stack(kick, hats, hats16, hatOpen, clap, rimGroove, - bajo, bajoSub, riff.lpf(2600), stabs, riffOctava, pad.gain(.22)) -const dropAbiertoVar = stack(kick, hats16, hatOpen, clap, rimGroove, - bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, - riff.every(4, x=>x.rev()), stabs, riffOctava, pad.gain(.22)) +const dropAbierto = stack(kickHard, hats, hats16, hatOpen, clap, rimGroove, ghost, + bajo, bajoSub, riff.lpf(2600), stabs, riffOctava, pad.gain(.22), leadLimpio, stab) +const dropAbiertoVar = stack(kickHard, hats16, hatOpen, clap, rimGroove, ghost, + bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + riff.every(4, x=>x.rev()), stabs, riffOctava, pad.gain(.22), leadLimpio, stab, contra) const salida = stack(kick, hats, clap, bajo, riffRespira.gain(.55), stabs.gain(.35)) const coda = stack(kick, hats, bajo.lpf(550).gain(.7), - riff.gain(.4).room(.6), pad) + riff.gain(.4).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.3), riff.gain(.28).room(.8).lpf(800), pad.gain(.25), bajoSub.gain(.3)) @@ -4181,19 +5907,23 @@ arrange( [8, salida], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "45 · feel good inc bass — gorillaz (2005)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 45 · FEEL GOOD INC BASS — Gorillaz (2005) → Bass Techno Remix -// 127 BPM · Em · TR-808 · bajazo + risa maníaca (white+vowel+stut) · oscuro y chulesco +// 127 BPM · Em (i·VII·VI·v = Em·D·C·Bm) · TR-808 · oscuro y chulesco +// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado E·D·C·B siguiendo +// el tresillo) + sub/pad que siguen los acordes + groove (swing+ghost) + +// 7as/9as e hi-pass + carácter peak-time (distort) + riser. Estructura conservada. // Estructura: intro sombría→groove 808→drop bajo→break risa→drop total→coda (136 compases ≈ 4:17) // ════════════════════════════════════════════════════════════════ setcps(127/60/4) -// ── EL BAJAZO (línea EXACTA de Feel Good Inc) ── +// ── EL BAJAZO (línea EXACTA de Feel Good Inc, outlinea la armonía) ── const bajo = note("e2 ~ g2 e2 d2 ~ c2 b1") .s("sawtooth").shape(.45).lpf(800).lpq(7) .attack(.002).decay(.2).sustain(.4).release(.06) @@ -4201,20 +5931,32 @@ const bajo = note("e2 ~ g2 e2 d2 ~ c2 b1") const bajoSub = note("e1 ~ g1 e1 d1 ~ c1 b0").s("sine") .attack(.003).decay(.3).sustain(.4).gain(.65).orbit(1) const bajoSucio = bajo.distort(1.1).lpf(1100).gain(.85) +// ── BAJO OFFBEAT (rompe el tresillo: pulsa en las "y", sigue raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.42).duck("1").orbit(1) -// ── BEAT 808 HIP-HOP-TECHNO (bombo con huecos, tresillo 3-3-2) ── -const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").shape(.4).gain(1.05) +// ── KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── +// el boom sigue el tresillo 3-3-2 con fundamental por compás E·D·C·B +const kickClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0) -const kickDuro = s("bd ~ [~ bd] bd ~ ~ bd ~").bank("RolandTR808") - .shape(.5).distort(1.05).gain(1.1) +const kickBoom = note("").struct("x ~ ~ x ~ ~ x ~").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0) +const kickDuroClick = s("bd ~ [~ bd] bd ~ ~ bd ~").bank("RolandTR808") + .hpf(38).shape(.6).distort(1.3).gain(1.05) .duck("1:2").duckattack(.08).duckdepth(.55).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickDuro = stack(kickDuroClick, kickBoom.gain(1.05)) + const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.8).room(.15).orbit(0) const snareGhost = s("sd(3,16,6)").bank("RolandTR808").gain(.25) .pan(rand.range(.3,.7)).orbit(0) -const hats = s("hh*8").bank("RolandTR808") +const hats = s("hh*8").bank("RolandTR808").swingBy(1/24,8) .gain("[.5 .3]*4").sometimesBy(.15, x=>x.ply(2)).pan(.6).orbit(0) -const hatOpen = s("~ ~ [~ oh] ~").bank("RolandTR808").gain(.4).orbit(0) +const hatOpen = s("~ ~ [~ oh] ~").bank("RolandTR808").nudge(.004).gain(.4).orbit(0) const cowRim = s("~ ~ ~ rim").bank("RolandTR808").gain(.35).pan(.3).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0) // ── LA RISA MANÍACA (ruido blanco + vocales + stut) ── const risa = s("white*8").attack(.001).decay(.07).sustain(0) @@ -4230,35 +5972,59 @@ const hook = note("e4 ~ e4 d4 e4 g4 ~ e4 d4 c4 ~ b3 ~ d4 e4 ~") .gain(.6).pan(sine.slow(8).range(.4,.6)).orbit(2) const hookOctava = hook.add(note(12)).gain(.25).crush(8).orbit(2) -// ── ATMÓSFERA OSCURA ── -const pad = note("[e2,g2,b2]").s("sawtooth").lpf(450) - .attack(1.1).release(2).room(.65).rsize(7).gain(.35).orbit(4) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("e4 ~ e4 d4 e4 g4 ~ e4 d4 c4 ~ b3 ~ d4 e4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Em7·Dadd9·Cmaj7·Bm7) + hi-pass ── +const stab = note("<[e3,g3,b3,d4] [d3,fs3,a3,e4] [c3,e3,g3,b3] [b2,d3,fs3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ e4 ~ b3 ~ g3 ~] [~ ~ d4 ~ a3 ~ fs3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── ATMÓSFERA OSCURA (pad que SIGUE los acordes, con 7as e hi-pass) ── +const pad = note("<[e2,g2,b2,d3] [d2,fs2,a2,c3] [c2,e2,g2,b2] [b1,d2,fs2,a2]>") + .s("sawtooth").lpf(450).attack(1.1).release(2).hpf(120) + .room(.65).rsize(7).gain(.35).orbit(4) const viento = s("wind:2").slow(2).gain(.3).lpf(2000) .room(.7).rsize(8).pan(sine.slow(12).range(.3,.7)).orbit(4) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, pad.gain(.25)) const introB = stack(kick, hats, cowRim, snare.gain(.5), bajoSub.gain(.45)) const groove = stack(kick, hats, hatOpen, snare, snareGhost, cowRim, bajo.lpf(saw.slow(16).range(300,800)).gain(.8)) -const grooveFin = stack(kickDuro, snare, hats.fast(2).gain(.4), +const grooveFin = stack(kickDuro, snare, hats.fast(2).gain(.4), riser, bajo, risa.gain(.35)) -const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, +const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, ghost, bajo, bajoSub) -const dropBajoHook = stack(kickDuro, hats, hatOpen, snare, snareGhost, - bajo, bajoSub, hook) +const dropBajoHook = stack(kickDuro, hats, hatOpen, snare, snareGhost, ghost, + bajo, bajoSub, hook, leadLimpio, stab) const breakRisa = stack(risa, viento, pad, bajoSub.gain(.35), - hats.gain(.25), hook.gain(.4).room(.6)) -const breakBuild = stack(risa.degradeBy(.15).gain(.6), pad, + hats.gain(.25), hook.gain(.4).room(.6), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(risa.degradeBy(.15).gain(.6), pad, riser, snareGhost.fast(2).gain(.35), bajo.lpf(500).gain(.7), hook.gain(.5)) -const dropTotal = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, - bajoSucio, bajoSub, hook, hookOctava) -const dropTotalVar = stack(kickDuro, hats, hatOpen, snare, - bajoSucio.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, - hook.every(4, x=>x.iter(4)), hookOctava, risa.degradeBy(.6).gain(.35)) +const dropTotal = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, ghost, + bajoSucio, bajoSub, bajoOff, hook, hookOctava, leadLimpio, stab) +const dropTotalVar = stack(kickDuro, hats, hatOpen, snare, ghost, + bajoSucio.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + hook.every(4, x=>x.iter(4)), hookOctava, risa.degradeBy(.6).gain(.35), leadLimpio, stab, contra) const salida = stack(kick, hats, snare, cowRim, bajo, bajoSub, hook.gain(.45)) const coda = stack(kick, hats, bajo.lpf(500).gain(.7), - hook.gain(.35).room(.6), pad) + hook.gain(.35).room(.6), pad, leadLimpio.gain(.4)) const codaFin = stack(viento, hook.gain(.25).room(.85).delayfeedback(.6), pad.gain(.25), bajoSub.gain(.3)) @@ -4277,14 +6043,18 @@ arrange( [8, salida], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "46 · seven nation army anthem — the white stripes (2003)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 46 · SEVEN NATION ARMY ANTHEM — The White Stripes (2003) → Peak-Time Anthem Remix -// 130 BPM · Em · TR-909 · riff masivo + multitud de estadio + rodillos militares +// 130 BPM · Em (i·i·VI·V = Em·Em·C·B) · TR-909 · riff masivo de estadio +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado E·E·C·B) + bajo/sub +// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass +// + carácter peak-time (distort) + riser. Estructura conservada. // Estructura: stomp→build→drop riff→break estadio→drop octavas→drop final→coda (152 compases ≈ 4:41) // ════════════════════════════════════════════════════════════════ setcps(130/60/4) @@ -4303,58 +6073,94 @@ const riffLead = note("e4 ~ ~ e4 [g4 e4] d4 ~ ~ c4 ~ ~ ~ b3 ~ ~ ~") .attack(.01).decay(.2).sustain(.35).release(.15) .room(.5).rsize(6).delay(.3).delaytime(.375).delayfeedback(.35) .gain(.6).orbit(2) +// ── SUB-BAJO afinado que SIGUE la fundamental por compás E·E·C·B ── +const bajoSub = note("").struct("x*4").s("sine") + .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) + +// ── LEAD LIMPIO (el riff una octava arriba, nítido y al frente) ── +const leadLimpio = note("e4 ~ ~ e4 [g4 e4] d4 ~ ~ c4 ~ ~ ~ b3 ~ ~ ~") + .s("triangle").lpf(5200).lpq(1) + .attack(.005).decay(.22).sustain(.45).release(.16) + .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Em7·Em7·Cmaj7·B7) + hi-pass ── +const stab = note("<[e3,g3,b3,d4] [e3,g3,b3,d4] [c3,e3,g3,b3] [b2,ds3,fs3,a3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ b3 ~ g3 ~ e3 ~] [~ ~ b3 ~ g3 ~ e3 ~] [~ ~ c4 ~ g3 ~ e3 ~] [~ ~ b3 ~ fs3 ~ ds3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) // ── LA MULTITUD (oleadas de ruido blanco, estadio) ── const multitud = s("white*2").attack(.35).decay(.6).sustain(.3).release(.5) .lpf(1500).hpf(300).gain(sine.slow(8).range(.12,.3)) .pan(sine.slow(5).range(.3,.7)).room(.6).rsize(8).orbit(4) -// ── BATERÍA 909 MILITAR ── +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── const stomp = s("bd ~ bd ~").bank("RolandTR909").shape(.5).gain(1.1).orbit(0) const stompClap = s("~ ~ cp ~").bank("RolandTR909").room(.4).rsize(5).gain(.8).orbit(0) -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(1) .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0) const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0) + .gain(perlin.range(.25,.5)).swingBy(1/24,16).pan(rand.range(.35,.65)).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.35).orbit(0) const sdGhost = s("sd(5,16,2)").bank("RolandTR909").gain(.28) .pan(rand.range(.3,.7)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) const rodilloMil = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.25,.9)).speed(saw.slow(4).range(1,1.3)).orbit(0) -// ── CUERDAS ÉPICAS (Em→Em→C→B) ── -const cuerdas = note("<[e3,g3,b3] [e3,g3,b3] [c3,g3,c4] [b2,ds3,fs3]>") +// ── CUERDAS ÉPICAS (Em7→Em7→Cmaj7→B7, hi-pass) ── +const cuerdas = note("<[e3,g3,b3,d4] [e3,g3,b3,d4] [c3,e3,g3,b3] [b2,ds3,fs3,a3]>") .s("supersaw").unison(6).spread(.8) - .lpf(sine.slow(32).range(400,2200)).attack(.5).release(1) - .room(.6).rsize(7).gain(.38).orbit(4) + .lpf(sine.slow(32).range(400,2200)).hpf(200).attack(.5).release(1) + .room(.6).rsize(7).gain(.36).orbit(4) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const introStomp = stack(stomp, stompClap, multitud) const introRiff = stack(kick, hats, riff.lpf(500).gain(.6), multitud.gain(.15)) const build = stack(kick, hats16, clap, sdGhost, riff, riffSub.gain(.4), cuerdas.gain(.25)) -const buildFin = stack(kickHard, rodilloMil, riff, riffLead.gain(.4)) -const dropRiff = stack(kickHard, hats16, hats, clap, sdGhost, - riff, riffSub) -const dropRiffVar = stack(kickHard, hats16, hats, clap, ride, sdGhost, - riff, riffSub, riffLead.gain(.45), multitud.gain(.12)) +const buildFin = stack(kickHard, rodilloMil, riser, riff, riffLead.gain(.4)) +const dropRiff = stack(kickHard, hats16, hats, clap, sdGhost, ghost, + riff, riffSub, leadLimpio, stab) +const dropRiffVar = stack(kickHard, hats16, hats, clap, ride, sdGhost, ghost, + riff, riffSub, bajoOff, riffLead.gain(.45), multitud.gain(.12), leadLimpio, stab, contra) const breakEstadio = stack(multitud.gain(.3), cuerdas, - riffLead.gain(.55).room(.8), stomp.gain(.5), stompClap.gain(.5)) -const breakBuild = stack(multitud.gain(.2), cuerdas, riff.lpf(800).gain(.7), + riffLead.gain(.55).room(.8), stomp.gain(.5), stompClap.gain(.5), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(multitud.gain(.2), cuerdas, riser, riff.lpf(800).gain(.7), rodilloMil, hats16.gain(.4)) -const dropOctavas = stack(kickHard, hats16, hats, clap, sdGhost, - riffOctavas, riffSub, riffLead.gain(.5)) -const dropOctavasFull = stack(kickHard, hats16, hats, clap, ride, sdGhost, - riffOctavas, riffSub, riffLead, cuerdas.gain(.28), multitud.gain(.12)) -const dropFinal = stack(kickHard, hats16, hats, clap, ride, - riffOctavas.sometimesBy(.2, x=>x.ply(2)), riffSub, - riffLead.every(4, x=>x.add(note(12)).gain(.4)), cuerdas.gain(.3)) +const dropOctavas = stack(kickHard, hats16, hats, clap, sdGhost, ghost, + riffOctavas, riffSub, riffLead.gain(.5), leadLimpio, stab) +const dropOctavasFull = stack(kickHard, hats16, hats, clap, ride, sdGhost, ghost, + riffOctavas, riffSub, bajoOff, riffLead, cuerdas.gain(.28), multitud.gain(.12), leadLimpio, stab, contra) +const dropFinal = stack(kickHard, hats16, hats, clap, ride, ghost, + riffOctavas.sometimesBy(.2, x=>x.ply(2)), riffSub, bajoOff, + riffLead.every(4, x=>x.add(note(12)).gain(.4)), cuerdas.gain(.3), leadLimpio, stab, contra) const coda = stack(kick, hats, clap, riff.lpf(700).gain(.7), - riffSub.gain(.5), cuerdas, multitud.gain(.15)) + riffSub.gain(.5), cuerdas, multitud.gain(.15), leadLimpio.gain(.4)) const codaFin = stack(multitud, cuerdas.gain(.3), riffLead.gain(.3).room(.9).delayfeedback(.6), stomp.gain(.4)) @@ -4373,14 +6179,18 @@ arrange( [16, dropFinal], [12, coda], [8, codaFin] -)`, +) +`, }, { name: "47 · kids melodic — mgmt (2008)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 47 · KIDS MELODIC — MGMT (2008) → Melodic Techno Remix -// 128 BPM · Am · TR-909 · tipo Afterlife: supersaw suave + arpegio contrapunto +// 128 BPM · Am (i·i·VII·VI = Am·Am·G·F) · TR-909 · tipo Afterlife +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado A·A·G·F) + bajo/sub +// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass +// + carácter peak-time + riser. Estructura conservada. // Estructura: intro→build→drop A→breakdown emotivo largo→drop B→coda (152 compases ≈ 4:45) // ════════════════════════════════════════════════════════════════ setcps(128/60/4) @@ -4393,6 +6203,26 @@ const hook = note("a4 ~ c5 b4 a4 g4 a4 e5 d5 c5 b4 c5 b4 a4 g4 ~") .room(.5).rsize(6).gain(.75).pan(sine.slow(10).range(.35,.65)).orbit(2) const hookEco = hook.add(note(12)).gain(.25).late(.125).lpf(3000).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("a4 ~ c5 b4 a4 g4 a4 e5 d5 c5 b4 c5 b4 a4 g4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Am7·Am7·G7·Fmaj7) + hi-pass ── +const stab = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ e4 ~ c4 ~] [~ ~ a4 ~ e4 ~ c4 ~] [~ ~ g4 ~ d4 ~ b3 ~] [~ ~ f4 ~ c4 ~ a3 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── ARPEGIO CONTRAPUNTO (a2 e3 a3 c4 en 16avos) ── const arpegio = note("[a2 e3 a3 c4]*4").add(note("<0 0 -2 -4>")) .s("triangle").lpf(sine.slow(16).range(700,2200)) @@ -4400,33 +6230,46 @@ const arpegio = note("[a2 e3 a3 c4]*4").add(note("<0 0 -2 -4>")) .delay(.2).delaytime(.1875).delayfeedback(.3) .gain(.6).pan(.4).orbit(3) -// ── BAJO PULSANTE (corcheas, progresión Am→Am→G→F) ── +// ── BAJO PULSANTE (corcheas, sigue las fundamentales A·A·G·F) ── const bajo = note("a1*8").add(note("<0 0 -2 -4>")) - .s("sawtooth").lpf(600).lpq(6).attack(.002).decay(.14).sustain(.25).release(.04) - .shape(.25).gain("[.9 .55]*4").orbit(1) + .s("sawtooth").lpf(perlin.slow(4).range(500,1100)).lpq(6).attack(.002).decay(.14).sustain(.25).release(.04) + .shape(.3).coarse(1).gain("[.9 .55]*4").orbit(1) const bajoSub = note("").s("sine") .attack(.05).decay(.5).sustain(.5).gain(.55).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) -// ── BATERÍA 909 ELEGANTE ── -const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92) .duck("1:2").duckattack(.14).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.2).gain(.98) .duck("1:2").duckattack(.14).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.04)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.65).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.45).pan(.6).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.45).pan(.6).orbit(0) const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.42 .2 .3 .2]*4").pan(rand.range(.4,.6)).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.25).pan(.35).orbit(0) + .gain(perlin.range(.22,.45)).swingBy(1/24,16).pan(rand.range(.4,.6)).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.25).pan(.35).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.15,.7)).speed(saw.slow(4).range(1,1.3)).orbit(0) -// ── PADS OSCUROS Y CUERDAS ── +// ── PADS OSCUROS Y CUERDAS (7as, hi-pass para dejar el sub libre) ── const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>") - .s("sawtooth").lpf(550).attack(1).release(1.8) + .s("sawtooth").lpf(550).hpf(150).attack(1).release(1.8) .room(.75).rsize(8).gain(.4).orbit(4) const cuerdas = note("").s("supersaw").unison(5).spread(.7) - .lpf(sine.slow(32).range(350,1800)).attack(.6).release(1) + .lpf(sine.slow(32).range(350,1800)).hpf(200).attack(.6).release(1) .vib(4).vibmod(.15).room(.6).rsize(6).gain(.3).orbit(4) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4), pad.gain(.25)) @@ -4434,25 +6277,25 @@ const introB = stack(kick, hats, clap.gain(.4), bajo.lpf(400).gain(.6), arpegio.lpf(900).gain(.4)) const build = stack(kick, hats16, clap, bajo, arpegio, pad, hook.lpf(saw.slow(16).range(400,2000)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, arpegio, hook.gain(.6)) -const dropA = stack(kickHard, hats16, hats, clap, bajo, bajoSub, - arpegio, hook) -const dropAvar = stack(kickHard, hats16, hats, clap, ride, bajo, bajoSub, - arpegio, hook, hookEco, cuerdas) +const buildFin = stack(kickHard, rodillo, riser, bajo, arpegio, hook.gain(.6)) +const dropA = stack(kickHard, hats16, hats, clap, ghost, bajo, bajoSub, + arpegio, hook, leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hats, clap, ride, ghost, bajo, bajoSub, bajoOff, + arpegio, hook, hookEco, cuerdas, leadLimpio, stab, contra) const breakdown = stack(pad, cuerdas, hook.gain(.6).room(.85).rsize(9), - arpegio.lpf(800).gain(.4), bajoSub.gain(.3)) -const breakBuild = stack(pad, cuerdas, hook.gain(.7), arpegio, + arpegio.lpf(800).gain(.4), bajoSub.gain(.3), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pad, cuerdas, riser, hook.gain(.7), arpegio, rodillo, hats16.gain(.35)) -const dropB = stack(kickHard, hats16, hats, clap, bajo, bajoSub, - arpegio, hook, hookEco) -const dropBFull = stack(kickHard, hats16, hats, clap, ride, bajo, bajoSub, +const dropB = stack(kickHard, hats16, hats, clap, ghost, bajo, bajoSub, + arpegio, hook, hookEco, leadLimpio, stab) +const dropBFull = stack(kickHard, hats16, hats, clap, ride, ghost, bajo, bajoSub, bajoOff, arpegio.sometimesBy(.2, x=>x.add(note(12)).gain(.4)), hook, hookEco, - cuerdas, pad.gain(.2)) -const dropBvar = stack(kickHard, hats16, clap, ride, - bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, - arpegio, hook.every(4, x=>x.iter(4)), hookEco, cuerdas) + cuerdas, pad.gain(.2), leadLimpio, stab, contra) +const dropBvar = stack(kickHard, hats16, clap, ride, ghost, + bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + arpegio, hook.every(4, x=>x.iter(4)), hookEco, cuerdas, leadLimpio, stab, contra) const coda = stack(kick, hats, bajo.lpf(500).gain(.65), - hook.gain(.45).room(.7), arpegio.gain(.4), pad) + hook.gain(.45).room(.7), arpegio.gain(.4), pad, leadLimpio.gain(.4)) const codaFin = stack(hats.gain(.25), hook.gain(.3).room(.9).delayfeedback(.65), pad.gain(.3), cuerdas.gain(.2)) @@ -4471,14 +6314,18 @@ arrange( [16, dropBvar], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "48 · hung up disco — madonna sobre abba (2005)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 48 · HUNG UP DISCO — Madonna sobre ABBA (2005) → Disco Techno Remix -// 126 BPM · Dm · TR-909 · arpegio ABBA con phaser + tick-tock de reloj +// 126 BPM · Dm (i·i·i·VII = Dm·Dm·Dm·C) · TR-909 · arpegio ABBA con phaser +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado D·D·D·C) + bajo/sub +// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass +// + carácter peak-time (distort) + riser. Estructura conservada. // Estructura: intro→motor arpegio→drop disco→break reloj→drop brillante→coda (144 compases ≈ 4:34) // ════════════════════════════════════════════════════════════════ setcps(126/60/4) @@ -4497,38 +6344,71 @@ const hook = note("a4 ~ a4 g4 f4 g4 a4 d5 ~ c5 a4 g4 f4 ~ e4 ~") .delay(.3).delaytime(.25).delayfeedback(.35) .room(.4).rsize(5).gain(.8).pan(sine.slow(9).range(.35,.65)).orbit(2) +// ── LEAD LIMPIO (la melodía real, nítida y al frente) ── +const leadLimpio = note("a4 ~ a4 g4 f4 g4 a4 d5 ~ c5 a4 g4 f4 ~ e4 ~") + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Dm7·Dm7·Dm7·Cadd9) + hi-pass ── +const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + // ── TICK-TOCK DE RELOJ (rim panorámico, como el original) ── const reloj = s("rim*4").bank("RolandTR909") .speed("1 .82 1 .82").pan("0.15 0.85 0.15 0.85") .gain(.6).room(.4).rsize(4) .delay(.3).delaytime(.375).delayfeedback(.4).orbit(3) -// ── BAJO DISCO CON OCTAVAS (Dm→Dm→Dm→C) ── +// ── BAJO DISCO CON OCTAVAS (sigue las fundamentales D·D·D·C) ── const bajo = note("d1 [~ d2] d1 [~ d2] d1 [~ d2] d1 [~ d2]") .add(note("<0 0 0 -2>")) .s("sawtooth").lpf(800).lpq(4).attack(.003).decay(.15).sustain(.3).release(.05) - .shape(.2).gain(.9).orbit(1) + .shape(.3).coarse(1).gain(.9).orbit(1) const bajoSub = note("").s("sine") .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.4).duck("1").orbit(1) -// ── STRINGS DISCO (supersaw brillante) ── -const cuerdas = note("<[d3,f3,a3] [d3,f3,a3] [d3,f3,a3] [c3,e3,g3]>") +// ── STRINGS DISCO (supersaw brillante, 7as, hi-pass) ── +const cuerdas = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3]>") .s("supersaw").unison(6).spread(.8) - .lpf(sine.slow(16).range(500,2000)).attack(.4).release(.9) + .lpf(sine.slow(16).range(500,2000)).hpf(200).attack(.4).release(.9) .room(.55).rsize(6).gain(.4).orbit(4) -// ── BATERÍA 909 DISCO ── -const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(1) .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0) -const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0) +const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0) const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.48 .22 .34 .22]*4").pan(rand.range(.4,.6)).orbit(0) + .gain(perlin.range(.22,.48)).swingBy(1/24,16).pan(rand.range(.4,.6)).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.8)).speed(saw.slow(4).range(1,1.35)).orbit(0) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4), reloj.gain(.3)) @@ -4536,27 +6416,27 @@ const introB = stack(kick, hats, hatOpen, clap.gain(.45), arpegio.lpf(700).gain(.5)) const motor = stack(kick, hats16, hats, clap, bajo, arpegio, cuerdas.gain(.25)) -const motorFin = stack(kickHard, rodillo, bajo, arpegio, +const motorFin = stack(kickHard, rodillo, riser, bajo, arpegio, hook.lpf(900).gain(.5)) -const dropDisco = stack(kickHard, hats16, hats, hatOpen, clap, - bajo, bajoSub, arpegio, hook) -const dropDiscoVar = stack(kickHard, hats16, hats, hatOpen, clap, - bajo, bajoSub, arpegio, arpegioAlto, hook, cuerdas.gain(.3)) +const dropDisco = stack(kickHard, hats16, hats, hatOpen, clap, ghost, + bajo, bajoSub, arpegio, hook, leadLimpio, stab) +const dropDiscoVar = stack(kickHard, hats16, hats, hatOpen, clap, ghost, + bajo, bajoSub, bajoOff, arpegio, arpegioAlto, hook, cuerdas.gain(.3), leadLimpio, stab, contra) const breakReloj = stack(reloj, cuerdas, hook.gain(.55).room(.75), - bajoSub.gain(.3), hats.gain(.25)) -const breakBuild = stack(reloj.gain(.4), cuerdas, hook.gain(.65), + bajoSub.gain(.3), hats.gain(.25), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(reloj.gain(.4), cuerdas, hook.gain(.65), riser, arpegio.lpf(saw.slow(8).range(600,2200)).gain(.6), rodillo, hats16.gain(.35)) -const dropBrillante = stack(kickHard, hats16, hats, hatOpen, clap, - bajo, bajoSub, arpegio.lpf(2400), arpegioAlto, hook, cuerdas.gain(.32)) -const dropBrillanteVar = stack(kickHard, hats16, hatOpen, clap, - bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, +const dropBrillante = stack(kickHard, hats16, hats, hatOpen, clap, ghost, + bajo, bajoSub, arpegio.lpf(2400), arpegioAlto, hook, cuerdas.gain(.32), leadLimpio, stab) +const dropBrillanteVar = stack(kickHard, hats16, hatOpen, clap, ghost, + bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, arpegio.every(4, x=>x.rev()), arpegioAlto, hook, cuerdas.gain(.32), - reloj.gain(.25)) + reloj.gain(.25), leadLimpio, stab, contra) const salida = stack(kick, hats, clap, bajo, arpegio.gain(.6), hook.gain(.5), cuerdas.gain(.25)) const coda = stack(kick, hats, bajo.lpf(550).gain(.7), - arpegio.lpf(900).gain(.45), hook.gain(.4).room(.7), cuerdas) + arpegio.lpf(900).gain(.45), hook.gain(.4).room(.7), cuerdas, leadLimpio.gain(.4)) const codaFin = stack(reloj.gain(.4), hook.gain(.3).room(.9).delayfeedback(.6), cuerdas.gain(.25)) @@ -4575,14 +6455,18 @@ arrange( [12, salida], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "49 · touch me deep — rui da silva (2001)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 49 · TOUCH ME DEEP — Rui da Silva (2001) → Deep Progressive Remix -// 126 BPM · Am · TR-909 + piano · nocturno, sensual, subida lenta +// 126 BPM · Am (i·VII·VI·VII = Am·G·F·G) · TR-909 + piano · nocturno +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado A·G·F·G) + bajo/sub +// que siguen los acordes + groove (swing+ghost+velocity) + pad con 7as e hi-pass +// + carácter peak-time + riser. Estructura conservada. // Estructura: intro→groove profundo→drop piano→break piano solo→drop abierto→coda (144 compases ≈ 4:34) // ════════════════════════════════════════════════════════════════ setcps(126/60/4) @@ -4595,58 +6479,85 @@ const piano = note("a3 c4 e4 a4 g4 e4 c4 e4").add(note("<0 -2 -4 -2>")) const pianoAlto = piano.add(note(12)).gain(.3).room(.7).orbit(2) const pianoSolo = piano.room(.85).rsize(9).delayfeedback(.5).gain(.85) -// ── BAJO PROFUNDO Y REDONDO (triangle, sigue la progresión) ── +// ── LEAD LIMPIO (el riff de piano una octava arriba, nítido y al frente) ── +const leadLimpio = note("a3 c4 e4 a4 g4 e4 c4 e4").add(note("<12 10 8 10>")) + .s("triangle").lpf(5000).lpq(1) + .attack(.005).decay(.2).sustain(.4).release(.16) + .room(.32).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25) + .gain(.5).pan(.5).orbit(2) + +// ── CONTRAMELODÍA (zona media, Am·G·F·G) ── +const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>") + .s("triangle").lpf(2700).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.3).pan(.62).orbit(3) + +// ── BAJO PROFUNDO Y REDONDO (triangle, sigue las fundamentales A·G·F·G) ── const bajo = note("a1 ~ [~ a1] ~ a1 ~ [~ a1] ~").add(note("<0 -2 -4 -2>")) .s("triangle").lpf(500).attack(.01).decay(.3).sustain(.5).release(.08) - .shape(.15).gain(.95).orbit(1) + .shape(.18).gain(.95).orbit(1) const bajoSub = note("").s("sine") .attack(.05).decay(.5).sustain(.55).gain(.55).orbit(1) +// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.38).duck("1").orbit(1) -// ── BATERÍA 909 SEDOSA ── -const kick = s("bd*4").bank("RolandTR909").shape(.3).gain(1) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.48).gain(.9) .duck("1:2").duckattack(.15).duckdepth(.45).orbit(0) -const kickHondo = s("bd*4").bank("RolandTR909").shape(.4).gain(1.06) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0) +const kickHondoClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.58).distort(1.15).gain(.96) .duck("1:2").duckattack(.15).duckdepth(.55).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHondo = stack(kickHondoClick, kickBoom.gain(1.04)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).rsize(4).gain(.6).orbit(0) -const hats = s("[~ hh]*4").bank("RolandTR909").gain(.45).hpf(8000).pan(.6).orbit(0) +const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.45).hpf(8000).pan(.6).orbit(0) const hats16 = s("hh*16").bank("RolandTR909") .gain(rand.range(.12,.35)).hpf(9000).swingBy(.04, 8) .pan(rand.range(.35,.65)).orbit(0) const rimSuave = s("~ ~ ~ rim ~ ~ rim ~").bank("RolandTR909") .gain(.35).pan(.35).room(.3).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.26)).hpf(400).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(8).range(.1,.6)).speed(saw.slow(8).range(1,1.25)).orbit(0) -// ── VOZ SINTÉTICA Y PAD NOCTURNO ── +// ── VOZ SINTÉTICA Y PAD NOCTURNO (sigue los acordes, con 7as e hi-pass) ── const voz = note("").s("sawtooth").vowel("") - .attack(.7).release(1.2).lpf(1500) + .attack(.7).release(1.2).lpf(1500).hpf(160) .room(.7).rsize(8).gain(.35).orbit(4) -const pad = note("<[a2,c3,e3] [g2,b2,d3] [f2,a2,c3] [g2,b2,d3]>") - .s("sawtooth").lpf(sine.slow(32).range(350,900)).attack(1.2).release(2) +const pad = note("<[a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3] [g2,b2,d3,f3]>") + .s("sawtooth").lpf(sine.slow(32).range(350,900)).hpf(150).attack(1.2).release(2) .room(.75).rsize(8).gain(.38).orbit(4) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, bajoSub.gain(.4)) const introB = stack(kick, hats, rimSuave, clap.gain(.4), bajo.lpf(350).gain(.7)) const groove = stack(kick, hats, hats16, clap, rimSuave, bajo, bajoSub, - piano.lpf(saw.slow(32).range(600,3500)).gain(.6)) -const grooveFin = stack(kickHondo, rodillo, bajo, piano.gain(.7)) -const dropPiano = stack(kickHondo, hats, hats16, clap, rimSuave, - bajo, bajoSub, piano) -const dropPianoVar = stack(kickHondo, hats, hats16, clap, rimSuave, - bajo, bajoSub, piano, pianoAlto, voz) -const breakPiano = stack(pianoSolo, bajoSub.gain(.25), hats.gain(.2)) -const breakBuild = stack(pianoSolo.gain(.75), pad, voz, + piano.lpf(saw.slow(32).range(600,3500)).gain(.6), leadLimpio.gain(.42)) +const grooveFin = stack(kickHondo, rodillo, riser, bajo, piano.gain(.7), leadLimpio.gain(.5)) +const dropPiano = stack(kickHondo, hats, hats16, clap, rimSuave, ghost, + bajo, bajoSub, piano, leadLimpio, contra) +const dropPianoVar = stack(kickHondo, hats, hats16, clap, rimSuave, ghost, + bajo, bajoSub, bajoOff, piano, pianoAlto, voz, leadLimpio, contra) +const breakPiano = stack(pianoSolo, bajoSub.gain(.25), hats.gain(.2), contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(pianoSolo.gain(.75), pad, voz, riser, rodillo, hats16.gain(.3), bajo.lpf(400).gain(.6)) -const dropAbierto = stack(kickHondo, hats, hats16, clap, rimSuave, - bajo, bajoSub, piano, pianoAlto, pad.gain(.25)) -const dropAbiertoVar = stack(kickHondo, hats16, clap, rimSuave, - bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, - piano.every(4, x=>x.rev()), pianoAlto, voz, pad.gain(.25)) +const dropAbierto = stack(kickHondo, hats, hats16, clap, rimSuave, ghost, + bajo, bajoSub, piano, pianoAlto, pad.gain(.25), leadLimpio, contra) +const dropAbiertoVar = stack(kickHondo, hats16, clap, rimSuave, ghost, + bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, + piano.every(4, x=>x.rev()), pianoAlto, voz, pad.gain(.25), leadLimpio, contra) const salida = stack(kick, hats, clap, bajo, piano.gain(.6), voz.gain(.25)) const coda = stack(kick, hats, bajo.lpf(400).gain(.7), - piano.gain(.5).room(.75), pad) + piano.gain(.5).room(.75), pad, leadLimpio.gain(.4)) const codaFin = stack(pianoSolo.gain(.4).delayfeedback(.6), pad.gain(.3), voz.gain(.25), hats.gain(.2)) @@ -4665,14 +6576,18 @@ arrange( [12, salida], [8, coda], [4, codaFin] -)`, +) +`, }, { name: "50 · adagio big room — tiësto / samuel barber (2005)", folder: "remixes 2000s", code: `// ════════════════════════════════════════════════════════════════ // 50 · ADAGIO BIG ROOM — Tiësto / Samuel Barber (2005) → Big Room Trance Remix -// 140 BPM · Am · TR-909 · cuerdas supersaw masivas · el cierre épico de la colección +// 140 BPM · Am (i·iv·III·v = Am·Dm·C·Em) · TR-909 · cuerdas supersaw masivas +// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado A·D·C·E) + bajo/sub +// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass +// + carácter peak-time (distort) + riser. Estructura conservada. // Estructura: intro→build→drop A→breakdown orquestal 20→drop final devastador→coda en cuerdas (172 compases ≈ 4:55) // ════════════════════════════════════════════════════════════════ setcps(140/60/4) @@ -4687,10 +6602,31 @@ const melodia = note("e4 f4 e4 d4 e4 ~ f4 g4 f4 e4 f4 ~ g4 a4 g4 f4 g4 ~ a4 ~") const melodiaOctava = melodia.add(note(12)).gain(.3).lpf(3400).orbit(2) const melodiaSola = melodia.room(.95).rsize(10).lpf(2800).gain(.7) -// ── CUERDAS MASIVAS (Am→Dm→C→Em, unison 7 spread .9) ── -const cuerdas = note("<[a2,c3,e3] [d3,f3,a3] [c3,e3,g3] [e3,g3,b3]>") +// ── LEAD LIMPIO (la melodía real, nítida y al frente · .slow(4) para alinear con melodia) ── +const leadLimpio = note("e4 f4 e4 d4 e4 ~ f4 g4 f4 e4 f4 ~ g4 a4 g4 f4 g4 ~ a4 ~") + .slow(4).clip(1.5) + .s("triangle").lpf(5000).lpq(1) + .attack(.004).decay(.18).sustain(.5).release(.14) + .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2) + .gain(.6).pan(.5).orbit(2) + +// ── ZONA MEDIA: stab armónico con 7as (Am7·Dm7·Cmaj7·Em7) + hi-pass ── +const stab = note("<[a2,c3,e3,g3] [d3,f3,a3,c4] [c3,e3,g3,b3] [e3,g3,b3,d4]>") + .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4) + .attack(.004).decay(.13).sustain(.08).release(.08) + .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3) + +const contra = note("<[~ ~ a4 ~ e4 ~ c4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ b4 ~ g4 ~ e4 ~]>") + .s("triangle").lpf(2800).lpq(2) + .attack(.004).decay(.15).sustain(.2).release(.1) + .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3) + .gain(.32).pan(.62).orbit(3) + +// ── CUERDAS MASIVAS (Am7→Dm7→Cmaj7→Em7, unison 7 spread .9, hi-pass) ── +const cuerdas = note("<[a2,c3,e3,g3] [d3,f3,a3,c4] [c3,e3,g3,b3] [e3,g3,b3,d4]>") .s("supersaw").unison(7).spread(.9) - .lpf(sine.slow(32).range(400,2400)).attack(.8).release(1.6) + .lpf(sine.slow(32).range(400,2400)).hpf(200).attack(.8).release(1.6) .room(.8).rsize(9).gain(.45).orbit(4) const cuerdasBajas = note("").s("sawtooth").lpf(400) .attack(.5).release(1).room(.5).gain(.4).orbit(4) @@ -4698,30 +6634,43 @@ const cuerdasBajas = note("").s("sawtooth").lpf(400) // ── BAJO TRANCE (offbeat, sigue la progresión A→D→C→E) ── const bajo = note("[~ a1]*4").add(note("<0 5 3 7>")) .s("sawtooth").lpf(700).lpq(5).attack(.002).decay(.18).sustain(.3).release(.05) - .shape(.3).gain(.95).orbit(1) + .shape(.3).coarse(1).gain(.95).orbit(1) const bajoFin = note("a1*8").add(note("<0 5 3 7>")) .s("sawtooth").lpf(perlin.slow(8).range(500,1200)).lpq(7) .attack(.001).decay(.1).sustain(.2).release(.03) - .shape(.35).gain("[1 .6]*4").orbit(1) + .shape(.35).coarse(1).gain("[1 .6]*4").orbit(1) const bajoSub = note("").s("sine") .attack(.03).decay(.5).sustain(.5).gain(.55).orbit(1) +// ── BAJO OFFBEAT REFUERZO (sigue raíces, en el clímax) ── +const bajoOff = note("").struct("~ x ~ x ~ x ~ x").s("sawtooth") + .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04) + .shape(.2).gain(.38).duck("1").orbit(1) -// ── BATERÍA 909 BIG ROOM ── -const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) +// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ── +const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95) .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) -const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) +const kickBoom = note("").struct("x*4").s("sine") + .penv(26).pattack(.001).pdecay(.05).pcurve(0) + .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0) +const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(1) .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +const kick = stack(kickClick, kickBoom) +const kickHard = stack(kickHardClick, kickBoom.gain(1.05)) const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0) -const hats = s("hh*8").bank("RolandTR909").gain(.4).pan(.6).orbit(0) -const hatsOff = s("[~ oh]*4").bank("RolandTR909").gain(.55).orbit(0) +const hats = s("hh*8").bank("RolandTR909").swingBy(1/24,8).gain(.4).pan(.6).orbit(0) +const hatsOff = s("[~ oh]*4").bank("RolandTR909").nudge(.004).gain(.55).orbit(0) const hats16 = s("hh*16").bank("RolandTR909") - .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0) -const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0) + .gain(perlin.range(.25,.5)).swingBy(1/24,16).pan(rand.range(.35,.65)).orbit(0) +const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.35).orbit(0) const crash = s("cr/4").bank("RolandTR909").gain(.5).room(.5).rsize(5).orbit(0) +const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0) const rodillo = s("sd*16").bank("RolandTR909") .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.4)).orbit(0) const rodilloLargo = s("sd*16").bank("RolandTR909") .gain(saw.slow(8).range(.1,.8)).speed(saw.slow(8).range(1,1.35)).orbit(0) +// ── RISER de ruido filtrado para transiciones ── +const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000)) + .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4) // ── SECCIONES ── const intro = stack(kick, hats, cuerdasBajas.gain(.25)) @@ -4729,28 +6678,28 @@ const introB = stack(kick, hats, hatsOff, clap.gain(.45), bajo.lpf(400).gain(.6), cuerdasBajas.gain(.3)) const build = stack(kick, hats16, clap, bajo, cuerdas.gain(.35), melodia.lpf(saw.slow(16).range(400,2200)).gain(.5)) -const buildFin = stack(kickHard, rodillo, bajo, melodia.gain(.65)) -const dropA = stack(kickHard, hats16, hatsOff, clap, crash, - bajo, bajoSub, melodia, cuerdas.gain(.3)) -const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, crash, - bajo, bajoSub, melodia, melodiaOctava, cuerdas.gain(.35)) -const breakdown = stack(melodiaSola, cuerdas, cuerdasBajas) -const breakBuild = stack(melodiaSola.gain(.75), cuerdas, cuerdasBajas, +const buildFin = stack(kickHard, rodillo, riser, bajo, melodia.gain(.65)) +const dropA = stack(kickHard, hats16, hatsOff, clap, crash, ghost, + bajo, bajoSub, melodia, cuerdas.gain(.3), leadLimpio, stab) +const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, crash, ghost, + bajo, bajoSub, melodia, melodiaOctava, cuerdas.gain(.35), leadLimpio, stab, contra) +const breakdown = stack(melodiaSola, cuerdas, cuerdasBajas, contra, leadLimpio.gain(.42).room(.7)) +const breakBuild = stack(melodiaSola.gain(.75), cuerdas, cuerdasBajas, riser, rodilloLargo, hats16.gain(.3), bajo.lpf(450).gain(.5)) -const buildFin2 = stack(kickHard, rodillo, melodia, cuerdas.gain(.4)) -const dropFinal = stack(kickHard, hats16, hatsOff, clap, crash, - bajoFin, bajoSub, melodia, melodiaOctava) -const dropFinalFull = stack(kickHard, hats16, hatsOff, clap, ride, crash, +const buildFin2 = stack(kickHard, rodillo, riser, melodia, cuerdas.gain(.4)) +const dropFinal = stack(kickHard, hats16, hatsOff, clap, crash, ghost, + bajoFin, bajoSub, melodia, melodiaOctava, leadLimpio, stab) +const dropFinalFull = stack(kickHard, hats16, hatsOff, clap, ride, crash, ghost, bajoFin, bajoSub, melodia, melodiaOctava, cuerdas.gain(.4), - cuerdasBajas.gain(.3)) -const dropFinalVar = stack(kickHard, hats16, hatsOff, clap, ride, - bajoFin.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, + cuerdasBajas.gain(.3), leadLimpio, stab, contra) +const dropFinalVar = stack(kickHard, hats16, hatsOff, clap, ride, ghost, + bajoFin.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, melodia, melodiaOctava.every(4, x=>x.add(note(12)).gain(.2)), - cuerdas.gain(.4)) + cuerdas.gain(.4), leadLimpio, stab, contra) const salida = stack(kick, hats, clap, bajo, melodia.gain(.55), cuerdas.gain(.35)) const coda = stack(melodiaSola.gain(.6), cuerdas, cuerdasBajas, - hats.gain(.25), bajoSub.gain(.3)) + hats.gain(.25), bajoSub.gain(.3), leadLimpio.gain(.4)) const codaFin = stack(melodiaSola.gain(.35).delayfeedback(.6), cuerdas.gain(.25), cuerdasBajas.gain(.2)) @@ -4771,6 +6720,7 @@ arrange( [8, salida], [8, coda], [8, codaFin] -)`, +) +`, }, ];