Tools for creating visual novels

In a previous article, we reviewed some of the tools available to create your game's storyline. In this one, we’ll look at some of the tools you can use to turn that storyline into one of the simplest and most addictive types of games: visual novels.

Visual novels are a genre of video games that focus on interactive storytelling, where the player makes decisions that affect the narrative. They typically feature static visual art (such as 2D or 3D character illustrations) and are presented as a combination of text, images, and sometimes music or voice acting. Gameplay mainly involves reading dialogue and descriptions, making choices at key moments, and occasionally solving small puzzles.

It’s a technically simple genre, but it requires a strong, complex storyline that hooks the player despite the simplicity of the gameplay mechanics. That’s why these games must offer deep narratives with complex stories that often have multiple endings, depending on the player’s choices.

Conceptually, this type of game should feel familiar to anyone who grew up reading “Choose Your Own Adventure” books. Visual novels are the video game counterpart of that book category. As video games, they first gained popularity in Japan but have since spread worldwide thanks to gaming platforms like Steam and itch.io.

You can find examples of this genre in games like Phoenix Wright: Ace Attorney, The House in Fata Morgana, or Fate/stay night.

This makes visual novels a very interesting genre if you have the ability to create a captivating story and can support it with good illustrations and fitting sound, but lack the resources required for other types of games (such as programmers, animators, modelers, or visual effects specialists).

In this article, we’ll explore some of the tools you can use to create a visual novel using only those three ingredients—story, illustrations, and sound—while minimizing (or completely eliminating) the need for other skills, such as programming.

Ren'Py

Ren'Py is a free and open-source development engine specifically designed for creating visual novels and interactive narrative games. It’s one of the most popular tools for this genre, especially among indie developers, due to its ease of use, flexibility, and active community.

Ren'Py logo

Once installed, it works by creating text files with the .rpy extension. These files use a combination of Ren'Py’s own scripting language (similar to Python) and standard Python. Ren'Py scripting is intuitive, with simple commands for dialogue, choices, and transitions, while Python allows for more advanced customization. The result is highly self-descriptive text files that often read almost like natural language.

To work with these text files, you can use any editor or the one integrated into the Ren'Py environment, which also offers real-time preview, speeding up development. It’s a tool that allows you to create visually appealing visual novels without needing deep technical knowledge.

To enrich the storytelling, it supports images (PNG, JPG), animations, transitions, music, and sound effects. It also allows for character sprites with variable expressions. It includes an automatic system for saving games and checkpoints.

The integration of Python within the engine allows developers to create custom menus, point systems, mini-games, or unique mechanics using Python.

To reach the widest possible audience, Ren'Py lets you create multiple translations of your games and export them to various platforms, including Windows, macOS, Linux, Android, iOS, and web browsers.

Ren'Py’s website features detailed official documentation, and there are also plenty of forums, templates, tutorials, and community-shared assets to enhance and simplify game development with this engine.

Thanks to all these advantages, Ren'Py has been used to develop hits like Doki Doki Literature Club, Katawa Shoujo, and Long Live the Queen.

Of all the options we’ll cover in this article, this is the one I recommend by default. It’s hard to go wrong with it. And since it’s free, the experiment won’t cost you anything. Only if this engine falls short for some reason would I consider the other options I’ll now describe.

Tyrano Builder

TyranoBuilder is a visual novel development software based on a drag-and-drop interface, ideal for those who prefer to avoid programming or who want an intuitive interface. It allows you to create interactive games with dialogue, images, music, and choices without writing code, although it offers advanced options for those who want more customization.

Tyranno Builder logo

Its typical workflow involves using its visual editor to build your visual novel by adding “components” (like dialogue, images, sounds) from a menu. If you want to add advanced features, custom game mechanics, or complex effects, you can use TyranoScript, a scripting language heavily based on JavaScript. Its main advantage over Ren'Py is this visual component that lets you create simple stories without writing anything resembling code. However, once you cross a certain threshold and want to do more sophisticated things, you’ll have to use TyranoScript, which I find a worse option than the Python offered by Ren'Py.

It supports multiple image and audio formats, as well as video (for cutscenes or transitions). To enhance the game visually, the tool allows basic effects like fades, character movements, zooms, or transitions. It also supports “speech bubbles” to bring the dialogue style closer to comics.

As with any visual novel, the gameplay mechanics you can implement with this tool are based on displaying dialogue with text and character names. These dialogues are adjustable in speed and style. The tool allows you to create choices that branch the story based on the player’s decisions. These branches can be enriched with simple variables (without code) to track choices or unlock content.

The tool’s editor lets you test the game as it takes shape, making it extremely fast to reach a functional prototype and then a final version.

The resulting game can be exported to Windows, Mac, HTML5, and mobile devices, both iOS and Android.

TyranoBuilder is not free, although its cost is very low (around €15) and is a one-time purchase. It has plugins to extend its functionality, although most of them seem to come from Japan, where this tool appears to be especially popular.

