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

Hello, developers!

I'm excited to announce the first public release of the LDL library.

What is LDL?

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.

The Journey: From C++98 to C89

I originally wrote LDL in C++98, which already provided good portability. But over time, I reconsidered my approach:

1. I switched entirely to C89 — this gives maximum compatibility with old compilers and platforms, including DOS, Windows 95, Solaris, and even PlayStation 1.

2. 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 🔜

This way, the project doesn't stall offline for years but grows gradually in front of the community.

Backends: Not a Replacement, but a Bridge

LDL doesn't try to replace SDL, SFML, or GLFW — it becomes a layer on top of them. Planned backends include:

• SDL 1.2
• SDL 2.x
• SDL 3.x
• SFML
• GLFW

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.

Why is this useful?

• 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.

Minimal Window Example

/*
 * -----------------------------------------------------------------------------
 * 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;
}

Features in Current Version (0.1)

Supported Platforms

Build & Install

# 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

Roadmap: Version 0.2

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.

• On modern systems → Vulkan or OpenGL with hardware acceleration
• On retro hardware → software rasterizer

Same code. Same visual result. Everywhere.

Planned 2D API Features:

• Sprite loading and drawing
• Position, rotation, scale
• Color effects and transparency
• Line and rectangle drawing
• Text rendering with fonts

Goal: Code written with LDL should live for decades — from '90s consoles and retro PCs to ultra-modern workstations — without rewrites or surprises.

Philosophy: The Charm of Old Hardware

"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:

• 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

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.

Why Does This Matter?

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.

Screenshots

OpenGL 1.2 Examples

3D Atom Model	Animated 3D Terrain	Rotate

Terrain Flight	Water Wave Simulation

OpenGL 2.1 Examples

Textured Terrain	Solar System

OpenGL 3.3 Examples

Animated Water Surface	Rotating Cube	Textured Sphere

License

GitHub: github.com/JordanCpp/LDL

One API. One Codebase. Thirty Years of Computing History. 🚀