# Nova: a Unity visual novel framework built around jumping back to any line

> Nova is a C# framework for building visual novels and text adventures in Unity, with dialogue and save systems written in Lua and running through ToLua#. Its defining constraint is that the whole dialogue and save design centres on returning to any previous line at any moment, and the maintainers are explicit that this makes Nova a framework or template rather than a plugin you can drop into an existing game.

**Lunatic-Works/Nova** — Programmer-friendly framework for visual novels (VN) / text-based adventure games (AVG) on Unity

- Repository: https://github.com/Lunatic-Works/Nova
- Stars: 724 · Forks: 95
- Language: C#
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/lunatic-works-nova

## What the sample project and its scripts actually contain

The usage instructions in the readme are short, and they are the clearest description of how a Nova project is laid out.

The first step is a clone, and the readme notes you can add a filter to save time:

```bash
git clone
--filter=blob:none
```

The second step is to change the Unity version number in ProjectSettings/ProjectVersion.txt to your own version. The third is to open Assets/Scenes/Main.unity in the Unity Editor, run the game, and play the sample work Colorless through once. The fourth is to work through the tutorial in the game itself, while trying to modify the scripts, which are the tut01.txt files and similar under Assets/Resources/Scenarios/. Pressing Ctrl on the chapter selection screen reveals further test scripts.

That last detail tells you something about how the project is meant to be learned. The tutorial is not a document you read, it is a chapter of the sample game that you play, and the scripts are plain text files in the project that you can edit while playing. A developer who wants to see how a feature is implemented is expected to open the txt file next to it.

The repository layout supports that. There is an Assets/ directory at the top, alongside Packages/, ProjectSettings/, Tools/, a Doxyfile for generated documentation and a run-tests.ps1 script.

## The design decision that makes Nova a framework, not a plugin

The readme answers the difference between Nova and other galgame engines with a question, and then answers the question about combining it with other genres. The answer is the single most important thing to understand about the project.

Nova's dialogue and save systems are essentially built around the feature of being able to jump back to any previous line of dialogue at any time. And because of that, adding some gameplay to Nova is also difficult.

The readme puts it plainly: most gameplay that Unity can do can be added to Nova, but adding Nova to other games is difficult, and Nova's positioning is a framework or template rather than a plugin or extension package.

That is a coherent position rather than a limitation being excused. A framework that owns the dialogue state machine and the save format can guarantee that jump-back works everywhere, including into a save file written three hours earlier. A plugin bolted onto an existing game cannot promise that, because the other game's own state management does not know about the dialogue history.

The corollary is stated too. If your game does not need that feature, you may not need Nova. That is a real filter for anyone evaluating it, and it is worth applying before you clone anything.

## Unity versions, target platforms, and the WebGL Lua caveat

The platform question is answered in detail, and the answers contain several genuine caveats.

On Unity versions, Nova supports Unity 2020 to 2022. Unity 6 requires compatibility mode, and the maintainers invite help with migrating to the render graph.

On platforms, Windows, macOS, Android and iOS are supported, with works already published on Google Play, TapTap and the App Store. Linux builds run on Steam Deck, though other distributions are not guaranteed, because the number of Linux graphical environments varies, and issues are welcome. WebGL is theoretically supported but needs more testing, and there is a specific reason for the difference: on WebGL the ToLua# native plugin uses Lua 5.1.5 rather than LuaJIT, so some behaviours differ, and the maintainers welcome help compiling LuaJIT to WebGL. Publishing to IPFS is supported, with an example link given. OpenHarmony compilation is theoretically possible through the Chinese Unity distribution, but it requires recompiling the ToLua# native plugin.

So there are four solidly supported targets, two conditional ones, and one with a documented behavioural difference that could bite you if your script depends on LuaJIT specifics.

## The dependency set and what it implies for your script language

The dependencies are listed explicitly, and they explain most of the framework's character.

The scripting layer is ToLua#, the Lua binding for Unity. The data layer is Newtonsoft Json. The UI list rendering uses Loop Scroll Rect, which is a virtualised list component, and that choice is not incidental for a visual novel with long backlogs.

The ToLua# dependency is the one with the widest consequences, and it is why the WebGL note about Lua 5.1.5 rather than LuaJIT matters. Your scripts are Lua, the runtime is Lua, and the binding is a native plugin in the project. That is what makes the scripts editable as plain txt files inside the Unity project, which in turn is what makes the in-game tutorial possible. The trade-off is the one the maintainers spell out: a native plugin has to be recompiled for any platform where the default binary is not available, which is the stated reason OpenHarmony needs extra work and the stated reason WebGL runs a different Lua build.

The three dependencies are all open source projects with their own licences, and a team shipping a commercial title will need to review the terms of each of them alongside Nova's own MIT licence.