It has a community, but it’s much smaller than Ren'Py’s, making it harder to find tutorials for it, especially in Spanish. The official website tyranobuilder.com and discussions on Steam offer support, but they’re not as extensive. YouTube tutorials (in English) are helpful but less abundant.

Unlike Ren'Py, TyranoBuilder doesn’t have any major hit games to its name. It’s more common in lesser-known indie projects published on platforms like Itch.io.

In general, TyranoBuilder is used by creators who want quick results without programming. Which is perfectly fine if that’s your case. Just keep in mind that if you want to make your game more sophisticated, Ren'Py is probably the better choice.

Visual Novel Maker

Visual Novel Maker (VNM) is a commercial software developed by Degica (the creators of RPG Maker) specifically designed to create visual novels.

Visual Novel Maker logo

Like TyranoBuilder, it combines a drag-and-drop visual interface with scripting options (JavaScript), making it accessible to beginners but also allowing customization for more advanced users. In this sense, it’s very similar to TyranoBuilder, but it has several distinctive capabilities.

To start with, it integrates support for Live2D animations, which allow characters to have fluid movements and dynamic expressions (like blinking, head movements, or gestures) without external setups. This is ideal for projects with a more professional or visually dynamic focus.

It also offers a real-time preview feature that lets you quickly test changes, even in large projects. This speeds up the design and correction process, reducing frustration during creation. TyranoBuilder also has a preview feature, but complaints about its slowness and other issues (like delays or bugs when previewing complex scenes) are common.

The visual editor is more sophisticated than TyranoBuilder’s and lets you implement more complex mechanics (like variable systems, conditions, or advanced transitions) without programming. For example, you can set up point systems or conditional choices directly in the interface. It’s true that TyranoBuilder allows the same functionalities, but to do so you have to use TyranoScript.

Another advantage is that Visual Novel Maker comes with several pre-installed assets (images, music, etc.) that can be useful for building your prototypes.

Additionally, the general consensus is that Visual Novel Maker’s user interface is polished and modern, with a design inspired by RPG Maker. If you’re already an RPG Maker user, you’ll feel right at home. Another connection to RPG Maker is that it offers compatibility with certain plugins and resources from that tool, which can be useful if you plan to incorporate RPG elements or use assets designed for that platform.

The visual effects it can offer from the visual editor are much more advanced than TyranoBuilder’s, which needs scripting to achieve similar results.

It exports to Windows, Mac, Linux, Android, iOS, and browsers (HTML5). Exporting to mobile requires additional setup (like Android SDK or Cordova), which can be complicated for beginners.

As for the community, it’s small, although perhaps slightly larger than TyranoBuilder’s thanks to RPG Maker’s popularity.

The conclusion is that with Visual Novel Maker, it’s easier to achieve a professional look for your visual novel compared to TyranoBuilder. Of course, everything comes at a price, and Visual Novel Maker’s is higher (around €60) than TyranoBuilder’s (€15), although it’s still a one-time purchase.

In the end, if budget isn’t an issue and you have good artists who can take advantage of the Live2D functionality, Visual Novel Maker is the safest option.

Is it worth it compared to Ren'Py? Well, Ren'Py is free. It doesn’t come with preloaded assets, but its community is so huge that it’s easy to find all kinds of assets and plugins. It’s true that Ren'Py is based on text files, but that can be an advantage if you plan to work in a team using a code repository. On the other hand, I’m a convinced hater of JavaScript (sorry, it’s just a language I can’t stand, and I’ve given it plenty of chances), while Ren'Py’s use of Python seems ideal to me. It’s true that Ren'Py doesn’t offer Live2D animations out of the box, but its community comes to the rescue, and thanks to it, there’s a plugin that allows it, with even greater control over effects and transitions thanks to Python. Perhaps the biggest advantage of Visual Novel Maker is its preview feature that lets you test changes quickly without exporting the game, while Ren'Py has to run the full game, although you can jump to specific sections using tags, which is less convenient.

Tools for Developing a Video Game's Storyline

The importance of the storyline depends on the type of game and its target audience. There are games like Tetris or Among Us, where the narrative is minimal and the fun lies in the mechanics. These types of games do not require a complex storyline.

However, the storyline is a fundamental pillar of the experience in narrative, RPG, or adventure games. In these games, the storyline is important for multiple reasons. A good storyline creates a believable world and characters with whom players can empathize, increasing immersion. Well-developed stories generate emotions, motivating players to continue to discover what happens next. The storyline provides a narrative framework that gives meaning to the player's actions. Without a story, the mechanics can feel empty or repetitive. For example, in games like The Last of Us, the storyline drives decisions and gives emotional weight to the mechanics. A solid narrative offers clear objectives and reasons to move forward, whether it's saving a world, avenging a character, or unraveling a mystery. This keeps interest high, especially in long games. In a saturated market, an original or well-executed storyline can make a video game stand out from others with similar mechanics. Titles like Hollow Knight or Disco Elysium are examples where the narrative elevates the experience. A storyline with branches, moral choices, or multiple endings (as in Mass Effect or The Witcher 3) encourages replayability, as players want to explore different outcomes.

