---
title: "Roadmap"
description: "Where Evil Engine stands, goal by goal: what's built, what's started and what's still on paper."
url: "https://evil-engine.com/roadmap"
modified: "2026-11-02T19:00:00.000Z"
site: "Evil Engine"
about: "Evil Engine, the passthrough modding engine"
---

# Roadmap

20 built, 4 started and 12 designed so far, checked as of 2026-11-02.

## 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 →](https://evil-engine.com/engines)

- 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 →](https://evil-engine.com/games)

- 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](https://evil-engine.com/devlogs).

## About Evil Engine

Evil Engine is a **passthrough modding** engine by Pushbar Interactive. Modding through the games you already own instead of around them: the content comes from each player's own copy and is never extracted, ported or redistributed. The term took off in September 2026 with mods that run two games at once and wire them together by hand, one pair at a time. Evil Engine comes from that lineage and makes the process repeatable: it learns each engine once, maps each game onto shared vocabularies once, and gives mods one API, so every mounted game works with every other. More: https://evil-engine.com/passthrough-modding

- Every page, for agents: https://evil-engine.com/llms.txt
- Wishlist on Steam: https://store.steampowered.com/app/3731310/Evil_Engine
