Skip to content
Vilanel
Roadmap

Now, next, and directional

Deliberately undated. This is my plan for my own engine rather than a commitment to anyone, and a date on it would be a date I invented for a reader who is not owed one.

Now3
Landing in current commits
Deeper animation graphsAnimation

Characters can now switch between animations with a proper blend, carry movement from the animation itself into the world, and mix several clips together based on how fast they are going.

More file formatsAssets

glTF is still the format the engine is built around, but it will now open FBX and OBJ as well. Asking someone to install Blender and convert a file before the engine will look at it is a worse answer than reading the format.

A more consistent editorEditor

The editor had four different tree views that had each been drawn separately, so they disagreed on spacing, icon size and text size. They now share one implementation. Right-click menus and asset previews are filling in the parts that were still unfinished.

Next3
Named in the plan, not yet built
Better collision shapesPhysics

A complicated object can currently have a rough collision shape that is cheap, or an exact one that only works when it does not move. Splitting it into several simple pieces would give you both. What exists covers most cases, which is why this has waited.

Other languagesInterface

Text that runs right to left, writing systems where letters change shape depending on what is next to them, and more flexible ways to arrange things on screen. None of it matters until the interface has to work in a language other than English, and all of it matters immediately after.

Previews for models and fontsEditor

You can see images in the asset browser. Models and fonts still show a generic icon, because previewing those means rendering them first, and that is a separate piece of work.

Later3
Directional, no dates
Let the compiler write itCore

Saving a file, filling the properties panel and surviving a code reload all need the engine to know what a type contains. It works that out at build time today. A future version of C++ can do it on its own, so the current version is kept behind a boundary and can be swapped without touching anything that uses it.

Threading built into the languageCore

Splitting work across processor cores is something every engine currently writes for itself. A future version of C++ makes it part of the language, so the engine's version is kept narrow enough to swap out when that lands.

LinuxPlatform

The code stays portable and a Linux compiler is kept working, but Linux is not a supported target today and no work on it is scheduled.

The reasoning behind most of these lands in the devlog before it lands here.