This release gives projects new ways to organize both their data and their ideas. Data Assets hold typed values that can inherit from a parent, be edited together in a Table Viewer and be read or changed by scripts while the game runs. Characters gain the same inheritance model. Canvas boards let you arrange files, notes and connections visually, while Markdown notes gain a full rich-text editor alongside their source. A new Localization dashboard gathers the text in your project for translation, CSV handoff and language switching in a running game. There is more for interface authors too: containers that fit a fixed design to different screens, Scroll Box actions, pointer events across widget types and a per-image choice between smooth and pixel-sharp scaling.

What's New

New Features

• Data Assets for Reusable Game Data: Create a Data Asset in the Content Browser and give it named values for text, numbers, booleans, enums, arrays, maps and asset references. Make a child from an existing asset to inherit its variables, then override only the values that differ. Change a parent and children still following that value update with it. A child can reset an override to return to the inherited value

• Edit a Whole Data Asset Family in the Table Viewer: Open a family as a table to compare its assets and edit values in place. Add assets and variables, resize columns, transpose the table, zoom, search and replace values. Arrays and maps can be edited inside their cells, while image and audio values show previews instead of bare paths. Export the table as CSV to edit supported values in a spreadsheet and import them back, or export resolved values as JSON. Arrays and maps appear in the CSV for reference but must be edited in the editor. A CSV import shows what will change first and can be undone in one step

• Data Assets in Scripts and Saves: Drag a Data Asset into a script or interface graph, then use Get and Set nodes for its variables. Array operations can write through those accessors as well. Play exposes the current values in the debugger, saves keep changes made during play and exports include the data needed to use those assets in a game

• Data References as Variables: The new Data variable type points to a Data Asset. Keep a selected item or quest in a variable, change the reference during play or store references in arrays and map values. Scripts, interfaces, characters and Data Assets can all hold these references

• Read Related Data Directly in Dialogue: Use paths such as {Sword.Cost}, {Quest.RewardItem.Name} or {Player.EquippedWeapon.Damage} in dialogue, options and text blocks. Paths can follow Character and Data references and read inherited values, so text can use the current asset values without copying them into extra variables

• Bind Interfaces Directly to Asset Fields: Text, images and value controls can bind to a selected character or Data Asset field, including inherited fields. Editable controls write changes back during play, and On Variable Changed can react to a selected asset field. A health display or shop price can use the same source as the story scripts

• Characters Can Inherit From Characters: Characters now use the Data Asset editor’s inheritance model. Derive a character, keep the shared values from its parent and override the details that make it different. The Table Viewer can show every character together, not just one family. Existing projects are upgraded when opened, with character links preserved so scripts and dialogue still point to the right character

• Canvas Boards for Planning and Organizing: Create a canvas board and drop files or folders from the Content Browser onto it. Add text cards, groups and labelled connections to map out a story or collect related assets. Cards preview images, portraits, audio and Markdown notes; a note can be edited right on the board. Board search finds card names, connection labels and note text, and file cards follow their files when those files are renamed or moved

