Si trabajas con desarrollo de videojuegos o aplicaciones multimedia multiplataforma, seguro que te suena SDL. Con la llegada de SDL 3.4, la librería da un salto bastante grande en cuanto a capacidades gráficas, soporte de plataformas y herramientas para pulir la experiencia de usuario, tanto en escritorio como en web y dispositivos móviles. No es una actualización menor: toca desde el motor de renderizado 2D y la API de GPU 3D hasta el manejo de audio, controladores, entrada de lápiz, sistemas Linux modernos y más.

Aunque SDL 3 sigue evolucionando, la rama 3.4 se presenta como una versión muy sólida pensada para que proyectos nuevos y en marcha puedan aprovechar mejoras de rendimiento, nuevas API y mejor integración con entornos como Emscripten, Wayland, Vision Pro o incluso PlayStation 2 en contextos muy concretos. Vamos a ver con calma qué trae de nuevo SDL 3.4, por qué es relevante para tu siguiente proyecto y qué detalles técnicos conviene tener en el radar si quieres sacarle todo el jugo.

Novedades generales más importantes de SDL 3.4

La línea principal de trabajo de SDL 3.4 se centra en mejorar la interoperabilidad entre 3D y 2D, algo clave para motores de juego y aplicaciones que mezclan interfaces 2D con contenido 3D. Hasta ahora, combinar ambas capas podía implicar más pegamento por parte del desarrollador; con esta versión se introducen utilidades y propiedades nuevas que facilitan este flujo.

Además de la parte gráfica, la actualización incorpora soporte nativo de imágenes PNG, avances notables en el sistema de entrada (ratón, lápiz, gestos, teclado en pantalla) y una batería de cambios específicos para Windows, macOS, Linux, Emscripten, iOS, visionOS y otras plataformas menos habituales. Se ha pulido también la integración con el ecosistema de Steam y su runtime, algo muy relevante para el gaming en Linux y el desarrollo multiplataforma orientado a distribución en Steam.

Interoperabilidad entre la API GPU 3D y el renderizado 2D

Uno de los puntos fuertes de SDL 3.4 es el empujón a la integración entre 3D y 2D. La librería introduce nuevas funciones para crear renderizadores 2D basados en GPU y para intercambiar información entre texturas de GPU y formatos de píxel manejados por SDL.

• Se añade SDL_CreateGPURenderer() para crear un renderizador 2D que aprovecha la API de GPU subyacente.
• Con SDL_GetGPURendererDevice() puedes recuperar el dispositivo de GPU asociado a ese renderizador.
• Se incorporan SDL_CreateGPURenderState(), SDL_SetGPURenderStateFragmentUniforms(), SDL_SetGPURenderState() y SDL_DestroyGPURenderState() para trabajar con shaders de fragmento dentro del renderizado 2D con GPU.
• Ahora se admiten texturas YUV y espacios de color HDR en el renderizador 2D basado en GPU, lo cual es especialmente interesante para vídeo y contenidos de alta gama.

También se incorporan funciones como SDL_GetGPUDeviceProperties(), que devuelve propiedades del dispositivo GPU, incluyendo nombre del dispositivo, nombre y versión del controlador y otra información relevante para decisiones de compatibilidad o diagnóstico. Además, SDL_GetPixelFormatFromGPUTextureFormat() y SDL_GetGPUTextureFormatFromPixelFormat() facilitan pasar de formatos de textura de GPU a formatos de píxel de SDL y viceversa.

En paralelo, se incluye la propiedad SDL_PROP_TEXTURE_CREATE_GPU_TEXTURE_POINTER para crear una textura 2D a partir de una textura de GPU ya existente, y SDL_PROP_TEXTURE_GPU_TEXTURE_POINTER para obtener la textura de GPU asociada a una textura 2D cuando se emplea el renderizador 2D de GPU. Esta línea de trabajo reduce bastante la fricción a la hora de mezclar contenido generado en la API de GPU con el pipeline 2D clásico de SDL.

