Loreset — Headless CMS for Game Content

Why Loreset

Game content is data, not spreadsheets

Generic CMSs don't understand polymorphic rewards, nested structures or balance versions. Loreset is designed for game developers and designers from day one.

Schema-as-Code (LSL)

Schemas are written in Loreset Schema Language — an extended JSON Schema with game-specific types: relation, union, dictionary, enum, asset. Keep schemas in Git; the admin UI generates forms automatically.

Immutable revisions

Every change to a record or schema creates a new snapshot. Old data is never overwritten: version diffs, full history and safe rollback are guaranteed by the architecture.

Built-in i18n

Translations live inside the JSON document and are automatically indexed into a flat registry. Export to CSV for Google Sheets and import back — with translation versioning preserved.

Hybrid Storage

Metadata, relations and versions go into relational tables in SQLite or MySQL. The objects themselves, with unlimited nesting, are stored as JSON documents. No exotic databases required.

API-first & CI/CD

REST API only, with JWT authentication and a single response contract. Bundle import and export plug into any build pipeline: Dev → Stage → Prod in one request.

CDN publishing

One click — and a versioned content bundle together with the versions.json index is uploaded to an S3-compatible CDN. The game learns about a new version without ever calling the API.

Loreset Schema Language

Polymorphism as a first-class type

A bonus reward can be a currency, an item or a skill — each with different fields. In LSL it's a single union type with a discriminator: the admin UI renders the right sub-form, and the validator checks the data before saving.

relation — links between collections with filters and target existence checks
union — one of several structures chosen by a discriminator field
dictionary — maps like "currency → amount"
i18n_string — translatable fields with automatic indexing

LSL specification →

"rewards": {
  "type": "array",
  "items": {
    "type": "union",
    "discriminator": "reward_type",
    "variants": {
      "currency": { "$ref": "#/$defs/RewardCurrency" },
      "item":     { "$ref": "#/$defs/RewardItem" },
      "skill":    { "$ref": "#/$defs/RewardSkill" }
    }
  },
  "ui": { "label": "Reward entries" }
}

// The game client downloads a static versions.json…
{
  "format": "loreset/versions-v1",
  "project": "heliostorm",
  "latest": 7,
  "versions": [
    {
      "version": 7,
      "file": "bundle-v7.json",
      "checksum": "sha256:ab12…",
      "items_count": 132
    }
  ]
}
// …and updates content without an app store release

Live content

Update balance without rebuilding the game

Publishing uploads a self-contained bundle to the CDN: schemas, published records and the translation dictionary, with a monotonic version number and a checksum. A single static file request is enough for the client to know whether there's an update.

No API calls from the game — static CDN files only
Integrity checks via sha256 checksum
Publication history — roll back to any previous version

versions.json format →

Collaboration

One platform for the whole team

A flexible access model: project-level roles plus per-collection overrides for individual users.

Game designer

Tweaks balance in forms generated from schemas, compares revisions and rolls back unsuccessful changes.

Developer

Keeps schemas in Git, moves content through the REST API, wires bundle export into the CI/CD pipeline.

Translator

Works with the translation registry or plain old Google Sheets — CSV export and import out of the box.

Producer

Manages members and permissions, tracks publication history, hides sensitive collections via ACL.

Demo project

Heliostorm — a game fully driven by Loreset

A vertical arcade shooter built with Godot 4.6. All content — ships, weapons, enemy waves, bosses and balance — lives in a single loreset/bundle-v1 bundle and updates from the CDN at launch.

Heliostorm — main menu — Menu: bundle version in the footer

Heliostorm — gameplay — Enemy waves come from Loreset collections

Heliostorm — hangar — Hangar: items and prices from the CMS

Heliostorm — victory screen — Rewards described by LSL schemas

Demo source on GitHub Play now!

Integrations

Plugs into your engine

The bundle is plain JSON readable from any language. Plugins will make integration even simpler.

Godot

Plugin in development. A working reference is already available: bundle loader, ContentDB and hot CDN updates in the Heliostorm demo project.

Unity

Integration planned: a package with typed access to collections, bundle caching and runtime content updates.

Any engine

Unreal, Defold, custom engines — the bundle and versions.json are static JSON files on a CDN. An HTTP client and a JSON parser are all you need.

14+

LSL data types, including union and relation

100%

of changes are versioned — revisions are immutable

2

databases out of the box: SQLite and MySQL

1

static request — and the game knows about new content

Open Source

Open code under Apache 2.0

Loreset is developed in the open: self-host it on your own infrastructure with no restrictions, or use cloud hosting with a free tier — your data can always be taken away as a bundle export.

No vendor lock-in — a SQL database and a portable bundle format
Local publishing driver for development, S3-compatible for production (MinIO, DO Spaces, Selectel and more)
OpenAPI spec and a Postman collection generated from code

See pricing

# Publish content from CI/CD
curl -X POST https://api.loreset.dev/v1/projects/1/publish \
  -H "Authorization: Bearer $LORESET_TOKEN"

# Response
{
  "success": true,
  "data": {
    "version": 7,
    "file_url": "https://cdn.example.com/bundle-v7.json",
    "checksum": "sha256:ab12…",
    "items_count": 132
  }
}

Headless CMS for Game Content