What's New

I am currently working on two major features: change history and three-way merging of two branches. These features will likely be ready by the end of the year.

A Heavenly Battle using the updated Charon plugin (2025+) has been released on Steam! There may have been others, but I found this one by searching through game assets on steamdb.info.
https://store.steampowered.com/app/4920140/Heavenly_Battle/

P.S. If you would like to showcase your upcoming or released game, please send me a DM or email support@gamedevware.com.

2026.4.1

Date: Tuesday, September 1, 2026

Parsed Accessors for Vector, Rectangle and Tag Properties

A text property that carries a vector2/vector3/vector4, int-vector*, rectangle, int-rectangle,
tags or tags-collection editor is stored as a string, and until now every game had to split and parse that
string itself on each read. Generated code now does it, once, and caches the result.

The property keeps its name and returns the parsed value; the original string moves to a <Name>Raw companion,
the same pairing already used for references and localized texts:

// Unity

UnityEngine.Vector3 spawn = enemy.SpawnPoint;

// non-Unity C#

System.ValueTuple<float, float, float> spawn = enemy.SpawnPoint;

var (x, y, z) = enemy.SpawnPoint;

// the stored text is still there

string raw = enemy.SpawnPointRaw;

Every target that generates document classes carries it, using whatever its language offers for a small fixed
group of values:
C# 7.3 (Unity) - UnityEngine.Vector3, UnityEngine.Rect, UnityEngine.RectInt, ...
C# 7.3 (non-Unity) - System.ValueTuple<float, float, float>, ... — deconstructs with var (x, y, z) = ...
TypeScript - readonly [number, number, number], readonly string[]
Haxe - {x:Float, y:Float, z:Float}, Array<String>
Lua - { x = ..., y = ..., z = ... }, array table
Unreal Engine C++ - GetParsedSpawnPoint() beside the unchanged FString SpawnPoint

Missing and malformed components read as zero rather than throwing — these accessors have no error channel, and
the editor already validates the stored text.

New rawCompositeTypes Optimization

--optimizations rawCompositeTypes turns the above off: composite text properties keep their original name and
type, and no parsing helpers are generated. Use it when a project already parses these strings itself, or to
avoid the rename when updating existing code is not worth it. Unreal Engine C++ never renames a property, so the
option has no effect there.

Note that switching an existing property to a composite editor is a breaking change for game code: the property
changes type and the string moves to <Name>Raw. This optimization is the way out.

UI

Filters now accept document collection properties, looking for the value in every entry of the collection.

The filter menu gained a Reset Filters item that clears the filters and the search query together, and its
trigger icon is now colored while any filter is applied and gray otherwise.

Fixes

• Filters were not displayed in a document collection.

Known Issues

• Filters not being displayed in document collection and can't be removed/dismissed. Will be fixed in next hotfix (soon) and "Reset Filters" button will be added.


• Index out of range when "" (empty string) met while integer is expected.

2026.4.0

Date: Monday, August 31, 2026
Actual Unity Plugin: 2026.2.1 (not changed)
Actual Unreal Engine Plugin: 2026/07/04 (not changed)

Highlights

Editing Read-Only Game Data with a Separate Changes File

Game data files that live under source control, ship inside a package, or are simply marked read-only can now be
opened and edited anyway. Point Charon at a changes file and the original game data file is opened read-only and
never written — every edit is accumulated into the changes file as a patch document instead.

Start the editor this way with the new --changesFile option:

dnx dotnet-charon -- SERVER START --dataBase ./aurora_gamedata.gdjs --changesFile ./new_frontier_mod.patch.json

The option can also be supplied as a changesFile query parameter on the data source URI (with an optional
readOnly parameter to force read-only mode on a writable file), so it works for every verb, not just the server.
A relative path is resolved against the game data file's directory. When you are ready to fold the work back in,
merge the patch into the game data file with the existing DATA APPLYPATCH command.

This makes a few workflows practical that were awkward before: reviewing a patch as a small, readable diff instead
of a whole-file change; letting several people edit branches of the same immutable base data; and shipping
designer tweaks on top of a build's baked-in game data without touching it.

