Crate simple_game_engine[][src]

A minimal game engine that’s really easy to get started with.

This project aims to create a minimal, yet usable, game engine. It is heavily inspired by the Pixel Game Engine, with the goal of creating something that abstracts away the complexities of creating graphical, interactive apps and games. Right now, it’s a thin wrapper around SDL2 (using the sdl2 crate) for visuals.


  • Very simple to use: Just implement the Application trait on a type of your choice, then pass an instance of this type to Engine::new.
  • Powerful: Anything you can do with sdl2 from Rust, you can do with this library, and we provide thin abstractions over some of the more convoluted sdl2 interfaces.
  • Built-in text rendering: No need to find a TTF font and distribute it with your application, just call the [Canvas::draw_text][canvas::Canvas::draw_text] method. (see below)

Caveats With Text Rendering

This crate uses the GNU Unifont for built-in text rendering. As such, if you wish to use this feature, you must distribute your project under the GPL. As this is not desirable for many projects, this feature is only enabled if this crate is built with the “unifont” cargo feature.

version = "0.8.2"
features = ["unifont"]

If you’d like to render text without using this font, consider checking out the SDL2 TTF module.


The simplest SGE program looks like this:

use simple_game_engine::{self as sge, prelude::*};
use std::error::Error;

struct App {}

impl sge::Application for App {
    fn on_create(
        &mut self,
        canvas: &mut WindowCanvas,
        input: &InputState,
    ) -> sge::ApplicationResult {
        // Do one-time initialisation here
        Ok(true) // `true` indicates to continue running the application

    fn on_update(
        &mut self,
        canvas: &mut WindowCanvas,
        input: &InputState,
        elapsed_time: f64,
    ) -> sge::ApplicationResult {
        // Handle user input, update the canvas, and perform any other tasks to be ran on each frame
        Ok(true) // `true` indicates to continue running the application

fn main() -> Result<(), Box<dyn Error>> {
    let mut app = App {};
    let mut engine = sge::Engine::new(
        &mut app,   // Application instance
        "Test App", // Window title
        640,        // Window width
        480,        // Window height
    engine.start(true) // `true` starts the app with vsync enabled

on_create and on_update are optional, but their default implementation does nothing, so you’ll probably want to define some logic for at least on_update, which is called for every frame.


pub use canvas::WindowCanvas;



Provides the Canvas struct, which allows the screen to be manipulated, such as by drawing points, lines, rectangles, text, or textures to it.


Data structures for inspecting user input.


Commonly used types.



The main game engine, which manages the display and input.


Immutable point type, consisting of x and y.


A (non-empty) rectangle.



An application using this framework.

Type Definitions


The return type of Application::on_create and Application::on_update.