## Localisation, the Chinese and English script split, and the tooling

The sample project ships in two languages, and the readme explains what you have to do if you want to keep only one.

The scripts live in Assets/Resources/Scenarios/. The English versions are under Assets/Resources/LocalizedResources/English/Scenarios/, and Assets/Resources/LocalizedResourcePaths.txt records which files the English version uses. If you modify the Colorless scripts, you need to delete the English ones first, otherwise the Chinese and English scripts will not line up.

That is a small instruction with a large implication. A Nova project's script set is a directory of text files with a parallel localised copy and an index of which localised files exist, and the engine matches them by path. Any tool that edits scripts, and any translator workflow, has to respect that arrangement.

The tooling is a VS Code extension, vscode-nova-script, maintained alongside the framework. So the intended authoring loop is a plain text file in a text editor, with the game as the runtime, which is a familiar loop for anyone who has written Ren'Py or any text-driven game, and it is why the project describes itself as programmer-friendly rather than as a no-code tool.

The default user interface is deliberately plain, on the reasoning that every work tends to need a UI that matches its own theme, so customising the UI with any method Unity offers is expected rather than optional.

## Version history, the shipped works, and where the project is going

The version notes describe four stages, and each maps to a Unity version rather than to a feature list.

Version 0.1 was compatible with the first commercial title the team shipped, at v1.1.0 of that game. Version 0.2 added Unity 2019 compatibility along with asynchronous GameState support, minigame support, a new script parsing system and a new save system. Version 0.3 brought Unity 2020, URP support, a new character portrait composition system and the Input System. Version 0.4 is rolling along on the master branch, with a new dialogue box among the notable features and Addressables listed as expected.

The list of works made with the framework is long, with nine titles linked on Steam, each listed with its own store page. That is the most concrete evidence available of what the framework can carry, and it covers the range from commercial releases to smaller experiments.

The project is MIT licensed. The last push to the repository was on 2026-08-01, and there are no GitHub releases, so the version that is in use is the state of the master branch rather than a tagged artefact.

There is also a successor in progress. The readme points to Nova2, a Godot implementation, with an open issue and an invitation to help, and the accompanying slogan in the readme is blunt about the reasoning.

## Conclusion

Adopt Nova if you are making a visual novel in Unity from scratch and want dialogue, saves, localisation and a working sample project to build on, since the framework already ships the parts that take a team months to get right and the sample work Colorless gives you a complete reference implementation. Do not adopt it if you want to add Nova to an existing puzzle or tactics game, because the project says plainly that Nova is positioned as a framework or template rather than a plugin, and the jump-back-to-any-line design makes adding other gameplay difficult. Before you start, check your Unity version against the supported 2020 to 2022 range, since Unity 6 needs compatibility mode, and decide early whether your story needs that jump-back feature at all, because the maintainers say you may not need Nova without it.

## FAQ

### What is the Nova visual novel framework for Unity?

Nova is a programmer-friendly framework for visual novels and text based adventure games built on Unity, with C# for the framework and Lua for the scripts, run through the ToLua# binding. It ships a sample project called Colorless with playable in-game tutorials and plain text script files.

### Which Unity versions and platforms does Nova support?

Unity 2020 to 2022, with Unity 6 requiring compatibility mode. Windows, macOS, Android and iOS are supported, Linux runs on Steam Deck, WebGL is theoretically supported but needs more testing, and OpenHarmony requires recompiling the ToLua# native plugin.

### Can Nova be used inside an existing puzzle or tactics game?

Not easily. The readme states that Nova's positioning is a framework or template rather than a plugin or extension package, because its dialogue and save systems are built around jumping back to any previous line of dialogue, and adding gameplay to Nova is also difficult for the same reason.

### Which Lua version does Nova use on WebGL?

On WebGL the ToLua# native plugin uses Lua 5.1.5 rather than LuaJIT, so some behaviours differ. The maintainers say they welcome help compiling LuaJIT to WebGL.

### How do I start using the Nova framework?

Clone the repository, change the Unity version in ProjectSettings/ProjectVersion.txt to your own, open Assets/Scenes/Main.unity in the Unity Editor, run the sample Colorless, then work through the in-game tutorial while editing the scripts under Assets/Resources/Scenarios/. The GitHub Wiki holds the rest of the documentation.

## Sources

- [Issues](https://github.com/Lunatic-Works/Nova/issues)
- [License: MIT](https://github.com/Lunatic-Works/Nova/blob/master/LICENSE)
- [Lunatic-Works/Nova on GitHub](https://github.com/Lunatic-Works/Nova)
- [README](https://github.com/Lunatic-Works/Nova/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lunatic-works-nova