Mejoras en el renderizado 2D y manejo de texturas

SDL 3.4 va más allá de la mera interoperabilidad y añade funciones específicas para afinar la calidad y el control del renderizado 2D. Por ejemplo, se introduce SDL_RenderTexture9GridTiled(), que permite hacer un renderizado 9-grid con texturas en modo “mosaico” en lugar de estirarlas, evitando deformaciones en elementos de interfaz o marcos.

Para gestionar cómo se escalan las texturas, se añaden SDL_GetDefaultTextureScaleMode() y SDL_SetDefaultTextureScaleMode(), lo que permite fijar un modo de escala por defecto para nuevas texturas. RELACIONADO con esto, aparecen SDL_GetRenderTextureAddressMode() y SDL_SetRenderTextureAddressMode(), junto con la constante SDL_TEXTURE_ADDRESS_WRAP, que proporciona soporte de wrap de texturas cuando el renderizador indica que admite wrapping (SDL_PROP_RENDERER_TEXTURE_WRAPPING_BOOLEAN).

Una novedad muy interesante para juegos con estética retro es SDL_SCALEMODE_PIXELART, un algoritmo de escalado pensado para pixel art que evita el desenfoque clásico de otros modos de filtrado, conservando bordes definidos incluso al ampliar mucho la imagen.

También se suma la posibilidad de trabajar con paletas de texturas: SDL_SetTexturePalette() y SDL_GetTexturePalette() permiten asignar y consultar paletas en texturas, algo útil si estás recreando estilos gráficos antiguos o quieres optimizar ciertos flujos de memoria y ancho de banda.

En la parte de superficies, SDL 3.4 incorpora SDL_RotateSurface() para crear copias rotadas de una superficie, y se añade SDL_FLIP_HORIZONTAL_AND_VERTICAL para voltear superficies a la vez en los dos ejes. Además, la propiedad SDL_PROP_SURFACE_ROTATION_NUMBER (sustituida después por SDL_PROP_SURFACE_ROTATION_FLOAT en los últimos cambios de la release candidate) se utiliza para indicar el ángulo necesario para mostrar correctamente imágenes de cámara.

Soporte nativo de PNG y carga de superficies

Una de las mejoras más agradecidas a nivel de practicidad es que SDL 3.4 incluye soporte nativo para PNG, sin depender de bibliotecas externas en muchos casos. Esto simplifica montones de proyectos pequeños y prototipos.

• SDL_LoadPNG() y SDL_LoadPNG_IO() permiten cargar imágenes PNG directamente como superficies.
• SDL_SavePNG() y SDL_SavePNG_IO() sirven para guardar superficies en formato PNG.
• Con SDL_LoadSurface() y SDL_LoadSurface_IO() SDL detecta de forma automática si el archivo es BMP o PNG y lo carga en una superficie sin que tengas que preocuparte del formato.

Este soporte integrado se traduce en menos dependencias y configuraciones externas, especialmente útil cuando compilas para varias plataformas o usas SDL dentro de entornos como Emscripten, donde reducir el número de librerías auxiliares marca la diferencia tanto en tamaño del binario como en complejidad.

Entrada: ratón, lápiz, gestos y teclado en pantalla

SDL 3.4 pule bastante todo lo relacionado con dispositivos de entrada avanzados. En el ámbito del ratón, se introduce SDL_SetRelativeMouseTransform(), que permite aplicar una transformación personalizada a la entrada relativa del ratón, útil para técnicas de escalado, inversión de ejes o mapeos especiales.

En cuanto a lápices y stylus, aparece SDL_GetPenDeviceType(), que permite distinguir si el lápiz está actuando directamente sobre la pantalla o sobre un touchpad separado, detalle muy útil para adaptar la UX según el tipo de dispositivo.