The changes file is an ordinary patch document, so it does not have to be merged back at all — most code
generators (C# 7.3, TypeScript, Haxe and Unreal Engine C++) accept patches in their load options and apply them
on top of the base game data at runtime. A game can ship its baked-in game data untouched and load a folder of
patches over it at startup, which is what makes modding and live-ops workflows possible: players or designers edit
against the immutable base, and the resulting patch file drops straight into the game. See the
Modding Support and Patch and Diff Workflow documentation for the load options and merge rules.

UI Extensions: Full Pages, Menus, Dialogs and Navigation

UI extensions grew from "add an action to one menu" into a way to build real screens inside Charon.

Custom routed pages. Declare full pages in package.json (config.customPages: id, selector, title,
breadcrumb) and open them with context.navigation.customPage(packageName, pageId, restOfRoute?, params?).
Pages get real, bookmarkable, refreshable URLs (/ext/:packageName/:pageId/...), can own extra path segments for
their own deep linking (tabs, wizard steps, and so on), and receive a context carrying params, restOfRoute,
and the same services available everywhere else.

More places for custom actions. Beyond the dashboard's "New Schema" menu, actions can now be added to the
single-document edit form's Actions menu (document-action-menu) and the document list's Actions menu
(document-list-action-menu, formerly grid-action-menu). Form actions receive the open document's
documentControl; list actions receive the collection's schema and the current row selection.

Actions that open pages, and a sidebar. A customActions entry can set pageId instead of functionName, so
clicking it navigates to one of the extension's own pages rather than running code. This works in every action
location plus a new one — side-navigation-menu, a persistent entry in the project's left sidebar. Sidebar names
follow a Section/Label convention: Design/Summary Page creates a "Design" heading with a "Summary Page" link,
while a bare name lands under the existing "Home" heading. Link entries highlight when their page is open, just
like Dashboard and Metadata do.

Custom dialogs. Extensions can pop their own dialog UI with context.ui.dialog.showCustom(selector, data,
options) — no package.json declaration required, just a custom element the extension has already registered.
Charon draws a consistent title bar and close button around your content; the element receives .data and a
.dialogRef.close(result) handle to return a result to the caller. Unlike progress dialogs, custom dialogs stack.

Wider service surface. context.navigation also gained dashboard(), settings(), documentCollection(),
documentForm(), errorPage() and back() for one-line navigation from any action, and the action context now
exposes the editor's preferences, routing, document form, collection UI state and inline-editing services under a
single services property.

Extension Safety and Easier Installation

Custom npm-based UI extensions run with full access to your data and credentials, so Charon now asks before
loading a project's extensions for the first time. The prompt offers Don't Load, Allow Once and **Always
Allow**, marks extensions you have previously allowed, and applies a short cooldown on the Allow buttons to
prevent accidental click-through. The decision is remembered per project and per extension list — change the list
and Charon asks again. A toggle in Project Settings → Extensions grants or revokes the consent directly, without
waiting for the prompt.

Installing an extension is also less manual. Uploading a package now reads its name and version from the package
itself and fills in a row in the project's extension list, instead of leaving you to retype both by hand; uploading
a newer build of an already-declared extension refreshes its version in place. The behavior is controlled by a
checkbox next to the upload, enabled by default. An upload whose package.json cannot be read is now rejected
outright rather than being reported as accepted.

Command Line

Several read-only inspection commands were added, mirroring what the MCP tools and the editor already expose:

• DATA SEARCH — cross-schema text search with an optional schema filter, printing either a flat

Schema | Document Id | Path | Value table or the full JSON result.

• DATA LISTSCHEMAS — browse schema definitions, a sibling of DATA LIST fixed to the schema metadata.


• DATA EXAMINE — document counts and hashes without loading full data.


• DATA FINDFILES — scan a folder for game data files and report what was found.


• DATA PROJECTSETTINGS — retrieve the project settings document (languages, primary language, and other

project-level configuration).

DATA UPDATEPROJECTSETTINGS writes a single project settings property, addressed by name or by JSON Pointer. The
value is stored as text by default, or parsed as JSON with --valueIsJson.

DATA LIST filter and sorter descriptions now document the JSON Pointer syntax for deeper property paths.

AI Assistants (MCP)

• data_get_project_settings — read the project settings document (languages, primary language and the rest),

mirroring data_find_by_id.

• generate_lua_code — generate Lua source code, alongside the existing C#, TypeScript, Haxe and Unreal tools.

Code Generation

⚠️ BREAKING CHANGE: ⚠️ C# name pluralization now uses a full port of the Pluralize.NET / pluralize.js rule set instead of
the previous ad-hoc rules. Coverage of irregular and uncountable words is far better, but a handful of generated
plural names will differ from the previous release — regenerate your code and expect a small number of renames (mostly collection properties).

Generated game data now exposes the project Version in Haxe, Lua and TypeScript alongside change number and
revision hash, matching C# and Unreal. It is an empty string on every target when the game data has no project
settings document (C# previously returned null there).

LocalizedText was made faster on C#, TypeScript, Haxe and Lua by comparing an internal version counter instead
of the current language string on every access.

Fixes

• INIT could exit before the new game data file was written, leaving only .tmp and .bak files behind while

still reporting success.

• C# LocalizedText cached values by current language only, so changing the fallback language or fallback option

without changing the current language did not refresh the cached value.

• Generated Lua ignored the project's language settings and always fell back to the language baked in at

generation time.

• The Unreal C++ generator reported a spurious "Tagged Union has multiple conflicting options." error when

re-publishing game data.

• Uploading an extension package could fail or be silently ignored: packages already loaded were locked against

replacement, re-uploading a cached package left a stale temporary file, and packages placed in the pickup
folder as plain .tar were invisible until the server restarted.

• Malformed email addresses were accepted by the sign-up, member invite, profile email change and password reset

forms, then failed server-side.

• Changing a profile email to an address another account already uses is now rejected instead of failing later;

signing in also no longer breaks when two accounts share an email. Reported by <@1541862769731567671>.

• Workspace, user and project search now tolerates typos instead of matching substrings only.


• CLI snippets copied from the editor's wizards used a form that requires a global tool install; they now use the

one-shot dnx dotnet-charon -- form.

Documentation

Game Data

• Basic Navigation and User Interface Overview [Reworked]


• Editing a Document [New]


• Filling Documents [Reworked]


• Schema [Updated]


• Schema Property [Updated]


• Publishing Game Data [Reworked]


• Generating Source Code [Reworked]

Advanced

• Importing and Exporting Data [Reworked]


• Internationalization (i18n) [Reworked]


• Validation [Reworked]


• Backup and Restore [Reworked]


• CI/CD Integration [Updated]

UI Extensions

• UI Extensions [Reworked]


• Custom Actions [New]


• Custom Pages [New]


• Host Services [New]


• Implementing CharonSchemaEditorElement [New]


• Implementing CharonPropertyEditorElement [Updated]

Command Line

• Command Line Interface (CLI) [Reworked]


• Search Documents [New]


• Examine Game Data [New]


• Find Game Data Files [New]


• Project Settings [New]


• Update Project Settings [New]

Editions and Plugins

• Workspaces, Projects, and Branches [Reworked]


• Roles and Permissions[Reworked]


• Unreal Engine/How to Create Game Data File [Updated]

2026.3.4 (Unreal Engine 5.8 support)

Date: Saturday, July 4, 2026

CLI

• Added support for the --lockFile parameter to join an already running server process instead of starting an independent one, allowing shared usage of the same game data files between different servers. The first process serves requests; later ones redirect to it, wait for its exit, and replicate its exit code.


• The --lockFile parameter for SERVER START now accepts a default value, which resolves to a lock file path in the %PROGRAMDATA%/Charon folder. This allows process joining without needing to know where the shared lock file is located.


• Fixed the command line argument parser incorrectly interpreting options placed after the -- separator.

Game Data Editing

• Fixed a "Value <id> is already used in another document" error when importing a schema with shared properties. Thanks <@807614161793056818> for reporting it.

Code Generation

• Added clearer error messages for invalid member invocations in formulas.


• Fixed C++ float constants missing the f suffix, causing "double to float coercion" warnings.


• Fixed C++ formula generation not forward-declaring used game data model classes, causing compilation errors, and added missing includes for used enum headers.


• Fixed generated C++ enums missing the .generated.h include, causing StaticEnum<T> expressions to fail due to missing metadata.


• Fixed the C++ generator to use the proper Unreal Engine JSON key type (FSharedString instead of FString) in Unreal Engine 5.8.

User Interface

• Changed the displayed Unreal Engine C++ compatibility version from 5.4 to 5.3.

Unreal Engine 5.8

Support for the new version of Unreal Engine will be implemented soon.

2026.3.2

Date: Wednesday, May 20, 2026

User Interface

• Fixed undo/redo actions being blocked when triggered while editing a grid cell. Editing is now cancelled instead.


• Fixed UI not reflecting changes on non-text field types after the undo/redo update in 2026.3.1.

2026.3.1

Date: Monday, May 18, 2026
Actual Unity Plugin: 2026.2.1 (not changed)
Actual Unreal Engine Plugin: 2026/04/26 (not changed)

General

• Fixed process lock file not properly functioning on Unix file systems.

Code Generation

• Added Lua source code generation target. Basic support providing game data collections and model access. JSON/MessagePack deserialization is not included and should be provided by the caller.

Game Data Editing

• Fixed game data file version being checked against the supported format version instead of the actual application version.


• Fixed import report incorrectly reporting updated entries as created in 'Replace' mode.


• Fixed wrong value being reported when duplicate IDs or values are found.


• Fixed Integer type returning an Overflow error instead of InvalidFormat when given a long string value.


• Fixed Multi-Pick list not clamping values to defined options, similar to but softer than the Pick list validation.


• Fixed Number data type precision not being applied when values are converted from other types (text, integer, pick lists).

User Interface

• Added Lua code generation option to the "Generate Source Code" wizard.


• Added undo-redo functionality while editing documents (form/grid). Changes are tracked at the field level; native undo-redo inside text fields is retained.


• Updated tutorial links to point to current YouTube videos.

Web Application

• Added project view permission to any invited member, allowing them to preview an inviting project before accepting the invite.


• Fixed OAuth2 login with Microsoft.

Lua source code generation

This version adds an option to generate Lua source code for your game data. Currently, support is fairly basic, with typed models and a core game data class. A usage example can be found in the documentation.

Undo/Redo Changes

Undo and Redo changes have been added to the grid and document editing form. Since undo/redo is a fairly complex feature to implement correctly, expect bugs. Please report them in the <#1159049016701636660> section, and they will be fixed.

2026.2.1

Date: Friday, March 27, 2026
Actual Unity Plugin: 2026.2.1
Actual Unreal Engine Plugin: 2026/04/26

General

• Changed ToolsVersion format to use a version range instead of the exact app version, allowing a wider compatibility window between charon DATA ... tools and data files.

CLI

• Added game data tool version detection across all modes (CLI, UI, MCP) to prevent opening newer game data files with outdated tools.

Game Data Editing

• Fixed empty translation notes being saved as an empty object {} instead of null.

MCP

• Fixed an invalid tool name that caused the MCP server to fail on startup.

User Interface

• Fixed cases where the UI was not updated when metadata changed (e.g., schema or property renames).


• Fixed machine translation not translating nested documents when the "Translate Text" action is used.

Web Application

• Added DeepL as a translation provider, replacing Google Translate.


• Added last update time tracking for User, Workspace, and Project entities to detect stale accounts.

2026.2.0

Date: Monday, March 23, 2026

CLI

• Added MCP server mode for the Charon CLI tool. Use charon MCP to run in stdio MCP mode. Discover available tools and resources with npx @modelcontextprotocol/inspector.

MCP

• Added tools:

- Data: data_get_metadata, data_get_schema_as_json_schema, data_examine, data_export, data_export_to_file, data_import, data_import_from_file, data_backup, data_backup_to_file, data_restore, data_restore_from_file, data_validate, data_create, data_update, data_delete, data_find_by_id, data_list, data_search, data_create_patch, data_apply_patch, data_create_patch_to_file, data_apply_patch_from_file
- Localization: i18n_get_languages, i18n_add_language, i18n_export, i18n_export_to_file, i18n_import, i18n_import_from_file
- Discovery: data_find_files
- Code Generation: generate_csharp_code, generate_typescript_code, generate_uecpp_code, generate_haxe_code

• Added resources:

- enum_data_type, enum_import_mode, enum_export_mode, enum_validation_options, enum_schema_type, enum_id_generator_type, enum_bulk_change_status
- languages

• Added prompts:

- getting_started, creating_documents, creating_documents_multiple, editing_documents, editing_documents_multiple, importing_documents, replacing_whole_document_collection, deleting_documents_multiple, localization, code_generation, database_parameter

Game Data Editing

• Fixed an issue where subscription updates from Stripe were occasionally missed, causing the subscription state to become stale.

Code Generation

• Added support for Member/List initializer expressions in formulas for C# and TypeScript. The Unreal Engine C++ generator already includes this support.


• Added formula parameter and return type remapping for non-C# targets. For example, string is automatically replaced with FString in Unreal Engine C++ generated code.


• Added typed accessors for vector2/3/4 fields in Unreal Engine C++ generated code. Field values can now be accessed using native types (FVector2D, FVector, FVector4) instead of unparsed FString. For example, a Text Position field with a vector2 sub-type will generate an additional FVector2D GetParsedPosition() accessor method.


• Added formula support to the Unreal Engine C++ code generator. A class with an Invoke method is now generated for each formula type.


• Fixed x is Type expressions incorrectly returning true for null and Object in TypeScript generated code.


• Fixed private field names in Unreal Engine C++ generated code to start with a capital letter. Private caching fields on UClass-derived classes now include a UPROPERTY attribute to maintain valid object references.


• Fixed unsafe code execution in TypeScript formula code by forbidding Function constructor, eval(), prototype walking, Reflect, and similar mechanisms.

Project

• Updated icons for project and package.

User Interface

• Redesigned the schema deletion dialog to hide empty lists when deleting an empty or unused schema.


• Added support for copying and pasting documents directly from the table using Ctrl/Cmd+C and Ctrl/Cmd+V.


• Added recent document pinning. Pinned documents no longer decay and are always displayed first in the list.


• Added a notification for UI extension load errors, which fires when extensions are broken, incompatible, or conflict with each other.


• Added UI services to custom extension actions, enabling progress dialogs and snackbar action notifications. The Dashboard "New Schema" button now includes its first extension point in the menu.


• Fixed cases where the UI was not updated when metadata changed (e.g., schema or property renames).

Unreal Engine Formula Support

Formula support is now available in C++ code. Create a property with the Formula type, define the parameters and return type, and a class will be generated in C++ code that allows you to execute formulas with this signature from Blueprints and directly from your code.

Model Context Protocol

You can now add game data support to your preferred agenting tool (Claude Code, Copilot, Cline ...) via Charon MCP server. This server allows you to query game data based on criteria, ask questions about your game data, and make fine-grained edits with simple language commands. Be sure to instruct the agent to use the MCP server rather than attempting to modify JSON data directly.

dotnet tool install -g dotnet-charon

Claude Code (CLI):

claude mcp add --transport stdio charon -- charon MCP

New Documenation

• Server Edition


• Working with Source Code (UE C++) [Updated]


• MCP


• Workspaces, Projects, and Branches


• Formula Expression AST


• Schema Types


• Validation


• Patch and Diff Workflow


• Document Merge Logic


• CI/CD Integration


• Backup and Restore

Mail Delivery Problems

Due to issues with Google Workspace and its payment, the charon.live is currently being migrated to another email provider. Registration and two-factor authentication codes may not work. The migration is expected to take one day.

Unreal Engine Plugin Update

Features

• Added formula AST type definitions to support implementation of custom interpreters. Build-in interpreter is still in progress.


• Added automatic re-import of the game data asset after C++ code generation, ensuring the asset is updated on the next editor reload.

Fixes

• Fixed an issue where some UI icons were not displayed due to incorrect plugin path resolution.


• Resolved a warning in the Unreal Engine log caused by asset validation running before the validation module was loaded during auto-import.


• Fixed an incorrect “Failed to import game data” warning message.


• Enforced an editor restart after adding a new game data file to the project.


• Fixed the FGameDataDocumentReference type not being editable outside of “default value” contexts by changing its metadata from EditDefaultsOnly to EditAnywhere.


• Renamed Charon bootstrap scripts from .bat and .sh to neutral .windows and .unix extensions.

Code generation templates are now located in this repository: https://github.com/gamedevware/charon/tree/main/code-generation-templates

2026.1.2 - QoL Update

Date: Friday, January 16, 2026

Actual Unity Plugin: 2025.4.6
Actual Unreal Engine Plugin: 2026/01/16

CLI

• Deprecated the GENERATE TEMPLATE command in favor of direct downloads from the repository. The tool no longer bundles .tt code generation templates and will attempt to download them from GitHub when templates are requested.

Code Generation

• Breaking Change: Renamed Context in C# formulas and context in TypeScript formulas to the SetGlobal() and setGlobal() methods, respectively.


• Added AutoNullPropagation and autoNullPropagation support for formulas in C# and TypeScript generated code.


• Fixed an issue in the Unreal Engine C++ generator where an incorrect logger name caused a compilation error.

User Interface

• Added automatic focus to embedded documents when opened from the grid via double-click. Requested by <@405897367016046604>


• Added switchable single-expansion and multi-expansion view modes for document collections. Requested by <@405897367016046604>


• Added document and document collection representations in the grid, enabling navigation to embedded documents via double-click. Requested by <@405897367016046604>


• Added single-line text, localized text, and logical dropdown options to property type selectors.


• Added support for custom external asset servers for picture assets.


• Introduced a UI state service to persist per-schema and per-document UI state (e.g., expanded panels and user preferences).


• Fixed an issue where a 'null' tag appeared when the suggestion list was empty.


• Fixed delayed platform detection for Unreal Engine on macOS.


• Updated Pick List and Multi-Pick List configuration to sort options by value when editing. Unedited options retain their current order.


• Fixed the Tag form field to correctly respond to focus events in the grid and added a “no results” message for empty tag suggestion lists.

2025.4.7 - Minor Fix

Date: Tuesday, December 30, 2025

Code Generation

• Fixed an issue in the Unreal Engine C++ generator where an incorrect logger name was used, resulting in a compilation error.

User Interface

• Added support for 📋 pasting multiple numeric values separated by spaces or commas into Vector2, Vector3, Vector4, and Rectangle input fields.

2025.4.6 - QOL Update

Date: Sunday, December 21, 2025

Game Data Editing

• Fixed an issue where the ID generator could occasionally produce 0 as a document identifier. While technically valid, this value is not recommended and is now avoided.

User Interface

• Added a soft red background to visually indicate invalid cells in document tables.


• Fixed an issue where newly created table documents using custom identifiers disappeared after a successful save and only reappeared after a refresh.


• Replaced the separate Save with Errors dialog with a progressive Save → Save Anyway workflow. The option to save with errors on the first click is still available by holding the Shift key while clicking Save.


• Updated required text fields in newly created documents to initialize as null instead of empty strings, ensuring they are correctly reported as validation errors when left unfilled.

Search

Improved search relevance calculation and result sorting to favor exact matches and shorter results.

2025.4.5 - Minor Update

Date: Thursday, December 11, 2025

CLI

• Removed network interface enumeration from the log file header initialization, which previously could introduce startup delays.

Game Data Editing

• Added detection of Perforce and PlasticSCM version control systems for purpose of postponing file reloads.


• Updated the extension manager to select the latest available version between local sources and NPM packages, rather than prioritizing the local version.

Code Generation

• Added support for reusing existing Unreal Engine C++ documents when re-importing game data.


• Enabled the use of commas (,) to separate constant definitions for supported languages (C++ and C#).


• Relocated Unreal Engine C++ #define constants from the top of each file into the module declaration.


• Refactored document merge code generation to produce many smaller functions per document type rather than a single large merge function.

User Interface

• Added the app-version meta tag and the data-app-version attribute to the HTML document’s <body> element.

Added a Migrate button to the conversation editor, allowing you to convert any Schema to the desired shape directly from the error window.

2025.4.4

Date: Sunday, November 23, 2025

Game Data Editing

• Fixed an issue where re-uploading the same file through a UI extension resulted in an HTTP 500 error.

User Interface

• Added a dedicated expand/collapse button to the side menu to make the menu state easier to control and avoid confusion when restoring the expanded view.


• Implemented additional safeguards when loading invalid or malformed metadata (e.g., schemas or properties) to improve UI resilience.


• Resolved an issue where the Shift + D shortcut triggered document duplication while typing capital “D”. The table row duplication shortcut has been updated to Ctrl + Shift + D.

User Interface

• Added an Upload NPM Package button to Project Settings → Extensions for Unity Plugin, Unreal Plugin, and Standalone versions. Also added a dropdown suggestion list sourced from local NPM packages when selecting a UI extension.


• Added automatic focus on the first editable field after adding a sub-document in the Document Form.


• Added new relevance-based sorting for document search results, factoring in exact match, partial match, and Levenshtein distance.


• Replaced spinning progress loaders with skeleton loading blocks.


• Added a Subscription Expired notification with a quick renewal option.


• Disabled the Schema menu visibility field when not applicable for the schema type (e.g., Component or Union schemas).


• Added the ability to collapse or expand the side menu. On smaller screens, the menu now overlays the content.


• Added local document lookup to the reference validator to prevent false “broken reference” errors.


• Disabled CSS animations in the Unreal Engine plugin and on devices using prefers-reduced-motion.


• Ensured that ValueControl values always match the type defined by the associated SchemaProperty, improving UI extension reliability.


• Fixed an issue where changes containing Date values could not be discarded due to incorrect equality handling.


• Corrected uniqueness validation issues caused by invalid ID comparison for schemas with Pick List–based IDs.


• Fixed oversized preview images causing the asset list layout to stretch.


• Improved asset list positioning for fields located at the right edge of the screen to prevent cropping.


• Fixed validation errors showing before a control is interacted with for the first time.

• Ensured document order is preserved in collections by avoiding numeric key reordering in JavaScript objects.


• Corrected document search handling for Pick List and Multi–Pick List–based IDs.


• Fixed duplicate entries appearing in Reference Collection dropdown lists.


• Resolved an issue where editable IDs appeared in embedded documents despite IDs being immutable.


• Ensured advanced Schema fields (e.g., Display Text Template, Editor) are properly hidden in basic mode.


• Highlighted invalid non-empty fields in new documents; empty fields remain unvalidated until first interaction.


• Fixed cases where validation errors were not shown in new documents, often after page reloads.


• Fixed multiline localized text editor is not properly displayed. Reported by <@148118780671688705>


• Fixed Logical toggle showing validation error in toggled-off state. Reported by <@148118780671688705>


• Ensured JSON errors are correctly displayed for both new and existing documents.


• Ensured only actual local documents appear in Reference and Reference Collection selectors, preventing “ghost” references to removed documents.

Tagged Unions

Tagged Unions — also known as Discriminated Unions, Sum Types, ADTs, Choice Types, Disjoint Unions, or $oneOf — allow you to store documents of different shapes within the same collection or inside nested documents.
To define one, create a new Schema, set its kind to Union, and add several Properties that represent the possible variants. You can then reference this Union Schema from any Property in other Schemas where such a choice is required.

Union Schemas have several important characteristics:

• By default, they use the Numeric Sequence Id Generator.


• All of their Properties are implicitly optional.


• Unassigned Properties are not stored in the document and take no space.


• In the editor's left-side bar Union Schemas are hidden (similarly to Component Schemas), since documents of this type are always embedded inside other documents.

Language Support

C# (7.3)

To simplify work with Union types, the generated C# code includes helper methods:

• Match


• ApplyVisitor

These methods provide convenient pattern-matching–style handling of Union variants.

TypeScript

Since Sum Types are supported, the generated TypeScript code includes:

• An asUnion() converter that reinterprets a document as a Sum Type.


• A match helper method as an alternative for ergonomic pattern matching.

Haxe

Because Haxe natively supports ADTs, the generated code includes:

• An asEnum() converter that transforms a document into an Enum type.

Unreal Engine C++

To ease working with Union types in C++, the generated code includes:

• An ApplyVisitor method.


• Additional Blueprint nodes for matching a Union document against its known variants.

Custom Document Editors

Conversation Editor Source Code

This release brings a stable version of custom UI extensions for document editor.
You can now build your own editors not only for individual fields but for entire documents.
Examples include a tile-based map editor or a visual-node–based dialogue editor with graph transitions.

The extension API now provides services for accessing current game data, the currently selected localization language, and the server’s full REST API.
You can learn more about UI extensions in the documentation: https://gamedevware.github.io/charon/advanced/extensions/overview.html.

For easier development and debugging, a new button was added to Project Settings → Extensions that allows loading a UI extension from a local folder
as an NPM package. This enables rapid iteration without publishing every version to npmjs.org.

Unity Engine Plugin

• Wrapped SettingsService usage in #if UNITY_2022_3_OR_NEWER to maintain compatibility with older Unity Editor versions.


• Updated the example project to include character portraits.

Unreal Engine Plugin

• Added support for Unreal Engine 5.7.


• Added caching for FGameDataDocumentReference::GetReferencedDocument based on GameData->RevisionHash. The current GetRevisionHash() implementation is reflection-based; future generated code will provide a faster version.


• Fixed delayed visibility of asset thumbnails for 10–30 seconds after the editor starts.


• Updated the example project to include character portraits.

Search Impovements

Wherever word search is used, it now uses the Levenshtein distance, which results in a more relevant order to the query and is more forgiving of minor typos.
Improved in 2025.4.6

Known Issues

-- Unreal Engine: Error C4883 : 'UGameData::MergeDocument': function size suppresses optimizations error for very large game data files