GLSL para builders: un laboratorio de shaders realmente usable

Los shaders GLSL se vuelven intuitivos cuando puedes cambiar un número y ver el resultado a 60 fps. Este laboratorio interactivo incluye shaders preconfigurados que puedes modificar en tiempo real: ondas senoidales que modulan campos de color, funciones de ruido que generan terreno y ray marching que construye escenas 3D solo con matemáticas.

Aprendí shaders cambiando un número a la vez y observando qué pasaba. Leer las matemáticas me decía qué hace una onda senoidal. Mover un slider me mostraba cómo se ve una onda senoidal modulando un campo de color a 60 fps. El segundo tipo de comprensión es el que se queda. Este laboratorio forma parte de la serie Interactive Explorations y del territorio más amplio de la ingeniería de diseño.

El post incluye un laboratorio GLSL en vivo con shaders preconfigurados que puedes modificar en tiempo real. La estructura es la de un taller, no la de una clase magistral: iteración rápida, feedback visual y suficientes anotaciones para que entiendas qué hace cada control y por qué.

TL;DR

Si quieres dominar GLSL, deja de leer teoría de shaders de forma pasiva y empieza a manipular uniforms de forma agresiva. Cambia un parámetro cada vez, observa cómo se deforman los campos de espacio y tiempo, y luego codifica lo aprendido en patrones reutilizables. El laboratorio interactivo de abajo te da un bucle práctico: elige un preset, ajusta Speed, Scale, Detail y Color Shift, y construye intuición gracias al feedback visual inmediato.1



Por qué esto importa en el trabajo de producto

Los shaders resuelven problemas reales de producto. El post sobre la ciencia del color en interfaces explica cómo funciona la percepción del color a nivel teórico; los shaders son donde esa teoría se convierte en salida visual en tiempo real. Son útiles para:

  • fondos con movimiento ambiental que siguen siendo ligeros
  • firmas visuales de marca sin enviar assets de video pesados
  • bloques de storytelling interactivo dentro de contenido editorial
  • sistemas visuales generativos parametrizables por campaña

El laboratorio de esta página es en sí mismo un ejemplo de producción: un componente WebGL sin dependencias, integrado en un post de blog renderizado en el servidor y sin herramientas de build, que cumple cada una de las salvaguardas descritas más abajo.

Un caso concreto: el Sorting Visualizer de este sitio usa un fragment shader a pantalla completa como fondo ambiental detrás de la animación de ordenamiento. El shader renderiza un degradado de movimiento lento que responde al progreso del algoritmo de ordenamiento: la fase de color se desplaza a medida que se acumulan los intercambios, creando una “temperatura” visual que sube con el trabajo algorítmico. La implementación ocupa 48 líneas de GLSL (una variante de plasma controlada por un único uniform u_progress que va de 0.0 a 1.0). En el MacBook Air M1 del autor, el shader añade 0.3 ms por frame al presupuesto de renderizado, algo insignificante a 60 fps (16.6 ms de presupuesto). En un iPhone 12 Mini (A14, probado mediante la depuración remota de Safari), el mismo shader añade 0.8 ms por frame, todavía muy dentro del presupuesto. El shader reemplazó una animación de degradado en CSS que necesitaba 6 KB de definiciones de keyframes, no podía responder al estado de la aplicación y provocaba recálculos de layout con cada cambio de color. La versión GLSL es más pequeña (1.2 KB), se compone en la GPU (cero costo de layout) y está parametrizada (el uniform de progreso se conecta a cualquier fuente de datos).

La restricción práctica siempre es el rendimiento. Si el presupuesto de frames se desploma en móvil, la idea visual muere, por elegante que sea la matemática.

El modelo mental que sí se queda

Trata cada fragment shader como tres problemas resueltos en secuencia:2

  1. un problema de transformación de coordenadas
  2. un problema de señal periódica
  3. un problema de mapeo de color

En GLSL, cada paso se traduce en unas pocas líneas. Los tipos vec2, vec3 y vec4 son los tipos vectoriales integrados de GLSL para floats de 2, 3 y 4 componentes, usados respectivamente para coordenadas, colores y píxeles de salida:

