sprite-stacking es un skill de código abierto para agentes, creado por Daniel White, que convierte cuatro vistas en pixel art de un objeto (arriba, lateral, frontal y trasera) en un "sprite stack": una tira de capas planas que el juego dibuja una encima de otra para simular un objeto 3D que puedes girar. Funciona con Claude Code, Codex, Cursor, OpenCode, Gemini CLI y Pi. El repositorio se creó el 20 de noviembre de 2026 y tenía 187 estrellas cuando lo consultamos el 21 de noviembre de 2026. Su licencia es MIT.

Esta guía explica qué es el sprite stacking, qué añade el skill, cómo instalarlo, qué hay que darle y dónde se queda corto. Todos los comandos están copiados del README del repositorio o de su SKILL.md. Leímos los archivos el 21 de noviembre de 2026, pero no ejecutamos el skill nosotros, así que los resultados descritos son los que la documentación dice que deberían salir.

Qué es el sprite stacking

Un sprite stack es un objeto visto desde arriba y cortado en capas horizontales, como una barra de pan rebanada desde el suelo hacia arriba. El juego dibuja las capas de abajo arriba. Cada una se gira el mismo ángulo, se aplasta en vertical según la inclinación de la cámara y se sube 1 píxel respecto a la anterior. El resultado parece un pequeño modelo de vóxeles que gira con suavidad, pero sigue siendo dibujo 2D normal: sin motor 3D, sin mallas, y cada ángulo conserva píxeles nítidos.

El README deja claro que la técnica no es nueva: "Sprite stacking is a long-standing indie game technique, not invented here." Lo que aporta el skill es el tallado a partir de cuatro vistas y un flujo de trabajo para agentes.

Lo pesado suele ser dibujar las capas. Un coche de 30 capas son 30 imágenes pequeñas que tienen que encajar. El skill se lo salta: tú (o tu agente) dibujas cuatro vistas normales y un script talla las capas a partir de ellas.

Qué hace el skill

El README describe cuatro pasos:

  1. Vistas: una hoja con las vistas superior, lateral, frontal y trasera, ortográficas, en una sola fila.
  2. Tallado: un vóxel solo se conserva donde lo cubren las cuatro vistas.
  3. Capas: el volumen tallado se corta en una tira de capas planas, empezando por la del suelo.
  4. Render: cada capa se gira, se aplasta según la inclinación y se sube 1 px.

La carpeta del skill contiene:

  • SKILL.md, las instrucciones que lee tu agente: cómo conseguir una buena hoja de cuatro vistas, una lista de comprobación antes de cortar, las opciones del cortador, el bucle de render y sus valores, una lista de "terminado cuando" y una tabla de errores pasados con sus soluciones.
  • scripts/views_to_slices.py, el cortador. Quita el fondo, elimina el contorno de 1 px de cada vista, reduce todo a una paleta compartida, talla las capas y puede generar una imagen de comprobación y una página de visor independiente.
  • scripts/viewer.html, un visor para el navegador que también se abre por sí solo y acepta tiras de capas arrastradas.
  • references/engines.md, recetas breves para Canvas web y React, Godot 4, Unity, y Phaser, Pygame o cualquier otro.

Instalarlo en Claude Code o Codex

La instalación en una línea del README usa la CLI de skills, que necesita Node 22.20 o posterior:

npx skills add danielwh2/sprite-stacking

Eso instala el skill en el proyecto actual. Según el README, añade -g para instalarlo en todos tus proyectos y -a claude-code (o codex, cursor, etc.) para elegir el agente.

La otra opción es copiar la carpeta skills/sprite-stacking del repositorio en la carpeta de skills de tu agente:

Agente Carpeta
Claude Code ~/.claude/skills/
Codex, Cursor, OpenCode, Gemini CLI, Pi ~/.agents/skills/

El cortador es un script de Python, así que también necesitas Python 3 con Pillow y NumPy. El comando del README:

pip install pillow numpy

Cómo usarlo: qué pedirle al agente

No hace falta llamar al skill por su nombre. Una vez instalado, pide lo que quieres y el agente lo usa. Los ejemplos del README (traducidos):

  • "Haz un coche de pixel art que se pueda girar."
  • "Haz un sprite stack con esta hoja de 4 vistas y dame un giro de 360°."
  • "Añade un árbol de pixel art en 3D falso a mi juego de Godot."

SKILL.md le indica al agente que elija un camino según lo que le des:

  • Un PNG con la tira de capas o una exportación de capas de MagicaVoxel: pasa directamente al render.
  • Una hoja de cuatro vistas: la revisa y luego la talla.
  • Solo un prompt o una idea: primero crea la hoja de cuatro vistas y después talla y renderiza.

