dotnet-charon
2025.3.3
dotnet tool install --global dotnet-charon --version 2025.3.3
dotnet new tool-manifest
dotnet tool install --local dotnet-charon --version 2025.3.3
#tool dotnet:?package=dotnet-charon&version=2025.3.3
nuke :add-package dotnet-charon --version 2025.3.3
Charon - Game Data Editor
Documentation • Discord • Website • Changelog • Issues
Plugins
[Unity Asset Store] [Unity OpenUPM] [Unreal Engine Marketplace]
Standalone
How to start with custom game engine → C# • TypeScript
Summary
Charon is a powerful data-driven game development tool designed to streamline the creation and management of static game data within Unity. It allows both developers and game designers to efficiently model and edit game entities such as characters, items, missions, quests, and more, directly within the Unity environment. Charon simplifies the process of data manipulation, offering a user-friendly interface and automatic source code generation, which significantly reduces development time and minimizes manual coding errors. Charon also offers support for working with text in multiple languages, with easy loading and unloading of translated text.
With Charon, game developers can focus on creating engaging gameplay experiences without worrying about the technical details of managing game data. It is available in three deployment variants, including a standalone/offline application, web application, Unity and Unreal Engine plugins.
Why Choose Charon?
Charon replaces traditional spreadsheets or config files with an in-game database, offering a structured and efficient way to manage game data. It allows developers to focus on creating engaging gameplay experiences without worrying about the technical details of data management.
Is It Free?
The offline version, CLI and plugins are completely free and have no restrictions. They are distributed under a free license and allow you to distribute tools along with the game for modding games.
The online version, which allows working in large teams on shared game data, requires a subscription.
What is Charon
It is a .NET 8 console application that can be used as a command-line tool for performing CRUD operations with your game data, or as an HTTP Server to provide a UI for modeling and editing your game data. There are plugins for Unity and Unreal Engine that provide a more integrated experience while using Charon.
As with any .NET application, it can be launched as is on Windows, macOS and Linux and via dotnet.
How it works
To get started with Charon, you’ll need the following:
- The
dotnetruntime installed. - Either Unity [Asset] [OpenUPM], the Unreal Engine plugin, or the standalone tool, which you can install globally using the command:
dotnet tool install dotnet-charon --global
Once set up, follow these steps:
- Create an empty
gamedata.jsonfile or usedotnet charon INIT gamedata.jsoncommand. - Launch the Charon tool by running:
This command starts an HTTP server and automatically opens the Charon UI in your default web browser.dotnet charon gamedata.json - Use the intuitive web-based UI to design and edit your game data.
- After editing, utilize Charon’s source code generator to produce engine-specific source code for your game data.
- Integrate the generated source code into your game project. This allows you to load the
gamedata.jsonfile into your game in a structured and type-safe way, ensuring seamless and error-free data usage.
C# Code Example
using System.IO;
using var fileStream = File.OpenRead("gamedata.json"); // or .gdjs
var gameData = new GameData(fileStream, new Formatters.GameDataLoadOptions { Format = Formatters.Format.Json });
var heroes = gameData.Heroes.AsList // -> IReadOnlyList<Hero>
// or
var heroById = gameData.AllHeroes.Find("Arbalest"); // -> Hero | null
C++ Code Example
#include "UGameData.h"
TSoftObjectPtr<UGameData> GameDataPtr = TEXT("/Game/Content/GameData");
auto GameData = GameDataPtr.LoadSynchronous(); // -> UGameData*
auto Heroes = GameData->Heroes; // -> TMap<FString,UHero*>
auto HeroById = GameData->Heroes.Find(TEXT("Arbalest")); // -> UHero**
TypeScript Code Example
import { GameData } from './game.data';
import { Formatters } from './formatters';
// Node.js
import { readFileSync } from 'fs';
const gameDataStream = readFileSync(gameDataFilePath);
// Blob or File
const gameDataStream = gameDataFileBlob.arrayBuffer();
// XMLHttpRequest (XHR)
// gameDataRequest.responseType -> "arraybuffer"
const gameDataStream = gameDataRequest.response;
const gameData = new GameData(gameDataStream, {
format: Formatters.GameDataFormat.Json
});
let heroes = gameData.heroes; // -> readonly Hero[]
let hero = gameData.heroesAll.find("Arbalest"); // -> Hero | undefined
Haxe Code Example
import GameData;
import Formatters;
import haxe.io.Path;
sys.io.File;
var input = File.read("RpgGameData.gdjs"); // or .json
var options = new GameDataLoadOptions();
options.format = GameDataFormat.Json;
var gameData = new GameData(input, options);
var allHeroes = gameData.heroesAll.list // -> ReadOnlyArray<Hero>
var heroById = gameData.heroesAll.get("Arbalest"); // -> Hero
License
- Generated Code - MIT
- Plugins:
- Unreal Engine - MIT
- Unity - Unity Asset Store License
- Charon - CC BY-ND - can freely use and can redistribute, as long as it is passed along unchanged and in whole.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 was computed. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 was computed. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
This package has no dependencies.
# 2025.3.3
Monday, May 26, 2025
## CLI
- Added `--validationOptions` parameter to all data-modifying commands. You can now use `--validationOptions None` to disable data validation.
- Improved descriptions for CLI parameters related to data manipulation.
- Fixed the `--resetPreferences` flag not being respected in standalone mode; it now correctly clears user preferences on startup.
- Updated CLI documentation with clearer descriptions of commands and their parameters.
## Code Generation
- Removed `Schema` and `SchemaProperty` from generated classes.
- Fixed a bug with wrong collection types in the generated Haxe code.
- Fixed a bug with duplicating extension method names in the generated Haxe code.
## Game Data Editing
- Import reports now include a list of skipped documents.
- Added support for string length limit specifiers (e.g., `L100`) in Display Text Templates, where the number defines the character limit.
- Fixed incorrect formatting of Pick List values in Display Text Templates—they now use display names instead of numeric values.
## User Interface
- Added live preview of Display Text Template output using the first valid document.
- Introduced layout animations in forms to indicate when data changes.
- Added a release notes announcement window to the project dashboard.
- Improved Export, Backup, Restore, Code Generation, and Publish wizards with clearer help text, tooltips, and links to documentation.
- Enhanced Import Wizard results to show all imported documents along with their status (created, updated, deleted, etc.).
- Updated Import Localization Data flow to provide a detailed import report, consistent with the main Import Data wizard.
- Fixed an issue when importing raw document collections (JSON array as root) from the UI. Now requires a single schema name in the parameters to reconstruct the document structure properly.
- Made the "Import TypeScript Interface as Schema" feature available offline (+Plugins).
# 2025.3.2
Monday, May 12, 2025
## User Interface
- Resolved an issue where the TypeScript interface parser could hang the JavaScript interpreter.
- Fixed importing of raw document collections (i.e., JSON arrays as root documents) via the UI. This now correctly requires exactly one schema name in the input parameters to properly reconstruct the document structure.
- Fixed breadcrumb titles now update correctly when the underlying content changes.
# 2025.3.1
Friday, May 2, 2025
## General
- Added support for URLs in the format `https://charon.live/view/project/{projectName}/{branchName}/` to the CLI, in addition to existing `/view/data/` URLs, improving compatibility.
## CLI
- The `enum` CLI parameters are now matched in a case-insensitive manner.
- The `--defineConstants` parameter now supports multiple values.
## Game Data Editing
- Support for array indexing and properties like `Count`/`Length` in Display Text Templates.
- Automatic coercion of Document, Collection, Text, Localized Text, Number, Integer, and `null` values to Logical (boolean). Collections and strings are checked for emptiness.
- Format specifier support in Display Text Templates, similar to C# (e.g., decimal precision `F`, hexadecimal `X/x`, binary `B`).
- Template functions such as `Trim`, `Substring`, `Join`, and `ToString` in Display Name Templates.
- Fixed incorrect evaluation of the Left Shift operation in Display Text Template interpolation.
- Export results no longer include empty collections from non-included Schemas.
- Metadata is now grouped under a "Metadata" section during migration to the latest tool version. Icons for Schema, Property, and Project Settings have also been updated.
## Code Generation
- Support for accessing `.Length` and `.Count` on arrays from TypeScript formulas.
## User Interface
- Validation error messages are now clearer.
- Added auto-completion suggestions for the Display Text Template field in Schema designer.
- Added icons to sub-types and editors to help visually distinguish them in selection lists.
- Added option to import a TypeScript interface directly as a Schema.
- Resolved an issue in the TypeScript interface parser that could freeze the JavaScript interpreter.
- Added staging environment warning banner on the login page.
- Disabled "Uniqueness" and "Requirement" fields for the `Id` field in schema designer.
- Updated description for the `Id Generator -> Sequence` setting to indicate that IDs are unique within their schema.
- Discarding changes in collections now properly deletes temporary documents and avoids leaving empty items behind.
## Web Application
- The web editor now suggests available assets from game data when selecting assets (previously returned an empty list).
- Improved resource usage calculation in subscription to prevent `tooManyProjects` errors.
# 2025.2.2
Wednesday, April 23, 2025
## Overview
- Introduced a UI extension mechanism for creating custom field editors using `Web Components` packaged as NPM modules.
- Added new data subtypes: `Asset` / `Asset Collection` with support for Unity, Unreal Engine, and standalone assets.
- Introduced `Tag` / `Tag Collection` data subtypes for free-form tagging of documents.
- Added new data types: `Vector2`, `Vector3`, `Vector4`, and `Rectangle` for representing engine-specific structures.
- Implemented `Shared Properties` to synchronize property parameters across multiple schemas.
- Added support for Chrome 93 to maintain compatibility with Unreal Engine’s CEF 93.
- Extended REST API documentation for improved clarity and integration support.
---
## Game Data Editing
- Added `select` parameter to the List Documents CLI/REST endpoint to allow output shaping by including specific fields.
- Introduced the `Extensions` field in `ProjectSettings` to specify which NPM packages should be loaded into the editor.
- Enhanced support for `Multi-Pick List` types with multiple delimiters (space, `;`, `|`) to assist future tag conversions.
- Fixed saving issues for documents using PickList-based identifiers (`Id`) which previously threw "Document not found".
- Fixed errors when creating `Settings` or `Component`-typed schemas to ensure at least one document is created.
- Resolved validation logic preventing switching to types requiring `ReferenceType` values.
- Automatically remap legacy requirement value `1 (Unused)` to `2 (NotNull)` for better consistency.
---
## User Interface
- Added a "Graph" button to switch to a custom Schema editor.
- Enabled custom/extension editor selection at both the schema and property levels.
- Automatically load and register editor extensions during grid/form rendering.
- Added an Extensions table in Project Settings to manage and verify loaded extensions. Imposed size/count limits in the online version to prevent abuse.
- Displayed native tooltips for long property names and field hints.
- Implemented REST APIs for file retrieval and extension load progress monitoring.
- Added a `Sync Name` field in the Schema Designer for shared properties.
- Exposed document form, JSON view, and fields as `Web Components` for extension integration.
- Persisted view mode (`form`, `layout`, `json`) in the document URL for sharing and reload consistency.
- Disabled password reset for invited (non-registered) users and improved error messages.
- Fixed JSON view sync issue when editing documents.
- Hid navigation buttons (next/previous) for newly created documents.
- Fixed navigation button behavior when opening documents directly via link.
- Added icons to distinguish subtypes/editors in selection lists.
- Merged `Custom Editor` and `Data Type` fields into a unified `Data Type` tree in the Schema Designer.
- Added `Tags` subtype that shares tag lists across documents.
- Introduced alternative editors (`Toggle`, `Button Toggle`, `Checkbox`) for `Logical` types.
- Added subtypes for `Vector2`, `Vector3`, `Vector4`, and `Rectangle`.
- Fixed a memory leak in `AbstractFieldComponent` by unsubscribing `valueControl` on destroy.
- Ensured `Text` fields are initialized as `null` instead of empty strings.
- Automatically remove draft documents on save/discard/reload to reduce local storage clutter.
---
## CLI
- Added `--select` parameter to `DATA LIST` CLI command to control output structure by selecting specific fields.
---
## Code Generation
- Ensured shared properties generate enums consistently, even when `Generated Type Name` is not explicitly set.