Features

Every editor area of Terra Engine, what it does and where its limits are. Built on a real game and checked by tests.

Area editor

The area editor is where your world takes shape. You paint ground with a brush in several sizes, scatter, fill, erase, select and stamp, and you place world pieces from a library of about 9,900 entries.

The library has search, filters and favorites, and you can switch art styles and colors. Stairs come in twelve kinds, and steps, cliffs, rock walls, hills and ascents have their own tools. Protected layers keep finished work safe.

A check line lists problems while you build. Undo and redo, mouse-wheel zoom in whole steps, copy, paste, duplicate and mirror are built in, and a play-from-here button starts the game at the spot you are working on. Areas can be split and moved.

Brush, scatter, fill, eraser, select, stamp
About 9,900 world pieces with filters and favorites
Twelve kinds of stairs, cliffs, rock walls, hills
Check line, undo and redo, play from here

World and planet generator

The world generator works with planets, biome zones and rules, and shows a preview and a zone map. Our data holds 13 biome files across several planets.

A generator can fill an area from a biome. It uses a seeded random generator, so the same seed gives the same result.

A walk measurement checks whether the result is reachable, using the real hero speed of 120 px per second (about 3.75 tiles per second at 32 px).

Planets, biome zones and rules
Preview and zone map
Seeded, reproducible generation
Walk measurement for reachability

Dungeon and mine editor

Mines and dungeons are built as floors made of rooms with roles, such as entrance, elevator stop or ore storage. Doors work with keys, floors connect through stairs, ladders and holes, and respawn points are set per dungeon.

You switch between a plan view and a close-up view, and a check reports problems. A builder turns the plan into game scenes, and the same plan always gives the same result.

Enemies, chests and light belong to the setup. Our game ships 117 dungeon data files.

Floors made of rooms with roles
Doors, keys, stairs, ladders, holes
Plan view, close-up view, check
Deterministic builder: same plan, same scenes

Quests

Quests are drawn as a network of stages and areas. You edit each quest through step forms and condition sets, so you describe what has to happen without writing code.

There are 24 step types: go to, travel, gather, mine, craft, build, repair, defeat, talk, deliver, investigate, interact, use, solve a puzzle, defend, escort, learn, dungeon goal, wait, decision, world fact, event and group.

Templates come with a difference view, and a check runs before you save. Quest anchors tie a quest to a place in the world. A main-quest layer and a chapter book are separate areas on top. Our own game uses about 100 quest files.

24 step types
Condition sets, templates with difference view
Quest anchors tie quests to places in the world
Main-quest layer and chapter book

Our separate app, available now

Quest Helper

A calm, visual planning board where you lay out a region and its quests together: where things are, what happens there, and why the player moves on.

Quest Helper is our planning board for every game developer, as its own app. It works with or without Terra Engine. Try it at quest-helper.com.

Region and story in one view: every stop on the map is a place and a piece of the story.
Treasure map and storyboard: plan on the map, read your journey like a comic strip.
Quest type box: 9 proven quest types built from 25 design templates, instantly shows what your region is missing.
Built for creative people, not spreadsheets: big pictures, one sentence per idea, details only on click.
Works fully by hand, with one plan file per region.

Game systems

The systems area is where you work with the ready-made runtime systems that the other editors sit on: inventory, combat, farming, crafting with recipes and workbenches, merchants, currency, companions, hazards, weather, day and night, sleeping, hunger and stamina bars, and buffs.

These systems come from a real game, not from a diagram. They save through their own save sections, talk to each other through registered events, and are available through the command interface (Pro license).

Inventory, merchants and currency
Real-time combat with roll, block and parry
Farming, fishing and crafting
Weather, day and night, hunger and stamina

Sound engine

The sound engine starts with a library with search and tags. You assign sounds to places in the game, and our game has 112 sound places with 292 assignments.

Music runs in intensity levels (calm, tension, combat) with crossfades. Ambience and voiced lines have their own tabs, and a play bar plus volume controls let you listen while you work.

The library of our game lists 1,025 sounds. Playback goes through one audio service with a pool of players.

Library with search and tags
Sounds assigned to places in the game
Music in calm, tension and combat levels with crossfades
Ambience and voiced lines