Therefore, the process of developing the game's storyline is as important as programming or asset modeling. In this article, we will look at some specialized tools that can be useful for creating the storyline of our game, as well as designing its dialogues.

Obsidian

Obsidian is a note-taking and knowledge management application designed to create and organize content through interconnected notes, using a Markdown-based system and a "knowledge graph" approach that visualizes relationships between ideas. Although it is not specifically designed for video game development, its flexibility, customization, and ability to handle large amounts of information make it a valuable tool for writers, narrative designers, and developers working on story planning, lore, scripts, and project documentation.

Obsidian Logo

Obsidian stands out as a lightweight and versatile solution for pre-production and organization, especially for indie projects or small teams. Each note can be linked to others via bidirectional links (similar to a personal wiki). Its graph view shows visual connections between notes, making it easier to explore complex ideas. Therefore, it is an ideal tool for mapping relationships between characters, events, and quests.

When editing, you have two main modes: a plain text editor using Markdown formatting, and a Canvas mode that offers a visual canvas to connect notes with arrows, similar to an idea board. When creating a new note, links to other notes are made using Markdown links. In Canvas, you can create two types of nodes: cards, which are small nodes with just a title, and notes that contain full Markdown text (you can even import a separately created note). Ultimately, Canvas is a visual space to organize notes as connected nodes, ideal for mapping branching stories or narrative flows.

Editing notes in Obsidian

Obsidian canvas mode

A possible workflow could be brainstorming and collecting loose ideas in notes, then structuring them in a Canvas. Additionally, outside of Canvas, if you need a high-level view of all your notes, you can open the graph view that shows a note’s tree and its links to other notes.

Another powerful feature is the ability to tag elements, which facilitates advanced searches using Boolean operators.

By default, Obsidian saves everything locally in plain text files, ensuring portability and low resource consumption. These files can be exported to Markdown, HTML, PDF, or Word. It syncs with Dropbox, iCloud.

Obsidian is free, but if you want synchronization across all your devices, you’ll need to pay a small subscription. If you want to publish notes on the Obsidian Publish website, another subscription is required.

All of the above already makes it a very interesting option for what we’re looking for in this article, but additionally, Obsidian has a hyperactive community on forums, Discord, and Reddit, where they offer templates, examples of specific workflows (e.g., for video game narrative). This activity has already produced more than 2,600 community plugins, such as:

• Dataview: Creates dynamic tables to manage characters, quests, or items (e.g., “show all NPCs with status ‘ally’”).
• Obsidian Tasks: Task tracking for development planning.
• Kanban: Boards to manage sprints or milestones.
• Excalidraw: Drawings for storyboards or maps.

In the end, no two Obsidian installations are alike. Each user customizes it with multiple plugins to suit their particular tastes, making it a tremendously powerful tool.

Ink

Inkle Studios is an independent video game development studio. They specialize in interactive narrative games, i.e., titles focused on branching stories, player decisions, and non-linear narratives, where text and user choices are key elements to advance the plot.

Their work is not limited to video games; they have also created tools for development. Among them is Ink, an open-source narrative scripting language (under MIT license), specifically designed to write highly branching stories in games. Ink is not a traditional programming language but a simple and elegant markup that allows writers and developers to create dialogues, choices, and complex plots efficiently. Ink integrates easily with engines like Unity (via a free plugin), Unreal Engine, and Godot, and has been adopted by both large and independent studios.

Ink logo

To put it simply, Ink is what the authors of the popular “Choose Your Own Adventure” book series would use today to write their stories. With it, you can offer choices to the reader and let the story branch out as those choices unfold.

Ink offers an easy-to-learn syntax for non-programmers but is powerful for advanced structures (like loops, lists, and conditional logic). It is also very lightweight, so the workflow is fast, allowing you to see changes almost as you write.

Ink syntax

All these advantages have led to its widespread use in many games (Haven, NeoCab, Sable, Sea of Thieves, The Banner Saga 3, for example) and there are plenty of online resources to learn how to use it.

To make its use even easier, Inkle also offers a free editor called Inky, available on the same page as Ink. It’s a minimalist editor that offers a preview window where you can test the options and branches you write. It also alerts you to Ink syntax errors you make while writing. It has versions for Windows, Linux, and Mac. And finally, most importantly, it allows you to export to JSON so you can load all the story information into the game you’re developing.

Inky logo

Twine

Twine is a free and open-source tool designed to create interactive fiction and text-based narrative games, especially non-linear stories where player choices determine the course of the narrative. Created in 2009 by Chris Klimas, it is widely used by both beginner developers and professionals in video game development, creative writing, education, and artistic projects. What it offers is similar to Ink, in the sense that it allows you to create interactive stories in hypertext format, where the player navigates through text nodes (called “passages”) connected by links. Each passage contains text, options, and optionally, code to handle logic, variables, or multimedia.

The downside is that there is no clear and easy path to import the story into a game engine (as there is with Ink), so Twine is more suitable for shaping the game’s script or creating a very simple prototype to show possible branches of the script.

Twine logo

