« Changelog History


cray v6.0 Release Notes

Release Date: 2026-04-23 // 6 months ago

  • raylib60_banner

    🚀 raylib 6.0 release notes

    🚀 A new raylib release is finally ready and, again, this is the biggest raylib release ever! Thanks to the support of many amazing contributors this release comes packed with many new features and improvements, also thanks to the financial support of NLnet and the NGI Zero Commond Fund that allowed me to work on this project mostly fulltime for the past few months.

    🚀 Some astonishing numbers for this release:

    • +330 closed issues (for a TOTAL of +2150!)
    • +2000 commits since previous RELEASE (for a TOTAL of +9760!)
    • +20 new functions ADDED to raylib API (for a TOTAL of 600!)
    • +70 new examples to learn from (for a TOTAL of +215!)
    • +210 new contributors (for a TOTAL of +850!)

    Highlights for raylib 6.0:

    • NEW Software Renderer - rlsw: The biggest addition of this new release. A new software renderer backend, that allows raylib to run purely on CPU, with no neeed for a GPU. It finally closes the circle of my search for a portable self-contained, with no-external-dependencies , graphics library, able to run on any device providing some CPU-power and some RAM memory. It has been possible thanks to the amazing work of Le Juez Victor (@Bigfoot71), who created rlsw, a single-file header-only library implementing OpenGL 1.1+ specification, tailored to fit into raylib rlgl OpenGL wrapper, and allowing to run raylib seamlessly over CPU with no code changes required on user side. As expected, software rendering is slower than hardware-accelerated rendering but it is still fast enough to run basic application at 30-60 fps. Actually, it already proved it usefulness on a new raylib port for ESP32 microcontroller by Espressif, useful for industrial applications, and opens the door to the upcoming RISC-V powered devices that start arriving to the marked, and many times come with no GPU. Along the new software renderer, some of the existing platform backends have been adapted to support it (SDL, RGFW, DRM) and also new platforms backends have been created to accomodate it (Win32, Emscripten), incluing a new PLATFORM_MEMORY, that allows direct rendering to a memory framebuffer.

    💅 raylib_rlsw.mp4

    • NEW Platform backend: Memory - rcore_memory: This new platform has been added along the software renderer backend, allowing 2d and 3d rendering over a platform-agnostic memory framebuffer , it can run headless and output frames can be directly exported to images. This new backend could also be useful for graphics rendering on servers or process images directly using the memory buffer.

    • NEW Platform backend: Win32 - rcore_desktop_win32: A new Windows platform backend and the first step towards a potential replacement/alternative to the platform libraries currently used by raylib (GLFW/SDL/RGFW). This backend follows same API template structure than the other raylib backends, but directly implementing Win32 API calls. It allows initializing OpenGL GPU-accelerated windows and also GDI based windows, useful for the software renderer backend. This new backend approach, following a common template-structure and separating the platform logic by specific OS/Windowing system, will simplify code, improve maintenance, readability and portability for raylib, setting some bases for the future. NOTE: This backend is new and it could require further testing, use it as an experimental backend for now.

    • NEW Platform backend: Emscripten - rcore_web_emscripten: In the same line as Win32 backend, this new web backend moves away from libglfw.js and directly implements Emscripten/JS functionality , with no other dependencies , adding support for the new software renderer to draw directly on a non-accelerated 2d canvas but also supporting a WebGL-hardware-accelerated canvas when required. NOTE: This backend is new and it could require further testing, use it as an experimental backend for now.

    raylib_platforms_supported_600

    • REDESIGNED Fullscreen modes and High-DPI content scaling : After many years and many related issues, the full-screen and high-dpi content scaling support has been completely redesigned from scratch. New design prioritizes borderless fullscreen modes and automatically detects current monitor content scaling configuration to scale window and framebuffer accordingly when required. Still, High-DPI support must be requested by user if desired enabling FLAG_WINDOW_HIGHDPI on window creation. This new system has been carefully tested on Windows, Linux (X11, Wayland), macOS with multiple monitors and multiple resolutions, including 4K monitors.

    • REDESIGNED Skeletal Animation System : A new animation system for 3d models has been created to support animation blending, between single frames but also between differents frames on different animations, to allow easy timed transitions between animations. This redesign implied reviewing several raylib structures to better accomodate animation data: Model, ModelSkeleton, ModelAnimation, but the API was simplified and support for GPU-skinning was improved with multiple optimizations.

    raylib_animation_blending.mp4

    • 🏗 REDESIGNED Build Config System - config.h: raylib allows lot of customization for specific needs (i.e. disabling modules not needed for specific applications like rmodels or raudio) but previous implementation did not allow easely disabling some features from custom build systems. New design not only allows disabling features with simple -DSUPPORT_FILEFORMAT_OBJ=0 on building command-line but also the full system has been reviewed, removing useless flags and exposing new ones.

    • NEW File System API : Along the years, multiple filesystem functions have been added to raylib API as required but it felt somewhat inconsistent with some pieces missing. In this new release, the full filesystem API has beeen reviewed and reorganized, compiling all the functionality single module: rcore, consequently utils module has been removed and build system has been simplified even more; only 6-7 modules (.c) need to be compiled containing the full raylib library. This new filesystem API will allow raylib to be used on the creation of custom build systems , as already demostrated with the new rexm tool for examples management. At the moment raylib includes +40 file system management functions :

      // File system management functionsunsigned char*LoadFileData(constchar*fileName,int*dataSize);// Load file data as byte array (read)voidUnloadFileData(unsigned char*data);// Unload file data allocated by LoadFileData()boolSaveFileData(constchar*fileName,void*data,intdataSize);// Save data to file from byte array (write), returns true on successboolExportDataAsCode(constunsigned char*data,intdataSize,constchar*fileName);// Export data to code (.h), returns true on successchar*LoadFileText(constchar*fileName);// Load text data from file (read), returns a '\0' terminated stringvoidUnloadFileText(char*text);// Unload file text data allocated by LoadFileText()boolSaveFileText(constchar*fileName,constchar*text);// Save text data to file (write), string must be '\0' terminated, returns true on successintFileRename(constchar*fileName,constchar*fileRename);// Rename file (if exists)intFileRemove(constchar*fileName);// Remove file (if exists)intFileCopy(constchar*srcPath,constchar*dstPath);// Copy file from one path to another, dstPath created if it doesn't existintFileMove(constchar*srcPath,constchar*dstPath);// Move file from one directory to another, dstPath created if it doesn't existintFileTextReplace(constchar*fileName,constchar*search,constchar*replacement);// Replace text in an existing fileintFileTextFindIndex(constchar*fileName,constchar*search);// Find text in existing fileboolFileExists(constchar*fileName);// Check if file existsboolDirectoryExists(constchar*dirPath);// Check if a directory path existsboolIsFileExtension(constchar*fileName,constchar*ext);// Check file extension (recommended include point: .png, .wav)intGetFileLength(constchar*fileName);// Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)longGetFileModTime(constchar*fileName);// Get file modification time (last write time)constchar*GetFileExtension(constchar*fileName);// Get pointer to extension...