En dispositivos con teclado virtual, SDL añade eventos como SDL_EVENT_SCREEN_KEYBOARD_SHOWN y SDL_EVENT_SCREEN_KEYBOARD_HIDDEN, que informan cuando el teclado en pantalla se muestra u oculta. Esto te da margen para ajustar la interfaz, mover elementos o evitar que campos de texto queden tapados.

También se amplía el sistema de gestos con los eventos SDL_EVENT_PINCH_BEGIN, SDL_EVENT_PINCH_UPDATE y SDL_EVENT_PINCH_END, que detectan gestos de pellizco para zoom y similares. Además, en el entorno Wayland se corrige el soporte de más de cinco botones de ratón, y se introduce desplazamiento de precisión en X11, mejorando la sensación de fluidez en scrolls finos.

Por último, SDL 3.4 incorpora SDL_GetEventDescription(), una función para obtener una descripción en inglés de un evento, pensada para logs y depuración, algo muy útil cuando estás rastreando comportamientos raros de entrada en varias plataformas.

Audio: flujos más flexibles y sin reprocesado del sistema

El subsistema de audio también se lleva su buena ración de mejoras, con un foco fuerte en procesamiento eficiente y control del pipeline. Para empezar, SDL_EVENT_AUDIO_DEVICE_ADDED ahora se envía también durante la inicialización por cada dispositivo de audio detectado, lo que facilita descubrir y listar dispositivos sin tener que esperar a eventos dinámicos.

Dos funciones nuevas, SDL_PutAudioStreamDataNoCopy() y SDL_PutAudioStreamPlanarData(), dan más opciones al trabajar con flujos de audio: la primera evita copias innecesarias en ciertos casos, y la segunda permite introducir datos en formato planar en lugar de intercalado, ideal para flujos avanzados o integración con librerías de procesamiento de audio de alto nivel.

Además, la pista SDL_HINT_AUDIO_DEVICE_RAW_STREAM cobra protagonismo: este hint indica que el sistema operativo no debe aplicar procesamiento adicional al audio (como cancelación de ruido). Esto es clave si tu aplicación o juego ya se encarga del procesado y no quieres que el OS meta mano y distorsione el resultado. Se introduce también SDL_PROP_AUDIOSTREAM_AUTO_CLEANUP_BOOLEAN, que permite que ciertos streams sobrevivan más allá del ciclo de vida del subsistema de audio, algo útil en arquitecturas más complejas.

Controladores y dispositivos HID

SDL 3.4 mejora bastante el soporte de mandos y dispositivos HID, ampliando la gama de hardware que funciona “a la primera” sin configuraciones externas. En particular, se añade soporte mejorado para mandos 8BitDo, FlyDigi y Hand Held Legend SInput, lo que facilita que muchos gamepads de terceros funcionen de forma más consistente.

También se incorpora soporte para mandos Nintendo Switch 2 por cable cuando SDL se compila con libusb, algo interesante para usuarios que prefieren conexión directa frente al modo inalámbrico. A nivel de API HID, aparece SDL_hid_get_properties() para asociar propiedades SDL a dispositivos HID, y la propiedad SDL_PROP_HIDAPI_LIBUSB_DEVICE_HANDLE_POINTER permite recuperar el handle libusb asociado a un SDL_hid_device cuando se ha abierto con libusb.

Estas mejoras se suma al hecho de que SDL 3.4 incluye soporte para el nuevo Steam Controller dentro de su ecosistema de entrada, y eso encaja muy bien con su papel dentro del runtime de Steam y el enfoque en el gaming en Linux y otras plataformas.

Eventos, sistema y utilidades generales

Más allá de la parte gráfica y de entrada, SDL 3.4 introduce una serie de cambios en el sistema de eventos y en utilidades generales que conviene conocer. Por ejemplo, SDL_EVENT_WINDOW_EXPOSED ahora rellena el campo data1 con true cuando se envía durante un redimensionado en vivo de la ventana, aportando contexto extra.

