Novella

Type: Visual novel framework
Package: Divooka.Novella (Novella toolbox), in the Game Development workload of Divooka Compute; C# assemblies Novella.Core and Novella
Context: Procedural (Routine and Events graphs), dataflow (Flows and Function graphs), C#, and plain script folders
Design: RFC 170
Status: Iteration 1, the revamp. The engine, its script language, its Divooka package, the Explore examples and the sample game are in place for this iteration.

Novella is the visual novel framework of Parcel NExT. A game is data: a story of labels and statements, the definitions it refers to (characters, images, transforms, transitions, audio), a configuration and a theme. The same game runs from a folder of scripts, from a C# program, from a Divooka procedural graph, or from the preview of a Divooka dataflow graph, and it plays the same way in each.

Its feature target is parity with Ren'Py, the most widely used visual novel engine, so a writer who knows Ren'Py will recognise the script language at once. Its APIs and programming style are its own: conditions and assignments use a small, safe expression language, anything a story needs beyond that is a command implemented in C# or Divooka, and a game that wants Python can opt into it for blocks of real Python run through IronPython. A story need not be a script at all: C# and Divooka nodes write the same story data, conditions and changes to variables included.

Ways to make a game

Way	What you write	How it runs
A folder of scripts	.novella script files beside the game's images, sounds and fonts	NovellaPlayer run <folder>
C#	A NovellaGame, or a class derived from it, with the story in scripts, written with the C# story builder, or as a live script	game.Run() opens a window
Divooka	A Routine or Events graph that creates and runs the game, or a Function graph that describes it as data, down to its conditions, effects and scenes	Run the graph, or play a definition from its Custom Preview

The story itself can be written four ways: as scripts; in C# with the story builder, with no script; in C# as a live script, a procedure that is the story; and as Divooka nodes, functional (sequences, conditions, effects and scenes built as data) or procedural (a live script in an Events graph). All of them meet in the same place: whatever writes the game produces a story and its definitions, and the same runtime plays them. A script folder becomes a C# program with a few lines of code, a Divooka graph can load the same scripts from the document's own library, and scripts, built labels and scenes mix in one story.

define config.title = "The Garden"
character q "Qinglan" color "#c0392b" image qinglan

label start:
    scene bg garden with fade
    show qinglan smile at right with dissolve
    q "You came."
    menu:
        "I did.":
            q "Then sit with me a while."
        "I was passing.":
            q smile "Of course you were."
    return

Features

• A screenplay-like script language. Indentation makes blocks; dialogue is a speaker and a quoted line. Labels, jumps, calls with arguments, menus with conditions, if/elif/else, while, variables and persistent variables. See the script language reference.
• Images without bookkeeping. Image files are named from their paths (sprites/qinglan/smile.png is qinglan smile), a missing image is drawn as a placeholder so a story can be played before any art exists, and layered images combine outfits and expressions without a file per combination.
• The stage. Show, hide and scene with positions, z-order and layers; ATL-style animation timelines (properties, warpers, pauses, picture lines for frame animation, repeat, block, parallel, choice, time, on show/replace/hide, contains, function), which replay exactly after a load or rollback; images that animate themselves, such as a flickering candle; nearly fifty built-in transitions, from dissolve and fade to pixellate, irisin, pushleft and image dissolves through a mask.
• Text. Ren'Py's text tags (bold, colour, size, font, ruby for furigana and pinyin, {w}, {p}, {nw}, {fast}, {cps}), [variable] interpolation, NVL pages, centered text, side images and typing sounds.
• Sound and video. Music, sound, voice and ambience channels with fades, queues and looping, automatic voicing by line id, full-screen movies and movie sprites.
• Screens of the game's own. A screen language of boxes, grids, frames and scrolling viewports, if, for and use, screen variables, buttons, bars, text fields, timers and keys, laid out again every frame from the story's variables: an inventory, a status bar, a map, a riddle board. Shown over the story or called to ask the player something, written as a screen in a script, in C# or as nodes; a C# class for anything more.
• Keyboard, mouse and gamepad. Every screen, the game's own included, can be played from a gamepad as well as the keyboard and mouse.
• Python, if a game wants it. python: and init python: blocks run real Python through IronPython, with its standard library; what they set saves, loads and rolls back with the story, objects and dictionaries included, and the functions they define can be called from any expression.
• Every screen a player expects. Main menu, game menu, save and load with thumbnails, preferences, history, gallery, music room, achievements, about, help, confirmations and notifications, styled by a theme that is plain data and works without a single image.
• Stories without a script. A fluent C# story builder and Divooka nodes, each able to say what the script language says, from lines, menus, conditions and effects to animations, layered images, translations, screens and Python blocks; scenes, the configuration model of Novella One (a background, music, lines and where the story goes next); and Function graphs for logic the nodes cannot put together. All of them produce the same story a script would, so it saves and rolls back the same way; the one difference is that the arguments they pass to a label, a command or a screen are values fixed when the story is built, where a script's are expressions.
• Save, load and rollback. Every line, menu and input is a checkpoint; the player can roll back and forward, skip seen text, auto-forward, quick save and load, and a save restores the screen exactly, random draws included.
• Translation. Line-by-line and string translations written in the script itself, with the engine's own interface already translated into Simplified Chinese, Traditional Chinese and Japanese.
• Tools for writers. A lint that checks a story against its files, a developer console with a label warp, script reload while playing, and headless playthroughs that save a described screenshot of every step.

Pages

• Installation: where Novella comes from, in Divooka and in C#.
• Getting Started: a first game from a script folder, from C# and from Divooka.
• Concepts: stories, labels, scenes, characters, images, the stage, the runner, checkpoints, saves, stories written in code, live scripts, and the keyboard and gamepad controls.
• Script Language: the complete reference, with examples.
• Theming: every configuration and theme setting, fonts, nine-patch images and interface translations.
• Novella in Divooka: the toolbox, procedural and functional graphs, conditions, effects, scenes, animations and screens as nodes, logic in Function graphs, previews and embedded assets.
• Development: the C# API, the story builder, custom commands, screens as data and as classes, and headless testing.
• Examples: the Explore examples and The Red Thread, the sample game.
• Ren'Py Parity: what is supported, what is partial, and what is not there yet.

References

• RFC 170 - Framework - Novella: the design.
• DevLog 20250512 Visual Novel Game Framework (Highlights) by Charles Zhang (dev.to), on the first design, Novella One.
• DevLog 20250516 NovellaOne, A Visual Novel Game Framework - Early Introduction by Charles Zhang (dev.to).