Making a Game Engine in Rust 01: Introduction

In my previous series, I delved into building a Unix shell in Rust, a project that was both challenging and rewarding, offering a deep dive into the language and its capabilities. With that foundation laid, I’m now ready to take on a new challenge: creating a simple 2D game engine in Rust. This series will detail the entire journey, from the first lines of code, exploring both the upsides and downsides of this ambitious project.

What is a Game Engine?

A game engine is the core software framework that developers use to create video games. It provides the essential components needed to build a game, such as rendering engines for 2D and 3D graphics, physics engines for realistic movement, and audio engines for sound effects. Game engines also typically include tools for scripting, animation, and artificial intelligence.

Some well-known examples of game engines include:

• Unity: A highly popular engine that supports both 2D and 3D game development. It’s known for its ease of use and extensive asset store.
• Unreal Engine: Renowned for its high-fidelity graphics, particularly in 3D games, and used in both games and real-time cinematic production.
• Godot: An open-source engine that’s gaining popularity for its flexibility and lightweight design, especially in indie game development.

These engines have become the backbone of modern game development, allowing developers to focus more on the creative aspects of game design rather than building tools from scratch.

Why Make a Game Engine?

At first glance, making your own game engine might seem unnecessary, especially with so many robust options available. However, my primary motivation is to learn about the inner workings of game engines and the challenges involved in building one from the ground up.

Building a game engine offers an in-depth understanding of systems like rendering, input handling, and physics simulation. It’s an invaluable learning experience for anyone interested in game development or low-level programming.

That said, it’s important to acknowledge that apart from educational purposes, there are few practical reasons to create your own game engine. The market is saturated with engines, each catering to different needs. For instance, if you’re working with Unity but find it lacks a specific feature, you generally have two options: either extend Unity’s functionality through custom scripts, which often requires deep dives into documentation, or switch to another engine that already offers the feature.

The point is, in 99% of situations, the primary reason to develop your own engine is to learn—and that’s not a bad thing. But you want to make a somewhat professional game engine for your owns games be prepared to spend as much, if not more, time on the engine itself than on the games you want to create.

Why Rust?

Initially, I considered using C++ to build the engine due to its low-level control and performance. C++ has been the go-to language for game development for decades, offering the kind of fine-grained control over hardware that games often require. However, after my experience with Rust in the Unix shell project, I decided to go with Rust for this endeavor.

Rust offers performance comparable to C and C++, but with the added benefits of memory safety and a more modern development experience. Its strong focus on preventing common bugs, such as null pointer dereferencing and data races, makes it an excellent choice for developing complex systems like a game engine. Additionally, Rust’s package manager, Cargo, and its ecosystem of crates simplify project management and integration with other libraries.

How Will I Build It?

In building this game engine, I plan to code almost everything myself, with one key exception: rendering. For that, I’ll be using SDL2, a powerful library that simplifies rendering and is well-suited for 2D game development. SDL2 strikes a good balance between simplicity and capability, making it an ideal choice for a project like this.

Some of the game engine’s functionality will be inspired by Unity, as it’s the engine I’ve used the most in my past projects. Unity’s design is intuitive and highly effective for a wide range of games, and borrowing some of its concepts will help streamline the development process while ensuring the engine is flexible and easy to use.

What to Expect?

In this series, I’ll be sharing my experience as I build the game engine, highlighting the challenges, solutions, and insights I encounter along the way. This isn’t intended to be a step-by-step tutorial, but rather a detailed account of the development process. I’ll discuss the problems I face, the design decisions I make, and how I overcome obstacles.

If you’re interested in game development, Rust, or just enjoy following along with programming projects, I think you’ll find this series engaging and informative. You’ll get a behind-the-scenes look at what it’s like to build a game engine from scratch, and perhaps even pick up a few tips and tricks along the way.

So, let’s get started on this exciting journey into game development with Rust!