// Step 1: Coordinates, where am I in normalized space?
vec2 uv = gl_FragCoord.xy / u_resolution;  // 0.0 to 1.0
vec2 p = uv * u_scale;                     // scale the coordinate space

// Step 2: Signal, what scalar field exists at this point and time?
float signal = sin(p.x * 6.28 + u_time);   // periodic wave across x-axis

// Step 3: Color, how do I map that scalar to visible output?
vec3 color = vec3(signal * 0.5 + 0.5);      // remap -1..1 to 0..1
gl_FragColor = vec4(color, 1.0);             // WebGL 1.0 (GLSL ES 1.00) output

Los valores u_resolution, u_scale y u_time son uniforms: valores que la CPU envía a la GPU en cada frame. Los uniforms son la superficie de control. Cambiar u_scale hace zoom sobre el espacio de coordenadas. Cambiar u_time anima la señal. El código del shader sigue igual; el comportamiento cambia porque cambian las entradas. El laboratorio de abajo expone cuatro uniforms (Speed, Scale, Detail, Color Shift) para que lo sientas directamente.

Casi todo se puede construir a partir de ese bucle de tres pasos.

Tres presets, tres comportamientos

El laboratorio incluye tres comportamientos de shader para que puedas comparar patrones:

  • Plasma: ondas sin() superpuestas crean patrones de interferencia. Tres ondas senoidales con frecuencias y fases distintas se superponen y producen interferencia constructiva (bandas brillantes donde las ondas coinciden) e interferencia destructiva (bandas oscuras donde se cancelan). El uniform Scale controla cuántos ciclos de onda caben en el viewport. Súbelo y el patrón de interferencia se cierra en un grano fino. Bájalo y aparecen degradados amplios y orgánicos.3

    glsl float a = sin(p.x + t * 1.1); float b = sin((p.y + t * 0.9) * 1.3); float c = sin((p.x + p.y + t * 0.7) * 0.8); float signal = (a + b + c) / 3.0;

  • Contour Rings: length() calcula la distancia radial desde el centro y crea un degradado suave que crece hacia afuera, desde 0.0 en el centro hasta valores mayores en los bordes. Luego sin() hace oscilar esa distancia, que crece de forma continua, en ondas que se repiten, por la misma razón por la que las ondas en un estanque forman anillos concéntricos. abs() + smoothstep() afilan esas ondas suaves hasta convertirlas en bandas discretas, con el mismo efecto visual que las curvas de nivel de un mapa topográfico. El uniform Detail controla la densidad de las bandas multiplicando la distancia antes de que sin() la envuelva: más detalle significa anillos más apretados. El resultado visual recuerda a un barrido de radar o a una lectura topográfica.

    glsl float d = length(p); float wave = sin((d * 18.0 * u_detail) - t * 2.0); float bands = smoothstep(0.1, 0.85, abs(wave));

  • Flow Warp: el shader convierte coordenadas cartesianas a forma polar (atan para el ángulo, length para el radio). Las coordenadas polares son la clave: el ángulo crece de forma lineal al girar alrededor del centro, así que sin(8.0 * angle) crea ocho radios (ocho ciclos senoidales completos en 360 grados). El radio crece hacia afuera desde el centro, así que cos(12.0 * radius) crea doce ondas concéntricas. Su suma produce el patrón de interferencia: radios que cruzan anillos. Un término de brillo exponencial (exp(-3.0 * radius)) añade una caída de luminosidad desde el centro, porque exp(-x) decae rápidamente a medida que x crece. El uniform Color Shift rota el mapeo de tono y revela cómo el mismo campo de distorsión produce paletas de color distintas.

    glsl float angle = atan(p.y, p.x); float radius = length(p); float field = sin(8.0 * angle + t * 2.2) + cos(12.0 * radius - t * 1.7); float glow = exp(-3.0 * radius) * (0.6 + 0.4 * sin(t + radius * 8.0));

Comparten la misma interfaz de uniforms (Speed, Scale, Detail, Color Shift) para que sientas cómo controles idénticos producen resultados distintos según el diseño de la señal.

Estrategia ganadora para aprender rápido