Twine is known for its simplicity, accessibility, and flexibility. Its visual editor allows you to drag and connect nodes, creating a map of the narrative. It also has a code mode to customize game logic.

Interactive stories created in Twine are published as HTML files, playable in web browsers, making them highly portable. They can also be exported to other platforms with additional tools. The output files can be dumped into various supported formats for further processing and customization of the story.

Using a visual editor makes text editing much easier than in Ink. Ultimately, writing is limited to typing text and adding simple links (e.g., [[Go to the cave]]) to connect passages. Although you can also use JavaScript and macros for more advanced features.

Twine editor

With all this, you can create highly branching stories, from “choose your own adventure” tales to complex narratives with variables (e.g., health points, inventories) and conditional logic.

The tool and its code are available under the open GPL-3 license. It can be used online (twinery.org) or downloaded for Windows, macOS, and Linux. It also has an active community, tutorials (like those on twinery.org), forums, and templates on platforms like itch.io. There are also extensions and add-ons created by the community.

Yarn Spinner

Yarn Spinner is a tool originally developed by the Australian studio Secret Lab (creators of Night in the Woods), although part of the team later split from the video game studio to focus on developing the tool, becoming known by the same name.

Halfway between Ink’s scripting language and Twine’s visual tool, it uses a simple scripting language called Yarn, inspired by formats like film or theater scripts, which allows you to write dialogues in plain text with flow control elements, variables, and commands. Then, a plugin integrated with the engine acts as an interpreter that executes these scripts during gameplay, sending dialogue lines, options, and commands to the engine.

Yarn Spinner webpage cover

Some games made with Yarn Spinner include Night in the Woods, A Short Hike, DREDGE, Lost in Random, Frog Detective, Button City, and Escape Academy.

For script editing, they have a Visual Studio Code extension that offers a text editor with highlighting to create Yarn scripts, as well as a graph window to view story branches.

Yarn Spinner extension for Visual Studio Code

They also have a website where you can edit and test simple scripts.

The main advantages of Yarn Spinner are:

• Narrative Flexibility: Supports highly branching stories, with memory of previous choices (by default), storylets (dynamic content based on salience), and groups of nodes/lines for organization.
• Customization: Integrates multimedia (images, audio, video) via commands. Includes pre-made UIs (e.g., dialogue bubbles, option wheels) and samples for customization.
• Localization: Robust support for translations, extracting strings to separate files (e.g., JSON or CSV) for tools like Unity Localization or I2 Localization, facilitating multilingual workflows.
• Debugging and Tools: Errors with line numbers, browser preview, and voice-over support (line synchronization). Active community on Discord and GitHub.

If you use Unity, you’re in luck, because it’s the only engine with an official integration plugin. The plugin code for Unity is available on GitHub under the MIT license, so you can download and install it in Unity for free. Another option is to use the Unity Asset Store to purchase the Unity plugin; the cost is not very high and helps fund the tool’s development. They also offer other Unity add-ons, such as one that displays conversation text in comic-style bubbles, and another that allows decisions to be made using a selection wheel.

There are also plugins for Unreal and Godot, but they are still in Beta and not recommended for production.

Articy Draft

Articy:draft (now primarily known as articy:draft X in its latest version) is a professional tool for narrative design and interactive content organization, developed by Articy Software GmbH, a German company founded in 2009.

It is a visual software that acts as a centralized database for creating, managing, and planning branching stories, dialogues, quests, characters, and other narrative elements in interactive projects, with a special focus on video game development. Unlike pure scripting tools like Ink or Yarn Spinner, Articy:draft is more of an integrated visual environment (similar to a "narrative CMS" or content management system for games), combining story flow editing, object databases, and team collaboration.

Articy Draft logo

It is widely used in the industry by indie and AAA studios to handle complex narratives and has been key in titles such as Disco Elysium, Suzerain, HipWitch, Saint Kotar, Garden Scapes, and Spell Force III.

It features a non-linear visual editor for designing interactive content, unifying specialized editors (for dialogues, quests, objects, locations) into a single interface. It allows graphical representation of game entities (such as NPCs, items, or quests) with automation, variables, and conditional logic, acting as a "visual frontend" for game data. It does not generate executable code directly but exports structured data for integration into game engines.

Articy Draft visual editor

It uses nested views (Flow View) to map high-level stories (chapters) to fine details (dialogue lines). It includes a flexible template editor for game objects, a simulator to test logic (with voice and localization support), and tools such as a vector location editor to plan 2D maps.

Views nested in Articy Draft

It offers a simulation mode that plays the story with voice, languages, and logic, ideal for iterating before exporting. The simulation mode allows checking the evolution of variables linked to dialogues and choices, as well as the effect these variables have on the story path.

Articy Draft simulation mode

Other additional tools include a storyboarding panel; a location editor (useful for planning levels or quests); voice-over support (TTS generation for prototypes and synchronization); integrated localization (exports strings for translation and reimports); and AI extensions to generate dialogues, images, or automatic translations (e.g., with DeepL).

Storyboarding in Articy Draft

Location editor

It also serves as a database to store the configuration of all NPCs and game objects. The idea is that game designers can manipulate the data from the Articy Draft interface, then export all the data at once and load it from the game engine.