Se añade SDL_EVENT_DISPLAY_USABLE_BOUNDS_CHANGED, que se dispara cuando cambian los límites utilizables del escritorio (por ejemplo, al mover barras de tareas o paneles). También se incorpora SDL_EVENT_SCREEN_KEYBOARD_SHOWN/SDL_EVENT_SCREEN_KEYBOARD_HIDDEN y los eventos de pellizco ya comentados, con lo que el ecosistema de eventos cubre mejor los escenarios de UI dinámica.

En el lado de utilidades, SDL_HINT_MAIN_CALLBACK_RATE puede establecerse ahora como un valor en coma flotante, dando más precisión; SDL_AddAtomicU32() añade soporte para sumas atómicas sobre enteros de 32 bits sin signo; y SDL_GetSystemPageSize() devuelve el tamaño de página del sistema, útil para tareas de memoria de bajo nivel.

También se incluye SDL_ALIGNED(), un macro para indicar que ciertos datos deben tener una alineación específica, algo muy relevante en optimizaciones de rendimiento y uso de instrucciones SIMD. Por su parte, SDL_PROP_IOSTREAM_MEMORY_FREE_FUNC_POINTER permite definir una función de liberación personalizada para la memoria usada por SDL_IOFromMem() y SDL_IOFromConstMem(), dando más control cuando integras SDL con tus propios allocators.

Otra mejora curiosa es el soporte de salida de log detallada cuando la variable de entorno DEBUG_INVOCATION se establece a «1», pensado para depuración profunda de la inicialización y comportamiento de la librería en contextos complejos.

Mejoras específicas en Windows

En Windows, SDL 3.4 incluye cambios importantes que tocan tanto el audio como el vídeo y el sistema de entrada. Uno de los puntos interesantes es el hint SDL_HINT_RENDER_DIRECT3D11_WARP, que permite activar WARP (el rasterizador por software de D3D11). Esto es útil en máquinas sin GPU compatible o en entornos virtualizados donde no hay aceleración directa pero quieres seguir usando la API.

El driver WASAPI aprovecha SDL_HINT_AUDIO_DEVICE_STREAM_ROLE para ajustar la categoría del stream de audio, integración importante para comportamientos coherentes con el sistema (por ejemplo, audio de juego, comunicaciones, etc.). También se apoya en SDL_HINT_AUDIO_DEVICE_RAW_STREAM para indicar si el driver debe aplicar o no procesamiento extra.

Por el lado de entrada de teclado, se introduce el hint SDL_HINT_WINDOWS_RAW_KEYBOARD_EXCLUDE_HOTKEYS, que permite desactivar ciertos atajos del sistema cuando estás usando entrada en modo “raw”, muy práctico para juegos que necesitan capturar combinaciones de teclas sin que el sistema se interponga. Y a nivel de API GameInput, SDL_HINT_WINDOWS_GAMEINPUT pasa a estar desactivado por defecto, lo que reduce potenciales conflictos en algunos entornos hasta que se configure explícitamente.

Se añade también SDL_PROP_DISPLAY_WINDOWS_HMONITOR_POINTER para obtener el HMONITOR asociado a una pantalla, algo muy útil si mezclas SDL con código Win32 clásico y necesitas coordinar ventanas o monitores.

macOS, iOS y visionOS

En macOS, SDL 3.4 incorpora un hint muy práctico: SDL_HINT_MAC_PRESS_AND_HOLD, que controla si al mantener pulsada una tecla se repite la pulsación o se abre el menú de acentos. Esto permite ajustar el comportamiento del teclado para juegos y aplicaciones que requieren repetición rápida de teclas en lugar del menú de acentos típico de macOS.