Usa esta secuencia en el laboratorio:

  1. Empieza con Plasma, pon Scale bajo y luego sube Speed.
  2. Cambia a Contour Rings, aumenta Detail y reduce Speed.
  3. Cambia a Flow Warp y arrastra Color Shift para ver el mapeo de fase.
  4. Pausa la animación y compara fotogramas fijos entre presets.
  5. Vuelve a tu preset favorito y ajústalo hacia un objetivo de estilo acotado (calmado, agresivo, técnico, cinematográfico).

Ese bucle te obliga a tomar decisiones de gusto explícitas, no a hacer ajustes al azar. El mismo tipo de exploración estética estructurada se aplica a la tensión entre belleza y brutalismo en el diseño, donde la restricción revela el carácter.

Ejercicio: después del paso 5, escribe tres palabras que describan el visual que creaste. Luego lleva un slider a su extremo opuesto y escribe tres palabras nuevas. Compara las dos descripciones. La distancia entre ellas es tu superficie de gusto: el rango de resultados visuales que puedes nombrar y alcanzar de forma intencional. Repite con otros presets para ampliar esa superficie.

Errores comunes al empezar con GLSL

Hay tres errores que aparecen en casi todos los primeros shaders:

Olvidar normalizar las coordenadas. gl_FragCoord devuelve coordenadas en píxeles (de 0 a 1920 en una pantalla 1080p). Sin dividir entre u_resolution, cada sin() y cos() opera sobre valores enormes y produce ruido visual en lugar de patrones suaves. La solución siempre es la primera línea: vec2 uv = gl_FragCoord.xy / u_resolution;

Tratar el rango de color como -1 a 1. sin() devuelve valores de -1.0 a 1.0, pero los canales de color esperan de 0.0 a 1.0. Los valores de color negativos se recortan a negro y producen bandas duras en lugar de degradados suaves. La fórmula de remapeo signal * 0.5 + 0.5 convierte el rango -1..1 en 0..1. Todos los shaders del laboratorio de arriba usan este patrón.

Animar sin u_time. Un shader que solo usa coordenadas espaciales produce una imagen estática. La animación requiere un uniform de tiempo que la CPU incrementa en cada frame y envía a la GPU. El shader en sí nunca lleva la cuenta del tiempo: recibe el tiempo actual como uniform y calcula el frame como si ese momento fuera el único. Cada frame es una función pura de sus entradas.


Depuración de errores de shaders

Los errores de shaders WebGL aparecen en la consola del navegador. Al principio parecen crípticos, pero siguen patrones predecibles. Estos son los tres errores que encontrarás con más frecuencia y lo que significan:

ERROR: 0:12: 'u_resolution' : undeclared identifier: el shader hace referencia a un uniform que nunca se declaró. O falta la declaración uniform en el código del shader, o está mal escrita. Solución: añade uniform vec2 u_resolution; al principio del fragment shader, antes de void main().

ERROR: 0:8: '' : compilation terminated: el shader tiene un error de sintaxis antes de la línea 8. GLSL exige una sintaxis al estilo de C: punto y coma al final de cada instrucción, llaves emparejadas y nada de comas finales. La causa más común es un punto y coma que falta en la línea anterior. Solución: revisa las líneas 1-7 en busca de puntos y coma faltantes, paréntesis sin cerrar o nombres de tipo incorrectos.

Un canvas negro o blanco sin errores en la consola: el shader se compiló y enlazó correctamente, pero los valores de salida están fuera del rango 0.0-1.0. gl_FragColor espera cada canal (R, G, B, A) entre 0.0 y 1.0. Los valores por encima de 1.0 se recortan a blanco. Los valores por debajo de 0.0 se recortan a negro. Solución: añade la fórmula de remapeo (signal * 0.5 + 0.5) para desplazar tu señal del rango -1..1 al rango 0..1. Si el canvas es blanco puro, todos tus valores están por encima de 1.0. Si es negro puro, todos están por debajo de 0.0.

Una técnica de depuración para cualquier shader: pon gl_FragColor = vec4(uv, 0.0, 1.0); como última línea. Esa línea pinta un degradado de negro (abajo a la izquierda, donde uv = 0,0) a amarillo (arriba a la derecha, donde uv = 1,1), con rojo a lo largo del eje x y verde a lo largo del eje y. Si el degradado se ve correcto, tu espacio de coordenadas funciona y el problema está en la señal o en el mapeo de color. Si el degradado está mal (por ejemplo, todo de un solo color o invertido), la transformación de coordenadas tiene un bug. La técnica aísla cuál de los tres problemas (coordenadas, señal, color) contiene el error.