Assets and character database in Articy Draft

Regarding integrations with game engines, Articy Draft has official assets to integrate with both Unity and Unreal. For other engines, Articy Draft also allows export to XML and JSON. If that’s not enough, they also offer a NuGet package to build your own integration package.

Articy Draft follows a subscription licensing model but has a free version, with all functionalities, which can even be used for commercial projects, with the only limitation of a maximum of 700 objects per project. Still, that object count is very generous and probably more than enough for most medium and small projects. In any case, it’s more than sufficient to try the tool and decide if it’s worth it. If you need more than 700 objects in your game, you can opt for any of the paid licenses (individual ones are quite affordable).

Dialogic

The previous tool only had direct integration with Unity and Unreal, so to balance things out, now we’ll talk about one that exists only for Godot: Dialogic.

Dialogic is a plugin for Godot aimed at creating interactive dialogue systems, visual novels, RPGs, and character management. Initially developed by Emilio Coppola in 2021 as a solution to easily add branching conversations, it has evolved into a mature and popular tool in the Godot community, especially for indie developers looking to integrate complex narratives without writing extensive code from scratch. It is available under the MIT license, allowing free commercial use and modifications.

Dialogic logo

It provides an integrated editor in Godot to design "timelines" (dialogue timelines), which are sequences of events such as text, player choices, animations, logical conditions, and signals. These timelines run during gameplay to display dynamic conversations with branches, events, and choices. Conditions (if/else with variables), signals (for in-game triggers), animations, and backgrounds can be added to these conversations.

Dialogic timeline editor

It includes a character management system with portraits, expressions, and custom colors, and supports extensions for custom events.

Dialogic character editor

Visually, it is fully customizable, with editable themes (colors, fonts, text bubble styles), audio support (voice-over, SFX), animations (e.g., screen shake), and custom events with minimal GDScript code. It includes pre-made styles like "text bubble" for visual novels.

It also supports localization, allowing integrated translations with translatable glossaries.

It has a very active community that has created extensions to interact with other plugins like SmartShape2D for terrain or Godot Steamworks for achievements.

If you’re developing with Godot, Dialogic is the simplest and most cost-effective option since it’s packed with features, well-tested in many Godot games, and free.

Scrivener

All the previous tools, except perhaps Twine, consider some level of integration or compatibility with game engines. Scrivener is something very different. It is a tool 100% designed for writers and screenwriters.

Developed by the company Literature & Latte, although not specifically created for video game development, it is a versatile tool that can be extremely useful for writing and structuring video game scripts, especially for narrative projects like RPGs, graphic adventures, visual novels, or any game with branching stories.

Scrivener logo

It takes the form of an advanced word processor and project management tool that combines writing with note organization, research, and non-linear structuring. It allows dividing a project into manageable sections (chapters, scenes, etc.), managing reference materials (images, PDFs, notes), and exporting in multiple formats. Additionally, each piece of content created with Scrivener can be enriched with metadata, notes, tags, and references.

To plan narrative arcs, it offers a corkboard-like visualization mode where each section is displayed as a card.

Scrivener corkboard

The entire interface is very flexible, and by using it properly with tags, you can configure timelines to develop parallel storylines.

Scrivener timelines

Don’t expect formatting tools. In that sense, Scrivener is very simple, almost primitive. It’s actually designed to focus on generating content and then exporting it for formatting in other tools. For example, many people configure Scrivener to export the generated content to LaTeX and then, from a LaTeX editor, export to PDF with the formatting of the chosen LaTeX template.

Therefore, Scrivener is an excellent tool for writing and organizing a video game script in the pre-production phase, especially for structuring complex narratives and keeping lore organized. However, it is not designed to simulate interactivity or integrate directly with game engines, so you’ll need to combine it with tools like Twine (for quick prototypes), Dialogic (for Godot), Yarn Spinner (for Unity), or Articy:draft (for AAA projects). If your focus is writing a detailed script before technical implementation, Scrivener is a great choice; if you need immediate interactivity, opt for a tool specific to video games.

C# Interfaces and the Unity Inspector

In C#, an interface is a contract that defines a set of methods, properties, events, or indexers that a class or structure must implement, without providing the actual implementation. It's like a blueprint that specifies "what" must be done, but not "how". When a class adheres to an interface, it publicly commits to providing at least the methods defined by that interface. Therefore, the class must implement the code for each of the interface's methods.

Interfaces in C# offer several advantages that make them fundamental in software design. The main ones are:

• Abstraction: They define a contract without implementation details, allowing focus on "what" an object does, not "how" it does it.
• Flexibility and extensibility: They make it easy to add new classes that implement the same interface without modifying existing code.
• Multiple inheritance: They allow a class to implement multiple interfaces, overcoming C#'s single inheritance limitation. A class can only inherit from one base class but can implement several interfaces simultaneously.
• Decoupling: They reduce dependency between components, promoting modular design and facilitating dependency injection.
• Maintenance and testing: They simplify replacing implementations (e.g., in unit tests with mocks) by working with contracts instead of concrete classes.
• Consistency: They ensure that classes implementing the interface adhere to a standard behavior, improving interoperability.
• Support for design patterns: They are essential in patterns like Strategy, Factory, or Repository, which rely on abstractions.