• Write Markdown Notes Visually or as Source: Markdown files now open in a rich-text editor with a Source pane when you want to edit the markup directly. Format a selection from the floating toolbar, insert images from the Content Browser, draw a table, add links and turn blocks into other kinds of content. Link one note to another with [[, navigate by the heading outline, find and replace text, zoom the page and use focus mode when you want the page to yourself. Word and character counts help with longer notes, and each note keeps its own undo and redo history

• A Localization Dashboard for the Whole Project: The new dashboard gathers translatable text from scripts, interfaces, characters and Data Assets. Add target languages, edit translations in the table and track how much has been translated. Filter by file or content type, search source text or translations, sort columns and jump from a row to its source. Repeated source text can suggest an existing translation, and the dashboard warns when a translation breaks placeholders or important spacing

• Translation CSV Handoff: Export one language or all target languages to CSV, then import the edited sheets. Each sheet identifies its language, and a folder of sheets can be imported together. The dashboard reports rows it could not apply instead of silently guessing, so a translation pass can move through a spreadsheet without losing its connection to the project

• Edit Original Story Text Through CSV: The Localization dashboard can also export source text, including filtered rows for a particular file, node or kind of content. Import a revised sheet to update the original text in the project. The editor previews the changes, skips conflicts with newer edits and keeps a restore option for the last successful import

• Switch Languages While the Game Runs: Interface scripts can get or set the current language, list available languages and respond when the language changes. The Play debugger has a language picker for checking translations without rebuilding an export. A switch refreshes the visible scene, including interface text, backgrounds and completed animation states, and the selected language is available in exported games

• Interfaces That Fit Different Screen Shapes: Size Box gives a child a defined design size, while Scale Box fits a child uniformly into the space available. Put fixed-size artwork and its clickable areas inside them and they resize together as the window changes. Scale Box can scale up or down, or only down, and can align the fitted content within the available space. Existing interfaces keep their current layout until you add these containers

• Control Scroll Boxes From Interface Scripts: Scroll to Start, Scroll to End and Scroll Widget Into View let a script move a Scroll Box after layout. The last action can reveal a particular widget with a chosen alignment, optional animation and padding

• Choose Smooth or Nearest Scaling Per Image: An image can keep smooth interpolation or use sharp nearest-neighbor pixels for pixel art. Set the choice in the image editor; the UI preview, Play and exports use it wherever that image appears

• An Experimental Light Theme: Appearance settings now include Light (Experimental). It gives the editor, canvases, notes, tables and dialogs a light palette, and switching themes takes effect across open windows

• Pointer Events on More Interface Widgets: Click and other pointer events are available across widget types, so an interface script can respond to the element the player actually interacts with instead of needing an extra button over it

Improvements

• Descriptions for Data Asset and Character Variables: Add or edit the short description beneath a variable in its file editor. Descriptions support undo and redo, and inherited descriptions follow the file where the variable was defined

• An Example Project That Shows the New Data Workflows: Newly created Example Projects use Data Assets for items, locations, services and quest settings, with character files holding character-owned values. Explore the shop and combat scripts to see Data references, inherited fields and direct interface bindings working together

• Find the Thing You Are Editing: Ctrl+F now searches script and interface graphs, canvas boards, Data Asset editors, the Table Viewer and Markdown notes. Searches stay with their tab as you move around the editor. Global Search also reads Data Asset contents

• Data Asset Editing Feels Like the Rest of the Editor: The single-file editor separates inherited and own variables, lets you filter by name or type and keeps its sections and filters when you return. Drag to reorder your own variables, rename them in place and undo or redo edits from the editor menu. The Table Viewer keeps its scroll position and the same visible rows when you zoom or switch tabs

• File References Are Easier to Follow: Data Asset references appear in the References panel and its file cells can reveal the selected asset in the Content Browser. Markdown links and images count as references too. When a referenced note or board is deleted, the replacement dialog offers other compatible files

• Characters Are Easier to Place in Graphs: Drop a character from the Content Browser onto a script canvas to make an accessor already bound to that character. Interface scripts can access character variables as well, and their searchable pickers work from the keyboard

• Localization Has a Better Review Flow: The source and translation cells are easier to read and edit in place, with room for longer text. The table can be panned and zoomed, and a source cell can be copied from its menu. The dashboard can fill untranslated rows from translations that already match the same source text

• More Useful Content Browser Defaults: Search and filters are on by default, and the icon-size choices are visible. A Data Asset can use one of its image values as its Content Browser preview, making a family easier to recognize at a glance

• More Complete Menus: The menu bar now includes Switch Project, an Edit menu, File > New and Close Tab, and direct ways to reveal a file in the Content Browser or open its references. Export confirmations offer a Show in Folder button

• Clearer File Operations and Recovery: Delete warnings, recovery choices, audio-channel changes and image cropping use consistent dialogs that fit their content. A file with references shows what will be affected before you act

• Interface Design Is Easier to Handle: A widget outside the stage can be hovered, selected and opened from its context menu. Containers remain draggable when a child fills them, and searchable dropdowns across the editor now share keyboard navigation

• Exports Point Out Missing Assets: If a referenced file has disappeared from disk, the export warns about it instead of leaving you to discover the gap after the game is built

Bug Fixes

• Unsaved Work Survives More File Operations: Moving an editor tab between windows, renaming files repeatedly or recovering after a crash no longer drops the latest draft or confuses which window owns it. Markdown, canvas boards and Data Asset edits are preserved through the same kinds of operations

• Save and Load Restore the Running Scene More Reliably: Loading a game brings back character values, Data Asset changes, media and settled animation positions more consistently. Work left over from before a load or reset can no longer continue afterward and change the restored scene

• Localization Imports Respect Newer Work: Source imports detect text that changed after the sheet was exported, and a reference rewrite cannot silently overwrite an imported edit. Translation rows keep their authored source separate from text changed at runtime, so playing or switching languages does not alter what you wrote

• Changing Languages Refreshes the Whole Scene: Switching languages during Play now updates scene backgrounds and finished animation states along with text, and interface construction runs against the refreshed stage

• Data Asset Overrides Resolve Correctly: A child uses the nearest valid override in its inheritance chain. Changing a base value no longer leaves a redundant child override behind, and edits in another window reach the assets and tables that depend on them

• Table Edits Are Safer: Closing a Data Asset cell commits the intended edit, Escape cancels an edit in progress and a CSV import stays together as one undo step. Zooming a virtualized table no longer jumps to a different part of the data

• Boards and Notes Keep Up With Your Files: Board previews show unsaved note changes, and cards stay connected to their targets after a file rename or move. Markdown edits keep their scroll position, links open the intended file once and wide tables scroll inside the page

• Search Results Reveal the Right Content: Opening a Markdown result from Global Search now reveals the matching text after the note is ready. Selecting a script-node reference also selects the target node consistently in story and interface graphs

• Text Editing Stays Steady as References Change: Refreshing referenced values preserves the caret, text selection and undo history while you write

• Interface Widgets Respond Where They Are Drawn: Clicks and hovers reach widgets placed outside the stage, including those that sit behind the designer’s usual bounds. An Overlay paints its children in the right order even when one child is an interface instance

• Character Links Survive the Upgrade: Older character references keep their bindings as projects move to the new character format. Renaming a character or changing a variable name no longer leaves the related accessor pointing at a stale name

• Save Screenshots Include External Images: A screenshot attached to a save now captures images loaded from outside the exported page rather than leaving them blank