ShapeEngine: Drawing Games Without a Single Texture

You know the drill: you're prototyping a game idea, and before you can test a single mechanic, you're already wrestling with sprite atlases, texture filtering, and asset pipelines. What if you could skip all that and just draw everything with code? That's the bet ShapeEngine makes—a custom engine built on top of Raylib that renders everything using draw functions instead of textures.

ShapeEngine is an open-source project by Dave Green, designed to be performant while relying exclusively on procedural drawing. It's not a replacement for Raylib—it's a layer on top of it, so everything Raylib offers remains available to you. If you've ever wanted the flexibility of vector-style rendering without the overhead of a full game engine, this is worth a look.

What It Does

ShapeEngine is a C# engine that wraps Raylib and adds its own drawing system on top. The core idea is simple: instead of loading image files and rendering them as textures, everything on screen is drawn using shapes—lines, polygons, fills, and other geometric primitives.

The project's showcase demonstrates the range of what this approach can do. There's a Helldivers-style top-down shooter, pathfinding visualizations, UI elements, striped fills, shape projection, word emphasis, input handling, and even fracture effects. The "gapped drawing" demos show how shapes can be rendered with intentional gaps, and there's a screen texture system that works differently from traditional texture loading.

Because it's built on Raylib, you get the underlying framework's capabilities for free. The README points to Raylib's examples and cheatsheet, meaning you can mix ShapeEngine's drawing primitives with standard Raylib features when you need them. The engine also depends on Clipper2 for polygon clipping operations and Microsoft.Toolkit.HighPerformance for performance utilities, so it's not just a thin wrapper—there's real computational geometry happening under the hood.

Why It's Cool

The texture-free approach is more than a stylistic choice—it solves real problems:

• No asset pipeline friction. You don't need to create, export, and import sprites. Everything is defined in code, which means you can tweak visual properties at runtime without touching external files.
• Resolution independence. Shapes scale cleanly. A circle drawn with code stays crisp at any size, which is a headache textures always have.
• Procedural effects are natural. The fracture, projection, and gapped-drawing demos would be painful to implement with sprite swapping. When everything is geometry, effects like breaking a shape into pieces become math problems, not asset problems.
• Performance focus. The README explicitly states the main focus is being performant. Drawing shapes instead of sampling textures can be faster in certain scenarios, especially when you're dealing with simple geometric visuals.
• Full Raylib compatibility. You're not locked into ShapeEngine's way of doing things. The README is clear that everything from Raylib is available, so you can mix approaches when it makes sense.

The project also has a healthy ecosystem around it. There's a separate demos repository with bigger examples like a small asteroids game, and the author has released trailers for versions 1.0 through 5.0, which suggests active, sustained development.

How to Try It

Getting started is straightforward, and the README offers several installation paths depending on how hands-on you want to be.

The easiest route is via NuGet:

dotnet add package DaveGreen.ShapeEngine

If you want to modify the engine itself, you can clone or fork the repository and reference the ShapeEngine project directly. That way, changes you make to the engine update automatically in your own project.

For manual setup, you'll need to gather these DLLs: Clipper2Lib, Raylib-Cs, Microsoft.Toolkit.HighPerformance, Shape Engine Core, and Raylib. The Raylib DLL must sit at the root level of your project, and you'll need the right version for your operating system—on macOS, you'll use the .dylib file instead and set "Copy if Newer" to true.

There's also a fourth option: just grab the ShapeEngine Core DLL and add the correct versions of Raylib_CsLo and Clipper2 from NuGet yourself. The GitHub releases page notes which versions were used.

You can check out the examples on Itch.io, and more substantial demos live in the ShapeEngineDemos repository.

Final Thoughts

ShapeEngine won't replace your favorite game engine, and it's not trying to. The author is upfront that it was designed for their specific game dev needs. But that honesty is refreshing—you know exactly what you're getting. If you're prototyping, building a game with simple geometric aesthetics, or just curious about what a texture-free rendering pipeline feels like, this is a solid tool to experiment with. The fact that it's built on Raylib means you're never stranded, and the demos show genuine creative potential. For indie developers who like to understand what's happening under the hood, ShapeEngine offers a different way of thinking about game rendering—one that's worth a weekend of tinkering.

Follow @githubprojects for more developer tools and open source projects.