From 970b89b08c9c1bf7bfe1b9d76eb8ada0fc0d2777 Mon Sep 17 00:00:00 2001 From: hacklab Date: Fri, 17 Jul 2026 02:10:41 +0200 Subject: [PATCH] Projects: incluye los 50 remixes retro en la libreria de fabrica Remixes 80s/90s/2000s escritos en codigo Strudel (sin samples de los originales). Sube DEFAULT_VERSION para que la siembra solo-anadir los incorpore en instalaciones existentes. --- .gitignore | 1 - README.md | 3 +- .../components/panel/default-projects.mjs | 11 +- .../repl/components/panel/remix-projects.mjs | 4776 +++++++++++++++++ 4 files changed, 4785 insertions(+), 6 deletions(-) create mode 100644 website/src/repl/components/panel/remix-projects.mjs diff --git a/.gitignore b/.gitignore index ca781aa6..18e1ddc5 100644 --- a/.gitignore +++ b/.gitignore @@ -149,4 +149,3 @@ samples/* # --- fork hacklab: material personal que no se publica --- my-patterns/ strudel-server.log -website/src/repl/components/panel/remix-projects.mjs diff --git a/README.md b/README.md index 81fbb0a8..ec9680d3 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,8 @@ pinchar en directo. Misma licencia que upstream: AGPL-3.0 (ver `LICENSE`). - Interfaz multiidioma (castellano, inglés, francés, alemán, italiano, portugués y más). Selector en el header. - Pestaña Projects: proyectos locales con carpetas, buscador y una librería - de tracks de fábrica para empezar a pinchar. + de tracks de fábrica para empezar a pinchar: bases techno/acid originales + y 50 remixes retro (80s/90s/2000s) escritos en código. - Barra de transporte bajo el editor: anterior / play-pausa / siguiente, tiempo y barra de progreso arrastrable (seek real sobre el reloj del scheduler). Al cargar un track el loop arranca desde cero; editar y diff --git a/website/src/repl/components/panel/default-projects.mjs b/website/src/repl/components/panel/default-projects.mjs index df15d9ba..f1d57505 100644 --- a/website/src/repl/components/panel/default-projects.mjs +++ b/website/src/repl/components/panel/default-projects.mjs @@ -10,12 +10,14 @@ // acid largo· temas ~7 min con estructura de directo: intro melódica → drop → // beat melódico (piano/flauta) → subida → clímax (todo junto + 2º // beat + melodía rompiendo ~50s) → descenso ~35s. Cajas VARIADAS. +// remixes → 50 remixes techno de melodías famosas 80s/90s/2000s (128-172 +// compases con arrange()), en remix-projects.mjs // -// Para añadir tu propio pack local sin tocar el repo: crea un modulo con tus -// proyectos (mismo formato {name, folder, code}) y concatenalo abajo en -// DEFAULT_PROJECTS. Los packs personales van fuera del control de versiones. +// Para añadir tu propio pack: crea un modulo con el mismo formato +// {name, folder, code} y concatenalo abajo en DEFAULT_PROJECTS. +import { RETRO_REMIXES } from './remix-projects.mjs'; -export const DEFAULT_VERSION = 6; +export const DEFAULT_VERSION = 7; const CLASSICS = [ { @@ -648,6 +650,7 @@ export const DEFAULT_PROJECTS = [ ...enCarpeta(DETALLE, 'detalle'), ...enCarpeta(ESTILOS, 'techno estilos'), ...enCarpeta(LARGOS, 'acid largo'), + ...RETRO_REMIXES, ].map((p, i) => ({ ...p, created_at: i + 1, diff --git a/website/src/repl/components/panel/remix-projects.mjs b/website/src/repl/components/panel/remix-projects.mjs new file mode 100644 index 00000000..13057a82 --- /dev/null +++ b/website/src/repl/components/panel/remix-projects.mjs @@ -0,0 +1,4776 @@ +// Remixes retro (80s/90s/2000s) para la pestaña Projects. +// GENERADO desde my-patterns/RETRO-TECHNO-REMIXES/*.strudel — edita alli y regenera. +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 +// Estructura: intro→build→drop A→break→acid drop→coda (144 compases ≈ 4:22) +// ════════════════════════════════════════════════════════════════ +setcps(132/60/4) + +// ── LA MELODÍA (el hook del sinte-coro, interpretación en Dm) ── +const hook = note("d5 ~ d5 ~ f5 ~ e5 ~ d5 ~ c5 d5 ~ a4 ~ ~") + .s("sawtooth").lpf(1800).lpq(6).attack(.01).release(.12) + .room(.4).rsize(4).delay(.35).delaytime(.375).delayfeedback(.45) + .gain(.8).pan(sine.slow(8).range(.3,.7)).orbit(2) + +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) + .attack(.001).decay(.15).sustain(.3).release(.05) + .shape(.3).gain(.9).orbit(1) + +const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.2) + .gain(.7).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) +const rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) + +// ── CAPA ACID (para el segundo drop) ── +const acid = note("d2 [~ d2] a2 [d2 d3] c3 [~ d2] [eb2 e2] d2") + .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))) + .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) + +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) + +// ── 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, + 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)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropAcid], + [16, dropAcidFull], + [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 +// Estructura: intro→build→drop A→break piano→drop B→coda (140 compases ≈ 4:00) +// ════════════════════════════════════════════════════════════════ +setcps(140/60/4) + +// ── LA MELODÍA (riff exacto de 16avos, dos compases alternados) ── +const melodia = 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]>") + +const riff = melodia.s("supersaw").unison(7).detune(.3).spread(.85) + .lpf(sine.slow(16).range(1400, 3800)).lpq(4) + .attack(.004).release(.14) + .room(.5).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.85).orbit(2) + +const riffCuerpo = melodia.add(note(-12)).s("sawtooth") + .lpf(1600).attack(.004).release(.1) + .gain(.4).pan(sine.slow(6).range(.3,.7)).orbit(2) + +// el riff a medio tiempo en piano, para el breakdown +const riffPiano = melodia.slow(2).add(note(-12)).s("piano") + .room(.85).rsize(8).delay(.45).delaytime(.375).delayfeedback(.5) + .gain(.8).orbit(2) + +// ── 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) + .attack(.001).decay(.11).sustain(.2).release(.03) + .shape(.35).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) + +// ── 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) +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) +// 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)) + .speed(saw.slow(8).range(1, 1.5)).orbit(0) +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]>") + .s("sawtooth").lpf(800).attack(.7).release(1.4) + .room(.7).rsize(8).gain(.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, + 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 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 coda = stack(kick, hats, clap.gain(.4), bajo.lpf(600).gain(.7), + riff.gain(.4).room(.7)) +const codaFin = stack(hats.gain(.35), + riffPiano.gain(.5).room(.9).delayfeedback(.7), pad.gain(.3)) + +// ── ARREGLO (140 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakPiano], + [8, breakBuild], + [16, dropB], + [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 +// 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) + .attack(.002).decay(.18).sustain(.35).release(.05) + .shape(.45).gain(.95).orbit(1) + +const sub = note("").struct("x*4").s("sine") + .decay(.3).sustain(.2).gain(.6).orbit(1) + +// ── HOOK VOCAL (interpretación sintética del estribillo) ── +const voz = note("g4 g4 eb4 g4 c5 ~ bb4 g4") + .s("sawtooth").lpf(1500).lpq(5).attack(.01).release(.2) + .vowel("").room(.5).rsize(6) + .delay(.35).delaytime(.375).delayfeedback(.45) + .gain(.8).orbit(2) + +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) + .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) + .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +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") + .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) +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]>") + .s("sawtooth").lpf(sine.slow(24).range(400, 900)).attack(.9).release(1.6) + .hpf(150).room(.7).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(.9) + .room(.6).gain(.32).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats.gain(.3), sub.gain(.4)) +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 breakdown = stack(pad, cuerdas, voz.gain(.55).room(.8), + hats.gain(.25), sub.gain(.3)) +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)) +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), + pad.gain(.3)) + +// ── ARREGLO (140 compases) ── +arrange( + [8, intro], + [8, introB], + [16, bajoSolo], + [8, build], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBvar], + [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 +// Estructura: intro→groove→build→drop A→break→drop B→coda (136 compases ≈ 4:19) +// ════════════════════════════════════════════════════════════════ +setcps(126/60/4) + +// ── EL BAJO EXACTO (la línea inmortal, redonda: capa sine + capa saw) ── +const linea = "fs1 cs2 e2 fs2 e2 cs2 b1 cs2" +const bajoSine = note(linea).swingBy(1/6, 8).s("sine") + .decay(.25).sustain(.4).release(.06).gain(.75).orbit(1) +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) + +// ── CONTRAMELODÍA DE STRINGS (interpretación) ── +const cuerdas = note("cs5 ~ b4 ~ a4 ~ gs4 fs4") + .s("supersaw").unison(5).spread(.7).detune(.2) + .lpf(sine.slow(16).range(900, 2200)).attack(.15).release(.35) + .room(.55).rsize(6).delay(.3).delaytime(.375).delayfeedback(.35) + .gain(.7).pan(sine.slow(7).range(.35,.65)).orbit(2) + +const cuerdasAlto = cuerdas.add(note(12)).gain(.3).lpf(3000).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]>") + .s("sawtooth").lpf(1900).lpq(6) + .attack(.004).decay(.13).sustain(0).release(.08) + .phaser(.6).phaserdepth(.5).room(.35) + .gain(.7).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) +const clap = s("~ cp ~ cp").bank("LinnDrum").room(.25).gain(.8).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) +const hats16 = s("hh*16").bank("LinnDrum").swingBy(1/6, 16) + .gain(rand.range(.15, .5)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ [~ oh] ~ [~ oh]").bank("LinnDrum").gain(.4).orbit(0) +const rimGhost = s("[~ rim]*4").bank("LinnDrum").swingBy(1/6, 8) + .degradeBy(.4).gain(.32).pan(.4).orbit(0) +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]>") + .s("sawtooth").lpf(750).attack(.8).release(1.4) + .room(.6).rsize(7).gain(.35).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 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)) +const codaFin = stack(hats.gain(.3), bajoSine.gain(.4), + cuerdas.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, grooveA], + [8, build], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// 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]>") + .s("square").lpf(2300).lpq(3) + .attack(.004).decay(.14).sustain(.15).release(.08) + .room(.35).rsize(4).delay(.3).delaytime(.375).delayfeedback(.35) + .gain(.8).pan(sine.slow(6).range(.35,.65)).orbit(2) + +const hookOctava = hook.add(note(12)).gain(.3).lpf(3600).orbit(2) + +// ── LA 303 (protagonista absoluta: lpf modulado lento + lpq alto) ── +const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1") + .s("sawtooth").ftype("ladder") + .lpf(sine.slow(24).range(140, 3200)).lpq(sine.slow(9).range(10, 24)) + .lpenv(4).lpattack(.003).lpdecay(.14) + .shape(.45).gain(.8).rarely(x=>x.add(note(12))) + .delay(.2).delaytime(.1875).delayfeedback(.3).orbit(3) + +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) + +// ── BATERÍA 606 (seca, sin room, puro garaje) ── +const kick = s("bd*4").bank("RolandTR606").shape(.45).gain(1.1) + .duck("2:3").duckattack(.09).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR606").shape(.6).distort(1.1).gain(1.1) + .duck("2:3").duckattack(.09).duckdepth(.6).orbit(0) +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 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]>") + .s("sawtooth").lpf(700).attack(.8).release(1.5) + .room(.65).rsize(7).gain(.35).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 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), + 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 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)) +const codaFin = stack(hats.gain(.3), hook.gain(.3).room(.85).delayfeedback(.65), + pad.gain(.3)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, acidSolo], + [8, build], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBvar], + [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 +// Estructura: intro→ding→build→drop A→break coros→drop B→coda (140 compases ≈ 4:18) +// ════════════════════════════════════════════════════════════════ +setcps(130/60/4) + +// ── EL STAB ICÓNICO ("ding ding", square corto con eco) ── +const ding = note("[d5 d5] ~ ~ ~").s("square") + .attack(.001).decay(.09).sustain(0).release(.04) + .lpf(3200).delay(.4).delaytime(.375).delayfeedback(.5) + .room(.4).rsize(4).gain(.85).orbit(3) + +const dingRespuesta = note("~ ~ [f5 f5] ~").s("square") + .attack(.001).decay(.09).sustain(0).release(.04) + .lpf(3200).delay(.4).delaytime(.375).delayfeedback(.5) + .room(.4).gain(.6).pan(.3).orbit(3) + +// ── VOCAL INTERPRETADO (frase sintética con formantes) ── +const voz = note("d4 f4 d4 c4 a3 c4 d4 ~") + .s("sawtooth").vowel("").lpf(1900) + .attack(.01).release(.15).room(.45).rsize(5) + .delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.8).orbit(2) + +const vozOctava = voz.add(note(12)).gain(.3).orbit(2) + +// ── 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) + .shape(.5).distort(1.05).gain(.8).orbit(1) + +const bajoProg = note("<[d2 d2 d3 d2]!2 [bb1 bb1 bb2 bb1] [a1 a1 a2 a1]>*4") + .s("sawtooth").lpf(750).lpq(7) + .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) + +// ── BATERÍA 808 (snare seca, marcial) ── +const kick = s("bd*4").bank("RolandTR808").shape(.5).gain(1.05) + .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) + .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +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 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") + .gain(.55).orbit(0) +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) + .attack(.6).release(1.2).room(.65).rsize(7) + .gain(.45).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 breakCoros = stack(coros, voz.gain(.55).room(.75), ding.gain(.5), + hats.gain(.25), sub.gain(.3)) +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 coda = stack(kick, hats, snare.gain(.5), bajo.gain(.6), + voz.gain(.45).room(.7), coros.gain(.35)) +const codaFin = stack(hats.gain(.3), ding.gain(.4).delayfeedback(.7), + coros.gain(.3)) + +// ── ARREGLO (140 compases) ── +arrange( + [8, intro], + [8, introDing], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakCoros], + [8, breakBuild], + [16, dropB], + [16, dropBvar], + [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 +// Estructura: intro→stabs→build→drop A→break→drop B→drop C→coda (144 compases ≈ 4:30) +// ════════════════════════════════════════════════════════════════ +setcps(128/60/4) + +// ── LA MELODÍA (tres frases exactas de 16 pasos, alternadas por ciclo) ── +const melodia = note("<[f4 ~ ~ ab4 ~ ~ f4 ~ f4 bb4 ~ f4 ~ eb4 ~ ~] [f4 ~ ~ c5 ~ ~ f4 ~ f4 db5 ~ c5 ~ ab4 ~ ~] [f4 c5 ~ f5 ~ f4 eb4 ~ eb4 c4 ~ g4 f4 ~ ~ ~]>") + +const lead = melodia.s("sawtooth").lpf(2000).lpq(5) + .attack(.004).decay(.18).sustain(.25).release(.12) + .room(.45).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.85).pan(sine.slow(8).range(.35,.65)).orbit(2) + +const leadOctava = melodia.add(note(12)).s("square") + .lpf(3400).attack(.004).release(.1).gain(.3).pan(.65).orbit(2) + +// ── 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) + .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) + .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) + .attack(.002).decay(.16).sustain(.3).release(.05) + .shape(.3).gain(.9).orbit(1) + +const sub = note("f1*4").s("sine").decay(.28).sustain(.2).gain(.6).orbit(1) + +// ── BATERÍA 909 (hats rápidos, ride Detroit) ── +const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05) + .duck("1:2").duckattack(.11).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.05).gain(1.1) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +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 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]>") + .s("sawtooth").lpf(sine.slow(24).range(450, 1000)).attack(.8).release(1.5) + .room(.7).rsize(8).gain(.4).orbit(4) + +const cuerdas = note("").s("supersaw").unison(5).spread(.7) + .lpf(sine.slow(32).range(400, 2000)).attack(.5).release(.9) + .room(.6).gain(.32).orbit(4) + +// ── 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), + 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 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(.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 grooveOut = stack(kick, hats16, open, clap, bajo, sub, stab, + lead.sometimesBy(.3, x=>x.add(note(12)).gain(.5))) +const coda = stack(kick, hats16.gain(.35), bajo.lpf(550).gain(.7), + lead.gain(.4).room(.7), pad) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introStabs], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→máquina→build→drop A→break→drop B→schranz total→coda (148 compases ≈ 4:05) +// ════════════════════════════════════════════════════════════════ +setcps(145/60/4) + +// ── EL RIFF (cuatro frases exactas de 8 pasos, alternadas por ciclo) ── +const melodia = note("<[cs5 b4 cs5 ~ fs4 ~ ~ ~] [d5 cs5 d5 cs5 b4 ~ ~ ~] [d5 cs5 d5 ~ fs4 ~ ~ ~] [b4 a4 b4 a4 gs4 fs4 gs4 ~]>") + +const riff = melodia.s("supersaw").unison(8).detune(.4).spread(.9) + .lpf(sine.slow(16).range(1800, 4200)).lpq(4) + .attack(.005).release(.2) + .room(.5).rsize(6).delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.9).orbit(2) + +const riffCuerpo = melodia.add(note(-12)).s("sawtooth") + .lpf(1400).shape(.3).attack(.004).release(.12).gain(.4).orbit(2) + +const riffBreak = melodia.slow(2).s("sawtooth") + .lpf(1200).attack(.05).release(.4) + .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) + .lpf(sine.slow(8).range(200, 600)).lpq(4) + .attack(.01).sustain(.8).release(.2).clip(1) + .shape(.3).gain(.7).orbit(1) + +const sub = note("fs1*4").s("sine").decay(.22).sustain(.2).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) + .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) + .duck("1:2").duckattack(.08).duckdepth(.7).orbit(0) +const clap = s("~ cp ~ cp").bank("RolandTR909").hpf(400).room(.25).gain(.7).orbit(0) +const hats16 = s("hh*16").bank("RolandTR909") + .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) +const rimLoop = s("rim*16").bank("RolandTR909").crush(5).hpf(1200) + .gain("[.4 .18 .28 .18]*4").pan(.35).orbit(0) +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) +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]>") + .s("sawtooth").lpf(600).attack(1).release(1.8) + .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 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 coda = stack(kick, hats16.gain(.3), clap.gain(.4), reese.gain(.5), + riffBreak.gain(.5)) +const codaFin = stack(hats16.gain(.2), riffBreak.gain(.4).delayfeedback(.7), + pad.gain(.3)) + +// ── ARREGLO (148 compases) ── +arrange( + [8, intro], + [8, maquina], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBFull], + [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 +// Estructura: intro→kalimba→build→drop A→break amplio→drop B→coda (136 compases ≈ 4:27) +// ════════════════════════════════════════════════════════════════ +setcps(122/60/4) + +// ── EL HOOK (interpretación del estribillo, 16 pasos) ── +const hook = note("cs5 b4 a4 b4 cs5 ~ b4 a4 fs4 ~ a4 b4 a4 ~ ~ ~") + .s("sawtooth").lpf(1700).lpq(4) + .attack(.01).decay(.2).sustain(.3).release(.18) + .room(.6).rsize(6).delay(.35).delaytime(.375).delayfeedback(.4) + .gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2) + +const hookSuave = hook.lpf(1100).gain(.55).room(.8) + +// ── 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) + .lpf(3200).delay(.4).delaytime(.333).delayfeedback(.45) + .room(.5).rsize(5).gain(.6) + .pan(sine.slow(3).range(.3,.7)).orbit(3) + +const kalimbaVar = note("<[a3 cs4 e4 a4 e4 cs4] [fs3 a3 cs4 fs4 cs4 a3]>") + .s("triangle").attack(.002).decay(.2).sustain(0).release(.1) + .delay(.4).delaytime(.333).delayfeedback(.45) + .room(.5).gain(.55).pan(.6).orbit(3) + +// ── BAJO CÁLIDO (redondo, sigue A→F#m→D→E) ── +const bajo = note("<[a1 ~ a1 [~ a1]] [fs1 ~ fs1 [~ fs1]] [d2 ~ d2 [~ d2]] [e2 ~ e2 [~ e2]]>") + .s("sine").decay(.3).sustain(.5).release(.08) + .gain(.85).orbit(1) + +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) + .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0) +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") + .gain(rand.range(.12, .42)).pan(rand.range(.35,.65)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR707").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) + +// ── PADS LARGOS Y VIENTO ── +const pad = note("<[a2,cs3,e3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>") + .s("sawtooth").lpf(sine.slow(32).range(500, 1300)).attack(1.2).release(2) + .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) + +// ── 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), + 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 breakAmplio = stack(pad, viento, hookSuave, kalimba.gain(.4), + bajo.gain(.4)) +const breakBuild = stack(pad, viento.gain(.2), 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 coda = stack(kick, hats, clap.gain(.4), bajo.gain(.6), + kalimba.gain(.45), hookSuave.gain(.4), pad) +const codaFin = stack(hats.gain(.25), kalimba.gain(.35).delayfeedback(.6), + viento, pad.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introKalimba], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakAmplio], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→stabs→build→drop A→break→build 2→drop B→coda (144 compases ≈ 4:22) +// ════════════════════════════════════════════════════════════════ +setcps(132/60/4) + +// ── LOS STABS DEL RIFF (interpretación: C-F-G sobre pedal de C) ── +const stabs = note("[g4,c5,e5] ~ [g4,c5,e5] [a4,c5,f5] ~ [g4,c5,e5] ~ [g4,b4,d5]") + .s("supersaw").unison(7).detune(.35).spread(.8) + .lpf(sine.slow(16).range(1800, 3200)).lpq(4) + .attack(.005).decay(.3).sustain(.2).release(.15) + .room(.6).rsize(7).delay(.25).delaytime(.375).delayfeedback(.3) + .gain(.9).orbit(2) + +const stabsCuerpo = note("[g3,c4,e4] ~ [g3,c4,e4] [a3,c4,f4] ~ [g3,c4,e4] ~ [g3,b3,d4]") + .s("sawtooth").lpf(1300).attack(.005).decay(.25).sustain(.15).release(.1) + .gain(.45).orbit(2) + +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) + +const bajoOff = note("[~ c2]*4").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) + .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) + .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0) +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") + .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").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") + .gain(saw.slow(8).range(.2, .95)).speed(saw.slow(8).range(1, 1.5)) + .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) + +// ── PAD ESTADIO ── +const pad = note("<[c3,e3,g3] [c3,e3,g3] [f3,a3,c4] [g3,b3,d4]>") + .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) + +// ── 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), + 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 coda = stack(kick, hats, clap.gain(.5), sub.gain(.5), + stabsBreak.gain(.5), pad.gain(.3)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introStabs], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, build2], + [16, dropB], + [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 +// Estructura: intro→chords→riff→drop A→break→drop B→dub final→coda (140 compases ≈ 4:45) +// ════════════════════════════════════════════════════════════════ +setcps(118/60/4) + +// ── EL RIFF (interpretación con shuffle, dos frases alternadas) ── +const riff = note("<[d4 e4 fs4 a4 fs4 e4 d4 ~] [d4 e4 fs4 b4 a4 fs4 e4 ~]>") + .swingBy(1/6, 8) + .s("sawtooth").lpf(1400).lpq(4) + .attack(.01).decay(.2).sustain(.25).release(.15) + .room(.7).rsize(8).delay(.5).delaytime(.375).delayfeedback(.55) + .gain(.75).pan(sine.slow(9).range(.35,.65)).orbit(2) + +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]> ~ ~") + .s("sawtooth").lpf(1100).lpq(3).hpf(250) + .attack(.01).decay(.4).sustain(0).release(.3) + .phaser(.7).phaserdepth(.5) + .delay(.6).delaytime(.375).delayfeedback(.68) + .room(.8).rsize(9).gain(.7).orbit(3) + +const chordsEco = chords.late(.5).gain(.35).lpf(800) + +// ── BAJO REDONDO (sine profundo, respirado) ── +const bajo = note("<[d1 ~ [~ d1] ~] [d1 ~ [~ d1] [~ a1]]>") + .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) + .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 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) + .gain(rand.range(.08, .32)).hpf(5000).pan(rand.range(.4,.6)).orbit(0) +const rimDub = s("~ rim ~ [~ rim]").bank("RolandCR78") + .delay(.45).delaytime(.375).delayfeedback(.5) + .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) + +// ── ATMÓSFERA (pads inmensos + textura) ── +const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [g2,b2,d3] [a2,cs3,e3]>") + .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) + +// ── 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 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), + shaker.gain(.25), rimDub, bajo) +const dropB = stack(kick, hats, shaker, open, rimDub, snareDub, 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)) +const coda = stack(kickIntro, hats.gain(.3), + chords.gain(.45).delayfeedback(.75), bajo.gain(.5), pad.gain(.3)) +const codaFin = stack(chords.gain(.3).delayfeedback(.78), espacio, + pad.gain(.3)) + +// ── ARREGLO (140 compases) ── +arrange( + [8, intro], + [8, introChords], + [16, grooveRiff], + [8, build], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBFull], + [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 +// Estructura: intro→groove→drop A→break robot→drop B→coda (136 compases ≈ 4:19) +// ════════════════════════════════════════════════════════════════ +setcps(126/60/4) + +// ── LA MELODÍA (el tema del sinte, maquinal y sin adornos) ── +const hook = note("c5 ~ b4 c5 g4 ~ eb4 g4 f4 ~ d4 f4 c4 ~ ~ ~") + .s("square").lpf(2600).lpq(3) + .attack(.002).decay(.13).sustain(.12).release(.04) + .crush(9).delay(.12).delaytime(.1875).delayfeedback(.2) + .gain(.8).pan(.5).orbit(2) + +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") + .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") + .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) + +// ── BATERÍA 606 (seca, sin reverb, precisión maquinal) ── +const kick = s("bd*4").bank("RolandTR606").shape(.35).gain(1.05) + .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 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") + .gain("[.45 .2 .3 .2]*4").pan(.45).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR606").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) + +// ── BLIPS DE ORDENADOR (textura minimal, aleatoria y fría) ── +const blips = note("c6 ~ ~ g5 ~ ~ eb6 ~").s("square") + .decay(.05).sustain(0).crush(7) + .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]>") + .s("triangle").lpf(600).attack(1).release(1.5) + .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, + 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 codaFin = stack(hats.gain(.35), hook.gain(.3).delayfeedback(.5), + blips.gain(.25), pad.gain(.25)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, groove], + [8, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakRobot], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→build→drop A→sirenas→break→drop hoover→coda (152 compases ≈ 4:24) +// ════════════════════════════════════════════════════════════════ +setcps(138/60/4) + +// ── EL HOOK (estribillo interpretado en G mayor) ── +const hook = note("g4 g4 fs4 g4 e4 e4 d4 e4 g4 g4 a4 g4 e4 ~ d4 ~") + .s("sawtooth").lpf(2200).lpq(5) + .attack(.005).decay(.12).sustain(.25).release(.08) + .room(.35).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.8).pan(sine.slow(6).range(.35,.65)).orbit(2) + +const hookAlta = hook.add(note(12)).gain(.35).lpf(3500).orbit(2) + +// ── 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) + .shape(.3).room(.4).gain(.7) + .every(4, x=>x.hurry(2).gain(.55)).orbit(3) + +// ── SIRENA RAVE (vibrato ancho, panea de lado a lado) ── +const sirena = note("g5").s("sawtooth") + .attack(.6).release(2.5).vib(3).vibmod(7) + .lpf(2800).room(.6).rsize(6).gain(.3) + .pan(sine.slow(4)).slow(4).orbit(3) + +// ── HOOVER (supersaw desafinado y sucio, riff grave) ── +const hoover = note("g2 ~ g2 g2 ~ e2 ~ [f2 fs2]") + .s("supersaw").unison(5).detune(.8).spread(.8) + .lpf(1400).distort(.8) + .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]") + .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") + .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) + .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) +const kick4 = s("bd*4").bank("OberheimDMX").shape(.4).gain(1.05) + .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0) +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") + .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("OberheimDMX").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) + +// ── PAD (colchón alegre G-Em-C-D) ── +const pad = note("<[g3,b3,d4] [e3,g3,b3] [c3,e3,g3] [d3,fs3,a3]>") + .s("supersaw").unison(4).spread(.6).lpf(900) + .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, + 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 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), + 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) +const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.8).delayfeedback(.6), + sirena.gain(.2), pad.gain(.3)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropHoover], + [16, dropFull], + [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 +// 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) + .attack(.001).decay(.14).sustain(.35).release(.05) + .shape(.3).gain(.95).orbit(1) + +const sub = note("e1 ~ ~ e1 e1 ~ e1 ~ ~ a1 ~ ~ ~ ~ ~ ~") + .s("sine").decay(.25).sustain(.3).gain(.6).orbit(1) + +// ── STABS MÍNIMOS (acorde Em seco, casi percusivo) ── +const stab = note("~ ~ [e3,g3,b3] ~ ~ [e3,g3,b3] ~ ~") + .s("sawtooth").lpf(1600).hpf(300) + .attack(.001).decay(.09).sustain(0) + .gain(.55).pan(.6).orbit(3) + +// ── RIFF FANTASMA (la guitarra interpretada, corta y lo-fi) ── +const riff = note("e4 ~ ~ g4 ~ e4 d4 ~ ~ e4 ~ ~ a4 g4 ~ ~") + .s("square").lpf(1900).crush(8) + .attack(.002).decay(.1).sustain(.05).release(.04) + .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) + .duck("1:2").duckattack(.09).duckdepth(.45).orbit(0) +const clap = s("[~ cp]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0) +const clapDos = s("~ cp ~ cp").bank("RolandTR808").gain(.65).orbit(0) +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)) + .pan(rand.range(.3,.7)).orbit(0) + +// ── TOMS TRIBALES (euclidianos, el corazón del remix) ── +const tomAlto = s("ht(3,8)").bank("RolandTR808") + .gain(.6).pan(.3).speed("<1 1.1 .95 1.05>").orbit(0) +const tomMedio = s("mt(5,16,2)").bank("RolandTR808") + .gain(.55).pan(.7).speed("<1 .9 1.15 1>").orbit(0) +const tomBajo = s("lt(3,16,5)").bank("RolandTR808") + .gain(.6).pan(.5).orbit(0) + +// ── CONGAS (toms agudos con speed variado, sabor latino) ── +const congas = s("[~ mt]*4").bank("RolandTR808") + .speed(choose(1.6, 1.8, 2, 1.4)).gain(.45) + .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) + +// ── 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) + .room(.5).rsize(5).gain(.35).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats) +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 breakTribal = stack(tomAlto, tomMedio, tomBajo, congas, shaker, + bajo.gain(.6), sub.gain(.4), pad) +const breakBuild = stack(tomAlto, tomMedio, tomBajo, congas, rodillo, + bajo, riff.gain(.5), pad) +const dropB = stack(kick, clap, clapDos.gain(.4), shaker, 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)) +const coda = stack(kick, hats, clap, bajo.gain(.7), congas.gain(.35), + riff.gain(.4), pad) +const codaFin = stack(hats.gain(.35), congas.gain(.3), sub.gain(.35), + riff.gain(.25).room(.7).delayfeedback(.55), pad.gain(.3)) + +// ── ARREGLO (140 compases) ── +arrange( + [8, intro], + [8, percusion], + [8, grooveBajo], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAtoms], + [8, breakTribal], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→arpegio→build→drop A→breakdown piano→drop B→coda (160 compases ≈ 4:38) +// ════════════════════════════════════════════════════════════════ +setcps(138/60/4) + +// ── EL HOOK (estribillo interpretado, supersaw nostálgico) ── +const hook = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~") + .s("supersaw").unison(5).spread(.7).detune(.35) + .lpf(2400).attack(.01).decay(.2).sustain(.5).release(.15) + .room(.6).rsize(7).delay(.35).delaytime(.375).delayfeedback(.4) + .gain(.75).pan(sine.slow(8).range(.35,.65)).orbit(2) + +const hookAlta = hook.add(note(12)).gain(.3).lpf(4000).orbit(2) + +// ── 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]>") + .s("piano").room(.8).rsize(8).gain(.7).orbit(4) + +// ── ARPEGIO PERPETUO (el motor del track) ── +const arpegio = note("[c3 e3 g3 c4]*2") + .s("sawtooth").lpf(sine.slow(16).range(800,2600)).lpq(4) + .attack(.002).decay(.12).sustain(.1).release(.05) + .delay(.3).delaytime(.1875).delayfeedback(.35) + .gain(.6).pan(.6).every(4, rev).orbit(3) + +const arpegio16 = note("[c3 e3 g3 c4]*4") + .s("sawtooth").lpf(sine.slow(8).range(1000,3200)).lpq(5) + .attack(.001).decay(.09).sustain(.05).release(.04) + .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) ── +const bajo = note("").struct("x*16") + .s("sawtooth").lpf(650).lpq(6) + .attack(.001).decay(.1).sustain(.25).release(.03) + .gain("[.9 .55 .7 .55]*4").shape(.25).orbit(1) + +const sub = note("").struct("x*4") + .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1) + +// ── BATERÍA 909 ── +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(.5).distort(1.1).gain(1.1) + .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +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 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) + +// ── 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) + .attack(.9).release(1.8).room(.75).rsize(8).gain(.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 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, + 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)) +const coda = stack(kick, hats, bajo.gain(.6), arpegio, hook.gain(.4).room(.7), + cuerdas.gain(.3)) +const codaFin = stack(piano.gain(.6), cuerdas.gain(.3), + arpegio.gain(.3).delayfeedback(.6)) + +// ── ARREGLO (160 compases) ── +arrange( + [8, intro], + [8, introArp], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakPiano], + [8, breakBuild], + [16, dropB], + [16, dropBvar], + [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 +// 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) + .attack(.002).decay(.18).sustain(.5).release(.08) + .shape(.15).gain(.95).orbit(1) + +const sub = note("d1 ~ ~ d1 ~ ~ d1 ~").s("sine") + .decay(.35).sustain(.35).gain(.6).orbit(1) + +// ── ECO DUB DEL BAJO (delay largo, flotando por detrás) ── +const bajoDub = note("d2 ~ ~ ~ f2 ~ ~ ~") + .s("triangle").hpf(200).lpf(900) + .delay(.5).delaytime(.5625).delayfeedback(.55) + .gain(.4).pan(.65).orbit(3) + +// ── EL LEAD (interpretación del rap-melodía, flotante a doble compás) ── +const lead = note("a4 ~ g4 f4 g4 ~ f4 ~ e4 d4 ~ ~") + .slow(2).s("sawtooth").lpf(1600).lpq(3) + .attack(.02).decay(.25).sustain(.3).release(.2) + .room(.5).rsize(5).delay(.35).delaytime(.375).delayfeedback(.45) + .gain(.7).pan(sine.slow(10).range(.35,.65)).orbit(2) + +const leadEco = lead.add(note(12)).late(.25).gain(.25).lpf(2600).orbit(2) + +// ── CHORDS DEEP (Dm7 con phaser, sofisticación urbana) ── +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) + .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) + .duck("1:2").duckattack(.1).duckdepth(.4).orbit(0) +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 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) +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) ── +const niebla = s("space").slow(8).lpf(1200).room(.8).rsize(8) + .gain(.25).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) + .room(.6).rsize(6).gain(.35).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats, niebla) +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 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, + 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, + bajoDub, chords, lead.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), + leadEco, niebla) +const coda = stack(kick, hats, bajo.gain(.7), chords.gain(.4), + lead.gain(.4).room(.7), pad) +const codaFin = stack(hats.gain(.3), bajoDub.gain(.3), + lead.gain(.25).room(.85).delayfeedback(.65), pad.gain(.3), niebla) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introSub], + [16, grooveChords], + [8, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakUrbano], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→stabs→build→drop A→break vocal→drop octava→coda (148 compases ≈ 4:25) +// ════════════════════════════════════════════════════════════════ +setcps(134/60/4) + +// ── EL LEAD (estribillo interpretado, el lamento del sinte) ── +const hook = note("a4 c5 d5 c5 a4 g4 a4 ~ f4 g4 a4 g4 f4 ~ e4 ~") + .s("sawtooth").lpf(2000).lpq(5) + .attack(.008).decay(.15).sustain(.35).release(.1) + .room(.4).rsize(4).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2) + +const hookOctava = hook.add(note(12)).gain(.85).lpf(3200).orbit(2) + +// ── 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) + .attack(.001).decay(.14).sustain(0) + .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) + .attack(.001).decay(.13).sustain(.3).release(.04) + .shape(.35).gain(.9).orbit(1) + +const bajoVar = note("[~ d2]!3 [~ [c2 e2]]") + .s("sawtooth").lpf(850).lpq(7) + .attack(.001).decay(.13).sustain(.3).release(.04) + .shape(.35).gain(.9).orbit(1) + +const sub = note("d1*4").s("sine").decay(.28).sustain(.2).gain(.65).orbit(1) + +// ── BATERÍA 909 (dura y directa) ── +const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +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 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) + +// ── 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) + .attack(.8).release(1.5).room(.65).rsize(7).gain(.38).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 breakVocal = stack(pad, stabs.gain(.4).room(.6), + hook.gain(.55).room(.7), hats.gain(.3), sub.gain(.35)) +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, + 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)) +const coda = stack(kick, hats, clap, bajo.gain(.7), stabs.gain(.4), + hook.gain(.45).room(.6), pad) +const codaFin = stack(hats.gain(.4), stabs.gain(.25).room(.8), + hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) + +// ── ARREGLO (148 compases) ── +arrange( + [8, intro], + [8, introStabs], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakVocal], + [8, breakBuild], + [16, dropOctava], + [16, dropOctavaVar], + [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 +// Estructura: intro→piano→build→drop A→break oh→drop hoover→coda (152 compases ≈ 4:21) +// ════════════════════════════════════════════════════════════════ +setcps(140/60/4) + +// ── EL HOOK (la melodía del sinte, interpretada en Gm) ── +const hook = note("g4 ~ bb4 g4 c5 ~ bb4 g4 d5 ~ c5 bb4 g4 ~ f4 g4") + .s("sawtooth").lpf(2300).lpq(5) + .attack(.005).decay(.14).sustain(.3).release(.1) + .room(.4).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2) + +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]>") + .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") + .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) + .attack(.001).decay(.12).sustain(.35).release(.04) + .shape(.3).gain(.9).orbit(1) + +const sub = note("g1 ~ g1 ~ bb1 ~ c2 ~").s("sine") + .decay(.3).sustain(.25).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) + .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1) + .duck("1:2").duckattack(.11).duckdepth(.65) + .every(8, x=>x.ply(2).gain(.95)).orbit(0) +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 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) + +// ── 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) + .attack(.8).release(1.6).room(.7).rsize(8).gain(.38).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats, sub.gain(.4)) +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 breakOh = stack(pad, pianoRave.gain(.5).room(.7), + hook.gain(.55).room(.75), openRave.gain(.35), sub.gain(.35)) +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)) +const coda = stack(kick, hats, clap, bajo.gain(.7), pianoRave.gain(.45), + hook.gain(.45).room(.6), pad) +const codaFin = stack(hats.gain(.4), pianoRave.gain(.3).room(.8), + hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, intro], + [8, introPiano], + [16, build], + [8, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakOh], + [8, breakBuild], + [16, dropHoover], + [16, dropHooverFull], + [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 +// 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) ── +const riff = note("c4 ~ c4 c4 eb4 c4 f4 eb4") + .s("square").lpf(2200).lpq(6) + .attack(.001).decay(.12).sustain(.25).release(.05) + .distort(.7).coarse(2) + .gain(.8).pan(.5).orbit(2) + +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]") + .s("supersaw").unison(6).detune(.9).spread(.85) + .lpf(1600).distort(.9) + .attack(.01).decay(.18).sustain(.4).release(.1) + .gain(.7).orbit(3) + +// ── VOZ PERCUSIVA ("no no no", samples de numbers troceados) ── +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) + .attack(.001).decay(.11).sustain(.35).release(.03) + .shape(.4).gain(.9).orbit(1) + +const sub = note("c1*4").s("sine").decay(.22).sustain(.2).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) + .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +const kickGabber = s("bd*4").bank("RolandTR909").shape(.6).distort(1.5).gain(1) + .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0) +const kickDoble = s("bd*8").bank("RolandTR909").shape(.55).distort(1.3).gain(.9) + .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0) +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") + .gain("[.55 .35]*4").pan(.45).orbit(0) +const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").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) + +// ── 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) + .attack(.7).release(1.4).room(.6).rsize(7).gain(.35).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats, sub.gain(.4)) +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 breakVoces = stack(pad, voz, riff.gain(.5).room(.5), + hats.gain(.3), sub.gain(.35)) +const breakBuild = stack(pad, voz, riff.gain(.65), rodilloDoble, + 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, + riff.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), riffAlta, + hoover.gain(.5), rodilloDoble.degradeBy(.5).gain(.3)) +const coda = stack(kick, hats, clap, bajo.gain(.7), riff.gain(.45), + pad.gain(.3)) +const codaFin = stack(hats.gain(.4), voz.gain(.3), + riff.gain(.25).room(.7), pad.gain(.3)) + +// ── ARREGLO (160 compases) ── +arrange( + [8, intro], + [8, introRiff], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakVoces], + [8, breakBuild], + [16, dropGabber], + [16, dropGabberFull], + [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 +// Estructura: intro→piano→build→drop A→break piano→drop supersaw→coda (144 compases ≈ 4:26) +// ════════════════════════════════════════════════════════════════ +setcps(130/60/4) + +// ── EL HOOK (estribillo interpretado, piano italo protagonista) ── +const hookPiano = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~") + .s("piano").room(.5).rsize(5) + .delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.95).pan(.5).orbit(2) + +// ── EL MISMO HOOK EN SUPERSAW (para el segundo drop) ── +const hookSaw = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~") + .s("supersaw").unison(5).spread(.7).detune(.4) + .lpf(2800).attack(.008).decay(.15).sustain(.4).release(.12) + .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]>") + .struct("[~ x]*4") + .s("piano").room(.4).rsize(4) + .gain(.7).pan(.55).orbit(3) + +// ── BAJO OCTAVADOR (corcheas saltando la octava) ── +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) + .attack(.001).decay(.12).sustain(.3).release(.04) + .shape(.3).gain(.9).orbit(1) + +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) +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) +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) + +// ── 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) + .attack(.8).release(1.6).room(.65).rsize(7).gain(.38).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), + 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 breakPiano = stack(pad, hookPiano.gain(.7).room(.75), + acordes.gain(.5).room(.6), sub.gain(.35)) +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, + 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) +const codaFin = stack(hats.gain(.4), hookPiano.gain(.4).room(.85).delayfeedback(.6), + acordes.gain(.25).room(.8), pad.gain(.3)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introPiano], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakPiano], + [8, breakBuild], + [16, dropSaw], + [16, dropSawFull], + [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 +// Estructura: piano solo→pads→build→drop A→break central→drop B→coda piano (168 compases ≈ 4:54) +// ════════════════════════════════════════════════════════════════ +setcps(137/60/4) + +// ── LA MELODÍA (exacta, dos frases alternadas de 16 pasos) ── +const melodia = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ ~ b4 ~ d5 ~ c5 b4 ~ a4 ~ ~]>") + .s("piano").room(.85).rsize(9) + .delay(.4).delaytime(.375).delayfeedback(.45) + .gain(.95).pan(.5).orbit(2) + +// ── LA MISMA MELODÍA EN SINTE (doblada para los drops) ── +const melodiaSinte = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ ~ b4 ~ d5 ~ c5 b4 ~ a4 ~ ~]>") + .s("supersaw").unison(5).spread(.7).detune(.3) + .lpf(2600).attack(.01).decay(.2).sustain(.45).release(.15) + .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) + .gain(.7).pan(.45).orbit(4) + +// ── BAJO ROLLING SUAVE (16avos redondos, progresión Am·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) + +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) + .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) +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 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) + +// ── 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)) + .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) + +// ── 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), + 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 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, + melodia, melodiaSinte.sometimesBy(.2, x=>x.add(note(12)).gain(.35)), + cuerdas.gain(.4), pianoAcordes.gain(.4)) +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 codaFin = stack(melodia.gain(.7).room(.95).delayfeedback(.6), + pianoAcordes.gain(.4), viento) + +// ── ARREGLO (168 compases) ── +arrange( + [16, pianoSolo], + [8, pianoPads], + [8, entraKick], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakCentral], + [8, breakBuild], + [16, dropB], + [16, dropBvar], + [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 +// Estructura: intro→arpegio→build→drop A→breakdown→drop épico→coda (152 compases ≈ 4:41) +// ════════════════════════════════════════════════════════════════ +setcps(130/60/4) + +// ── EL ARPEGIO PERPETUO (16avos; el lpf sube durante los 152 compases) ── +const arpegio = note("[fs2 fs3 a3 cs4 fs2 fs3 a3 e4]*2") + .s("sawtooth").lpf(saw.slow(152).range(260, 4400)).lpq(7) + .attack(.002).decay(.12).sustain(.25).release(.06) + .shape(.25).gain(.78).pan(sine.slow(6).range(.35,.65)).orbit(3) + +const arpegioAlto = arpegio.add(note(12)).gain(.3).orbit(3) + +// ── LA MELODÍA (interpretación del canto en F#m) ── +const hook = note("fs4 a4 gs4 fs4 cs4 ~ fs4 ~ a4 b4 a4 fs4 e4 ~ cs4 ~") + .s("supersaw").unison(5).spread(.6).detune(.15) + .lpf(2400).attack(.02).release(.3) + .room(.6).rsize(7).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.72).orbit(2) + +const hookEco = hook.add(note(12)).gain(.26).lpf(4200).orbit(2) + +// ── 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) + +const bajoSub = note("fs1*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) + .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1) + .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +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 rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).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) + .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) + .room(.7).gain(.32).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 codaFin = stack(hats.gain(.35), arpegio.gain(.35).room(.85), pad.gain(.3)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, intro], + [8, introArp], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [12, breakdown], + [8, breakBuild], + [16, dropEpic], + [16, dropEpicFull], + [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 +// Estructura: intro→build→drop A→break→drop B con ride→coda (136 compases ≈ 3:57) +// ════════════════════════════════════════════════════════════════ +setcps(138/60/4) + +// ── EL RIFF (16 pasos, la metralleta de Sandstorm) ── +const riff = note("b3 b3 b3 [b3 b3] e4 e4 e4 [e4 e4] d4 d4 d4 [d4 d4] a3 ~ b3 b3") + .s("sawtooth").lpf(2600).lpq(8) + .attack(.001).decay(.11).sustain(0).release(.05) + .shape(.3).delay(.3).delaytime(.1875).delayfeedback(.4) + .gain(.85).orbit(2) + +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) + .attack(.001).decay(.16).sustain(.2).release(.04) + .shape(.35).gain(.9).orbit(1) + +const bajoSub = note("b1*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) + .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.35).gain(1.1) + .duck("1:2").duckattack(.1).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 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 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) + +// ── 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) + .room(.6).rsize(6).gain(.38).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), + 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 codaFin = stack(hats.gain(.4), riff.gain(.3).room(.85).delayfeedback(.65), + pad.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [12, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBfull], + [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 +// Estructura: intro→build→drop A→break→drop B→coda (136 compases ≈ 4:05) +// ════════════════════════════════════════════════════════════════ +setcps(133/60/4) + +// ── EL HOOK (interpretación del estribillo, con vocal sintética) ── +const hook = note("bb4 ~ g4 ~ f4 g4 bb4 g4 ~ f4 ~ d4 f4 g4 ~ ~") + .s("sawtooth").vowel("").lpf(3000) + .attack(.01).decay(.15).sustain(.4).release(.15) + .delay(.28).delaytime(.375).delayfeedback(.35) + .gain(.82).pan(sine.slow(7).range(.35,.65)).orbit(2) + +const hookOctava = hook.add(note(12)).gain(.3).orbit(2) + +// ── 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) ── +const bajo = note("[g1 g2 g1 g2]*2").add(note("<0 0 -4 -2>")) + .s("sawtooth").lpf(820).lpq(5) + .attack(.001).decay(.14).sustain(.3).release(.04) + .shape(.3).gain(.9).orbit(1) + +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) + .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 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 rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0) + +// ── PADS BRILLANTES ── +const pad = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>") + .s("supersaw").unison(5).spread(.7) + .lpf(sine.slow(16).range(600, 2200)).attack(.5).release(1) + .room(.6).rsize(6).gain(.35).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, + 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 codaFin = stack(hats.gain(.4), hook.gain(.3).room(.85).delayfeedback(.6), + pad.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBfull], + [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 +// Estructura: intro→pluck solo→build→PAUSA→drop A→break→PAUSA→drop B→coda (134 compases ≈ 3:55) +// ════════════════════════════════════════════════════════════════ +setcps(137/60/4) + +// ── EL PLUCK INCONFUNDIBLE (16 pasos exactos, square+saw en ping-pong) ── +const melodia = "cs5 ~ cs5 ~ fs5 ~ e5 ~ ~ cs5 ~ b4 ~ cs5 ~ ~" +const pluckSq = note(melodia).s("square") + .lpf(2400).attack(.001).decay(.12).sustain(0).release(.06) + .delay(.4).delaytime(.1875).delayfeedback(.45) + .pan(square.fast(2).range(.25,.75)) + .gain(.6).orbit(2) +const pluckSaw = note(melodia).s("sawtooth") + .lpf(3200).attack(.001).decay(.1).sustain(0).release(.05) + .delay(.3).delaytime(.375).delayfeedback(.35) + .pan(square.fast(2).range(.75,.25)) + .gain(.5).orbit(2) +const pluck = stack(pluckSq, pluckSaw) +const pluckOctava = note(melodia).add(note(12)).s("square").lpf(4200) + .attack(.001).decay(.1).sustain(0).release(.05).gain(.25).orbit(2) + +// ── SUPERSAW DEL CLÍMAX (dobla la melodía) ── +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) ── +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) +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) +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) + .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) + .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0) +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 rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.88)).speed(saw.slow(4).range(1,1.45)).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) + .room(.7).rsize(7).gain(.38).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 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 codaFin = stack(hats.gain(.4), pluck.gain(.3).room(.85).delayfeedback(.65), + pad.gain(.3)) + +// ── ARREGLO (134 compases) ── +arrange( + [8, intro], + [8, introB], + [8, pluckSolo], + [16, build], + [2, pausa], + [16, dropA], + [14, dropAvar], + [8, breakdown], + [8, breakBuild], + [2, pausa], + [16, dropB], + [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 +// Estructura: lead solo→kick entra→toms→drop A→break→drop B→coda (140 compases ≈ 4:00) +// ════════════════════════════════════════════════════════════════ +setcps(140/60/4) + +// ── EL LEAD (16 pasos exactos, eléctrico y enorme) ── +const lead = note("e5 ~ gs5 e5 ~ fs5 e5 ~ b4 ~ cs5 ~ e5 ~ ~ ~") + .s("supersaw").unison(5).spread(.7).detune(.12) + .lpf(2700).attack(.015).decay(.3).sustain(.3).release(.5) + .room(.85).rsize(9).delay(.4).delaytime(.375).delayfeedback(.5) + .gain(.75).orbit(2) + +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]>") + .s("supersaw").unison(6).spread(.85) + .lpf(sine.slow(32).range(500, 2000)).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) + .duck("2:4").duckattack(.1).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.3).gain(1.1) + .duck("2:4").duckattack(.1).duckdepth(.6).orbit(0) +const kickBrutal = s("bd*4").bank("RolandTR909").shape(.65).distort(1.6).gain(1.1) + .duck("2:4").duckattack(.1).duckdepth(.65).orbit(0) +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) +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") + .shape(.3).gain(.6).pan(sine.fast(2).range(.25,.75)).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 crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.5).room(.4).orbit(0) + +// ── 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 codaFin = stack(lead.gain(.4).room(.95).delayfeedback(.6), pad.gain(.3)) + +// ── ARREGLO (140 compases) ── +arrange( + [8, leadSolo], + [8, leadCoro], + [8, kickEntra], + [16, kickLead], + [4, tomsBuild], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→build→drop A→break hpf→drop acid→coda (136 compases ≈ 4:05) +// ════════════════════════════════════════════════════════════════ +setcps(133/60/4) + +// ── EL RIFF (8vos exactos, stab metálico con FM alto) ── +const riff = note("c5 bb4 g4 bb4 c5 bb4 g4 f4") + .s("sawtooth").fm(9).fmh(2.01) + .lpf(2500).attack(.001).decay(.15).sustain(.1).release(.06) + .shape(.25).delay(.22).delaytime(.1875).delayfeedback(.3) + .gain(.78).pan(sine.slow(9).range(.35,.65)).orbit(2) + +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) + +const bajoSub = note("c1*4").s("sine").decay(.3).sustain(.2).gain(.65).orbit(1) + +// ── CAPA ACID SUAVE (segunda mitad) ── +const acid = note("c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [f2 eb2] c2") + .s("sawtooth").ftype("ladder") + .lpf(sine.slow(16).range(180, 2400)).lpq(sine.slow(9).range(7, 17)) + .lpenv(3).lpattack(.005).lpdecay(.12) + .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) + .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) + .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +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) +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 (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) + .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, + 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), + 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 codaFin = stack(hats.gain(.4), riff.gain(.3).room(.85).delayfeedback(.6), + pad.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakHpf], + [8, breakBuild], + [16, dropAcid], + [16, dropAcidFull], + [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 +// Estructura: intro→build→drop A→break susurrado→drop B→coda (144 compases ≈ 4:16) +// ════════════════════════════════════════════════════════════════ +setcps(135/60/4) + +// ── LOS POWER CHORDS (guitarra sintética distorsionada, F5→Bb5→Ab5→Db5) ── +const chords = note("[f2,c3] [f2,c3] [bb2,f3] ~ [ab2,eb3] [ab2,eb3] [db3,ab3] ~") + .s("sawtooth").distort(1.5) + .lpf(perlin.slow(4).range(700, 2400)).lpq(4) + .attack(.002).decay(.25).sustain(.45).release(.08) + .gain(.78).orbit(3) + +const chordsAlto = chords.add(note(12)).gain(.3).lpf(3000).orbit(3) + +// ── LA VOZ (interpretación susurrada de la melodía vocal) ── +const voz = note("f4 ab4 f4 eb4 f4 ~ c4 ~") + .s("sine").vib(4).vibmod(.25) + .attack(.03).release(.3) + .room(.8).rsize(8).delay(.35).delaytime(.375).delayfeedback(.45) + .gain(.6).orbit(2) + +const vozOctava = voz.add(note(12)).gain(.25).orbit(2) + +// ── REESE INDUSTRIAL (supersaw desafinado grave) ── +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) + +const bajoSub = note("f1*4").s("sine").decay(.3).sustain(.2).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) + .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) + .duck("1:3").duckattack(.1).duckdepth(.65).orbit(0) +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) + .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 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) + +// ── 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) + .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, + 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, + 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 codaFin = stack(voz.gain(.4).room(.9), pad.gain(.3), hatsInd.gain(.3)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [12, breakSusurro], + [8, breakBuild], + [16, dropB], + [16, dropBfull], + [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 +// Estructura: intro→build→drop A→break robótico→drop B→coda (132 compases ≈ 4:13) +// ════════════════════════════════════════════════════════════════ +setcps(125/60/4) + +// ── LA TROMPETA (16 pasos exactos, sonido teléfono) ── +const trompeta = note("d5 ~ d5 d5 cs5 d5 a4 f4 e4 d4 ~ ~ ~ ~ ~ ~") + .s("square").crush(5).lpf(2100).hpf(420) + .attack(.002).decay(.16).sustain(.3).release(.08) + .delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.72).orbit(2) + +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) + +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) + +const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.18).gain(.55).orbit(1) + +// ── VOZ ROBÓTICA (números hablados triturados) ── +const robot = s("numbers").n("<0 1 2 3>").crush(6).lpf(2000) + .gain(.5).pan(sine.slow(5).range(.3,.7)).orbit(3) + +// ── PIANO LO-FI (contrapunto del break) ── +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) + .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0) +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 toms = s("~ ~ ~ ~ ~ ~ [mt lt] ~").bank("RolandTR808").gain(.55).pan(.35).orbit(0) + +// ── 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) + .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 breakRobot = stack(pad, robot, piano, trompeta.gain(.5).room(.6), + hats.gain(.25)) +const breakBuild = stack(pad, trompeta.gain(.7), robot, 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 coda = stack(kick, hats, bajo.lpf(450).gain(.65), + trompeta.gain(.45).room(.6), pad) +const codaFin = stack(hats.gain(.3), trompeta.gain(.3).room(.8).delayfeedback(.6), + pad.gain(.25)) + +// ── ARREGLO (132 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [16, dropA], + [16, dropAvar], + [8, breakRobot], + [8, breakBuild], + [16, dropB], + [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 +// 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 ~") + .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) + +const bajoSub = note("a1*4").s("sine").decay(.3).sustain(.2).gain(.55).orbit(1) + +// ── EL VOCODER (interpretación, vocales sintéticas que respiran) ── +const vocoder = note("e4 e4 d4 c4 d4 e4 ~ ~") + .s("sawtooth").vowel("") + .lpf(sine.slow(32).range(700, 2600)) + .attack(.01).decay(.18).sustain(.4).release(.12) + .delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.72).pan(sine.slow(11).range(.35,.65)).orbit(2) + +const vocoderAlto = vocoder.add(note(12)).gain(.28).orbit(2) + +// ── STAB FUNKY (acorde filtrado, discoteca francesa) ── +const stab = note("~ [a3,c4,e4] ~ [a3,c4,e4] ~ ~ [g3,b3,d4] ~") + .s("sawtooth").lpf(sine.slow(16).range(500, 2200)).lpq(7) + .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) + .duck("1:2").duckattack(.13).duckdepth(.6).orbit(0) +const kickFuerte = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.08) + .duck("1:2").duckattack(.13).duckdepth(.7).orbit(0) +const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.7).orbit(0) +const hatsPhaser = s("[~ hh]*4").bank("RolandTR909") + .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) + .pan(rand.range(.35,.65)).orbit(0) +const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").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) + +// ── 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) + .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), + bajo.lpf(sine.slow(32).range(250, 700)).gain(.7)) +const build = stack(kick, hats16, clap, bajo, stab.gain(.4), + 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 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, + 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) +const codaFin = stack(hatsPhaser.gain(.35), bajo.lpf(400).gain(.6), + vocoder.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakFiltro], + [8, breakBuild], + [16, dropB], + [16, dropBfull], + [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 +// Estructura: intro→hook→build→drop A→break flotante→drop B→coda (152 compases ≈ 4:36) +// ════════════════════════════════════════════════════════════════ +setcps(132/60/4) + +// ── EL PLUCK-GUITARRA DE ATB (16 pasos exactos, bend característico con penv) ── +const hook = note("cs5 ~ d5 cs5 ~ b4 cs5 ~ e5 ~ cs5 ~ b4 ~ a4 b4") + .s("triangle").penv(12).pattack(.001).pdecay(.09) + .lpf(3200).attack(.002).decay(.2).sustain(.15).release(.12) + .delay(.35).delaytime(.375).delayfeedback(.45) + .room(.5).rsize(5).gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2) + +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) + +// ── 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) + .attack(.001).decay(.09).sustain(.15).release(.03) + .shape(.25).gain("[.8 .42 .58 .42]*4").orbit(1) + +const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine") + .decay(.3).sustain(.18).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) + .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0) +const kickDrop = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) + .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) +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 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) + +// ── PADS FLOTANTES ── +const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>") + .s("supersaw").unison(5).spread(.8) + .lpf(sine.slow(32).range(500, 1900)).attack(.8).release(1.8) + .room(.8).rsize(8).gain(.36).orbit(4) + +const colchon = note("").s("sine").attack(1).release(2) + .room(.9).rsize(9).gain(.3).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats, bajoSub.gain(.4)) +const introB = stack(kick, hats, hatsOpen, clap.gain(.45), 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 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, + 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) +const codaFin = stack(hats.gain(.35), hookFlotante.gain(.4), pad.gain(.3), + colchon.gain(.25)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, intro], + [8, introB], + [8, hookIntro], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [12, breakFlotante], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→build→PAUSA→drop A→break piano→PAUSA→drop B→coda (134 compases ≈ 3:50) +// ════════════════════════════════════════════════════════════════ +setcps(140/60/4) + +// ── EL HOOK (el grito "encore une fois", interpretación en Am) ── +const hook = note("a4 ~ a4 g4 a4 c5 a4 g4 a4 e4 ~ ~ g4 a4 g4 ~") + .s("supersaw").unison(5).spread(.6).detune(.18) + .lpf(2600).attack(.01).release(.15) + .room(.5).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.8).pan(sine.slow(6).range(.35,.65)).orbit(2) + +const hookOctava = hook.add(note(12)).gain(.3).lpf(4200).orbit(2) + +// ── 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) + .lpf(3500).room(.4).gain(.8).orbit(3) + +// ── BAJO OFFBEAT (rebota contra el kick, misma progresión) ── +const bajo = note("~ a1 ~ a1 ~ a1 ~ a1").add(note("<0 -4 3 -2>")) + .s("sawtooth").lpf(900).lpq(4) + .attack(.001).decay(.18).sustain(.15).release(.05) + .shape(.35).gain(.9).orbit(1) + +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) +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 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) + +// ── 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) + .room(.7).rsize(7).gain(.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, + 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 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) +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) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [1, silence], + [16, dropA], + [16, dropAvar], + [8, breakPiano], + [8, breakBuild], + [1, silence], + [16, dropB], + [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 +// Estructura: intro→bajo wah→groove→stabs FM→solo bajo→contramelodía→groove final (132 compases ≈ 4:07) +// ════════════════════════════════════════════════════════════════ +setcps(128/60/4) + +// ── EL BAJO WAH (la línea EXACTA de Flat Beat: square + filtro que mastica) ── +const bajo = note("f1 f1 ~ f1 ~ f1 eb1 f1") + .s("square").lpf(sine.slow(2).range(100,900)).lpq(16) + .attack(.001).decay(.22).sustain(.4).release(.04) + .shape(.3).gain(.95).orbit(1) + +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) + .gain(.4).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) +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) +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") + .gain(.5).speed(.9).mask("<0 0 0 1>").orbit(0) + +// ── STABS RAROS (campanitas FM que aparecen y desaparecen) ── +const stabs = note("~ ~ ~ [~ ab3] ~ ~ [c4 ~] ~") + .s("sine").fm(6).fmh(2.02).attack(.001).decay(.15).sustain(0) + .delay(.4).delaytime(.1875).delayfeedback(.5) + .gain(.6).degradeBy(.35).pan(rand.range(.2,.8)).orbit(3) + +// ── CONTRAMELODÍA (segunda parte, triangle suave) ── +const contra = note("c4 ~ ab3 bb3").s("triangle") + .attack(.02).release(.2).clip(.8).lpf(2200) + .delay(.3).delaytime(.375).delayfeedback(.4) + .room(.4).gain(.7).orbit(2) + +// ── 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 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 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) +const fin = stack(bajo.lpf(300).gain(.7), hats.gain(.25)) + +// ── ARREGLO (132 compases) ── +arrange( + [8, intro], + [8, introB], + [16, bajoIn], + [16, grooveA], + [8, grooveStabs], + [8, soloBajo], + [16, grooveB], + [16, grooveBFull], + [8, breakFm], + [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 +// Estructura: intro→build→drop A→break piano→drop B→drop final→coda (152 compases ≈ 4:21) +// ════════════════════════════════════════════════════════════════ +setcps(140/60/4) + +// ── LA MELODÍA (EXACTA: dos frases de corcheas que alternan por ciclo) ── +const melodia = note("<[e4 g4 e4 d4 e4 c4 d4 b3] [e4 g4 e4 a4 g4 e4 d4 c4]>") + +const leadSq = melodia.s("square").crush(8).lpf(2800).lpq(5) + .attack(.005).release(.1).shape(.3) + .delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.7).orbit(2) +const leadSaw = melodia.s("sawtooth").lpf(2200) + .attack(.005).release(.12) + .gain(.5).pan(sine.slow(5).range(.3,.7)).orbit(2) +const leadOctava = melodia.add(note(12)).s("square").crush(7).lpf(4200) + .gain(.3).orbit(2) + +// ── 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") + .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) + +// ── LA MULTITUD (ruido blanco con vocales = coros de estadio) ── +const multitud = s("white").struct("~ x ~ x").vowel("a") + .attack(.01).decay(.2).sustain(0).lpf(2500).hpf(300) + .room(.6).gain(.5).orbit(4) +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) + .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) +const kickEnorme = s("bd*4").bank("RolandTR909").shape(.65).distort(1.3).gain(1.12) + .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +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 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) + +// ── 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) + .room(.7).rsize(8).gain(.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, + 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 fin = stack(hats.gain(.35), piano.gain(.4).room(.85), estadio.gain(.2)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakPiano], + [8, breakBuild], + [16, dropB], + [16, dropBFull], + [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 +// Estructura: intro→arpegio→build→drop A→breakdown épico→drop B→coda (144 compases ≈ 4:14) +// ════════════════════════════════════════════════════════════════ +setcps(136/60/4) + +// ── EL ARPEGIO CRISTALINO (con delay ping-pong) ── +const arpegio = note("[a3 c4 e4 a4 e4 c4]*2") + .s("triangle").lpf(3200) + .attack(.002).decay(.12).sustain(.1).release(.08) + .delay(.45).delaytime(.375).delayfeedback(.5) + .pan(square.fast(3).range(.2,.8)) + .gain(.65).orbit(3) + +// ── LA MELODÍA (interpretación del lead celestial) ── +const melodia = note("e5 d5 c5 d5 e5 c5 a4 b4 c5 b4 a4 g4 a4 ~ ~ ~") + .s("sawtooth").lpf(2000).attack(.02).release(.3) + .room(.6).rsize(6).delay(.4).delaytime(.375).delayfeedback(.45) + .gain(.75).orbit(2) +const melodiaFlotante = melodia.slow(2).s("supersaw").unison(5).spread(.7) + .attack(.15).release(.8).room(.85).rsize(9).gain(.6) +const melodiaEpica = melodia.s("supersaw").unison(7).spread(.8).detune(.2) + .lpf(3500).gain(.8) +const melodiaOctava = melodiaEpica.add(note(12)).gain(.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) + .attack(.001).decay(.1).sustain(.2).release(.03) + .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) + +// ── 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 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 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) + +// ── 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) + .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) + +// ── 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, + 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 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) +const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(550).gain(.7), + arpegio.gain(.5), melodia.gain(.45).room(.75), pad) +const fin = stack(hats.gain(.3), arpegio.gain(.35).delayfeedback(.7), pad.gain(.35)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, arpIn], + [8, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→build→drop A→break piano→drop B→drop final→coda (144 compases ≈ 4:09) +// ════════════════════════════════════════════════════════════════ +setcps(139/60/4) + +// ── EL HOOK ITALO (la melodía inconfundible, sierra fina + delay corto) ── +const hook = note("a4 ~ bb4 a4 g4 f4 g4 ~ a4 ~ g4 f4 e4 f4 g4 ~") + .s("sawtooth").lpf(2600).lpq(3) + .attack(.004).release(.12).clip(.9) + .delay(.28).delaytime(.1875).delayfeedback(.35) + .room(.35).gain(.82).orbit(2) +const hookOctava = hook.add(note(12)).gain(.28).lpf(4200).orbit(2) + +// ── BAJO QUE BAILA (el salto de octava italo) ── +const bajo = note("f1 f2 c2 f1").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) + +// ── PIANO MARCATO (para los breaks, F Bb F C) ── +const piano = note("<[f3,a3,c4] [f3,bb3,d4] [f3,a3,c4] [e3,g3,c4]>") + .struct("x x x x").s("piano").clip(.5) + .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 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 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) + +// ── 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) + .room(.65).rsize(7).gain(.38).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), + 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 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)) +const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.8), piano.gain(.6), + hook.gain(.45).room(.7), pad) +const fin = stack(hats.gain(.32), hook.gain(.3).room(.85).delayfeedback(.6), pad.gain(.35)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakPiano], + [8, breakBuild], + [16, dropB], + [16, dropBFull], + [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 +// Estructura: intro→build→drop filtrado A→breakdown→drop B→coda (136 compases ≈ 4:25) +// ════════════════════════════════════════════════════════════════ +setcps(123/60/4) + +// ── EL FILTRO QUE RESPIRA (se aplica al bus melódico entero del drop) ── +const respira = p => p.lpf(sine.slow(16).range(500,4500)).hpf(sine.slow(16).range(40,650)) + +// ── EL BRASS HOOK (la fanfarria de celebración, interpretación en D) ── +const brass = note("d5 d5 c5 d5 ~ f5 ~ d5 c5 a4 c5 d5 ~ ~ ~ ~") + .s("sawtooth").attack(.008).decay(.18).sustain(.45).release(.12).clip(.85) + .lpf(2400).lpq(2).room(.5).rsize(4).gain(.82).orbit(2) +const brassOctava = brass.add(note(12)).gain(.25).orbit(2) + +// ── 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) + .attack(.001).decay(.18).sustain(.25).release(.05) + .shape(.3).gain(.9).orbit(1) +const sub = note("").s("sine") + .attack(.02).decay(.5).sustain(.4).gain(.5).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) + .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) +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) +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) + +// ── 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) + .phaser(.5).phaserdepth(.75).room(.6).rsize(6).gain(.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 coda = stack(kick, hatsSwing, clap.gain(.5), bajo.lpf(600).gain(.7), + brass.gain(.45).room(.7), pad) +const fin = stack(hatsSwing.gain(.3), brass.gain(.3).room(.85), pad.gain(.35)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAfiltro], + [16, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→build→drop A→breakdown→drop stut→coda (128 compases ≈ 4:10) +// ════════════════════════════════════════════════════════════════ +setcps(123/60/4) + +// ── EL HOOK VOCODER (vocales secuenciadas = robot que canta) ── +const hook = note("e4 e4 ~ e4 d4 e4 g4 ~ e4 d4 e4 ~ b3 ~ d4 ~") + .s("sawtooth").vowel("[e a o i]*2") + .lpf(2800).attack(.005).release(.1).shape(.25) + .gain(.85).orbit(2) +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)) + +// ── 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 ~ ~ ~") + .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) + .gain(.4).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) + .duck("1:2").duckattack(.09).duckdepth(.55).orbit(0) +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) +const toms = s("~ ~ ~ ~ ~ ~ [ht mt] lt").bank("RolandTR808") + .gain(.55).mask("<0 0 0 1>").orbit(0) + +// ── PAD LO-FI (coarse = circuito viejo) ── +const pad = note("<[e3,g3,b3] [g3,b3,d4] [e3,g3,b3] [d3,fs3,a3]>") + .s("sawtooth").lpf(800).coarse(3).attack(.5).release(1.1) + .room(.55).rsize(6).gain(.38).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats) +const introB = stack(kick, hats, snare, clave) +const build = stack(kick, hats, snare, bajo, + 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 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) +const fin = stack(hats.gain(.3), hook.slow(2).gain(.35).room(.8), pad.gain(.3)) + +// ── ARREGLO (128 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropStut], + [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 +// Estructura: intro→groove→drop A→breakdown→drop B (tensión máxima)→coda (132 compases ≈ 4:11) +// ════════════════════════════════════════════════════════════════ +setcps(126/60/4) + +// ── EL LA-LA-LA (interpretación nocturna, triangle + delay) ── +const lalala = note("d5 ~ d5 c5 a4 ~ c5 d5 c5 a4 g4 f4 g4 ~ ~ ~") + .s("triangle").lpf(2600) + .attack(.01).release(.15) + .delay(.4).delaytime(.375).delayfeedback(.5) + .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) ── +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") + .attack(.02).decay(.5).sustain(.35).gain(.5).orbit(1) + +// ── CUERDAS STACCATO (la elegancia oscura) ── +const cuerdas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>") + .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) + .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) + .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.08) + .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +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) + .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 rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.35)).orbit(0) + +// ── 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 breakdown = stack(cuerdasLargas, lalala.slow(2).gain(.55).room(.75), + hats.gain(.28), sub.gain(.35)) +const breakBuild = stack(cuerdasLargas, lalala.gain(.7), rodillo, + 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, + lalala.sometimesBy(.2, x=>x.add(note(12))), lalalaEco, cuerdas, + cuerdasLargas.gain(.28), rodillo.gain(.25)) +const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.75), + lalala.gain(.45).room(.7), cuerdasLargas) +const fin = stack(hats.gain(.3), lalala.gain(.3).room(.9).delayfeedback(.65), + cuerdasLargas.gain(.3)) + +// ── ARREGLO (132 compases) ── +arrange( + [8, intro], + [8, introB], + [16, groove], + [8, build], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→riff→build hpf→drop A→breakdown→drop B demoledor→coda (136 compases ≈ 4:11) +// ════════════════════════════════════════════════════════════════ +setcps(130/60/4) + +// ── EL RIFF BENASSI (EXACTO: sierra mordida con envolvente de filtro agresiva) ── +const riff = note("c3 ~ c3 eb3 ~ c3 f3 eb3") + .s("sawtooth").ftype("ladder") + .lpf(sine.slow(8).range(300,2200)).lpq(12) + .lpenv(4).lpattack(.001).lpdecay(.1) + .crush(6).shape(.5) + .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) ── +const sub = note("c1 ~ c1 eb1 ~ c1 f1 eb1").s("sine") + .decay(.25).sustain(.2).gain(.65).orbit(1) + +// ── BATERÍA 909 (sidechain exagerado: duckdepth .85) ── +const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) + .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0) +const kickDemoledor = s("bd*4").bank("RolandTR909").shape(.65).distort(1.25).gain(1.12) + .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0) +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") + .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0) +const open = s("~ ~ [~ oh] ~").bank("RolandTR909").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) + +// ── 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) + .room(.6).rsize(6).gain(.35).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, + 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 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) +const fin = stack(hats.gain(.3), riff.lpf(400).gain(.4).room(.7), pad.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, riffIn], + [8, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: intro→build→drop A→breakdown→drop B→coda (128 compases ≈ 4:00) +// ════════════════════════════════════════════════════════════════ +setcps(128/60/4) + +// ── EL HOOK (los stabs saturados de saw, interpretación en Bm) ── +const hook = note("fs4 ~ fs4 e4 d4 e4 fs4 ~ b4 ~ a4 fs4 e4 d4 e4 ~") + .s("sawtooth").shape(.5).lpf(2400).lpq(4) + .attack(.004).release(.1) + .room(.35).gain(.85).orbit(2) +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) ── +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) +const sub = note("").s("sine") + .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1) + +// ── BATERÍA 909 (el kick manda: duckdepth .9, duckattack .2) ── +const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08) + .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0) +const kickPump = s("bd*4").bank("RolandTR909").shape(.6).distort(1.15).gain(1.1) + .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0) +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) +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 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) + .attack(.05).release(.6) + .gain(saw.fast(4).range(.12,.45)).room(.5).rsize(5).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, + 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 coda = stack(kick, hatsMin, clap.gain(.5), bajo.gain(.8), + hook.gain(.45).room(.6), pad.gain(.3)) +const fin = stack(hatsMin.gain(.25), hook.gain(.3).room(.85), pad.gain(.28)) + +// ── ARREGLO (128 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [8, breakdown], + [8, breakBuild], + [16, dropB], + [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 +// Estructura: percusión sola→toms→drop tribal→melodía tardía→drop total→coda (144 compases ≈ 4:10) +// ════════════════════════════════════════════════════════════════ +setcps(138/60/4) + +// ── TAIKOS TRIBALES (el verdadero protagonista del track) ── +const taikoA = s("east:6(5,16)").speed(.9).shape(.3).gain(.95) + .pan(.42).orbit(3) +const taikoB = s("east:7(7,16,2)").speed(1.1).shape(.25).gain(.8) + .pan(.58).orbit(3) +const taikoC = s("east:8(3,16,1)").speed(.72).shape(.35).gain(.9) + .room(.3).rsize(3).orbit(3) +const taikoSolo = s("east:6 ~ east:7 east:6 ~ east:8 east:7 ~ east:6 east:6 ~ east:7 ~ east:8 east:7 east:8") + .speed("<.9 .95 1 1.05>").shape(.3).gain(1) + .pan(rand.range(.3,.7)).orbit(3) + +// ── TOMS 909 (respuesta grave a los taikos) ── +const toms = s("~ ~ [ht mt] ~ ~ lt ~ [mt ht]").bank("RolandTR909") + .gain(.8).pan(sine.slow(4).range(.35,.65)).orbit(0) +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) + .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1) + .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0) +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") + .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) + +// ── BAJO PUNCHY (stabs sincopados, deja hueco a los tambores) ── +const bajo = note("d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~") + .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") + .decay(.25).sustain(.25).gain(.7).orbit(1) + +// ── LA MELODÍA (entra tarde, interpretación del hook de Safri Duo) ── +const hook = note("d4 f4 g4 a4 g4 f4 d4 ~") + .s("square").lpf(1600).lpq(5).attack(.01).decay(.2).sustain(.3).release(.1) + .delay(.3).delaytime(.375).delayfeedback(.4) + .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) + .attack(1.2).release(2).room(.7).rsize(7).gain(.35).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, + hook.gain(.5).room(.6)) +const dropTotal = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, + bajo, bajoSub, hook, hookOctava) +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) +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)) +const codaFin = stack(taikoSolo.gain(.6).room(.7), drone.gain(.25), shaker.gain(.3)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, introPerc], + [8, percDobla], + [16, tribalFull], + [4, rodilloTom], + [16, dropPerc], + [16, dropMelodia], + [8, breakTribal], + [8, buildTribal], + [16, dropTotal], + [16, dropTotalVar], + [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 +// Estructura: intro→build→drop A→break cósmico→drop delay largo→coda (148 compases ≈ 4:17) +// ════════════════════════════════════════════════════════════════ +setcps(138/60/4) + +// ── EL RIFF ESPACIAL RUSO (16 pasos, interpretación) ── +const riff = note("a4 b4 c5 d5 e5 ~ c5 e5 a5 ~ g5 e5 d5 c5 b4 ~") + .s("supersaw").unison(5).spread(.65).detune(.18) + .penv(3).pattack(.01).pdecay(.14) + .lpf(2200).lpq(4).attack(.01).decay(.18).sustain(.25).release(.12) + .room(.5).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4) + .gain(.8).pan(sine.slow(8).range(.3,.7)).orbit(2) +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) ── +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) +const bajoSub = note("").s("sine") + .attack(.02).decay(.4).sustain(.5).gain(.6).orbit(1) + +// ── BATERÍA 909 TRANCE ── +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(.55).distort(1.15).gain(1.1) + .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0) +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") + .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 rodillo = s("sd*16").bank("RolandTR909") + .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).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) + .room(.7).rsize(7).gain(.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, + 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 breakCosmos = stack(espacio, pad, riffCosmico.gain(.6), + bajoSub.gain(.35), hats.gain(.25)) +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, + bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, + riff.every(4, x=>x.iter(4)), riffOctava, espacio.gain(.25)) +const coda = stack(kick, hats, bajo.lpf(550).gain(.7), + riff.gain(.45).room(.7), pad) +const codaFin = stack(hats.gain(.3), espacio, + riffCosmico.gain(.35).delayfeedback(.75), pad.gain(.3)) + +// ── ARREGLO (148 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [12, breakCosmos], + [8, breakBuild], + [16, dropDelay], + [16, dropTotal], + [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 +// Estructura: intro→groove→drop filtrado→break sedoso→drop abierto→coda (136 compases ≈ 4:28) +// ════════════════════════════════════════════════════════════════ +setcps(122/60/4) + +// ── EL RIFF FUNKY (pluck disco filtrado, el loop eterno de Modjo) ── +const riff = note("fs3 a3 b3 cs4 e4 cs4 b3 a3") + .s("sawtooth").lpf(1200).lpq(5).attack(.005).decay(.13).sustain(.08).release(.07) + .phaser(.5).phaserdepth(.4) + .gain(.85).pan(sine.slow(12).range(.35,.65)).orbit(2) +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) + +// ── 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) ── +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) +const bajoSub = note("").s("sine") + .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1) + +// ── BATERÍA 909 CÁLIDA CON SWING ── +const kick = s("bd*4").bank("RolandTR909").shape(.25).gain(1) + .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0) +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) +const rimGroove = s("~ ~ rim ~ ~ rim ~ ~").bank("LinnDrum") + .gain(.4).swingBy(.08, 8).pan(.35).orbit(0) + +// ── PAD SUAVE (strings de terciopelo) ── +const pad = note("[fs3,a3,cs4]").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) + +// ── 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, + 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 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), + 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 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) +const codaFin = stack(hats.gain(.3), riff.gain(.28).room(.8).lpf(800), + pad.gain(.25), bajoSub.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, groove], + [4, grooveFin], + [16, dropFiltrado], + [16, dropFunk], + [8, breakSedoso], + [8, breakBuild], + [16, dropAbierto], + [16, dropAbiertoVar], + [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 +// 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) ── +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) + .gain(.95).orbit(1) +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) + +// ── 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) + .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) + .duck("1:2").duckattack(.08).duckdepth(.55).orbit(0) +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") + .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 cowRim = s("~ ~ ~ rim").bank("RolandTR808").gain(.35).pan(.3).orbit(0) + +// ── LA RISA MANÍACA (ruido blanco + vocales + stut) ── +const risa = s("white*8").attack(.001).decay(.07).sustain(0) + .vowel("a e i o a i e o").hpf(700).lpf(3200) + .speed(rand.range(.7,1.5)).pan(rand.range(.2,.8)) + .stut(3, .5, .06).degradeBy(.35).gain(.5).orbit(3) + +// ── HOOK LO-FI (interpretación del canto, con crush) ── +const hook = note("e4 ~ e4 d4 e4 g4 ~ e4 d4 c4 ~ b3 ~ d4 e4 ~") + .s("square").crush(6).lpf(1800) + .attack(.01).decay(.15).sustain(.2).release(.08) + .delay(.25).delaytime(.375).delayfeedback(.35) + .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) +const viento = s("wind:2").slow(2).gain(.3).lpf(2000) + .room(.7).rsize(8).pan(sine.slow(12).range(.3,.7)).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), + bajo, risa.gain(.35)) +const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, + bajo, bajoSub) +const dropBajoHook = stack(kickDuro, hats, hatOpen, snare, snareGhost, + bajo, bajoSub, hook) +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, + 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 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) +const codaFin = stack(viento, hook.gain(.25).room(.85).delayfeedback(.6), + pad.gain(.25), bajoSub.gain(.3)) + +// ── ARREGLO (136 compases) ── +arrange( + [8, intro], + [8, introB], + [16, groove], + [4, grooveFin], + [16, dropBajo], + [16, dropBajoHook], + [8, breakRisa], + [8, breakBuild], + [16, dropTotal], + [16, dropTotalVar], + [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 +// Estructura: stomp→build→drop riff→break estadio→drop octavas→drop final→coda (152 compases ≈ 4:41) +// ════════════════════════════════════════════════════════════════ +setcps(130/60/4) + +// ── EL RIFF (16 pasos EXACTOS, como bajo masivo) ── +const riff = note("e3 ~ ~ e3 [g3 e3] d3 ~ ~ c3 ~ ~ ~ b2 ~ ~ ~") + .s("sawtooth").distort(1.1).lpf(1100).lpq(6) + .attack(.003).decay(.25).sustain(.45).release(.08) + .shape(.3).gain(.9).orbit(1) +const riffSub = note("e2 ~ ~ e2 [g2 e2] d2 ~ ~ c2 ~ ~ ~ b1 ~ ~ ~") + .s("sine").attack(.002).decay(.3).sustain(.5).release(.06) + .gain(.7).orbit(1) +const riffOctavas = riff.superimpose(x=>x.add(note(12)).lpf(2400).gain(.55)) +const riffLead = note("e4 ~ ~ e4 [g4 e4] d4 ~ ~ c4 ~ ~ ~ b3 ~ ~ ~") + .s("supersaw").unison(5).spread(.7).lpf(2800) + .attack(.01).decay(.2).sustain(.35).release(.15) + .room(.5).rsize(6).delay(.3).delaytime(.375).delayfeedback(.35) + .gain(.6).orbit(2) + +// ── 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 ── +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) + .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1) + .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0) +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("[.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) +const sdGhost = s("sd(5,16,2)").bank("RolandTR909").gain(.28) + .pan(rand.range(.3,.7)).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]>") + .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) + +// ── 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 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), + 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 coda = stack(kick, hats, clap, riff.lpf(700).gain(.7), + riffSub.gain(.5), cuerdas, multitud.gain(.15)) +const codaFin = stack(multitud, cuerdas.gain(.3), + riffLead.gain(.3).room(.9).delayfeedback(.6), stomp.gain(.4)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, introStomp], + [8, introRiff], + [16, build], + [4, buildFin], + [16, dropRiff], + [16, dropRiffVar], + [8, breakEstadio], + [8, breakBuild], + [16, dropOctavas], + [16, dropOctavasFull], + [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 +// Estructura: intro→build→drop A→breakdown emotivo largo→drop B→coda (152 compases ≈ 4:45) +// ════════════════════════════════════════════════════════════════ +setcps(128/60/4) + +// ── EL HOOK (16 pasos, interpretación del sinte de Kids) ── +const hook = note("a4 ~ c5 b4 a4 g4 a4 e5 d5 c5 b4 c5 b4 a4 g4 ~") + .s("supersaw").unison(4).spread(.5).detune(.12) + .lpf(2000).attack(.02).decay(.2).sustain(.35).release(.15) + .delay(.35).delaytime(.375).delayfeedback(.45) + .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) + +// ── 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)) + .attack(.005).decay(.12).sustain(.1).release(.06) + .delay(.2).delaytime(.1875).delayfeedback(.3) + .gain(.6).pan(.4).orbit(3) + +// ── BAJO PULSANTE (corcheas, progresión Am→Am→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) +const bajoSub = note("").s("sine") + .attack(.05).decay(.5).sustain(.5).gain(.55).orbit(1) + +// ── BATERÍA 909 ELEGANTE ── +const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02) + .duck("1:2").duckattack(.14).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08) + .duck("1:2").duckattack(.14).duckdepth(.6).orbit(0) +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 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) +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 ── +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) + .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) + .vib(4).vibmod(.15).room(.6).rsize(6).gain(.3).orbit(4) + +// ── SECCIONES ── +const intro = stack(kick, hats, bajoSub.gain(.4), pad.gain(.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 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, + 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, + 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) +const coda = stack(kick, hats, bajo.lpf(500).gain(.65), + hook.gain(.45).room(.7), arpegio.gain(.4), pad) +const codaFin = stack(hats.gain(.25), hook.gain(.3).room(.9).delayfeedback(.65), + pad.gain(.3), cuerdas.gain(.2)) + +// ── ARREGLO (152 compases) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [16, breakdown], + [8, breakBuild], + [16, dropB], + [16, dropBFull], + [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 +// Estructura: intro→motor arpegio→drop disco→break reloj→drop brillante→coda (144 compases ≈ 4:34) +// ════════════════════════════════════════════════════════════════ +setcps(126/60/4) + +// ── EL ARPEGIO ABBA (16avos, el motor del track) ── +const arpegio = note("[d3 f3 a3 d4 f4 d4 a3 f3]*2") + .s("sawtooth").lpf(1800).lpq(5).attack(.004).decay(.12).sustain(.12).release(.06) + .phaser(4).phaserdepth(.6) + .gain(.75).pan(sine.slow(6).range(.35,.65)).orbit(3) +const arpegioAlto = arpegio.add(note(12)).gain(.28).lpf(3000).orbit(3) + +// ── EL HOOK (interpretación de la voz de Hung Up) ── +const hook = note("a4 ~ a4 g4 f4 g4 a4 d5 ~ c5 a4 g4 f4 ~ e4 ~") + .s("supersaw").unison(4).spread(.55).lpf(2400) + .attack(.01).decay(.18).sustain(.3).release(.12) + .delay(.3).delaytime(.25).delayfeedback(.35) + .room(.4).rsize(5).gain(.8).pan(sine.slow(9).range(.35,.65)).orbit(2) + +// ── 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) ── +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) +const bajoSub = note("").s("sine") + .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1) + +// ── STRINGS DISCO (supersaw brillante) ── +const cuerdas = note("<[d3,f3,a3] [d3,f3,a3] [d3,f3,a3] [c3,e3,g3]>") + .s("supersaw").unison(6).spread(.8) + .lpf(sine.slow(16).range(500,2000)).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) + .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0) +const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1) + .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0) +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 hats16 = s("hh*16").bank("RolandTR909") + .gain("[.48 .22 .34 .22]*4").pan(rand.range(.4,.6)).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) + +// ── SECCIONES ── +const intro = stack(kick, hats, bajoSub.gain(.4), reloj.gain(.3)) +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, + 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 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), + 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, + arpegio.every(4, x=>x.rev()), arpegioAlto, hook, cuerdas.gain(.32), + reloj.gain(.25)) +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) +const codaFin = stack(reloj.gain(.4), hook.gain(.3).room(.9).delayfeedback(.6), + cuerdas.gain(.25)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, motor], + [4, motorFin], + [16, dropDisco], + [16, dropDiscoVar], + [12, breakReloj], + [8, breakBuild], + [16, dropBrillante], + [16, dropBrillanteVar], + [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 +// Estructura: intro→groove profundo→drop piano→break piano solo→drop abierto→coda (144 compases ≈ 4:34) +// ════════════════════════════════════════════════════════════════ +setcps(126/60/4) + +// ── EL PIANO (riff con progresión Am→G→F→G) ── +const piano = note("a3 c4 e4 a4 g4 e4 c4 e4").add(note("<0 -2 -4 -2>")) + .s("piano").clip(1.1) + .room(.6).rsize(7).delay(.25).delaytime(.375).delayfeedback(.35) + .gain(.8).pan(sine.slow(12).range(.4,.6)).orbit(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) ── +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) +const bajoSub = note("").s("sine") + .attack(.05).decay(.5).sustain(.55).gain(.55).orbit(1) + +// ── BATERÍA 909 SEDOSA ── +const kick = s("bd*4").bank("RolandTR909").shape(.3).gain(1) + .duck("1:2").duckattack(.15).duckdepth(.45).orbit(0) +const kickHondo = s("bd*4").bank("RolandTR909").shape(.4).gain(1.06) + .duck("1:2").duckattack(.15).duckdepth(.55).orbit(0) +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 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 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 ── +const voz = note("").s("sawtooth").vowel("") + .attack(.7).release(1.2).lpf(1500) + .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) + .room(.75).rsize(8).gain(.38).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, + 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 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) +const codaFin = stack(pianoSolo.gain(.4).delayfeedback(.6), + pad.gain(.3), voz.gain(.25), hats.gain(.2)) + +// ── ARREGLO (144 compases) ── +arrange( + [8, intro], + [8, introB], + [16, groove], + [4, grooveFin], + [16, dropPiano], + [16, dropPianoVar], + [12, breakPiano], + [8, breakBuild], + [16, dropAbierto], + [16, dropAbiertoVar], + [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 +// Estructura: intro→build→drop A→breakdown orquestal 20→drop final devastador→coda en cuerdas (172 compases ≈ 4:55) +// ════════════════════════════════════════════════════════════════ +setcps(140/60/4) + +// ── LA MELODÍA DEL ADAGIO (frases lentas sobre 4 compases, notas largas) ── +const melodia = note("e4 f4 e4 d4 e4 ~ f4 g4 f4 e4 f4 ~ g4 a4 g4 f4 g4 ~ a4 ~") + .slow(4).clip(1.5) + .s("supersaw").unison(7).spread(.9).detune(.2) + .lpf(2200).attack(.3).decay(.5).sustain(.8).release(1.2) + .room(.8).rsize(9).delay(.3).delaytime(.5).delayfeedback(.4) + .gain(.8).pan(sine.slow(16).range(.35,.65)).orbit(2) +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]>") + .s("supersaw").unison(7).spread(.9) + .lpf(sine.slow(32).range(400,2400)).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) + +// ── 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) +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) +const bajoSub = note("").s("sine") + .attack(.03).decay(.5).sustain(.5).gain(.55).orbit(1) + +// ── BATERÍA 909 BIG ROOM ── +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(.55).distort(1.2).gain(1.1) + .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0) +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 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) +const crash = s("cr/4").bank("RolandTR909").gain(.5).room(.5).rsize(5).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) + +// ── SECCIONES ── +const intro = stack(kick, hats, cuerdasBajas.gain(.25)) +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, + 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, + 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, + melodia, melodiaOctava.every(4, x=>x.add(note(12)).gain(.2)), + cuerdas.gain(.4)) +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)) +const codaFin = stack(melodiaSola.gain(.35).delayfeedback(.6), + cuerdas.gain(.25), cuerdasBajas.gain(.2)) + +// ── ARREGLO (172 compases · la más larga de la colección) ── +arrange( + [8, intro], + [8, introB], + [16, build], + [4, buildFin], + [16, dropA], + [16, dropAvar], + [20, breakdown], + [8, breakBuild], + [4, buildFin2], + [16, dropFinal], + [16, dropFinalFull], + [16, dropFinalVar], + [8, salida], + [8, coda], + [8, codaFin] +)`, + }, +];