Tools: Essential Guide: First Release of LDL 0.1 — A Small Library with a Big Soul. One API for 30 Years of Computer History

Tools: Essential Guide: First Release of LDL 0.1 — A Small Library with a Big Soul. One API for 30 Years of Computer History

What is LDL?

The Journey: From C++98 to C89

Backends: Not a Replacement, but a Bridge

Minimal Window Example

Features in Current Version (0.1)

Supported Platforms

Build & Install

Roadmap: Version 0.2

Planned 2D API Features:

Philosophy: The Charm of Old Hardware

Why Does This Matter?

Screenshots

OpenGL 1.2 Examples

OpenGL 2.1 Examples

OpenGL 3.3 Examples

License I'm excited to announce the first public release of the LDL library. LDL (Little Directmedia Layer) is more than just a cross-platform library — it's a bridge between different eras of software development. It lets you write code that runs just as well on Windows 95 as it does on Windows 11, on ancient Linux kernels as well as modern distributions, on FreeBSD 3.0 and the latest releases. The library is written in pure C89 (ANSI C), ensuring maximum portability — even to the most exotic compilers and platforms. I originally wrote LDL in C++98, which already provided good portability. But over time, I reconsidered my approach: I switched entirely to C89 — this gives maximum compatibility with old compilers and platforms, including DOS, Windows 95, Solaris, and even PlayStation 1. I abandoned the idea of releasing a full-featured 1.0 all at once — now releases are iterative: This way, the project doesn't stall offline for years but grows gradually in front of the community. LDL doesn't try to replace SDL, SFML, or GLFW — it becomes a layer on top of them. Planned backends include: This means you can build an LDL application on top of any of these libraries without changing a single line of code. The API stays the same; underneath, you can plug in any supported windowing and input system. The next major goal is adding a unified 2D renderer — a single interface for drawing sprites, lines, rectangles, and text that works identically on any hardware. The developer doesn't need to think about what's under the hood: modern Vulkan, legacy OpenGL, or just a CPU with no GPU. LDL automatically selects the optimal backend. Same code. Same visual result. Everywhere. Goal: Code written with LDL should live for decades — from '90s consoles and retro PCs to ultra-modern workstations — without rewrites or surprises. "We stand on the shoulders of giants whose names we often forget, but whose work continues to shape our world every day." LDL is an attempt to preserve the connection between generations of developers. It doesn't try to replace existing solutions (like SDL or GLFW) — it complements them, providing a unified API for platforms that usually get left behind. LDL isn't just a library. It's an attempt to preserve that special feeling of working with technology from the past: Today we have terabytes and teraflops, but we've lost something important — the art of doing more with less. LDL brings that approach back. Every line of the library is written with the thought that it might run on a Pentium 66 MHz with 8 MB of RAM. Because modern software lives 3–5 years. We throw away working hardware not because it's broken, but because software has become too heavy and lazy. LDL is a protest against planned obsolescence. It's code that doesn't require hardware upgrades every three years. One codebase. Thirty years of computer history. And the charm felt by those who remember when programming was a true art of survival within constraints. GitHub: github.com/JordanCpp/LDL One API. One Codebase. Thirty Years of Computing History. 🚀 Templates let you quickly answer FAQs or store snippets for re-use. Hide child comments as well For further actions, you may consider blocking this person and/or reporting abuse

Code Block

Copy

