You know that sinking feeling when you’re building a simple 2D dashboard or a lightweight simulation, and someone suggests using a full game engine? The dependency chain alone is enough to make you want to walk away. Unity, Unreal, Godot — they’re amazing for 3D worlds, but for a 2D painting library? It’s like bringing a flamethrower to a candle-lighting ceremony.
That’s why the moment I came across SDL_gp — a single-header, high-performance 2D graphics library built directly on SDL3’s GPU API — I felt a wave of relief. No build system nightmares. No 200MB runtime. Just a #include and you’re off to the races.
Hardware acceleration shouldn’t require a PhD in build configuration.
Here’s the trick: the author didn’t reinvent the wheel. They wrapped SDL3’s GPU primitives in a minimal, opinionated API that handles the 90% use case — blitting, transforms, color blending — without the overhead of a state machine that needs to be told what ‘draw’ means every single frame.
Most developers over-engineer 2D rendering. They reach for OpenGL directly, or pull in a massive framework like SFML or a full game engine, assuming that hardware acceleration demands complexity. But SDL_gp proves that a single-header, 2000-line C library can do the job with a fraction of the friction.
Simplicity is not a compromise. It’s an optimization.
I saw a comment on the repo that said: “This isn’t SDL_gpu, that is part of SDL3. This is SDL_gp, an external lib which builds on the former.” That’s the key insight. The library doesn’t compete with SDL_gpu — it leverages it. It’s a layer of convenience that acknowledges a truth: most of us don’t need a decade of abstraction between our pixels and the GPU.
We’ve been conditioned to believe that graphics programming means either writing raw GLSL shaders or accepting the bloat of a game engine. SDL_gp says: both are wrong. You can have hardware-accelerated, portable 2D rendering in a single header file. You can have performance without the baggage.
And the emotional hook? It’s the relief of escaping dependency hell. That moment when you realize you don’t need to install a package manager, set up a build system, or wrestle with CMake for 45 minutes. You just drop the header in your source tree and write code.
The best tools are the ones you forget you’re using.
If you’re making a 2D game, a UI overlay, a particle system, or any visual tool that needs to run fast on modern hardware, stop asking yourself “Which engine should I use?” and start asking “How little abstraction can I get away with?”
SDL_gp is that answer. It’s minimal, performant, and — most importantly — it respects your time.
Now go build something that renders.
FAQ
Q: Isn't SDL_gp just a wrapper around SDL_gpu? Why not use SDL_gpu directly?
A: SDL_gpu is the low-level API inside SDL3. SDL_gp abstracts away the state machine and boilerplate so you can draw 2D shapes and sprites in a few lines of code. If you want to write raw GPU commands, use SDL_gpu. If you want to ship something fast, use SDL_gp.
Q: Can I use SDL_gp for production 2D games?
A: Yes, as long as your needs fit within its scope: sprite batching, transforms, color blending, and basic primitives. It's not a full engine — no physics, no audio, no scene graph. For small to medium 2D projects, it's more than enough and much lighter than alternatives.
Q: Doesn't a single-header library mean poor organization or bad code?
A: Not at all. Single-header libraries are a C/C++ tradition that prioritizes ease of integration. SDL_gp is well-structured and documented. The trade-off is that everything is in one file, but for a focused library that's a feature, not a bug.