Salvaguardas de producción

Si despliegas shaders en páginas de contenido, respeta estas restricciones:

  • limita la resolución del canvas según el device pixel ratio para evitar picos de overdraw
  • expón solo una superficie de control pequeña y significativa
  • ofrece un fallback estático cuando WebGL no esté disponible
  • pausa el renderizado cuando la pestaña esté oculta
  • evita ramas costosas y bucles anidados en el código de fragmentos

El laboratorio sigue esas reglas para que puedas usarlo como plantilla. En el hardware de pruebas del autor (MacBook Air M1, GPU integrada), estos shaders mantienen 60 fps con un device pixel ratio de 1x; los resultados varían según la GPU, pero la complejidad de los shaders es deliberadamente lo bastante baja para la mayoría del hardware. Con un DPR de 2x en una pantalla Retina, el número de píxeles se cuadruplica; limitarlo con Math.min(dpr, 2) evita que la GPU haga cuatro veces el trabajo por una diferencia visual que la mayoría de los usuarios no puede percibir.8

Este es el patrón para pausar con la pestaña oculta en JavaScript, dos líneas que evitan que el shader queme ciclos de GPU en una pestaña que nadie ve:

document.addEventListener('visibilitychange', () => {
  if (document.hidden) cancelAnimationFrame(frameId);
  else frameId = requestAnimationFrame(render);
});

Y el límite de DPR:

const dpr = Math.min(window.devicePixelRatio || 1, 2);
canvas.width = canvas.clientWidth * dpr;
canvas.height = canvas.clientHeight * dpr;

Ambos patrones ya están implementados en el laboratorio de arriba. Cópialos directamente en tus propios proyectos WebGL.

Qué construir después

Buenos siguientes pasos:

  • Copiar los uniforms al portapapeles. Expón el estado actual { speed, scale, detail, colorShift } como un objeto JSON. Un botón “Copy Preset” lo escribe en el portapapeles. Restaurar un preset es Object.assign(state, JSON.parse(clipboard)). Serializar presets importa porque la exploración estética es efímera por defecto: en cuanto mueves un slider, el estado anterior desaparece. Un preset serializable convierte un visual pasajero en un artefacto que se puede guardar y compartir.

  • Exportar instantáneas de degradados. Llama a canvas.toDataURL('image/png') para capturar el frame actual como imagen estática. Dimensiona el canvas de exportación a los formatos de tarjetas sociales (1200x630 para Open Graph, 1080x1080 para Instagram). El shader produce degradados únicos y seguros para la marca sin fotos de stock.

  • Mapear la posición de scroll a un uniform. Usa IntersectionObserver o un listener de scroll para calcular un valor de progreso entre 0.0 y 1.0 y pásalo como uniform. El shader responde a la posición del lector en la página porque la GPU recibe un valor que cambia de forma continua y que controla el estado visual: el mismo mecanismo que el slider Speed, pero controlado por el scroll en lugar de por un control de la interfaz. El resultado son transiciones narrativas en las que el visual evoluciona a medida que avanza el contenido.4

  • Vincular la fase de color a un estado externo. Pasa la hora del día, parámetros de campaña o preferencias del usuario como uniforms. Un shader que desplaza el tono según la hora local crea una personalización ambiental sin servir assets distintos.

La clave es pasar de “el shader como juguete” a “el shader como primitiva de producto reutilizable”. El interactivo de corrección de errores de Hamming y el visualizador de tokenización siguen la misma filosofía: hacer tangibles los conceptos abstractos mediante la manipulación directa. Y el razonamiento espacial que hace intuitivos los shaders conecta con el mismo pensamiento espacial de la topología del conocimiento mediante embeddings, donde los espacios vectoriales de alta dimensión codifican significado semántico.

Conclusiones clave

