cursos.
← Programación
Ficha 005.497YouTubeGRATIS

Low-Level Graphics in C – Pixel Manipulation and Frame Buffers

Enseña a construir un renderizador por software en C con SDL3: frame buffer, put_pixel, bucle principal a 60 FPS y, como extra, el efecto de fuego de Doom.

Muy recomendado, valoración editorial 5 de 5

verificado 2026-10-05 — sigue siendo gratis en YouTube

Empezar en YouTube

Respuesta rápida

Curso gratis de Programación en YouTube (1 h 34 min). Nuestra valoración: 5/5, muy recomendado. Comprobamos que sigue siendo gratis el 5 de octubre de 2026.

Veredicto
5/5 · Muy recomendado
Para quién
Programadores con base en C que quieren entender cómo se dibuja un píxel en pantalla sin motores gráficos.
Duración
1 h 34 min
Precio
Gratis en YouTube
Publicado
2026
Plan sugerido
2 sem. · 4.5 h/sem.
Verificado
el 5 de octubre de 2026

Nuestro veredicto

Muy recomendado, valoración editorial 5 de 5

Curso breve, bien estructurado y muy práctico para entender cómo se dibuja en pantalla a bajo nivel con C y SDL3. Es ideal para quien ya conoce lo básico de C y quiere una base sólida en gráficos por software, con un resultado visual al final.

Puntos fuertes

  • Capítulos detallados que permiten seguir una progresión clara de la teoría a la práctica.
  • Proyecto final visual y motivador con el efecto de fuego de Doom.
  • Cubre instalación en tres sistemas operativos.
  • Publicado en 2026, con SDL3 actual.

A tener en cuenta

  • La descripción no indica nivel ni requisitos previos explícitos.
  • Está en inglés.
  • Solo cubre lo básico del renderizado por software; no hay 3D ni técnicas avanzadas.

De qué trata

Curso práctico en C que explica cómo manipular píxeles directamente en un frame buffer usando la biblioteca multiplataforma SDL3. Comienza con la teoría: resoluciones de monitor, el frame buffer y las restricciones de los sistemas operativos modernos frente a MS-DOS.

Después pasa a la práctica a lo largo de 94 minutos: instalación de SDL3 en Mac OS, Linux y Windows, creación de main.c y un Makefile, ventana, renderer y textura, bucle de eventos, comprobación de errores, la función put_pixel, limitación a 60 FPS y clear_framebuffer con protección de límites. Cierra comparando renderizado por CPU y GPU y con un bonus: el efecto de fuego de Doom.

  • Frame buffer y resoluciones de monitor
  • Instalación de SDL3 en Mac OS, Linux y Windows
  • Ventana, renderer y textura con SDL3
  • put_pixel: de coordenadas 2D a un array 1D
  • Bonus: efecto de fuego de Doom

Para quién es este curso

  • Programadores con base en C que quieren entender cómo se dibuja un píxel en pantalla sin motores gráficos.
  • Personas interesadas en gráficos por software o en el desarrollo de videojuegos desde cero.
  • Estudiantes curiosos por cómo la memoria y la CPU intervienen en el renderizado.

Mejor busca otro si…

  • Quien no haya programado nunca en C y busque una introducción al lenguaje.
  • Quien ya domine SDL y el renderizado por software y busque técnicas avanzadas.

Antes de empezar

  • Conocimientos básicos de C (arrays, funciones, compilación).
  • Un compilador de C y acceso a terminal en Mac OS, Linux o Windows.

Qué sabrás hacer al terminar

  • Configurar SDL3 y compilar un proyecto en C con un Makefile.
  • Crear una ventana, un renderer y una textura con SDL3.
  • Implementar un bucle principal que procese eventos y limite a 60 FPS.
  • Escribir put_pixel para mapear coordenadas 2D a un array 1D.
  • Entender la diferencia entre renderizado por CPU y por GPU.
  • Dibujar el efecto de fuego de Doom en un frame buffer.