Si no tienes hoja, el agente usa una herramienta de generación de imágenes si dispone de una, con un prompt que viene escrito en SKILL.md. Si no, dibuja él mismo las cuatro vistas en pixel art con un script corto de Python. El README lo resume así: "No image generator? The agent draws the views itself in a short Python script."

En un juego ya existente, SKILL.md le pide al agente que lea primero tu renderizador (motor, escala de píxel, cómo se dibujan y ordenan los sprites) y encaje el stack en él, sin añadir nunca un segundo canvas ni otra canalización de render.

Qué entrada necesita

La hoja de cuatro vistas tiene reglas estrictas, y la mayoría de los malos resultados vienen de saltárselas. Según SKILL.md:

  • Una fila en el orden TOP, SIDE, FRONT, BACK (superior, lateral, frontal, trasera), sobre blanco liso y con huecos claros entre vistas.
  • TOP mira en vertical hacia abajo, con el frente del objeto apuntando hacia abajo. En SIDE el frente apunta a la izquierda.
  • Estrictamente ortográfica: sin perspectiva, sin inclinación, sin vista de 3/4.
  • La misma escala en las cuatro vistas: el largo de TOP es igual al de SIDE, el ancho de TOP igual al de FRONT y BACK, y la altura de SIDE igual a la de FRONT y BACK.
  • Rellenos de color planos y contornos nítidos. Los bordes difuminados y las líneas internas de 1 px se emborronan cuando las capas giran, y el skill recomienda redibujar antes que intentar salvarlos.

También propone tres tamaños:

  • Retro grueso: de 15 a 20 capas, unos 25×48 px, mostrado a 8–10×.
  • Hi-bit detallado: de 26 a 44 capas, de 36×72 a 46×107 px, suficiente para rejillas, logotipos y llantas de radios.
  • Escaparate / vídeo 1080p: de 36 a 56 capas, de 30×30 a 148×148 px, mostrado a 4–6×.

Ejecutar el cortador a mano

Normalmente lo ejecuta el agente, pero puedes lanzarlo desde la raíz del repositorio con el comando del README:

python3 skills/sprite-stacking/scripts/views_to_slices.py views.png slices.png \
  --slices 36 --preview check.png --html viewer.html

views.png es tu hoja de cuatro vistas y slices.png la tira de capas que genera. Las opciones que lista el README:

  • --slices N: número de capas. De 15 a 20 para estilo grueso, de 32 a 48 para detallado.
  • --order reading: fuerza el orden TOP, SIDE, FRONT, BACK. Por defecto el script empareja las vistas por sus proporciones.
  • --round: talla torres, globos y macetas redondas en lugar de cuadradas.
  • --side-nose right: úsalo cuando la vista SIDE mire a la derecha.
  • --colours N: tamaño de la paleta compartida; 0 conserva todos los colores.
  • --normals path.png: guarda además una tira de capas con el mapa de normales.
  • --emissive path.png: guarda además una máscara de brillo detectada automáticamente (faros, ventanas, neón).

SKILL.md añade algunas más, como --top-nose (usa down para todo lo que no sea un vehículo), --shade, --bg-tol y --dark-thresh.

check.png muestra las cuatro vistas extraídas, cuatro ángulos del giro y una vista despiezada. El skill le dice al agente que la mire antes de escribir código del juego.

El visor

--html genera una página independiente. Según el README tiene giro de 360°, un modo Scene con objetos procedurales, un escaneo por capas, una vista despiezada y un modo Play en el que puedes conducir con WASD o las flechas. También tiene hora del día, un sol que se puede arrastrar con sombras, lluvia y nieve, y un botón de exportación que genera una hoja de sprites PNG en 16 direcciones. Esto último viene bien si tu motor solo quiere sprites direccionales normales.

Llevarlo a un juego

El bucle de render es el mismo en todas partes: para cada capa, desde el suelo hacia arriba, gírala alrededor de su centro, escala la y por el valor de aplastamiento, súbela según su índice por el espaciado, ajústala a píxeles enteros y dibújala con filtrado nearest-neighbour. SKILL.md da los valores por defecto: espaciado 1.0 y aplastamiento 0.75 para una cámara cenital inclinada (1.0 mira en vertical). references/engines.md incluye una función lista para Canvas 2D y un script Node2D para Godot 4, además de notas para Unity (un SpriteRenderer por capa, filtro Point) y para Phaser o Pygame.