En iOS, SDL ahora soporta escenas de ventana, lo que resuelve el aviso “CLIENT OF UIKIT REQUIRES UPDATE” y alinea la librería con las prácticas modernas de UIKit. Se introduce la propiedad SDL_PROP_WINDOW_CREATE_WINDOWSCENE_POINTER para especificar la escena de ventana al crear una ventana SDL, ayudando a integrar correctamente la app en el sistema de ventanas de iOS.

En visionOS y dispositivos como Apple Vision Pro, SDL 3.4 ajusta el comportamiento de la ventana y el refresco. La tasa de actualización por defecto se aumenta a 90 Hz, proporcionando una experiencia más fluida, y SDL_SetWindowSize() pasa a cambiar efectivamente el tamaño de la ventana en los cascos Vision Pro, dando más control sobre el layout en entornos de realidad mixta.

Linux, Wayland, KMS/DRM y Vulkan

En el mundo Linux, SDL 3.4 llega muy cargado. Por un lado, se añade soporte atómico para KMSDRM, lo que mejora estabilidad y sincronía al trabajar directamente con el subsistema de gráficos del kernel. Asociado a esto, el hint SDL_HINT_KMSDRM_ATOMIC permite controlar si KMSDRM usará o no esa funcionalidad atómica.

Para Wayland, se incorpora SDL_PROP_DISPLAY_WAYLAND_WL_OUTPUT_POINTER, con el que puedes obtener el wl_output asociado a una pantalla, facilitando integraciones profundas con el compositor. Además, se corrigen problemas con ratones de más de cinco botones y se mejora el desplazamiento de precisión bajo X11, aportando una sensación de control mucho más fina en aplicaciones que dependen mucho del scroll.

En cuanto a Vulkan, SDL 3.4 introduce render batching y otras mejoras para APIs como Vulkan, lo que reduce llamadas de dibujo redundantes y mejora el rendimiento general. También se trabaja en la lógica que detecta la GPU Vulkan más potente en sistemas con varias GPUs, ayudando a elegir de forma automática el dispositivo más adecuado, especialmente en equipos híbridos o portátiles con GPU integrada y dedicada.

Además, se añade la propiedad SDL_PROP_GPU_DEVICE_CREATE_VULKAN_OPTIONS_POINTER para configurar opciones de Vulkan al crear el dispositivo de GPU, y SDL_PROP_GPU_DEVICE_CREATE_VULKAN_REQUIRE_HARDWARE_ACCELERATION_BOOLEAN para exigir aceleración hardware cuando se crea dicho dispositivo. En el plano más de sistema, SDL se posiciona también como toolkit X11 con la introducción de X11TK como toolkit X11 propio para SDL.

Emscripten y uso en navegadores

SDL 3.4 mejora notablemente su integración con Emscripten y la ejecución en navegadores web, algo clave si quieres portar tu juego o app a la web sin reescribirlo desde cero. Una de las novedades consiste en permite que la ventana SDL pueda “llenar el documento” sin ser necesariamente fullscreen.

En versión previa se introdujo SDL_HINT_EMSCRIPTEN_FILL_DOCUMENT y en la release final se reorganiza en torno al flag SDL_WINDOW_FILL_DOCUMENT y la función SDL_SetWindowFillDocument(), junto a varias propiedades relacionadas. Destacan:

• SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_CANVAS_ID_STRING y SDL_PROP_WINDOW_EMSCRIPTEN_CANVAS_ID_STRING, para establecer y consultar el ID del canvas utilizado por SDL.
• SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_FILL_DOCUMENT_BOOLEAN y SDL_PROP_WINDOW_EMSCRIPTEN_FILL_DOCUMENT_BOOLEAN, para indicar y consultar si la ventana debe ocupar todo el documento.
• SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_KEYBOARD_ELEMENT_STRING y SDL_PROP_WINDOW_EMSCRIPTEN_KEYBOARD_ELEMENT_STRING, para especificar y consultar el elemento al que se vincula la entrada de teclado.

