← Journal

27 March 2026

A busy first month

The announcement

After a long period of behind-the-scenes work that started in 2024, itself born from various experiments in narrative system design, Loreline and the website you are reading this article on were finally made public at the end of February.

The feedback following my first post on Bluesky was very encouraging. It suggests that the language's syntax choices and documentation are well received, that they make people want to write, and that is a very good sign: it is motivating for what comes next!

Stories written with Loreline run (almost) everywhere

When Loreline was made public, it shipped with support for JavaScript, TypeScript, C# (including in Unity), C++ (on PC and Mac), Python and Lua (with LÖVE for example) to run stories written in .lor files.

That was already quite good, but this month, additional platforms were added:

• JVM / Java: Loreline now runs on the JVM, with a full Java API. This opens the door to Java, Kotlin, Scala, and frameworks like libGDX.

• Godot / GDScript: The Godot engine received special attention this month. A gdextension connects Loreline's C++ export, making it very easy to use with GDScript to add dialogue systems to any Godot game. Excited to see what the community will do with it!

• C++ on iOS and Android: Windows, Linux and Mac were already supported. Now, native libraries for iOS and Android are exported as well.

• SDL3: A cross-platform C++ sample was created using SDL3, covering Linux, macOS, Windows, iOS, and Android. It serves as a concrete starting point for anyone integrating Loreline into a C++ project without an engine.

With these additions, Loreline now covers a wide range of languages and platforms used in game development and interactive storytelling.

If you are wondering how so many targets can be supported without becoming unmanageable, take a look at the technical overview of Loreline.

The language keeps evolving

Alongside platform work, several improvements were made to the language:

• Ternary operator: Conditional expressions can now be written in ternary form condition ? if_true : if_false and inserted directly into text.

You're ${coffeesOrdered > 2 ? "fully awake" : "half asleep"}.

• Single-use choices: The - prefix marks a choice as single-use.

choice
  - An espresso, please.
    barista: Coming right up!
  - A green tea.
    barista: Good choice, I'll have that ready in a few minutes.
  Nothing for now.

This is the equivalent of choices prefixed with * in Ink

• Unquoted assignment: The := operator lets you assign text without quotes, staying closer to natural language.

weather := blue sky with a few clouds

// Equivalent
weather = "blue sky with a few clouds"

• Conditions on insertions: Choice insertions can now have a condition, making it easy to include or hide them based on the story's state.

choice
  + Recommendations if isRegular
  Coffee
  Tea

• Improved introspection: You can query the visit count of the current beat with beat_visits(), or that of another with BeatName.visits().

if beat_visits() == 1
  Welcome to the coffee shop!
else
  Good to see you again!

• Smarter quote handling: Loreline can now tell the difference between a string delimited by double quotes ("like this" which displays like this) and quotes that are part of the text itself. No need to escape quotes when they appear in dialogue, narrative text, or unquoted assignments.

"He's crazy!" // Displays: He's crazy! (no quotes in the text, like before)

"He's crazy!" she said. // Displays: "He's crazy!" she said. (with quotes)

\"He's crazy!" // Displays: "He's crazy!" (escaped when we really want the quotes)

barista: Want another "special" coffee?

proverbOfTheDay := "one coffee too many" is a myth

These improvements contribute to making the language more expressive, so that it adapts to the writer's needs and not the other way around.

What's planned next?

While there is plenty to be happy about with what has already been done, there are many more topics to tackle going forward:

Unreal Engine compatibility

Technically, you can already plug Loreline's native C++ build into Unreal, but it is not the simplest integration. To continue making Loreline compatible with the major game engines in use, the plan is to make it available as an Unreal Engine 5 plugin, usable with Blueprints. Once that is in place, Loreline will truly be compatible with all the major game engines out there!

An offline writing application

Currently, the best option for writing Loreline offline is with VS Code and its Loreline extension. It works well and is relatively easy to set up, but having a small dedicated application that provides syntax highlighting, a preview (like the one in the Playground), and an export of your story as an HTML file that anyone can read would be even better, right? The good news is that this is planned before the end of the year!

This application will be freely accessible to everyone, and will be the simplest way to use Loreline for writing interactive fiction.

Localization improvements

You can already translate your Loreline stories using .lor files. An upcoming update will add support for other common translation formats such as .po and .csv files, and it will be possible to test your translations directly from the VS Code extension or the upcoming offline application!

How to help?

Loreline is a project I use myself and in which I plan to invest considerably going forward. It is built with a level of quality that makes it viable for use in game studios and interactive fiction projects of all sizes. The language and runtimes are entirely free and open-source, while the VS Code extension and the upcoming standalone writing application will be permanently free as well.

In short, this is a fairly generous set of tools made available to the community, and a few simple forms of support are welcome, for example:

• You can star the project on its GitHub repository.

• Try Loreline in the Playground or with VS Code and spread the word if you like it.

• Share what you experiment with.

In the longer term

There is currently no way to financially contribute to the project, but a few options may be put in place when the time is right:

• An advanced application will be available as a one-time purchase (on Itch.io and Steam) at an accessible price, for creating complete narrative games on all platforms without a third-party game engine, and pushing Loreline's tooling and writing capabilities further, with or without your own game engine. This will be the most concrete way to contribute to Loreline's development.

This application will be the "supercharged" version of the free offline writing application mentioned above, and a way to support the project. The greatest care will be given to both versions of the application, tailored to different needs. The free option will always remain a solid solution for writing with Loreline, the advanced version will be for anyone who wants even more tools, or simply wants to support Loreline.

• If it ends up making sense, a page on a crowdfunding platform will be set up to allow regular support of the project. This support would remain entirely optional in any case, but could allow game development studios to actively support the improvement of Loreline, or even influence its direction based on the needs they express.

That's all (and that's already quite a lot) for now

This article gave a good overview of what has been done recently on Loreline, and the direction the project intends to take. Feel free to reach out or follow the project on Bluesky, share your feedback and talk about Loreline around you, but above all, happy writing!