/* * ----------------------------------------------------------------------------- * This example is in the public domain (CC0 1.0 Universal). * You can copy, modify, use, and distribute it for any purpose. * ----------------------------------------------------------------------------- */ #include <LDL/LDL.h> int main(void) { LDL_Result* result; LDL_Context* context; LDL_Window* window; LDL_Event event; result = LDL_ResultNew(); context = LDL_ContextNew(LDL_ContextOpenGL1); window = LDL_WindowNew(result, context, LDL_GetVec2i(0, 0), LDL_GetVec2i(800, 600), "LDL - Simple Window", LDL_WindowModeResized); if (LDL_ResultIsOk(result)) { while (LDL_WindowIsRunning(window)) { while (LDL_WindowGetEvent(window, &event)) { if (event.Type == LDL_EventIsQuit || LDL_EventIsKeyPressed(&event, LDL_KeyEscape)) { LDL_WindowStopEvent(window); } } LDL_WindowPresent(window); LDL_Delay(16); } LDL_WindowFree(window); LDL_ContextFree(context); LDL_ResultFree(result); } if (LDL_ResultIsFail(result)) { printf("Error: %s\n", LDL_ResultGetMessage(result)); } return 0; } /* * ----------------------------------------------------------------------------- * This example is in the public domain (CC0 1.0 Universal). * You can copy, modify, use, and distribute it for any purpose. * ----------------------------------------------------------------------------- */ #include <LDL/LDL.h> int main(void) { LDL_Result* result; LDL_Context* context; LDL_Window* window; LDL_Event event; result = LDL_ResultNew(); context = LDL_ContextNew(LDL_ContextOpenGL1); window = LDL_WindowNew(result, context, LDL_GetVec2i(0, 0), LDL_GetVec2i(800, 600), "LDL - Simple Window", LDL_WindowModeResized); if (LDL_ResultIsOk(result)) { while (LDL_WindowIsRunning(window)) { while (LDL_WindowGetEvent(window, &event)) { if (event.Type == LDL_EventIsQuit || LDL_EventIsKeyPressed(&event, LDL_KeyEscape)) { LDL_WindowStopEvent(window); } } LDL_WindowPresent(window); LDL_Delay(16); } LDL_WindowFree(window); LDL_ContextFree(context); LDL_ResultFree(result); } if (LDL_ResultIsFail(result)) { printf("Error: %s\n", LDL_ResultGetMessage(result)); } return 0; } /* * ----------------------------------------------------------------------------- * This example is in the public domain (CC0 1.0 Universal). * You can copy, modify, use, and distribute it for any purpose. * ----------------------------------------------------------------------------- */ #include <LDL/LDL.h> int main(void) { LDL_Result* result; LDL_Context* context; LDL_Window* window; LDL_Event event; result = LDL_ResultNew(); context = LDL_ContextNew(LDL_ContextOpenGL1); window = LDL_WindowNew(result, context, LDL_GetVec2i(0, 0), LDL_GetVec2i(800, 600), "LDL - Simple Window", LDL_WindowModeResized); if (LDL_ResultIsOk(result)) { while (LDL_WindowIsRunning(window)) { while (LDL_WindowGetEvent(window, &event)) { if (event.Type == LDL_EventIsQuit || LDL_EventIsKeyPressed(&event, LDL_KeyEscape)) { LDL_WindowStopEvent(window); } } LDL_WindowPresent(window); LDL_Delay(16); } LDL_WindowFree(window); LDL_ContextFree(context); LDL_ResultFree(result); } if (LDL_ResultIsFail(result)) { printf("Error: %s\n", LDL_ResultGetMessage(result)); } return 0; } # Install dependencies (Debian/Ubuntu) sudo apt-get install libx11-dev libgl1-mesa-dev # Clone and build git clone https://github.com/JordanCpp/LDL.git cd LDL cmake -B build cmake --build build # Install dependencies (Debian/Ubuntu) sudo apt-get install libx11-dev libgl1-mesa-dev # Clone and build git clone https://github.com/JordanCpp/LDL.git cd LDL cmake -B build cmake --build build # Install dependencies (Debian/Ubuntu) sudo apt-get install libx11-dev libgl1-mesa-dev # Clone and build git clone https://github.com/JordanCpp/LDL.git cd LDL cmake -B build cmake --build build - I switched entirely to C89 — this gives maximum compatibility with old compilers and platforms, including DOS, Windows 95, Solaris, and even PlayStation 1. - I abandoned the idea of releasing a full-featured 1.0 all at once — now releases are iterative: First: windows, events, graphics ✅ Next: 2D renderer 🔜 Then: audio and fonts 🔜 - First: windows, events, graphics ✅ - Next: 2D renderer 🔜 - Then: audio and fonts 🔜 - First: windows, events, graphics ✅ - Next: 2D renderer 🔜 - Then: audio and fonts 🔜 - If native support for a platform isn't ready yet, you can temporarily use a backend through an existing library. - Developers already familiar with SDL or GLFW can try LDL without completely replacing their toolchain. - You can leverage features from these libraries (like audio or fonts in SDL) earlier than they're implemented natively in LDL. - On modern systems → Vulkan or OpenGL with hardware acceleration - On retro hardware → software rasterizer - Sprite loading and drawing - Position, rotation, scale - Color effects and transparency - Line and rectangle drawing - Text rendering with fonts - The flicker of a CRT monitor - The warmth of a fanless CPU working hard on every clock cycle - How '90s engineers squeezed the impossible out of kilobytes of memory and megahertz of clock speed