+
code-sinth es un sintetizador modular gobernado por un pequeño lenguaje
+ de patches. El editor de la izquierda es la fuente de verdad: cada
+ línea node X = ... declara un nodo del grafo, y
+ out <- ... elige qué señal sale por los altavoces.
+ Cualquier cambio en el editor se recarga en caliente preservando el
+ estado interno (fases de osciladores, posición de secuenciadores,
+ envolventes en vuelo).
+
+
+
+
Lenguaje del patch
+
El patch es texto plano. Las construcciones son cuatro:
+
+ node nombre = expresión — declara un nodo con nombre.
+ Puedes referirlo por su nombre en cualquier expresión posterior.out <- expresión — la señal que se manda al
+ output. Debe haber exactamente una.voice nombre { ... } — bloque que define una
+ plantilla de voz reutilizable. Dentro tiene su propio
+ node y un out <- propio. Se instancia
+ desde poly(voice=nombre, voices=N, ...).# comentario — hasta fin de línea.
+
Las expresiones admiten números (0.5, 440),
+ identificadores, + - * /, paréntesis, listas
+ [1, 0, 1, 0] y llamadas a funciones-nodo. Los argumentos
+ pueden ser posicionales o con nombre: osc(saw, freq=220).
+ Las señales se mezclan sumándolas: out <- a*0.5 + b*0.3.
+ Multiplicar por una envolvente actúa como amplificador controlado:
+ o1 * env.
+
+
Cómo se ejecuta
+
El motor corre en un AudioWorklet y procesa bloques de 128
+ muestras a la sample-rate del navegador (típicamente 48 kHz). En cada
+ bloque se evalúa el grafo en orden topológico: cada nodo lee los
+ buffers de sus entradas, produce su buffer de salida, y al final el
+ buffer de out sale por los altavoces.
+
Pulsa RUN para arrancar el audio (los navegadores requieren
+ un click del usuario antes de abrir el AudioContext). El indicador
+ RUNNING_ abajo se enciende cuando el motor está procesando.
+
+
Osciladores · osc
+
Genera una forma de onda continua a la frecuencia indicada.
+ freq puede ser un número fijo o cualquier señal
+ (otro nodo) — eso da modulación.
+
node lfo = osc(sine, freq=4) # 4 Hz
+node pit = 220 + lfo*30 # vibrato +/-30 Hz
+node main = osc(saw, freq=pit)
+out <- main*0.4
+
+ | Forma | Carácter | Uso típico |
|---|
+ sine | limpio, sin armónicos | LFO, sub-bass, pads |
+ saw | brillante, todos los armónicos | leads, bajos, strings |
+ square | solo armónicos impares | chiptune, bajos huecos |
+ tri | cálido, armónicos impares decrecientes | flautas, sub-leads |
+
+
+
Envolventes · adsr y trig
+
trig(period, duration) emite una compuerta
+ (gate) cíclica: alta durante duration segundos, luego
+ baja, repitiéndose cada period segundos.
+
adsr(a, d, s, r, gate) es la envolvente clásica.
+ a/d/r en segundos, s nivel 0..1.
+ Mientras gate esté en 1 sube por la fase de attack,
+ cae al sustain y se queda; cuando vuelve a 0 entra en release.
+
node g1 = trig(period=0.5, duration=0.05)
+node env = adsr(a=0.005, d=0.1, s=0.0, r=0.2, gate=g1)
+node tone = osc(sine, freq=440)
+out <- tone * env
+
Truco: para una percusión, pon s=0 y
+ d corto (~0.1 s). Para un pad, sube
+ a a 0.5–2 s y deja s alto.
+
+
Filtro · filter
+
Biquad RBJ, tipos lp (low-pass), hp
+ (high-pass) o bp (band-pass). cutoff y
+ q (resonancia) pueden modularse a tasa de audio —
+ sumarle una envolvente al cutoff es la receta clásica del bajo
+ sintetizado.
+
node src = osc(saw, freq=110)
+node g = trig(period=0.5, duration=0.2)
+node e = adsr(a=0.005, d=0.2, s=0, r=0.1, gate=g)
+node lp = filter(lp, in=src, cutoff=300 + e*2500, q=4)
+out <- lp * e
+
+
Ruido · noise
+
Ruido blanco en [-1, 1]. Filtrado con hp alto y una
+ envolvente cortita, da un hi-hat. Filtrado con bp con
+ cutoff bajo, una caja.
+
node n = noise()
+node g = trig(period=0.25, duration=0.02)
+node e = adsr(a=0.001, d=0.04, s=0, r=0.03, gate=g)
+node hp = filter(hp, in=n, cutoff=5000, q=1.5)
+out <- hp * e * 0.4
+
+
Secuenciador básico · seq
+
Recorre una lista de valores a rate pasos por segundo,
+ manteniendo cada valor hasta el siguiente. Útil para listas de
+ frecuencias o de niveles de control.
+
node freqs = seq(rate=4, steps=[220, 277, 330, 220])
+node tone = osc(saw, freq=freqs)
+node g = trig(period=0.25, duration=0.18)
+node e = adsr(a=0.005, d=0.1, s=0.6, r=0.2, gate=g)
+out <- tone * e * 0.4
+
+
Delay · delay
+
Línea de delay con feedback. time en segundos,
+ feedback 0..0.99, mix 0..1
+ (0 = solo seco, 1 = solo retardado).
+
node src = osc(tri, freq=330)
+node g = trig(period=1.0, duration=0.05)
+node e = adsr(a=0.005, d=0.2, s=0, r=0.1, gate=g)
+node dry = src * e
+node dl = delay(in=dry, time=0.375, feedback=0.55, mix=0.5)
+out <- dl * 0.5
+
+
Polifonía · voice + poly
+
Define una plantilla de voz con un bloque
+ voice nombre { ... }: dentro tendrás dos identificadores
+ especiales — freq (la frecuencia que el allocator
+ asigna a la voz) y gate (la compuerta que se abre
+ durante gate_duration segundos por cada nota).
+
Luego instancia con poly(voice=nombre, voices=N, rate, notes,
+ gate_duration). notes es una lista de frecuencias;
+ 0 es silencio. El allocator asigna la voz menos reciente
+ (LRU) a cada nota nueva.
+
voice synth {
+ node o = osc(saw, freq=freq)
+ node e = adsr(a=0.005, d=0.2, s=0.4, r=0.3, gate=gate)
+ node f = filter(lp, in=o, cutoff=600 + e*1800, q=2.0)
+ out <- f * e
+}
+node mel = poly(voice=synth, voices=4, rate=4, gate_duration=0.18,
+ notes=[220, 277, 330, 0, 220, 330, 277, 0])
+out <- mel * 0.4
+
+
Knobs · faders · pads
+
Hay cuatro tipos de nodo cuyo valor lo decide el panel derecho en
+ vez del código. Al declararlos aparece un widget físico al que
+ puedes interactuar con el ratón.
+
+
Knob
+
node cutoff = knob(min=200, max=4000, default=900)
+
Arrastra arriba/abajo para girarlo, doble-click para volver al
+ centro, Shift + arrastrar para ajuste fino.
+
+
Fader
+
node mix = fader(min=0, max=1, default=0.5)
+
+
Step sequencer
+
node kick = step_seq(rate=8, steps=16,
+ default=[1,0,0,0, 1,0,0,0, 1,0,0,0, 1,0,0,0])
+
Click en una celda para encender/apagar; arrastra para pintar
+ muchas a la vez. La salida es 0/1, perfecta como
+ gate= de un ADSR.
+
+
Piano roll
+
node mel = piano_roll(voice=synth, voices=4,
+ rate=8, length=16, octaves=2, base=220,
+ gate_duration=0.18)
+
Es un poly() con las notas dispuestas en una rejilla
+ de pasos × semitonos. Click en cualquier celda para colocar una
+ nota. La columna 0 es base Hz, cada fila es un
+ semitono más arriba. Necesita un voice previo, igual
+ que poly.
+
+
Consejos
+
+ - Empieza bajo. El gain del header es 0.30 por algo:
+ sumar varias señales sin escalar satura rápido.
+ - Multiplica por la envolvente al final.
+
filter(...) * env evita clics al inicio/final
+ mejor que poner la envolvente solo en el cutoff.
+ - Hot-reload preserva el estado. Los osciladores no
+ saltan de fase, los secuenciadores no resetean. Borra y reescribe
+ el nodo si quieres reiniciarlo.
+ - El waveform inline después de cada nodo es lo que está
+ saliendo realmente del grafo en ese punto. Útil para ver dónde
+ se está rompiendo el sonido.
+ - Para mezclar varias fuentes, súmalas con
+
+ y multiplica el total por un factor pequeño:
+ out <- bass*0.6 + drum*0.5 + lead*0.4.
+
+
+
+ — fin del manual —
+
+