All this is better understood with examples. In my case, I developed an abstract class called SteeringBehavior, which implements the basic functionality for the movement of an intelligent agent. Many child classes inherit from it and implement specialized movements.

The abstract class SteeringBehavior

Some (not all) of these child classes need a target to calculate their movement—whether to reach it, pursue it, look at it, etc. That target is defined with a Target field.

I could have included that field within the definition of the child classes, but that would have reduced flexibility. The problem arises when chaining SteeringBehavior classes. Some SteeringBehavior classes provide their functionality by composing the outputs of simpler SteeringBehavior classes. The flexibility of this approach comes from being able to build the dependency tree of the different SteeringBehavior classes in the inspector.

An agent built by composing several SteeringBehavior classes

Inspector references to child SteeringBehavior classes

There are some SteeringBehavior classes for which we know exactly the type of child SteeringBehavior they will need. In the screenshot above, you can see that ActiveWallAvoiderSteeringBehavior specifically needs a child of type PassiveWallSteeringBehavior. But there are also cases where the parent SteeringBehavior doesn't care about the specific type of the child, as long as it inherits from SteeringBehavior and provides a Target field (to pass its own Target field to it). In the screenshot, I passed a SeekSteeringBehavior, but I could have passed an ArriveSteeringBehavior or a PursuitSteeringBehavior to get slightly different movement types. If I had implemented the Target field through inheritance, I would have lost the flexibility to pass any type of SteeringBehavior with a Target field, being forced to specify the concrete type, child of SteeringBehavior.

Instead, I created an interface.

The ITargeter Interface

As shown in the screenshot, the interface couldn't be simpler. It's declared with the interface keyword and, in this case, simply states that classes adhering to this interface must provide a Target property.

A class adhering to this interface only needs to implement that property.

A class implementing the ITargeter interface

As shown in the screenshot, the SeekSteeringBehavior class inherits from SteeringBehavior and also implements the ITargeter interface.

You may notice some overlap between abstract classes and interfaces. Although both are abstraction mechanisms, they have important differences in purpose and use. An interface defines a pure contract with method, property, event, or indexer signatures, without any implementation. It's ideal for specifying behaviors that different unrelated classes can share. An abstract class, on the other hand, is a class that cannot be instantiated directly and can contain both abstract (unimplemented) and concrete (implemented) members. It serves as a base for related classes that share common logic. In general, if you want to provide common behavior to related classes through a base class, you'd use abstract classes (possibly making the base class abstract); whereas if the common behavior occurs in heterogeneous classes, interfaces are typically used.