Hay dos consejos del skill que importan para el rendimiento y el aspecto. Ordena stacks completos por su punto de apoyo en el suelo y nunca intercales capas de dos objetos. Y convierte los stacks estáticos en sprites normales al cargar el juego: el skill señala que 200 árboles de 30 capas cada uno serían 6.000 dibujados por fotograma.

Límites

Salen de la propia lista de comprobación del skill y de su tabla de errores pasados:

  • Los huecos ocultos se rellenan. El tallado conserva solo lo que cubren las cuatro siluetas, así que la caja de una camioneta o un arco hueco que no se ve en ninguna vista sale macizo. Los voladizos que dejan ver el fondo en la vista lateral, como un alerón trasero elevado, se conservan. Los huecos hay que arreglarlos a mano después del tallado.
  • Las partes redondas salen cuadradas salvo que la vista superior tenga un círculo de píxeles, o pases --round cuando la parte redonda sea más estrecha que su base.
  • Las piezas de 1 px parpadean mientras el stack gira. Postes, cuerdas y antenas deben tener al menos 2 px de ancho; el cortador muestra un aviso.
  • Lo que sobresale se convierte en repisa. Algo que sale de una pared, como una jardinera o un cartel, talla una repisa a lo largo de toda la pared. Pinta los elementos pequeños planos.
  • Los huecos cerrados salen macizos. El fondo encerrado del todo dentro de una vista (entre patas, aletas o cuerdas) se toma como parte del objeto. Cada hueco tiene que llegar al exterior de su vista.
  • Los objetos descentrados se tambalean. El stack gira alrededor del centro de su caja delimitadora, así que centra el objeto en sus vistas.
  • Solo pixel art. La técnica y el cortador están pensados para sprites pequeños de sombreado plano. No sirven para obtener un modelo 3D real para un juego 3D en three.js o Unity.

Licencia

El repositorio usa la licencia MIT (copyright 2026 Daniel White), como muestran GitHub y su archivo LICENSE. Puedes usarlo, modificarlo e incluirlo en proyectos comerciales siempre que mantengas el aviso de copyright y de licencia en las copias del código. El README no dice nada sobre la licencia de los sprites que crees con él.

Preguntas frecuentes

¿Qué es el sprite stacking?

Una forma de simular 3D en un juego 2D. El objeto se guarda como una tira de capas planas vistas desde arriba, y el juego las dibuja de abajo arriba, cada una girada el mismo ángulo y subida 1 píxel. Parece un pequeño modelo de vóxeles que gira, sin dejar de ser pixel art nítido.

¿El skill sprite-stacking es gratis?

Sí. Es de código abierto con licencia MIT. Solo necesitas Python 3 con Pillow y NumPy, y Node 22.20 o posterior si lo instalas con npx skills. La suscripción o el uso de API de tu agente de IA va aparte.

¿Funciona con Claude Code y Codex?

Sí, ambos aparecen en el README. Instálalo con npx skills add danielwh2/sprite-stacking (con -a claude-code o -a codex para elegir el agente), o copia skills/sprite-stacking en ~/.claude/skills/ para Claude Code o en ~/.agents/skills/ para Codex.

¿Necesito un generador de imágenes?

No. Si tu agente tiene uno, el skill le da un prompt para la hoja de cuatro vistas. Si no, el agente dibuja las vistas él mismo con un script corto de Python. También puedes darle una hoja dibujada por ti, una tira de capas o una exportación de capas de MagicaVoxel.

¿Puedo usar el resultado en Godot, Unity o Phaser?

Sí. references/engines.md incluye un script para Godot 4, notas para Unity, una función de Canvas 2D para la web y React, y el bucle general para Phaser y Pygame. El visor también exporta una hoja de sprites PNG en 16 direcciones para motores que prefieren sprites normales.

¿Por qué partes de mi sprite salen macizas o cuadradas?

El cortador solo conserva un vóxel donde lo cubren las cuatro vistas. Los huecos que no se ven en ninguna vista se rellenan, las partes redondas necesitan un círculo en la vista superior o la opción --round, y los huecos totalmente encerrados dentro de una vista salen macizos. La sección de límites recoge las soluciones.

Guías relacionadas

Fuentes

Consultado el 21 de noviembre de 2026: README de danielwh2/sprite-stacking, SKILL.md, references/engines.md, LICENSE y los datos del repositorio en GitHub (creado el 20 de noviembre de 2026; 187 estrellas el 21 de noviembre de 2026).

¿Has hecho un juego con coches u objetos en sprite stacking? Envíalo a VibeGamer.