Progression and loot

Progression is tuned in charts. Level and XP curves are drawn as diagrams (hero level cap 100, profession level cap 10), and enemy profiles are set per chapter.

Loot is edited as pools: loot per enemy, per level and per planet, plus chest contents with undo.

Every balancing number lives in one place instead of being scattered through code. A script counts numbers that slip into code and may only go down, and a time-to-goal report tells you how many hours it takes to reach your goals.

Level and XP curves with charts
Enemy profiles per chapter
Loot pools per enemy, level and planet
Chest contents with undo

Story workshop and dialogue

The story workshop reads a story database kept with your project and lets you work with it next to the rest of the editor. Its format is specific to our setup.

Dialogue is written as branching conversations with a script editor and a test-dialogue button, so you can play a conversation without starting the game. Dialogues can be exported and imported for translators.

Quests, dialogue and story share one text service, so every line has one place and one entry per language.

Story workshop next to the other areas
Branching dialogue with a script editor
Test-dialogue button
Export and import for translators

Notes

The notes area keeps project context inside the editor, next to the tools you work with. It is read-only through the command interface (Pro license), so a script can read your notes but not change them. Game data itself lives in the JSON content of your project.

Project notes inside the editor
Readable through the command interface (Pro license)

Segments

Segments and tags give you a way to group and label parts of your areas. They have their own area in the editor, separate from the area editor, and they are available through the command interface (Pro license).

Own area for segments and tags
Available through the command interface (Pro license)

Game catalog

The game catalog holds all game content, sorted by system: farming, mining, gathering, crafting, professions and talents, combat, trade, abilities, and the world with weather, hazards and companions.

You create, edit and delete entries, see references as a list or as a graph, and work in tables with a choice of columns.

Our game ships 82 catalog files, 49 enemy definition files and 7 recipe files, all as plain JSON. The trade and world tabs are still in final review.

Everything sorted by game system
References as list and graph
Tables with column choice
Plain JSON content

Built in

The foundations that run through every editor, from co-op and languages to saves, the Steam Deck build and tests.

Co-op multiplayer up to 5 players

Terra Engine is built for co-op with up to 5 players: one host plus guests. Players can be in different areas at the same time, because the host can load several areas at once.

One machine is the host and computes everything that is saved: world, objects, story, quests, enemies, clock and loot. Guests send only the commands of their hero and display what the host sends. Playing alone uses the same path, with your own machine as host.

Inventory, stats, progression, input, pause, dialogue and sleep are kept per hero, and the save format keeps world data and per-player data apart. Enemy balancing already scales with the number of heroes in the same area.

Honest status: the host model, the network layer and the tests are done. Online play through Steam lobbies and invites is still being added, so plan your release around what you have tested yourself.

Languages and text service

All text a player sees lives in one text service as German and English entries (24 text files in our game), and the game reads it through one function.

The language list is extendable. German and English ship today, and the planned design adds more languages through standard translation files. Dialogues can be exported and imported for translators.

The editor interface itself is in German today, and an English interface is being prepared.

Stable world object IDs

The engine assigns the ID of every world object. It is never derived from path, name or list position, so renaming a chest or moving an object does not lose its state.

State moves with the ID when you rename, orphaned states are reported, and unknown IDs get an alias or a message instead of being dropped silently.

Save system and migration

The save system has slots and writes atomically with a backup. The format is versioned (current version 17) with migration steps.

For every earlier version from format 8 to 17 there is a real test file, so old saves keep loading when you update the engine.

Steam Deck export and size guard

A ready export preset builds a Linux package for the Steam Deck, with a separate data pack, and a nightly build script runs it. A size guard keeps a budget and a baseline that may only shrink, so the package does not creep up unnoticed.

Windows, macOS, Linux and Web exports use the export mechanism of the underlying engine. The Steam Deck path is the one we run nightly for our own game.

Automated tests and checks

About 1,400 test files cover the game systems. A type check makes sure untyped code may not increase, and a lint script, a text check and a test queue run alongside.

Architecture layers and balancing numbers are checked by scripts with baselines that may only improve, so quality does not slide while the project grows.

Start building your pixel RPG.

Buy Try free