Previous changes from v5.5

  • raylib55_banner

    One year after raylib 5.0 release, arribes raylib 5.5, the next big revision of the library. It's been 11 years since raylib 1.0 release and in all this time it has never stopped growing and improving. With an outstanding number of new contributors and improvements, it's, again, the biggest raylib release to date.

    🚀 Some numbers for this release:

    • +270 closed issues (for a TOTAL of +1810!)
    • +800 commits since previous RELEASE (for a TOTAL of +7770!)
    • +30 functions ADDED to raylib API (for a TOTAL of 580!)
    • +110 functions REVIEWED with fixes and improvements
    • +140 new contributors (for a TOTAL of +640!)

    Highlights for raylib 5.5:

    • 🏁 NEW raylib pre-configured Windows package : The new raylib portable and self-contained Windows package for raylib 5.5, intended for nobel devs that start in programming world, comes with one big addition: support for C code building for Web platform with one-single-mouse-click! For the last 10 years, the pre-configured raylib Windows package allowed to edit simple C projects on Notepad++ and easely compile Windows executables with an automatic script; this new release adds the possibility to compile the same C projects for Web platform with a simple mouse click. This new addition greatly simplifies C to WebAssembly project building for new users. The raylib Windows Installer package can be downloaded for free from raylib on itch.io.

    • NEW raylib project creator tool : A brand new tool developed to help raylib users to setup new projects in a professional way. raylib project creator generates a complete project structure with multiple build systems ready-to-use and GitHub CI/CD actions pre-configured. It only requires providing some C files and basic project parameters! The tools is free and open-source, and it can be used online!.

    • 👍 NEW Platform backend supported: RGFW : Thanks to the rcore platform-split implemented in raylib 5.0, adding new platforms backends has been greatly simplified , new backends can be added using provided template, self-contained in a single C module, completely portable. A new platform backend has been added: RGFW. RGFW is a new single-file header-only portable library (RGFW.h) intended for platform-functionality management (windowing and inputs); in this case for desktop platforms (Windows, Linux, macOS) but also for Web platform. It adds a new alternative to the already existing GLFW and SDL platform backends.

    • 👍 NEW Platform backend version supported: SDL3 : Previous raylib 5.0 added support for SDL2 library, and raylib 5.5 not only improves SDL2 functionality, with several issues reviewed, but also adds support for the recently released big SDL update in years: SDL3. Now users can select at compile time the desired SDL version to use , increasing the number of potential platforms supported in the future!

    • 👍 NEW Retro-console platforms supported: Dreamcast, N64, PSP, PSVita, PS4 : Thanks to the platform-split on raylib 5.0, supporting new platform backends is easier than ever! Along the raylib rlgl module support for the OpenGL 1.1 graphics API, it opened the door to multiple homebrew retro-consoles backend implementations! It's amazing to see raylib running on +20 year old consoles like Dreamcast, PSP or PSVita, considering the hardware constraints of those platforms and proves raylib outstanding versability! Those additional platforms can be found in separate repositories and have been created by the amazing programmer Antonio Jose Ramos Marquez (@psxdev).

    • 👍 NEW GPU Skinning support : After lots of requests for this feature, it has been finally added to raylib thanks to the contributor Daniel Holden (@orangeduck), probably the developer that has further pushed models animations with raylib, developing two amazing tools to visualize and test animations: GenoView and BVHView. Adding GPU skinning was a tricky feature, considering it had to be available for all raylib supported platforms , including limited ones like Raspberry Pi with OpenGL ES 2.0, where some advance OpenGL features are not available (UBO, SSBO, Transform Feedback) but a multi-platform solution was found to make it possible. A new example, models_gpu_skinning has been added to illustrate this new functionality. As an extra, previous existing CPU animation system has been greatly improved, multiplying performance by a factor (simplifiying required maths).

    • NEW raymath C++ operators: After several requested for this feature, C++ math operators for Vector2, Vector3, Vector4, Quaternion and Matrix has been added to raymath as an extension to current implementation. Despite being only available for C++ because C does not support it, these operators simplify C++ code when doing math operations.

    Beside those new big features, raylib 5.5 comes with MANY other improvements:

    • 👍 Normals support on batching system
    • 👍 Clipboard images reading support
    • CRC32/MD5/SHA1 hash computation
    • 👍 Gamepad vibration support
    • 👌 Improved font loading (no GPU required) with BDF fonts support
    • 🚚 Time-based camera movement
    • 👌 Improved GLTF animations loading

    ...and much much more, including many functions reviews and new functions added!

    👉 Make sure to check raylib CHANGELOG for a detailed list of changes!

    To end with, I want to thank all the contributors (+640!) that along the years have greatly improved raylib and pushed it further and better day after day. Thanks to all of them, raylib is the amazing library it is today.

    Last but not least, I want to thank raylib sponsors and all the raylib community for their support and continuous engagement with the library, creating and sharing amazing raylib projects on a daily basis. Thanks for making raylib a great platform to enjoy games/tools/graphic programming!

    After 11 years of development, raylib 5.5 is the best raylib ever.

    Enjoy programming with raylib! :)

    🆕 New Contributors