Paint, generate and explore hand-inked 2.5D cartoon terrain — terraces, cliffs, rivers, waterfalls, chasms, bridges and forests — rendered live in a comic look (one light ramp, hatching, ink outlines, soft shadows).

The terrain comes from a prototype of a flui.gg project: first built in TypeScript/three.js, then ported to Godot with Claude Code and Codex, reworked and boiled down into this standalone studio. Everything is code and shaders; there are no hand-made textures, models or sprites.

1. Clone this repository, or download it with Code → Download ZIP and unpack it (Windows 10/11).
2. Double-click Start.cmd. The first start downloads Godot 4.7.2 .NET, builds the project and imports the shaders, which takes a minute or two. A welcome card then offers the three modes.

Nothing has to be installed first: if the PC has no .NET SDK 8 or newer, Start.cmd also downloads a private .NET SDK 10 into .tools (about 290 MB). If the start fails, the window stays open and says why; the studio's own log is %APPDATA%\Godot\app_userdata\Cartoon Terrain Studio\logs\godot.log.

The studio has three modes, switched at the top of the window:

Style (top right) changes how the terrain looks, live and without rebuilding it: nine looks, Shuffle look (every press a clearly different look, rock included) with a variety dial, time of day, season (spring → winter), weather (clear, wet, rain, snow) and the six sliders people use most. All settings holds every material control — colour grade per material family, meadow/soil/path mixing, grain, stones, rock texture, strata, moss, pattern sizes, wind, water, weather, light and ink — and the Terrain shape switches (organic rock, uneven ground, 3D vegetation, flowers), which rebuild the terrain. Styles can be saved and loaded.

Generate a map …	… and edit it in Paint
Explore endless worlds	Restyle everything live

Every seed grows a world of its own, and every look restyles it:

• Windows 10/11 (Direct3D 12 or Vulkan), a GPU from roughly 2018 onwards (a Linux export preset is included but untested)
• .NET SDK 8 or newer — or let Start.cmd download a private one into .tools
• Godot 4.7.2 .NET — or let Start.cmd download it into .tools

Start.cmd (see Quick start) takes these options:

The project is an ordinary Godot 4.7 C# project; no scripts or tools beyond the editor are needed.

1. Install Godot 4.7.2 .NET (the ".NET" download) and the .NET SDK 8 or newer.
2. In the Project Manager choose Import, select project.godot and open it. The first import takes a minute.
3. Press F5 (or the ▶ button). Godot builds the C# code and runs scenes/Studio.tscn.

What you find in the editor:

• scenes/Studio.tscn is the main scene. Its root node Studio (src/Studio/StudioMain.cs) has three options in the Inspector: Start Mode (open in Paint, Generate or Explore instead of the last used mode), Start Quality and Allow Welcome. The rest of the interface is built in code, so it follows one design system.
• Colours, spacing, fonts of the interface: src/Studio/Ui/StudioTheme.cs. Icons are drawn from a few lines of path data in src/Studio/Ui/Icons.cs. Texts are written in the code and pass through src/Studio/Ui/Tr.cs.
• Looks (the Style presets), their colours and the season/weather keys: src/Studio/Core/LookSettings.cs.
• Shaders: shaders/ and assets/shaders/ — edit them in the editor's shader editor; the running studio picks the changes up on the next start.
• Editing C#: set your IDE under Editor → Editor Settings → Dotnet → Editor → External Editor; double-clicking a script then opens it there. The code is indented with four spaces (.editorconfig); Godot's built-in script editor converts to tabs on save unless Text Editor → Behavior → Indent → Type is set to Spaces.
• Debugging: open CartoonTerrainStudio.sln in Visual Studio, Rider or VS Code (C# Dev Kit) and attach to the running Godot process, or use Godot's own debugger panel (errors and GD.Print output appear there).
• Command-line options from the table above go into Project → Project Settings → General → Editor → Run → Main Run Args after --, for example -- --mode world --seed amber-vale-7.

1. Editor → Manage Export Templates → Download and Install (once per Godot version).
2. Project → Export: the presets Windows Desktop and Linux are ready. Choose one and press Export Project. The build lands in build/export/.

Everywhere

Paint

Generate: Enter makes a new map, Space skips the build animation. Explore: R rolls a new random world.

The line at the bottom of the window always explains what the current tool does.

• Maps are JSON documents of kind fluitown.terrain-artifact, version 1. The studio adds a look object, which is applied when the map is opened; maps saved from Generate also get a recipe object. Tools that don't know these fields ignore them.
• Styles (style.json) contain every Style value that differs from its default.
• Height maps: File → Export height map writes a grey-scale PNG with one pixel per cell (black −30 … white +25) plus a colour PNG of the materials.
• User data lives in the Godot user folder (%APPDATA%\Godot\app_userdata\Cartoon Terrain Studio):
  • settings.json holds the mode, quality, style, Explore seeds and saved places, and the generator recipe.
  • autosave.terrain.json holds the last painted map, which is restored on start.

project.godot, CartoonTerrainStudio.csproj/.sln, export_presets.cfg, icon.svg, Start.cmd/.ps1
LICENSE, THIRD_PARTY_NOTICES.md
scenes/Studio.tscn            main scene
src/Studio/                   the studio (namespace TerrainStudio)
  StudioMain.cs               modes, menus, keyboard, settings, screenshots, command line
  SelfTest.cs                 scripted checks (--selftest paint|look|world|generate|suite|ui <folder>)
  Terrain/                    TerrainView (renderer + session + camera + picking), orbit camera, overlays, look applier
  Modes/Painting/             painter: tool model, panel, controller (strokes, sculpting, compile worker, selection, files)
  Modes/Generate/             generator panel/controller and the build animation
  Modes/WorldController.cs    Explore: worlds, seed suggestions, minimap, saved places
  Core/                       engine-free studio logic: look settings, document/undo, themes, seeds, playback, overlays
  Ui/                         design system (theme, icons, widgets), shell, Style drawer, Explore panel, world previews,
                              dialogs, texts (Tr)
src/Domain/                   terrain domain (generation, editor, validation, map composer), engine-free
src/Render/                   terrain renderer core (tile manager, bake workers, geometry compiler, materials)
src/Runtime/                  JS-semantics helpers used by the port
src/Godot/                    Godot side of the renderer (scene renderer, lane meshes, vegetation, uniform binder)
src/Comic/                    the comic pipeline (material admission, world ink outline)
shaders/terrain, shaders/vegetation, shaders/studio, assets/shaders   shaders
assets/terrain/               the material noise texture of the terrain shader
docs/ARCHITECTURE.md          how the terrain is built and drawn, and how the studio is put together
docs/images/                  the screenshots of this README (ignored by Godot)

See docs/ARCHITECTURE.md for how the terrain is built and drawn, and for how the studio is put together.

.tools\Godot_v4.7.2-stable_mono_win64\Godot_v4.7.2-stable_mono_win64_console.exe --path . -- --user-dir build\selftest\userdata --selftest paint build\selftest\paint

Each self-test drives the studio through its controls, waits for the terrain after every step, and writes one screenshot per step plus report.txt. The exit code is 0 when every step passed. --user-dir gives the run a settings folder of its own, so it neither depends on nor changes yours. The scenarios are:

• paint: ridge, plateau, lake, forest, bridge, theme brush, sculpting (raise once per stroke, lower), undo/redo, chasm
• look: every look, a shuffled look, autumn, winter, rain, dusk and night
• world: several themes and seeds, a random world and a far-away place
• generate: one composed map with its build animation, then the live dials: Mountains, Water, Chasms and Forests at 0% leave none of their feature, and back at their defaults the dials give exactly the first map again
• suite: end to end: generate, hand to the painter, paint, save/load round trip, terrain shape switches, 3D view and picking, Explore, and an area taken into the painter
• ui: a screenshot of every tool page, panel and card

Cartoon Terrain Studio is released under the MIT License. It contains code derived from three.js, V8/fdlibm and Dave Hoskins' "Hash without Sine"; their notices are in THIRD_PARTY_NOTICES.md.