Estas opciones ofrecen un control muy fino sobre cómo se integra SDL con el DOM y el canvas, lo que ayuda a evitar hacks y capas intermedias cuando se trabaja con Emscripten. También facilitan compatibilizar SDL con frameworks web o integraciones más complejas donde el canvas es solo una parte de la página.

PlayStation 2 y otras plataformas menos habituales

Aunque pueda sorprender, SDL 3.4 también presta atención a plataformas veteranas como PlayStation 2. Se añaden hints para controlar parámetros de visualización: SDL_HINT_PS2_GS_WIDTH, SDL_HINT_PS2_GS_HEIGHT, SDL_HINT_PS2_GS_PROGRESSIVE y SDL_HINT_PS2_GS_MODE, que permiten ajustar resolución, modo progresivo y configuración general del Graphics Synthesizer.

Estos detalles dejan claro que SDL sigue siendo una opción muy flexible para proyectos homebrew, emulación o investigación en plataformas antiguas, aparte de su fuerte orientación a PCs modernos, móviles y web.

Gestión de procesos, permisos de cámara y metadatos ELF

A nivel de sistema, SDL 3.4 añade la propiedad SDL_PROP_PROCESS_CREATE_WORKING_DIRECTORY_STRING, que sirve para configurar el directorio de trabajo de nuevos procesos creados desde SDL. Esto simplifica la ejecución de subprocesos o herramientas externas desde tu aplicación SDL sin tener que bajar al API del sistema operativo.

En el ámbito de la cámara, SDL_GetCameraPermissionState() ahora devuelve un valor del tipo SDL_CameraPermissionState en vez de un entero genérico, alineando mejor la semántica y facilitando el manejo de permisos en plataformas móviles y de escritorio.

En sistemas Unix, SDL incluye notas ELF que describen sus dependencias de biblioteca no obligatorias siguiendo el formato documentado en systemd.io/ELF_DLOPEN_METADATA. La idea es que las distribuciones puedan analizar estas notas y generar dependencias de empaquetado de forma automática con herramientas como package-notes. SDL proporciona el macro SDL_ELF_NOTE_DLOPEN para que otras librerías y juegos puedan hacer lo mismo, facilitando una gestión de dependencias mucho más limpia.

Progreso de ventana y cursores animados

Para mejorar la experiencia de usuario, SDL 3.4 agrega funciones pensadas para mostrar progreso y enriquecer la interfaz. Por ejemplo, se introducen SDL_SetWindowProgressState(), SDL_SetWindowProgressValue(), SDL_GetWindowProgressState() y SDL_GetWindowProgressValue() para mostrar barras de progreso en el icono de la ventana en la barra de tareas de Windows y Linux.

Esta característica permite que el usuario vea el estado de una operación larga (descargas, cargas, compilaciones internas, etc.) aunque la ventana no esté en primer plano. Es una forma bastante elegante de dar feedback sin tener que diseñar HUDs adicionales.

Por otro lado, SDL_CreateAnimatedCursor() permite crear cursores de color animados, algo que aporta un toque de pulido visual en juegos o herramientas donde el cursor comunica estados (cargando, acción posible, alerta, etc.). Combinado con el nuevo hint SDL_HINT_MOUSE_DPI_SCALE_CURSORS, que ahora por defecto vale «0» para que los cursores no cambien de tamaño inesperadamente en entornos con escalado de DPI, se consigue un control más predecible sobre la apariencia del puntero.

Con este conjunto de cambios —desde la integración GPU 3D/2D, el soporte nativo de PNG, las mejoras en entrada y audio, hasta la atención a Linux moderno, Emscripten, visionOS y consolas clásicas— SDL 3.4 se consolida como una caja de herramientas muy completa para desarrollo multiplataforma, minimizando dependencias externas y ofreciendo una base sólida sobre la que iterar sin pasarte el día depurando problemas ajenos a tu propio código.