Para ingenieros que aprenden GLSL:

  • Manipula uniforms de forma agresiva y lee la teoría de forma pasiva. Cambiar un parámetro a la vez y observar el resultado visual construye intuición más rápido que estudiar las matemáticas de forma aislada. El laboratorio de arriba existe para que ese bucle sea rápido.

  • Todo fragment shader resuelve tres problemas en secuencia. Transformación de coordenadas, señal periódica, mapeo de color. Una vez que este modelo mental encaja, puedes descomponer cualquier shader que encuentres en sus tres capas y entender cada una por separado.

Para equipos que llevan shaders a producción:

  • El diseño de restricciones importa más que la complejidad del shader. Limitar el DPR, pausar cuando la pestaña se oculta, ofrecer fallbacks y exponer una superficie de control pequeña son las decisiones de producción que determinan si un shader sobrevive al contacto con usuarios reales en hardware real.

  • Los shaders son primitivas de producto reutilizables, no juguetes. Fondos de marca, visuales específicos de campaña, transiciones controladas por scroll y personalización ambiental son casos de uso de producción que los shaders cubren sin assets de video, ancho de banda de CDN ni dependencias de frameworks.


Preguntas frecuentes

¿Qué es GLSL y cómo funcionan los fragment shaders en WebGL?

GLSL (OpenGL Shading Language) es el lenguaje similar a C que se usa para escribir programas de shaders que se ejecutan en la GPU. WebGL es la API del navegador que da acceso a OpenGL ES, que ejecuta esos shaders. Un fragment shader escrito en GLSL se ejecuta una vez por fragmento en cada frame; en un quad sencillo a pantalla completa como el del laboratorio de arriba, cada fragmento corresponde a un píxel, así que el shader calcula en la práctica un color para cada píxel a partir de sus coordenadas, el tiempo actual y los valores de uniforms que proporcione la CPU. El laboratorio de arriba usa WebGL para compilar y ejecutar fragment shaders GLSL directamente en el navegador, sin plugins ni extensiones.5

¿Qué son los uniforms en la programación de shaders?

Los uniforms son valores de solo lectura que la CPU (JavaScript) envía a la GPU (shader GLSL) en cada frame. A diferencia de los atributos de vértice (que varían por vértice) o de los varyings (que se interpolan a lo largo de un triángulo), los uniforms permanecen constantes para cada píxel dentro de una misma draw call. Entre los uniforms habituales están el tiempo, la resolución, la posición del mouse y valores de control personalizados. El laboratorio expone cuatro uniforms (Speed, Scale, Detail, Color Shift) que puedes manipular con sliders para ver cómo, al cambiar los valores del lado de la CPU, cambia en tiempo real la salida visual del lado de la GPU.

¿Cómo logran los shaders un rendimiento en tiempo real?

Los fragment shaders se ejecutan en paralelo en miles de núcleos de GPU. El cálculo de cada píxel es independiente del de todos los demás, lo que significa que la GPU los procesa simultáneamente en lugar de uno tras otro. Un canvas de 1920x1080 tiene unos 2 millones de fragmentos. Una CPU los procesa de forma mayormente secuencial (SIMD ayuda, pero el rendimiento sigue siendo órdenes de magnitud menor). Una GPU los distribuye entre miles de núcleos y termina en milisegundos. La restricción es que ningún píxel puede leer el resultado del cálculo de otro píxel en la misma pasada, y por eso la programación de shaders exige un modelo mental distinto al del código secuencial de CPU.6

¿Puedo usar shaders WebGL de forma segura en proyectos web en producción?

Se puede, con restricciones. Limita la resolución del canvas en relación con el device pixel ratio para evitar overdraw en pantallas de alta densidad. Pausa el bucle de animación cuando la pestaña no esté visible (escucha el evento visibilitychange en document). Ofrece una imagen estática o un degradado CSS como fallback cuando WebGL no esté disponible. Evita operaciones costosas como bucles anidados, lecturas de texturas dentro de ramas condicionales o un exceso de ramificaciones en general. El laboratorio sigue todas estas salvaguardas de producción.

¿Qué debería aprender después de este laboratorio?