While an abstract class can include concrete methods, fields, constructors, and shared logic that derived classes can use directly, an interface cannot include method implementations or fields (only from C# 8.0 onward does it allow default methods, but with restrictions—generally everything must be implemented by the adopting class). Additionally, abstract classes allow access modifiers (public, private, protected, etc.) for their members, while in an interface all members are implicitly public and access modifiers cannot be specified. Also, abstract classes only allow single inheritance, while interfaces allow multiple inheritance.

Unity adds an additional difference, which is crucial for this article: it allows abstract classes to be shown in the inspector, but not interfaces. In one of the previous screenshots, you saw the inspector for the ActiveWallAvoiderSteeringBehavior class. Pay attention to its Steering Behavior field. The code that declares this field and shows it in the inspector is:

Declaration of the steeringBehavior field

Note that steeringBehavior is of type SteeringBehavior (an abstract class), and the inspector has no problem displaying it. Therefore, we can use the inspector to assign any script that inherits from SteeringBehavior to this field.

If we wanted this field to accept any script that implements ITargeter, we should be able to write [SerializeField] private ITargeter steeringBehavior. The problem is that while C# allows this, Unity does not allow interface-type fields to be exposed in the inspector.

So, how can we ensure that the steeringBehavior field receives not only a class that inherits from SteeringBehavior, but also implements the ITargeter interface? The answer is that Unity doesn't offer any built-in safeguard, but we can develop our own, as I’ll explain.

It will be easier if I first show you what we want to achieve and then explain how to implement it. The solution I found was to design my own PropertyAttribute to decorate fields that I want to verify for compliance with one or more interfaces.

Custom attribute to confirm interface compliance

In the screenshot above, you can see that I named my attribute InterfaceCompliant. In the example, the attribute verifies that the SteeringBehavior passed to the steeringBehavior field complies with the ITargeter interface.

If the script passed to the field does not comply with the interface, the attribute will display a warning message in the inspector.

Warning message when a script does not comply with the interface

Now that we understand what we want to achieve, let’s see how to implement it. Like other attributes, we need to create a class that inherits from PropertyAttribute. This class is abstract and requires us to implement the InterfaceCompliantAttribute method, whose parameters are passed to the attribute when decorating a field.

Implementation of our custom attribute

Note that the name of this class must be the name of our attribute followed by the suffix "Attribute". The class should be placed inside the Scripts folder.

This class serves as the data model for the attribute. We’ll store in it all the information needed to perform our check and display the warning message if necessary. In this case, the attribute accepts a variable number of parameters (hence the params keyword). These parameters are the types of our interfaces and will be passed in an array stored in the InterfaceTypes field.

To represent the custom attribute in the inspector, as well as the field it decorates, we’ll use a PropertyDrawer. These are classes that inherit—surprise!—from PropertyDrawer and must be placed in an Editor folder, separate from the Scripts folder. We can name our class whatever we want, but we must decorate it with a CustomPropertyDrawer attribute to indicate which attribute this PropertyDrawer draws in the inspector.

PropertyDrawer to draw our attribute and the field it decorates

In our case, I used the CustomPropertyDrawer attribute to indicate that this PropertyDrawer should be used whenever a field is decorated with an InterfaceCompliantAttribute.

PropertyDrawer is another abstract class that requires implementing a method called CreatePropertyGUI. This method is called by the inspector when it wants to draw a field decorated with this attribute.

Implementation of the CreatePropertyGUI method of InterfaceCompliantAttributeDrawer

A class inheriting from PropertyDrawer has a reference to the attribute it draws via the attribute field. That’s why in line 22 we cast it to the InterfaceCompliantAttribute type, which we know it actually is, to retrieve the list of interfaces to check in line 23.

Note that while the attribute can be retrieved using the attribute field of PropertyDrawer, the decorated field is passed as a parameter to the method, property, encapsulated in a SerializedProperty type (line 19).

Next, in line 26, we generate the visual container in which we’ll place the widgets to represent our field in the inspector, as well as the warning message if necessary. For now, that visual container is empty, but we’ll add content to it in the following lines. As we add elements to the container, they will be displayed top to bottom in the inspector.

If you look at the screenshot showing the warning message in the inspector, you’ll see that the message appears before the field, so the first element we’ll add to the container is the warning message, if necessary (line 28). This part is quite involved, so I moved it to its own method (AddErrorBoxIfNeeded) to make CreatePropertyGUI easier to read and to allow reuse of that method in line 45. Once we finish explaining the implementation of CreatePropertyGUI, we’ll look at AddErrorBoxIfNeeded.

After adding the warning message (if necessary) to the container, we need to display the decorated field. We want to show it with its default appearance in the inspector, so we simply create a PropertyField (line 31). PropertyField will detect the type of the field encapsulated in property and display it using Unity’s default widget for that type.

Now pay attention. We want the interface compliance to be re-evaluated every time a new script is assigned to the decorated field. To do this, in line 43 we instruct the container to monitor the value of property and re-evaluate whether to show the warning message (line 45), redrawing the field (line 46).

Once this is done, we add the decorated field to the container (line 50) and return this container for the inspector to draw.

As promised, let’s now analyze the implementation of AddErrorBoxIfNeeded.

Checking the decorated field for interface compliance

To access the field encapsulated within a SerializedProperty, we use its objectReferenceValue field (line 70).

This field is of type Object, so we’ll need to cast it to the specific type we want to check. We do this in the GetNotComplyingInterfaces method on line 74. We’ll look at its implementation shortly, but at a high level, this method takes a list of interfaces (line 75) and an object (line 76), then casts that object against each interface. If any of those casts fail, the type of the failed interface is added to a list that is returned as the method’s output (line 74).

This list is passed to the GenerateBox method, which draws the warning message if the list contains any elements. If the list is empty, the method draws nothing. The drawn message is returned in an ErrorBox (line 79), which is added to the container (line 85), after clearing its previous content (line 82).

The interface check itself is very simple.

Interface check on the script in the field

Starting at line 120, for each interface in the list (passed as parameters to the attribute), we check whether the script (checkedObject) implements it. To do this, we use C#’s IsInstanceOfType method (line 123). I’ve always found IsInstanceOfType misleading, because read left to right it seems to check whether "interfaceType is an instance of checkedObject", when in reality, it checks whether checkedObject is an instance of interfaceType.

If checkedObject does not implement the interface, IsInstanceOfType returns false, and the interface type is added to the list of non-compliant interfaces (line 125), which is returned as the method’s output.

Finally, for completeness, let’s look at how the error message is generated in the GenerateErrorBox method.

Generating the warning message

If the script being checked complies with all the interfaces, the list passed as a parameter to GenerateErrorBox would be empty, and the method would simply return null (line 90).

However, if there were any non-compliance, the names of the non-compliant interfaces would be chained together, concatenated with commas between them, as shown in lines 93 to 95.

That list of interface names, concatenated with commas, would be added to the end of the warning message (line 98), and with it, an error message would be created and returned to be added to the container (line 102).

And with that, you have everything. It's true that you won't be able to prevent scripts that don't comply with the interfaces from being assigned to the decorated field, but at least a message will appear warning of the issue. It will be very difficult not to notice the message and correct the oversight. On the other hand, this entire example has served to show you how to implement a custom attribute that leverages the flexibility of Unity's inspector. I hope you found it interesting.

Lights and Shadows of the "Stop Killing Games" Initiative

The Stop Killing Games initiative is a consumer movement launched in 2024 by YouTuber Ross Scott, known for his channel Accursed Farms, in response to the shutdown of the servers for The Crew, a Ubisoft video game that became unplayable due to its constant internet connection requirement, even in single-player mode. This sparked outrage, as the game, despite having multiplayer components, also included a single-player mode that did not inherently need an online connection. The initiative raises a crucial debate about digital ownership in an era where games are increasingly expensive (with prices reaching 80-100 euros) and rely on servers that can be shut down.

The Stop Killing Games Logo

Ross Scott released a video introducing the initiative and created a website (stopkillinggames.com) to collect signatures and promote government petitions in countries such as France, the UK, Canada, Australia, and the European Union.

In response to cases like this, the initiative demands the preservation of video games after their official support ends, protecting consumer rights and preventing purchased games from becoming inaccessible due to publishers' decisions. Its argument is rooted in opposing publishers selling games as temporary licenses rather than permanent products. It defends players' rights to enjoy what they paid for without time restrictions. Additionally, it claims video games as cultural heritage, comparing them to films or books that do not vanish after commercialization.

To this end, the initiative seeks legal protections for players against sudden server shutdowns that render games unplayable. It demands that games always include an offline mode, with single-player campaigns, so they do not rely on active servers, or that games allow users to create private servers to keep them alive when companies cease support.Since its launch, the initiative has garnered support from over 1.4 million signatories, media outlets, and content creators like PewDiePie, MoistCr1TiKaL, and Jacksepticeye. Even one of the European Parliament’s vice-presidents, Nicolae "Nicu" Ştefănuță, publicly endorsed the initiative and added his signature. While not decisive, given the size of the European Parliament, this support signals a growing trend to curb certain abusive practices.

Nicolae "Nicu" Ştefănuță, a vice-president of the European Parliament, publicly supported the initiative.

On the other side, major game developers, represented by the Video Games Europe lobby (including companies like EA, Ubisoft, and Activision), argue that the initiative’s proposals would make game development "prohibitively expensive" and maintain that players own revocable licenses, not the games themselves. Other voices in the gaming industry, such as streamer Pirate Software (Jason Thor Hall), have also criticized the initiative, claiming it is not viable for all games and could harm developers, leading to a public clash with Scott.

While publishers naturally defend their interests, some of their arguments have merit and deserve consideration to ensure well-intentioned initiatives do not harm indie studios or negatively impact the dynamic video game market.

For starters, the initiative oversimplifies by treating all video games the same, despite their diversity. A key distinction exists between games designed to run entirely on local resources (e.g., Half-Life: Alyx) and those reliant on online servers to manage game logic and player progress (e.g., Fortnite or World of Warcraft).

The initiative seems to overlook that redesigning a game built for online servers to work offline or on private servers is not always feasible. Online games often incorporate licensed elements on the server side (e.g., physics engines, matchmaking frameworks) that developers do not own and cannot redistribute without violating license terms. This is even clearer with audiovisual content, such as music licensed for use in Fortnite’s lobbies. If such content were redistributed to local game copies, the risk of uncontrolled distribution would skyrocket, prompting artists’ publishers to renegotiate rights. Alternatively, games could be distributed without licensed content, but this would contradict the initiative’s goal of preserving everything players paid for. Removing licensed functional elements could even render games inoperable. Additionally, computational power is a factor: maintaining the state and progression of an MMORPG requires significant processing, storage, and robust data networks, often relying on entire data centers. Replicating this in a user’s home is practically impossible.

Many online games run on complex data centers, impossible to replicate at home.

Then there’s the issue of time. Unlike films, which only require a compatible player, server-dependent games need ongoing, expert maintenance beyond the average person’s skills. Expecting users to maintain complex game servers at home is highly unrealistic.

Maintaining such complex infrastructure is beyond the average citizen’s capabilities.

While the initiative’s motivation is understandable, it overlooks practical challenges widely discussed in game development forums. However, this debate is healthy and may lead to a balanced solution. Some propose labeling games to warn consumers about external server dependency, enabling informed purchasing decisions.

Labeling as a Possible Solution

Others suggest a voluntary framework for developers, committing to design games with long-term preservation guarantees. For example, a first category could include games with limited offline modes using bots, specific maps, or local multiplayer; a second could involve partnerships with nonprofits to preserve games with security measures; a third could allow players to host local servers. Like labeling, these categories would be disclosed at purchase, letting buyers assess risks.

Voluntary Categorization as a Solution

While the initiative’s proposed regulations aim to protect consumers, they must be carefully crafted to avoid stifling the creativity and economic vitality of the video game industry. Conditions feasible for large studios could be prohibitive for small or indie developers, increasing costs and legal risks. Protecting consumers without harming small studios or limiting new game production is key. Legislators tackling this issue will need to navigate a delicate balance, requiring deep understanding of the complex and ever-changing video game market.

This initiative demands highly delicate legislative work.