dotnet-charon 2026.4.0

.NET 8.0 This package targets .NET 8.0. The package is compatible with this framework or higher.
There is a newer version of this package available.
See the version list below for details. 
dotnet tool install --global dotnet-charon --version 2026.4.0
This package contains a .NET tool you can call from the shell/command line. 
dotnet new tool-manifest
                    


                            if you are setting up this repo
                        

                    

                
dotnet tool install --local dotnet-charon --version 2026.4.0
This package contains a .NET tool you can call from the shell/command line. 
#tool dotnet:?package=dotnet-charon&version=2026.4.0
                    


                    

                
nuke :add-package dotnet-charon --version 2026.4.0

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 dotnet runtime 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
    On .NET SDK 10+, you can also run the tool once without installing it by prefixing commands with dnx dotnet-charon -- (e.g. dnx dotnet-charon -- gamedata.json). Once set up, follow these steps:
  • Create an empty gamedata.json file or use dotnet charon INIT gamedata.json command.
  • Launch the Charon tool by running: 
    dotnet charon gamedata.json
    This command starts an HTTP server and automatically opens the Charon UI in your default web browser.
  • 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.json file 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 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. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

This package has no dependencies.

Version Downloads Last Updated
2026.4.1 59 9/1/2026
2026.4.0 83 8/31/2026
2026.3.4 287 7/4/2026
2026.3.2 266 5/20/2026
2026.2.1 327 3/27/2026
2026.1.2 322 1/16/2026
2025.4.7 303 12/30/2025
2025.4.4 413 11/23/2025
2025.4.2 460 10/13/2025
2025.4.1 460 8/19/2025
2025.3.3 491 5/26/2025
2025.2.2 368 4/25/2025
Loading failed

# 2026.4.0
Date: Monday, August 31, 2026
## 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:** 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.
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.
- 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](https://gamedevware.github.io/charon/gamedata/basics.html) [Reworked]
- [Editing a Document](https://gamedevware.github.io/charon/gamedata/document_form.html) [New]
- [Filling Documents](https://gamedevware.github.io/charon/gamedata/filling_documents.html) [Reworked]
- [Schema](https://gamedevware.github.io/charon/gamedata/schemas/schema.html) [Updated]
- [Schema Property](https://gamedevware.github.io/charon/gamedata/properties/property.html) [Updated]
- [Publishing Game Data](https://gamedevware.github.io/charon/gamedata/publication.html) [Reworked]
- [Generating Source Code](https://gamedevware.github.io/charon/gamedata/generating_source_code.html) [Reworked]
**Advanced**
- [Importing and Exporting Data](https://gamedevware.github.io/charon/advanced/import_export.html) [Reworked]
- [Internationalization (i18n)](https://gamedevware.github.io/charon/advanced/internationalization.html) [Reworked]
- [Validation](https://gamedevware.github.io/charon/advanced/validation.html) [Reworked]
- [Backup and Restore](https://gamedevware.github.io/charon/advanced/backup_restore.html) [Reworked]
- [CI/CD Integration](https://gamedevware.github.io/charon/advanced/cicd.html) [Updated]
**UI Extensions**
- [UI Extensions](https://gamedevware.github.io/charon/advanced/extensions/overview.html) [Reworked]
- [Custom Actions](https://gamedevware.github.io/charon/advanced/extensions/custom_actions.html) [New]
- [Custom Pages](https://gamedevware.github.io/charon/advanced/extensions/custom_pages.html) [New]
- [Host Services](https://gamedevware.github.io/charon/advanced/extensions/host_services.html) [New]
- [Implementing `CharonSchemaEditorElement`](https://gamedevware.github.io/charon/advanced/extensions/implementing_schema_editor.html) [New]
- [Implementing `CharonPropertyEditorElement`](https://gamedevware.github.io/charon/advanced/extensions/implementing_property_editor.html) [Updated]
**Command Line**
- [Command Line Interface (CLI)](https://gamedevware.github.io/charon/advanced/command_line.html) [Reworked]
- [Search Documents](https://gamedevware.github.io/charon/advanced/commands/data_search.html) [New]
- [Examine Game Data](https://gamedevware.github.io/charon/advanced/commands/data_examine.html) [New]
- [Find Game Data Files](https://gamedevware.github.io/charon/advanced/commands/data_find_files.html) [New]
- [Project Settings](https://gamedevware.github.io/charon/advanced/commands/data_project_settings.html) [New]
- [Update Project Settings](https://gamedevware.github.io/charon/advanced/commands/data_update_project_settings.html) [New]
**Editions and Plugins**
- [Workspaces, Projects, and Branches](https://gamedevware.github.io/charon/web/workspaces_and_projects.html) [Reworked]
- [Roles and Permissions](https://gamedevware.github.io/charon/web/permission_and_roles.html)[Reworked]
- [Unreal Engine/How to Create Game Data File](https://gamedevware.github.io/charon/unreal_engine/creating_game_data.html) [Updated]