Estructura del curso

  1. 01

    Conceptos: píxeles, frame buffer y SDL3

    Desde 0:00. Introducción, resoluciones de monitor, frame buffer, restricciones de los sistemas operativos modernos frente a MS-DOS y por qué usar SDL3.

  2. 02

    Visión general de SDL e instalación

    Desde 17:47. Inicialización, ventanas, renderers y texturas de SDL, e instalación de SDL3 en Mac OS, Linux y Windows.

  3. 03

    Proyecto base: main.c, Makefile y ventana

    Desde 28:12. Preparación de main.c, compilación, Makefile, definición del array del frame buffer y creación de ventana, renderer y textura.

  4. 04

    Bucle principal y vinculación del frame buffer

    Desde 46:13. Gestión de eventos, bucle principal, enlace del array a la textura de SDL y comprobación de errores.

  5. 05

    Dibujo de píxeles y control del tiempo

    Desde 1:04:48. Función put_pixel, limitación a 60 FPS y clear_framebuffer con protección de límites del array.

  6. 06

    CPU vs GPU y bonus del fuego de Doom

    Desde 1:24:19. Comparativa entre renderizado por software y hardware, y desde 1:27:30 el efecto de fuego de Doom.

Plan de estudio sugerido

2 semanas · unas 4,5 h por semana

  1. 1.Sesión 1 (0:00–0:28): ve la teoría e instala SDL3 en tu sistema.
  2. 2.Sesión 2 (0:28–0:51): crea main.c, el Makefile, la ventana, el renderer y la textura; practica escribiendo el código tú mismo.
  3. 3.Sesión 3 (0:51–1:12): vincula el frame buffer, añade comprobación de errores e implementa put_pixel; dibuja formas simples.
  4. 4.Sesión 4 (1:12–1:34): limita a 60 FPS, implementa clear_framebuffer y reproduce el fuego de Doom, modificándolo después.

El plan cuenta con tiempo para pausar y practicar, no solo con la duración del vídeo. Si quieres adaptarlo a tu semana, lee cómo montar tu plan de estudio semanal.

Consejos para seguirlo

  • Pausa en 0:28 y escribe tú mismo el código y el Makefile en lugar de copiarlos, para detectar errores de compilación pronto.
  • Tras put_pixel (1:04:48), dibuja líneas o rectángulos propios para asentar la conversión 2D a 1D.
  • Comprueba que SDL3 compila con un ejemplo mínimo antes de seguir al código del frame buffer.
  • Antes del bonus de Doom, intenta imaginar cómo animarías los píxeles y compara con la solución.

Antes y después de este curso

Cómo lo presenta el autor

This C programming course teaches you about direct pixel manipulation and graphics. By leveraging the cross-platform power of the SDL3 library, you will learn how to safely navigate modern operating system restrictions to build a low-level software renderer from scratch. This hands-on approach will demystify how computers handle memory and CPU instructions, ultimately culminating in rendering the…

Extracto de la descripción original en YouTube.

Preguntas frecuentes

+¿Cuánto dura el curso?

Dura 94 minutos. Con pausas para practicar, cuenta con unas 3 horas de trabajo repartidas en dos semanas.

+¿Qué necesito saber antes?

La descripción no lo indica, pero el código se escribe en C desde el principio, así que conviene conocer lo básico del lenguaje y la compilación.

+¿Funciona en mi sistema operativo?

El curso muestra cómo instalar SDL3 en Mac OS, Linux y Windows.

+¿Qué construyo al final?

Un renderizador por software que escribe en un frame buffer y termina con el efecto de fuego de Doom como bonus.

Análisis editorial elaborado con ayuda de IA a partir de la descripción, los capítulos y la duración publicados en YouTube, y revisado según nuestro método. El contenido del curso es obra de su autor; si ves algún error, avísanos.

Guías para sacarle partido