Skip to content
Evil Engine home

Roadmap

20 built, 4 started and 12 designed so far, checked as of .

What each status means

  1. Built

    In the engine and working.

  2. Started

    Some of it works, the rest is on the way.

  3. Designed

    Planned out on paper, no code yet.

A Godot of its own

Built

Evil Engine runs on its own fork of Godot 4.8, built from source and kept up with upstream's fixes.

  • Fork of Godot 4.8, kept up with upstream (Built)
  • Double-precision .NET editor built from source (Built)
  • Shared, Server and Client code kept apart by the compiler (Built)
  • No more editor hangs at fractional scales (Built)
  • Export builds (done once by hand, no recipe yet) (Started)
  • Oblique camera projection for portals and water (Designed)

Every game is a mount

Started

The mount core is built and has been tried on twelve games across a bunch of engines, with every file readable.

Per-engine progress →
  • Mounts as pointers to a folder or disc image (Built)
  • Finding games in Steam's libraries (Built)
  • Layered, read-only file trees (Built)
  • Archives nested up to three levels deep (Built)
  • Mounts that need other mounts (Built)
  • Fingerprints to compare two players' copies (Built)
  • Games that another game mounts for itself (Designed)

Everything converts

Started

The pipeline is built and Evil Engine's own formats read and write. Converted maps reach Godot, drawn with a standard shader for now.

Per-game tickets →
  • namespace:object ids for all content (Built)
  • Converters that run on first ask, with an exact cache (Built)
  • Open formats: glTF, KTX2, and text maps and materials (Built)
  • Source models, textures, materials and maps (Built)
  • Drawing converted content in Godot (Started)
  • A cache that survives restarts (Designed)
  • Sounds, at one loudness across games (Designed)
  • Every game's animations in one engine (Designed)

Something to play

Started

It boots into a menu that opens every mount, and you can load any mounted game's map and fly around it. No player, physics or sessions yet.

  • Boot log and main menu (Built)
  • Adding games from the menu (Built)
  • Loading any mounted game's maps (Built)
  • Matching each game's own look (Started)
  • A player that walks, jumps, climbs and swims (Designed)
  • Physics across every game's stuff (Designed)
  • Single player, hosting and dedicated servers (Designed)
  • Console, convars and settings (Designed)
  • Spawn menu (Designed)

Plugins

Started

Plugin manifests are read and put in load order, but nothing runs a Plugin yet.

  • plugin.toml manifests (Built)
  • Load order from dependencies, refusing only what breaks (Built)
  • C# Plugins checked and sealed off before loading (Built)
  • The C# Plugin API (Started)
  • The Lua runtime (Designed)
  • Server, client and menu realms to run in (Designed)

On paper

Designed in full, waiting their turn.

  • Humanoids

    Any game's humanoid moving like any other's, with every model keeping its own bones.

  • Liquids

    Every game's water, slime and lava as one kind of thing, each keeping its own look.

  • Input

    Every control a named action you can rebind in one menu.

  • Localization

    Every name in your language, from each game's own string tables.

  • Records

    One store for everything the engine reads by id, patchable one key at a time.

  • AI and possession

    NPCs, taking over bodies, and scripted scenes.

  • Runtime geometry

    Meshes that Plugins build on the fly.

  • Menus and themes

    The menus, windows and loading screens, and how they look.

  • Generative motion

    An experimental switch that makes each person's walking and turning fresh every time, on your machine only.

Want the story behind it? It's all in the devlogs.