Milestones for 2026

Milestones for 2026

in

Last time I talked about making engines and why what I am doing doesn’t really fit nicely into that category so if you’re new here you should probably read that first.

Today I’ll be talking about my plans for the rest of the year and the three milestones I want to accomplish this year.

I’m going to implement the “engine” in parts. This will help guide my development towards measurable progress and hopefully prevent me from getting lost in the weeds on some unimportant side feature. It should also validate my progress with regular checkpoints to see if I’ve missed a necessary feature.

I’ve chosen each milestone to be something that could itself be used to make a simple game. Further milestones just give more capabilities to play with.

Also, these lists may change as I find out that a given feature actually requires something else to work. One of the purposes of the milesto

1st milestone: A slideshow

This is actually already done! Basically, the engine has to be able to handle a slideshow.

Even this entails a surprising number of things:

  • Display text (not bitmap fonts, we’re not in the 90s)
  • Display images (including 9-slice scaling for UI)
  • Layout algorithm (with support for flex elements)
  • Responsive scaling (for different sizes of screens)
  • Store state (for which slide you are on)
  • Conditionals (for showing the correct slide based on state)
  • Mouse input (for changing the slide when user clicks)
  • Domain specific language (for defining the contents of the slides and storing them)

Of course, the point is not only to blindly implement the bare minimum for these.
Each of these has been done so they support continued development and (hopefully) do not need to be returned to. For example, the last four items use DataScript to enable the future creation of arbitrary state and events. It’s not just a hardcoded variable for which slide we are on or a function for incrementing it.

Most of these are also backend agnostic so the layout function is pure CLJC files, as is the language implementation.

This could already be used to make a very simple CYOA style game. But this is not enough, so on we go to the second milestone.

2nd milestone: Cloak of Darkness

The second milestone is currently ongoing. The idea is to enable the things needed for a simple text adventure. For this, I will be using Cloak of Darkness as a benchmark. As stated on the IFWiki, the adventure is really basic and is designed to be easy to port to a given interactive fiction authoring system to see what it’s like. I am making one of those so this is a good spot to check how well it’s handled.

We need several new features to properly implement the game:

  • Widget state (hover and focus for buttons)
  • Entity notation (for defining the rooms and objects)
  • Text templates (for displaying current room description)
  • Loops (for listing carried objects)
  • Event system (incl. handlers and guards on player actions)
  • Undo, restart and restore (standard adventure state handling)

This should take us most of the way. But we still need polish and UX improvements so on we go to the third milestone.

3rd milestone: The Question

This mostly includes features that make the games look or sound better. For this the system should be able to handle The Question, the quickstart script for the Ren’Py visual novel engine.

I’m also adding some features not included in The Question and ignoring some it has.

Without further ado:

  • Music and sound (often neglected but important)
  • Shaders (for pizzazz!)
  • Transforms (see doc here)
  • Loading screen (to display during asset preloading)
  • Options menu (for volume at least)
  • Keyboard and gamepad support (including tab for changing UI focus)

Here the third item is doing most of the heavy lifting; the Ren’Py transformations include tween animations, image positioning and more.

There may be more items I want to add here as I go on. For example, I am unsure if I need a separate construct for longer “script” like sections like is typical for visual novels. But this should do for now.

Conclusion

As you can see from the above, the lists do not include a lot of possible features that you might expect, like 3D graphics, physics, animation, etc.
Like I said last time, making this type of thing you really want to focus on a specific type of game.

Here my focus is to support making turn based 2D games with relatively simple interfaces and high amounts of procedurality. If I wanted to make 3D or real-time games I would most likely choose an existing engine like Godot or Unreal and use that instead. On the other hand if I wanted to make interactive fiction that was mostly about an authored storyline with dynamic bits I would use something like Ren’Py or Ink.

But this is getting off-topic. I might make a separate post about this again, but I am done speaking about engines and plans for now. Hopefully next time I’ll be able to get into implementation details.

Until that time, hope you are doing well.