Pasa a The Book of Shaders de Patricio Gonzalez Vivo y Jen Lowe, un currículo estructurado que cubre funciones de ruido, campos de distancia y técnicas de GLSL más avanzadas.1 Para técnicas de campos de distancia en particular, los artículos de Inigo Quilez sobre funciones de distancia con signo son la referencia canónica.7 Cuando te sientas cómodo con los fragment shaders, explora los vertex shaders (manipulación de geometría) y los compute shaders (computación de propósito general en GPU).



  1. Patricio Gonzalez Vivo y Jen Lowe, The Book of Shaders, thebookofshaders.com. El recurso interactivo de referencia para aprender GLSL. Cubre los fragment shaders desde la salida de color básica hasta el ruido, los fractales y el procesamiento de imágenes, con ejemplos editables en vivo. ↩↩

  2. Esta descomposición en tres pasos (coordenadas, señal, color) simplifica el modelo presentado en The Book of Shaders, capítulos 5-7, que trata las funciones de forma, los colores y las figuras como capas sucesivas en la construcción de un fragment shader. ↩

  3. El preset Plasma demuestra la síntesis de Fourier: construir un patrón complejo sumando ondas senoidales de distintas frecuencias. El teorema de Fourier establece que cualquier señal periódica compleja puede construirse a partir de (o descomponerse en) ondas senoidales de distintas frecuencias y fases. Añadir más términos senoidales produce patrones de interferencia más complejos. Ver también: Gonzalez Vivo, “Shaping Functions,” thebookofshaders.com/05/. ↩

  4. Las animaciones de shaders controladas por scroll usan el mismo principio que scroll-timeline de CSS, pero con visuales arbitrarios calculados en la GPU. El uniform recibe una posición de scroll normalizada (0.0 arriba, 1.0 abajo) y el shader interpola entre estados visuales. MDN documenta la API de eventos de scroll subyacente: developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event. ↩

  5. WebGL 1.0 (basado en OpenGL ES 2.0) es compatible con más del 98 % de los navegadores a nivel mundial. Ver caniuse.com/webgl. WebGL 2.0 (basado en OpenGL ES 3.0) añade transform feedback, múltiples render targets y otras funciones, pero no es necesario para trabajar con fragment shaders como en el laboratorio de arriba. Los compute shaders están disponibles a través de WebGPU, no de WebGL. ↩

  6. El modelo de ejecución en paralelo de las GPU es la razón por la que la programación de shaders prohíbe la comunicación entre píxeles dentro de una misma draw call. John Owens et al., “A Survey of General-Purpose Computation on Graphics Hardware,” Computer Graphics Forum, Vol. 26, No. 1, pp. 80-113, 2007. Esta restricción da forma a todo el modelo de programación de GLSL. ↩

  7. Inigo Quilez, “Distance Functions,” iquilezles.org/articles/distfunctions2d/. El catálogo de Quilez de funciones de distancia con signo en 2D y 3D es la referencia estándar para la geometría procedural en shaders. ↩

  8. El modelo de ejecución en paralelo de la GPU que hace rápidos a los fragment shaders también limita cómo funcionan. Akenine-Moller, T., Haines, E. y Hoffman, N., Real-Time Rendering, 4.ª edición, A K Peters/CRC Press, 2018, capítulo 3 (The Graphics Processing Unit). El libro ofrece el tratamiento más completo de la arquitectura de GPU para programadores gráficos, incluida la relación entre el rendimiento de fragmentos, la tasa de relleno y el DPR. El Khronos Group mantiene la especificación GLSL ES que define el lenguaje usado en este laboratorio: registry.khronos.org/OpenGL/specs/es/2.0/GLSL_ES_Specification_1.00.pdf. ↩

Artículos relacionados

Códigos de Hamming: cómo las computadoras corrigen sus propios errores

De la RAM a los códigos QR y el espacio profundo: una explicación interactiva de cómo Hamming detecta y corrige errores …

8 min de lectura

De boids a agentes: reglas de enjambre para sistemas de IA

El algoritmo boids de Craig Reynolds, de 1986, produce bandadas a partir de tres reglas locales. Los mismos principios y…

17 min de lectura

The Shader Gallery That Lied: Debugging 216 WebGL Presets

A user said the shader playground looked broken. Pixel-readback testing found 30 dead presets, 11 that never compiled, a…

14 min de lectura