Info

This post is auto-generated from RSS feed The Rust Programming Language Forum - Latest topics. Source: ZlormaEngine: a lightweight procedural 2D game engine written in Rust

ZlormaEngine: a lightweight procedural 2D game engine written in Rust

Hello Rust community,

I would like to present ZlormaEngine, a small custom 2D game engine I am developing in Rust.

The engine is currently being used to build two games:

• Gemfall Arena;
• Zlorma Core: Signal Lost.

My goal is not to compete with mature engines.

ZlormaEngine is primarily a learning project and a practical engine for building compact procedural games with native Linux and Windows binaries.

Project Goals

The main goals of ZlormaEngine are:

• keeping the codebase relatively small;
• generating graphics and levels procedurally;
• producing lightweight native executables;
• supporting Linux and Windows;
• using a simple software-rendered framebuffer;
• learning how common game-engine systems work internally;
• reusing the same engine across several games.

The current engine version is 0.3.0.

Current Architecture

The project is organized as a Cargo workspace.

A simplified structure looks like this:

```text
ZlormaEngine/
├── Cargo.toml
├── crates/
│   └── zlorma_engine/
├── games/
│   ├── gemfall_arena/
│   └── signal_lost/
├── scripts/
└── dist/

The engine crate currently handles:

framebuffer creation;
pixel rendering;
primitive drawing;
bitmap text;
input;
window updates;
shared constants and utilities.

Each game is a separate binary crate using the shared engine crate.

The engine currently renders at 640 × 360 and uses minifb for the native window.

Linux builds use X11.

Windows builds are cross-compiled from Linux with:

x86_64-pc-windows-gnuSoftware Rendering

ZlormaEngine currently uses a CPU-side framebuffer represented as a buffer of 32-bit pixels.

The game code directly draws:

rectangles;
lines;
circles;
projectiles;
particles;
procedural sprites;
interface elements;
bitmap text.

The framebuffer is then passed to the native window.

This approach is intentionally simple.

It gives me direct control over every pixel and keeps the engine understandable while I continue learning Rust and game-engine architecture.

Procedural Content

The engine does not currently depend on large external graphical asset packs.

Most graphics and effects are generated through code.

Signal Lost also generates its station layout at runtime.

The generator:

creates rectangular rooms;
connects them with corridors;
places terminals;
places enemies and data fragments;
chooses an exit location;
checks that important locations remain accessible.

The system is still relatively simple, but it produces a different station layout for each run.

Zlorma Core: Signal Lost

Signal Lost is a procedural top-down sci-fi shooter.

The player explores a corrupted digital station, restores terminals, collects data, builds defenses and tries to escape.

The latest version includes:

procedural rooms and corridors;
several enemy types;
barriers and automated turrets;
visible corruption;
a boss encounter;
screen shake;
particles;
projectile trails;
procedural shockwaves;
floating text;
the Zlorma Data Forge upgrade system.

The Data Forge presents random upgrades after terminal repairs.

Each upgrade usually contains both a bonus and a penalty.

This creates combinations such as:

higher fire rate with reduced damage;
more health with reduced movement speed;
stronger turrets with increased construction cost;
more data rewards with faster corruption.
Executable Sizes

The current Signal Lost executable sizes are approximately:

Linux:   476 KB
Windows: 312 KB

Gemfall Arena remains similarly small.

These sizes are measured on optimized release builds and do not include the compressed distribution archives.

Reducing binary size is not the only objective, but it is one of the constraints that influences the design of the engine.

What I Am Learning

Developing ZlormaEngine has helped me work with:

Cargo workspaces;
shared library crates;
native windowing;
cross-compilation;
ownership and borrowing in game-state code;
collections of entities;
collision detection;
deterministic procedural generation;
release profiles;
build scripts;
Linux and Windows packaging.

One of the biggest challenges has been keeping game logic simple while several systems need mutable access to the same state.

I am gradually separating rendering, updates, entities, procedural generation and user-interface logic into clearer systems.

Current Limitations

ZlormaEngine is still experimental.

It currently does not have:

GPU rendering;
an editor;
scripting;
a public plugin system;
advanced audio;
a stable public API;
complete documentation;
a published crate.

The code is evolving alongside the games, so APIs can change frequently.

Play the Current Prototype

Zlorma Core: Signal Lost is available for Windows and Linux:

Development Articles

I publish longer development articles here:

Feedback

I would especially appreciate feedback about:

the Cargo workspace organization;
separating engine and game code;
software-rendered framebuffer design;
procedural level generation;
cross-platform build organization;
reducing coupling between game systems;
useful Rust crates for lightweight 2D development.

Thank you for reading.

---

Nicolas — ZlormaStudio
Créateur de ZlormaEngine, un moteur 2D léger développé en Rust.

Jouer à Zlorma Core: Signal Lost :

Suivre le développement de ZlormaEngine :

Repair the system. Contain the corruption. Find the exit.

community,
announcements,
#showcase,
#games,

1 post - 1 participant

Read full topic

🏷️ Rust_feed