Gaea 2 Illustrated Tutorial

A systematic guide to Gaea 2. The tutorial chapters explain every functional area and the parameter system; the node reference covers all 182 built-in nodes and is searchable in both Chinese and English; the case studies walk through six complete builds you can follow step by step; the troubleshooting chapter is organised by symptom.

Node names, parameter names and feature descriptions follow the official Gaea 2 documentation. The illustrations were generated to demonstrate landforms and are not screenshots of the software. Use the controls at the top right to switch between the light and dark theme, and between Chinese and English.

First, the whole process at a glance

These five images are the same terrain at five stages. Remember the order — establish the large form, then erode, then add surface detail, then colorize — and you have the skeleton that every case study later on is a variation of.

How to use this tutorial

• Complete beginner: read from "What Gaea 2 is" through "Core concepts", then jump to case one in "Build from scratch" and get a full pipeline working with three or four nodes. Come back to "Functional modules" afterwards.
• Experienced, solving a specific problem: go straight to the node reference. Type what you want to do (for example erosion, colour, fracture, dunes) to locate the node, then open its parameter table.
• Debugging: the troubleshooting chapter is grouped by installation and licensing, performance, graph and nodes, terrain quality, export and import, and colour and texturing.

What Gaea 2 Is

Gaea 2 is a procedural terrain generation application for Windows, developed by QuadSpinner. It does not ask you to sculpt mountains by hand. Instead, you build a node graph: each node does one job — generate a shape, distort an outline, simulate erosion, lay down rock strata, colorize, export — and once you connect them in order, the terrain is processed step by step along that pipeline. Change one parameter and the downstream chain recomputes, so the shape changes with it.

The Gaea interface is organized around one loop: build terrain logic in the Infinity Graph, preview it in the Viewport, and tune parameters in the Property Editor. That loop defines how the tool works. Parameter changes show up in the viewport immediately, so you can iterate at a very low resolution and only build at high resolution once the shape looks right.

It is primarily an asset generator. Gaea outputs heightfields, masks, color maps, splat maps, meshes, point clouds, and tiled worlds for downstream tools such as Unreal, Unity, Houdini, and Blender. It supports the mainstream heightfield and mesh formats, and provides engine-specific output nodes plus bridge integrations such as Gaea2Unreal and Gaea2Houdini. The Gaea 2 node library contains more than 180 nodes, grouped by family into nine categories: Primitive, Terrain, Modify, Surface, Simulate, Derive, Colorize, Output, and Utility.

Gaea 2.0 is a generation rewritten from the ground up. It shares the same brand as Gaea 1, but the engine, file format, and node system have all been replaced, which matters a great deal when you migrate.

Version and Licensing Differences

The version name that appears throughout the documentation is the Gaea 2.0 generation. The silent installation example gives the installer name Gaea-2.2.7.0.exe, and the screenshots in the setup wizard are labeled 2.0.1. In the local capture of the official documentation, the Release History page contains only explanatory text and does not list the update entries for individual versions.

Gaea is divided into four edition tiers, and these are the four names that appear explicitly in the documentation:

Two hard limits are worth remembering up front: Gaea2Houdini requires a Professional or Enterprise license; and the Gaea UI and Gaea Build Swarm are two programs that both call the Gaea Engine, so each needs its own license. If you have only one license, you can choose Close and Build in the Build menu to close the interface first and free the license for Swarm.

There are three license forms:

• Online license key: the standard format is xxxx-xxxx-xxxx-xxxx, and an online floating key carries the FL- prefix, as in FL-xxxx-xxxx-xxxx-xxxx.
• Offline license file: a .lic file containing XML, for example ABCD1234.lic, node-locked to one machine.
• Offline floating license: distributed by a locally deployed Fortress service. The workstation license file is named floating.lic and contains both the floating key and the server address.

System Requirements

Gaea depends on .NET 8.0 and the Visual C++ Runtime. The installer downloads and installs both runtimes automatically when they are needed, so the installation process requires an internet connection. Some hardware also requires the Intel CPU Runtime for OpenCL Applications with SYCL Support. If you need to install in an environment without internet access, install these prerequisites in advance.

There are two hard prerequisites for compute capability. For CPU compute, the CPU must support the AVX2 instruction set. For GPU compute, NVIDIA cards require CUDA 12.5 and AMD cards require HIP 6.0. Memory requirements vary widely from project to project; see the memory chapter for specific estimates. QuadSpinner also recommends using Community Edition first to confirm that your hardware can run it.

Installation Methods and First Launch

Gaea offers three installation paths. The Setup Executable is the primary and recommended method. It provides both a regular installation and a portable installation, and it writes the registry entries required by the Gaea2Unreal and Gaea2Houdini bridges. The 7-Zip package contains exactly the same files as the installer but is purely portable and writes no registry entries, which suits bulk distribution or repackaging. winget installs it with a single command:

winget install gaea

The winget repository accepts versions slowly and may lag behind the official website, so machines that already have Gaea installed will receive an in-app update prompt.

A Regular Installation requires administrator rights and installs to Program Files by default. If you install to a network location, it must be mapped to a drive letter; UNC paths are not supported, and Gaea may not work correctly otherwise. A Portable Installation installs to a user-writable directory, by default C:\Users\YOU\AppData\Local\Programs\Gaea 2.0. It needs no administrator rights and does not create the registry entries required by the bridges.

For bulk deployment, the installer supports the silent parameters /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /SP-, together with /ALLUSERS (install for all users), /CURRENTUSER (install for the current user only), /DIR="X:\PATH" (specify the installation directory), and /LOG="filename" (write a log).

On first launch, a Welcome dialog appears. It lets you set the storage path for Gaea Projects and choose the viewport navigation style, and you can enter a License Key there as well. A key can also be entered on the Start Screen shown at every launch, or under Help > About. If you received a .lic file, simply drag it onto the license dialog.

The location of the Gaea Data Folder varies with the installation mode. For a regular installation in Program Files, the data folder is <UserFolder>\AppData\Roaming\QuadSpinner\Gaea\2.0. For a portable installation, the data folder sits next to Gaea.exe; for example, an installation in D:\Programs\CG\Gaea\ creates D:\Programs\CG\Gaea\Data\. On first run, Gaea first checks whether the installation directory is writable. If it is, Data is created there; otherwise Gaea falls back to AppData. The default locations for projects and build output are Documents\Gaea\Projects\ and Documents\Gaea\Builds\ respectively, and both can be changed in the Paths panel of the Options dialog. Do not place the project directory or the user directory inside the Gaea installation directory.

License Activation

The license dialog has several entry points: the Welcome dialog on first launch (click Have a license key?), the Community Edition startup dialog, Help > Manage License, and Help > About. Enter the key and click activate; Gaea connects to the licensing server to complete activation.

Offline and unattended scenarios rely on file activation. Do not mix up the three file names:

• activate.lic: a plain text file containing only the license key, with no other characters or blank lines. Place it in the Gaea data folder. At startup, if the license is not yet active, Gaea tries to activate with it.
• gaea2.lic: rename an offline license file to this name and place it in the data folder.
• floating.lic: an offline floating license. Place it in the data folder, and Gaea reads the floating key and the server connection information from it.

Offline licenses are node-locked. To request one you must provide a Hardware Thumbprint: open Help > About and click the copy icon next to the purple Thumbprint reading below the License text. Major hardware changes such as a new motherboard or processor will invalidate an offline license; you then need to contact technical support with the new thumbprint to have a replacement issued.

Floating license keys carry the FL- prefix. When Gaea starts, it requests a seat from the online licensing server. If all seats are taken, you receive a prompt and must wait for someone else to release one. Keep-alive works through a heartbeat roughly every 5 minutes, with an additional grace period of about 5 minutes to tolerate network jitter. If the network drops, Gaea releases the seat on both the client and server sides, but running instances do not exit. They merely fall back to Community Edition, and you still have a chance to save your files. If you see "Maximum Clients Assigned" when you re-request after a crash or a disconnection, it is usually because the old seat has not been released yet; wait one heartbeat cycle (within 5 minutes) and try again. The Refresh button under Help > About forces revalidation and re-acquisition of the license, while the Release button releases the current license and falls back to Community Edition. If a workstation cannot reach the internet directly, you can specify a proxy address in the Options dialog.

There are two ways to release a license. Locally, use Help > About > Release License, which returns the installation to Community Edition. This is not a permanent deactivation, and you can activate again later. The command-line equivalent is:

Gaea.exe -deactivate

If you are not at that machine, sign in to your QuadSpinner account, open the License Dashboard, click Show, go to Activations, find the computer you want to remove, and click Release. Note that the documentation states explicitly that the number of activations allowed per year is limited. Activating too frequently will cause the server to disable the license, and you will need to contact technical support to restore it.

When troubleshooting, first confirm that the data folder contains only one .lic file — multiple license files interfere with each other because of differing load order. For networking, allow TCP ports 80 and 443 for *.quadspinner.com and *.gaea.app, including all subdomains.

Migrating from Gaea 1

Gaea 1 .tor project files cannot be opened in Gaea 2. The two engine generations are entirely different, and Gaea 2 uses .terrain files. Keep maintaining old projects in Gaea 1. If you really need to bring terrain into Gaea 2, the most accurate and direct approach is to export R32 from Gaea 1 and then import it into Gaea 2. If you used fixed file names in Gaea 1, you can refresh the input in Gaea 2 after every rebuild of the output.

At the node level, Gaea 2 discontinues a large number of GeoPrimitives and all LookDev nodes, replacing them with the new Landscape and Surface nodes. Some other nodes were renamed for clarity. The node change table in the documentation lists the status of each node by Gaea 2 category: new, improved, no major change, renamed. A few renames that are easy to trip over: FlowClassic was formerly called "Flow Map", MacroPort was formerly called "Wormhole", and Edge was formerly called "Zero Borders".

The number of new nodes is large and spans every family, for example Cellular, Cellular3D, DotNoise, LinearGradient, and RadialGradient under Primitive; CraterField, DuneSea, MountainRange, and Volcano under Terrain; Erosion2, EasyErosion, Wizard2, Thermal2, and Glacier under Simulate; and PointCloud, Unreal, Unity, and TextureBaker under Output. In the interface, the Gaea 1 Post Process Stack evolved into the Gaea 2 Modifier Stack, which can be attached to most nodes for post-processing fine-tuning and uses less memory than creating new nodes.

Interface Overview

The Gaea interface is organized around one loop: build terrain logic in the node graph, preview it in the viewport, and tune parameters in the property editor. The window is divided into a few fixed areas — the main menu at the top, the Infinity Graph in the middle, the property editor and Data View on the right, and a viewport that can either sit inside the main layout or float on its own. The sections below cover each area in turn.

Main Menu

The main menu follows the usual Windows application layout and contains eight menus: File, Edit, Graph, Node, Preview, Project, Tools, Help. They cover project management, graph tools, bake/build/export actions, and diagnostics. The menu paths that appear explicitly in the documentation are:

• File > Export > Macro... and File > Import > Macro: export and import a Macro.
• Graph > Bake > Bake Required Nodes: automatically bake every node that requires baking.
• Tools > Plugins: install plugins such as Gaea2Unreal.
• Help > Manage License, Help > About: manage the license, view the hardware fingerprint, and release the license.

Build-related settings are collected in the Build Options window, where the tabs on the left switch between Resolution, Build, Tiles, Nodes, Script, Terrain, Regions, Profiles, and Commands.

Infinity Graph

The Infinity Graph is the core workspace in Gaea. This is where you place nodes and draw connections, organizing terrain logic into a flow that runs from generation to output. It is designed to hold everything from small experiments to large production graphs, and it does not force any single fixed structure.

Nodes are divided into the families Primitive, Terrain, Modify, Surface, Simulate, Derive, Colorize, Output, and Utility, plus any Macro you install yourself. A few high-frequency shortcuts are worth memorizing: P opens the Manage Portals menu, F sets the current node as the Lock Preview, G sets a node as the Underlay, V temporarily switches the viewport to planar preview, and F3 marks a node for export (Mark for Export).

How the graph behaves is configured under Options > Graph: Grid Snap Size sets the node snap spacing and offers 10 / 20 / 25 / 50 / 100, with a default of 25; Allow Node Shortcuts Only When Cursor is Inside the Graph makes node-creation shortcuts respond only when the mouse is over the canvas, which prevents accidentally creating nodes elsewhere in the interface; the other two options are Hide Graph Tabs and Hide Bookmark Shortcuts.

How the Graph Is Organized

Tabs split one project into multiple graphs. A row of tabs at the top of the graph switches between them, and that row can also be hidden under Options > Graph. The node tree in the Data View shows tabs as the first level of the hierarchy; when the project uses .tfrag content, a tab can also represent an independent .tfrag.

Groups are containers inside a graph that keep related nodes together. The Data View hierarchy is Tabs → Groups → Nodes, and both groups and tabs can be expanded or collapsed. Nodes inside a container are listed in their left-to-right order on the graph, and notes are shown alongside them, so you can read annotations from the same navigation surface.

Portals let nodes connect across long distances without drawing a visible connection, and they can cross between tabs. There are three ways to create one: right-click an existing connection and choose Convert to Portal; right-click a node and choose Manage Portals (shortcut P), then pick the port to convert, and any existing connections on that port are converted to Portal connections as well; or hold Shift while converting a port in the Manage Portals menu, and Gaea first creates a Chokepoint node and then turns its output into a Portal. Choosing Connect to Portal on an input port opens a search box that lists the available Portals.

Chokepoints are Chokepoint nodes whose only purpose is to avoid rewiring a large number of nodes; they add no memory overhead of their own. Complex graphs naturally develop bottlenecks — a node referenced by several downstream nodes has to be rewired in a circle whenever it is replaced. Place a Chokepoint before an important branch, and changing the upstream side requires editing only one place.

Underlays decide which terrain is placed underneath when displaying colors or masks. By default Gaea picks the nearest Heightfield/Terrain node; if the graph branches, it may pick the wrong node, in which case you right-click the correct heightfield node and choose Use as Underlay, or select the node and press G. A node designated as the Underlay appears as a purple link on the Data View toolbar. For the opposite need, use Exclude from Underlay: right-click a node to exclude it, and Gaea walks upward to find a parent node. Note that modifying a node before the Underlay causes every node in between to update as well, which becomes noticeably slow at preview resolutions above 2K; when Gaea detects this kind of downstream Underlay it shows a warning in the property editor.

Lock Preview pins the viewport to a node, so that afterwards any edit to a node before it propagates all the way to the locked node, letting you judge the final result while changing the upstream side. Right-click a node and choose Lock Preview, or press F. A locked node appears as a green link on the Data View toolbar. Nodes that are not downstream of the locked node do not update until it is unlocked.

Viewport

The viewport is the main preview area. It supports 3D viewing and also offers an optional 2D viewport for evaluating the shape, scale, and detail of a terrain. It can sit inside the main layout or be used as a floating window. There are three navigation modes: Orbit, Free/WASD, and Orthographic. There are also toggles for viewport elements such as grid, bounds, and compass, plus camera save and load.

The appearance of the viewport itself is configured under Options > Viewport:

• Antialiasing: choose from None, 2x, 4x, 8x, with a default of 4x. Higher values give cleaner edges but cost performance on low-end GPUs; on a mid-range card, 2x or 4x is recommended.
• Display Options: Do not clear viewport when unselecting a node (keeps the previous terrain after deselecting a node), Show Grid, Show Compass, Show Base Marker, Conserve memory when displaying 4K terrains (saves memory for terrains above 4K, at a slight cost in fidelity).
• Background: the viewport background color. Click the swatch to pick a color, press X to restore the default.
• Mask Gradient: the color scheme for mask output. Choose from Greyscale (default), Red, Blue, Spectrum.

Mouse and keyboard behavior is configured under Options > Navigation: Rotate, Pan, and Zoom can each be assigned to the left, middle, or right mouse button, and can also require holding Alt to take effect. Each of the three has its own sensitivity slider, defaulting to 100%. Three more toggles affect the feel: Invert Y Axis reverses the vertical direction, Flip Y Pan Direction for QE Keys swaps the pan direction of Q and E, and Invert Zoom Direction reverses the wheel zoom direction.

Viewport Toolbar

The viewport toolbar provides a set of quick controls:

• Preview resolution: from 512 all the way to 4096.
• Lighting and atmosphere: controls for the sun, lights, and atmosphere.
• Render styles: the documentation gives examples in three categories: realistic, clay, and data-visualization.
• Viewport toggles and tools: including showing/hiding the 2D viewport, plus measuring and picking tools.

Property Editor

Select a node and its settings appear in the Properties panel on the right side of the interface. Changes take effect immediately and are reflected in the viewport, which is the basis of fast iteration in Gaea.

There are only a few property types: Integer (a whole number, usually a finite quantity such as a count or an angle), Decimals (a decimal number, usually a strength or an amount, where small changes often have a large effect), Toggle (on/off), Choices (a dropdown), Color (a color, used by colorizing nodes), and File (select a local file). Sliders that sit at their default value are drawn slightly dimmer, and this behavior can be controlled in Options.

Numeric properties accept a directly typed number on right-click. For properties displayed as a percentage, you can enter a value in meters, and Gaea converts it using the width from the Terrain Definition on the Build tab: when the terrain width is 5000m, entering 500m converts to 0.1, which is 10%.

Right-clicking an integer or decimal property opens the Nudge panel for higher-precision adjustments:

Nudge also has a Seed Reset: the random value a node is created with is recorded as the default seed, so no matter how much you change it afterwards, resetting the Seed returns it to that original value.

Above the property editor there is also a Property Editor Toolbar with node-specific actions: replace the current node with a related node, manage state (revert / reset / save state), and enable a gizmo for nodes that support viewport manipulators.

Modifier Stack

A Modifier is a layer of post-processing attached to most nodes. It acts directly on that node's output, so the result can be adjusted without rebuilding the node. Many modifiers do the same job as a node of the same name, but using the modifier costs less than building a dedicated node.

The order in the stack can be rearranged, and this often changes the final result, especially for high-impact modifiers such as Autolevel or Height Remap. The modifier stack is the evolved version of the Post Process Stack in Gaea 1, and it is more flexible and more memory-efficient.

According to the documentation, the available modifiers are:

In addition, three special modifiers are not provided as nodes: Influence, Min, and Max.

Data View

The Data View sits to the right of the graph. It is a set of tabs for inspecting project structure, build output, node diagnostics, and exposed variables. When you need to find a node in a large graph, run an audit before a build, look up a specific value, or expose parameters for automation and Macros, it is far faster than panning around the canvas looking for nodes.

The Terrain tab contains the node tree and the graph filter. The green and pink icons at the top represent the current Lock Preview node and Underlay node; hovering shows which node it is, and clicking jumps straight to it. The filter narrows nodes by type or behavior, and once enabled the other nodes are hidden from the tree and greyed out in the graph. The options are None (clear the filter), Marked for Export, Requires Baking (nodes that need baking before a Hybrid or Tiled build), Nodes with Errors, Heavy Nodes (the most time-consuming nodes, calculated from the median), Orphan Nodes (nodes that are unconnected and do not feed any output), Bypassed Nodes, Has Modifiers, and By Type (Generators, Simulations, Colorizors, Exportable, Logic, and so on).

Most keyboard shortcuts in the node tree match those on the graph, and they can also be customized under Options > Graph.

The Build tab lists the nodes marked for export, letting you verify the current build resolution, the build target and output filename format, which ports will be written out, and the output format of each export before leaving the Data View. The toolbar also has shortcuts that jump to the build configuration, the output files, and the output configuration.

The Stats tab shows detailed information about the selected node and the data it generates: node ID and name, build status and the time taken by the last build, output resolution, channel count and data type, estimated output size, the min/max/range of the heightfield and mask, per-channel information for multi-output or color nodes, and node errors and build messages. Use it when you need to supply a definite value downstream, or when a node's output looks wrong.

The Vars tab is for creating, organizing, and managing exposed parameters. A variable can be Float, Int, Range, Choice, Bool, String, or Color, and advanced workflows can also use Undefined; UI decorations such as Separator and Group are used to organize the exposed controls. Here you can edit variables, group them by node, bind and unbind properties, and copy the variable configuration string needed for the command line. Port shortcuts for plugins and Macros can create exposed controls for all ports at once, for input ports only, or for output ports only.

The appearance of the Data View is configured under Options > Data View: Icons Display offers Colorful (default), Muted, and Hide; Always Expand expands all categories by default.

Lazy Menu (F1)

The Lazy Menu is a configurable, keyboard-first quick-access hub. Press F1 to bring it up and jump straight to key areas and tools in the interface. Its entries include 2D Viewport, Lighting Options, Graph, Properties, Modifiers, Node Tree, Variables View, Build View, and Build Settings.

Each entry can be set to one of three visibility modes under Options > Lazy Menu: Hide removes it from the menu entirely, Muted keeps it but dimmed, and Bright highlights it (the default for most tools). To keep the interface cleaner, set rarely used items to Hide; to keep them reachable without drawing attention, use Muted.

Core Concepts

In Gaea a terrain is a grayscale image, and the numbers in that image are interpreted as elevation. Once this layer is clear, concepts such as nodes, resolution, build, and bake all have a single consistent explanation.

Heightfield

Gaea represents a terrain as a heightfield: a grid of pixels, where each pixel holds a value between 0 and 1 that corresponds to one elevation point on the terrain. 0 is the lowest point and 1 is the highest. The documentation gives this example: in a terrain with a maximum elevation of 100 meters, a height value of 0.5 means 50 meters of elevation.

What is stored is a ratio, not an absolute height, so the same heightfield paired with different Terrain Definitions produces terrains of different scale: the actual number of meters is determined by Height in the Terrain Definition under Build Options. Gaea stores pixel values as high-precision decimals (for example 0.005893f), so the cache is far larger than an 8-bit or 16-bit grayscale image.

A heightfield is single-channel data, while color nodes output multi-channel (RGB) data, and the data volume must also be multiplied by the number of output ports; the exact sizes are in the memory estimate at the end of this section. Coloring is based on the same set of numbers: a CLUT (color lookup table) is essentially a gradient that picks colors by height value from 0.0 to 1.0, so "the snow line sits at a certain altitude" means "the color switches at a certain height value".

Nodes, Ports, and Connections

A node is a processing step for terrain, and each node represents one specific function: generating shapes, adding erosion, creating textures, exporting. The Gaea 2 node library is organized by family:

A Port is a data inlet or outlet on a node. A node has at least one input port and one output port, and some nodes have multiple outputs — Erosion2 has 4 output ports (for example Out, Flow, Wear, Deposits), so its cache at 4096 x 4096 is 256MB, while Ridge, Adjust, and Shaper, which have only a single output, are 64MB. Ports also have a display type, for example Heightfield, Mask, or Color.

A Connection determines the direction of data flow. The graph is directed: data flows from upstream to downstream, only branches connected to a final output are computed, and isolated nodes do not take part in the build. An output port can be converted to a Portal for cross-graph connections, or attached to a Chokepoint to avoid large-scale rewiring.

To package a section of a graph into a single reusable node, Gaea provides the Macro: two MacroPort nodes enclosing several processing nodes, one set to Direction = Input and one to Direction = Output, with connections shaped like In > Shaper > Out. Export it with File > Export > Macro..., and the resulting .macro is stored under \Data\Macros once installed, after which it can be searched and used like any ordinary node. Version limit: Indie can only install and use existing Macros, while creating a Macro requires Professional or Enterprise.

Resolution and World Scale

Gaea describes the world in meters, and one unit equals one meter. The physical size of the terrain is determined by the Terrain Definition in Build Options: Width is the width (meters), Height is the maximum height (meters), Real Scale shows how many meters each pixel represents at the current build resolution, and Height-Scale Ratio shows the relationship between height and width. Resolution determines how many pixels are used to store this heightfield, with common ranges from 512 x 512 to 8192 x 8192; beginners are advised to start with 1024 x 1024 or 2048 x 2048.

Meters and pixels are two units that cannot be converted directly, so Gaea uses a vertical compression ratio to preserve proportions:

Compression ratio = Height / Size

The default world given in the documentation is 5000m x 5000m x 2500m, which works out to 2500 / 5000 = 0.5, exactly a 0.5 ratio. Another example is a terrain with a horizontal size of 2000 meters and a maximum elevation of 500 meters: 500 / 2000 = 0.25, meaning that you have to travel 4 meters horizontally before a 1-meter difference in height can occur, which reads as a gentle slope.

The most practical use of this ratio is restoring proportions when importing into 3D software: set the scale of the vertical axis (usually Z) to the calculated ratio, for example 0.25, keep the horizontal axes (X, Y) at the default 1.0, and then apply that scale. The ratio is also an adjustment tool: with the size unchanged, raising Height makes the terrain steeper, and lowering it makes it flatter.

Preview and Build

Preview and build use the same graph; they differ in scale and purpose. The preview resolution on the viewport toolbar can be switched between 512 and 4096 for day-to-day parameter tuning; a build specifies the output resolution on the Resolution tab of Build Options (for example 2K or 4K), which determines how many pixels of data are actually written out.

The remaining options on the Resolution tab: Region selects the build extent; Subdivision selects the balance between speed and quality, with the options None, Faster, Balanced, and Slower; Output selects Single Image or Tiled Images; once tiling is enabled, Tile Size sets the size of each tile and Blending sets the blend percentage between adjacent tiles.

Repeatedly testing parameters at low resolution is safe: Gaea's erosion algorithms are resolution-independent, so a 512 x 512 preview build and a full 4K or 8K build stay consistent in the main erosion features, and there is no need to guess at the output.

The rules for writing a build to disk are on the Build tab: Build Destination specifies the output directory, and you can keep a fixed directory for the latest copy, open the output directory automatically after the build finishes, and copy the .terrain along with it; Remove Primary port name in Build output removes the primary port name from the output filename; File Overwrite Mode decides whether a file with the same name is Overwrite or Increment. Build Path Tokens can be embedded in the path.

To make a node's output part of the build, right-click it and choose Mark for Export, or press F3; multiple nodes can be marked at once. The export filename format is <Name or NodeName>_<PortName>.<extension>. The global default formats are under Options > Build: Heightfield defaults to EXR (with RAW, TIFF, and others also supported), while Color Maps and Masks default to PNG16.

Baking and Linchpin Nodes

Baking locks a node's current output at a specified resolution, avoiding repeated computation. The bake resolution can be 1024 x 1024, 2048 x 2048 (default), 4096 x 4096, or 8192 x 8192.

The commands in the Bake menu are: Bake Selected (bake the selected nodes), Bake Required Nodes (bake the nodes involved in tiled computation, ensuring seams between tiles stay continuous), Force Load Baked Cache (force a reload of the baked cache), Unbake Selected (remove baking from the selected nodes so they become editable again), and Unbake All (remove all baking). Baking is not permanent; it can be undone and redone at any time.

The companion feature Cache Previews to Disk (formerly Session Cache) writes node previews to disk instead of keeping them in memory. It has two independently selectable triggers: When Closing File saves previews and build results to disk when the file is closed and persists with the file, while When Idle bakes automatically when the system is idle and a node has not been modified for several minutes, and is a session-level setting that resets the next time Gaea starts. There is also Delete Cache to clear the existing cache.

The Linchpin node is an extra benefit of baking. When loading a baked cache, Gaea loads only those nodes that are baked and connected to an unbaked node; their ancestors are not loaded. The documentation's example is: of 5 baked nodes, only the last is recognized as a linchpin and the other 4 are unloaded, reducing memory and cache usage by about 66%. These unloaded nodes are shown on the graph with a dashed border and can be loaded manually from the property editor; to modify them, the recommendation is to unbake, make the changes, and then bake again.

Regions and Tiled Builds

Regions zoom a small part of the terrain up to a high resolution on its own. The documentation's example takes one sixth of an 8192 x 8192 terrain and enlarges it to 8192 x 8192, increasing pixel density nearly 6 times. There is no limit on the number of regions, and each can be previewed separately. To add one, right-click on the Regions tab of Build Settings and choose Add Region, then drag the control point in the bottom-right corner to adjust its size and position; after exiting, an extra dropdown appears next to the preview resolution selector for switching between regions. The full terrain and the region come from the same procedural graph, so a change in one is reflected in both.

As with tiled builds, a region's initial generators must be baked before it can be built or previewed, and Gaea prompts you when a node is missing. The Gate node is a common technique: place it at the end of the node chain that needs baking, use Bake Required Nodes to bake all Gates at once, and Unbake All to remove all of them. Baking looks like it reduces quality but in practice almost never does — the initial shape may be slightly lower, but once Erosion or another simulation is attached, Gaea renders the result at full resolution, so the initial shape should be as simple as possible.

Tiled Builds process the terrain in tiles rather than building the whole thing at once: the workload is split into smaller pieces, peak CPU, GPU, and memory pressure drop; and the exported result is tiled by nature, which suits engines that stream terrain by block, reducing runtime memory and enabling on-demand loading.

Tiled results can differ from the full image, because some operations can only "see" part of the terrain: nodes that depend on information outside the current tile evaluate in isolation and produce discontinuities at tile or bucket boundaries, with common sources being screen-space generators that assume the whole canvas, filters with a very large sampling radius, and details that are implicitly normalized per region. There are three solutions: bake the upstream portion that is unsuitable for tiling into a stable base; use Hybrid Builds to provide a sufficiently large bucket and blend amount; and avoid per-tile normalization.

For organization, the recommendation is to do the macro shapes first, identify the nodes unsuitable for tiling during the macro stage and bake them into a base, and then attach erosion and surface detail after that. Before building, check: the world resolution must be evenly divisible by the tile resolution; and if you want globally consistent tone, do not let operations adjust themselves per tile.

Hybrid Builds are a mode of tiled building: the exported tiles can be small (for example 512 x 512), but they are built in larger buckets (for example 4096 x 4096) and then subdivided, so one bucket produces 8 x 8, or 64, tiles, and nodes that need neighborhood information therefore get more surrounding data. The Hybrid Subdivision options are None (only when the world fits within 8K or 16K), Faster, Balanced, and Slower. Handling buckets separately makes their boundaries mismatch, so the blend amount between buckets has to be increased; the documentation recommends starting at about 25%, and if seams remain, increase the bucket size first.

There is one more rule of thumb for working with baking: the bake resolution should be the step closest to the full world size. For example, if the world consists of 8 x 8 tiles of 512 x 512, choose 4096 x 4096 as the bake resolution.

Estimating Memory Requirements

When a build fails, the most common things you hear are "my graphics card has 8GB" and "I have 64GB of memory", but the amount of data a procedural graph represents is far beyond intuition: every node generates single-channel (heightfield) or multi-channel (RGB) data, and that must also be multiplied by the number of output ports.

The pattern is that doubling the resolution makes the memory requirement 4 times larger. An 8K terrain graph with 20 nodes has a cache of roughly 5 to 8GB; in theory 16GB of memory is the minimum, but the official recommendation is 32GB, to reduce paging, where the disk is used as memory when memory runs out. 16K is even more extreme: with the same 20 nodes, the actual cache needs 20GB to 30GB, and including overall processing and management it can reach 96GB, so the official recommendation is at least 64GB for a 16K build, and 128GB if conditions allow.

There are three ways to save memory: split the project into multiple files (one for shape generation, one for color production); use baked nodes to move data from active memory to disk; and use as few nodes as possible, replacing nodes with Modifiers wherever possible.

Exporting a mesh is a separate account: a mesh generates one vertex per pixel, so a 2048 x 2048 terrain has 2049 x 2049 vertices, about 4 million. The Optimized option of Mesher allocates polygons by complexity and can reduce the polygon count by up to 60% in typical scenes; another approach is to export a high-resolution displacement map together with a low-resolution mesh.

The Allocated Memory readout in the bottom-right corner of the status bar updates every 5 seconds and counts only allocated caches, excluding temporary usage during intermediate processing, so it can only be used as a rough estimate.

Parameter System and Node Operations

Property Editor

Select a node and all of its settings appear in the Properties panel on the right side of the interface. Changes take effect immediately and are reflected in the viewport; there is no "Apply" button and no node rebuild. Sliders whose default value has not been changed are shown in a slightly darker color, so you can see at a glance which parameters have been touched. This behavior can be adjusted in Options.

The Property Editor Toolbar at the top of the properties panel groups several operations that concern the node itself: replacing the current node with a related node, managing node states (revert, reset, save state), and enabling the Gizmo for nodes that support viewport manipulators. A Gizmo is a draggable handle in the viewport, well suited to parameters that are faster to tune by eye than to type, such as the X/Y offset of Mountain or the outline of Island.

Parameter magnitudes vary widely. Integer parameters usually represent a count or a discrete value, such as an angle or a number of passes; decimal parameters usually represent an intensity or a ratio, where a small change can produce an obvious difference. The documentation specifically warns that if a parameter is named Iteration, Strength, Cycles or Amount, watch the processing time when raising it.

There are several ways to enter values:

• Right-click an integer or decimal parameter to type a value directly.
• Right-clicking opens the Nudge panel, which offers commands such as Halve, Double, Minimum, Maximum, Decrease Large, Decrease Small, Increase Large, Increase Small and Reset for high-precision adjustment. Reset returns the parameter to its default value.
• Seed Reset sets the "default value" to the random seed the node had when it was created, so you can return to the original look with one click after experimenting.
• A value displayed as a percentage accepts a metric value directly. For example, with the Terrain width set to 5000m, entering 500m makes Gaea convert it as 500m / 5000m to 0.1, that is, 10%.

Parameter Type Table

The table below is compiled from the official node data by deduplicating 1215 parameter instances across 182 built-in nodes. The left side is the type name in the data; the right side is the control form in the interface.

Two points need attention: Byte, Color, List1 and Dictionary2 have no type description in the official parameter data; and 25 parameter instances have an empty type description. They are essentially the special types above or pure information fields.

Enum is the type you need to know best after Single. Its options come in two common forms. One is a semantic tier, usually the four levels Low, Med, High and Ultra; Power, Depth, Scale, Deposits, Flow, Shape and Detail in Wizard2, as well as Amount in SuperColor, are written this way. The other is an algorithm or style code: Style in EasyErosion has fifteen entries such as Simple, Ancient, Alpine, Rocky, Flows and Strata, while texture nodes such as Sandstone use letters from A to L. Quality Enums commonly take the values Quarter, Third, Half and Full; they directly determine the processing resolution of the node and are the parameters with the most obvious effect on speed in the whole table.

Common Parameters

After counting the frequency of all parameter names, the parameters that occur most often are listed below. They recur across families and nodes with broadly the same meaning, so understanding them saves a great deal of node-by-node trial and error.

The text for these parameters in the official documentation is almost word for word identical, which shows that they are common controls reused across families. One rule is worth remembering in practice: Seed changes only the shape, not the strength; Scale and Size change the physical size of features; Strength, Amount and Intensity change the magnitude of the effect. When tuning, set the scale first, then the strength, and only then the seed; this avoids repeatedly overturning earlier decisions.

Also note that a parameter with the same name can have different units in different nodes. Feature Scale is measured in meters in the descriptions of Erosion and Thermal2; Height is the vertical scaling of the noise in Perlin, the height of stones above the ground in Stones, and the pixel height of the normal map in TextureBaker. Direction is a Single in most directional nodes but an Int32 in Uplift and Stratify. When you see a familiar parameter name, first confirm its type and description in that node, then decide how to tune it.

Modifier Stack

Modifiers are post-processing adjustments layered on top of a node's output; they are not nodes in the graph. They cost very little: 6 Modifiers use the same memory as 1, whereas 6 nodes with the same function incur 6 times the cost. More importantly, changing a Modifier does not require rebuilding the node, only changing the post-processing result.

The available Modifiers fall into four groups:

Three of them, Influence, Min and Max, exist only as Modifiers and have no node of the same name. The mechanism of Min and Max deserves a separate explanation: they compare, pixel by pixel, "the result after the node processes it" with "the node's original input". Max keeps the regions that became higher and Min keeps the regions that became lower. This differs from the Min/Max blend modes of Combine, which compare two independent inputs.

The order of the Modifier Stack can be rearranged by dragging, and the order often changes the final result, especially for strong items such as Autolevel and Height Remap. Common uses:

• Height Remap: raise the floor or compress the top when the height range of a terrain or mask is wrong. Pushing the top past 1.0 can make the terrain higher than its original range.
• Autolevel: when an imported terrain or a generated mask uses only a small part of the range and looks too flat and washed out, stretch the current minimum and maximum across the whole range.
• Strengthening a mask: add Autolevel or Equalize directly, or give Shaper a positive value.
• Clamp: when values overflow after heavy deformation or blending, place it at the end, after Height Remap, Shaper, Autolevel and Equalize.
• Drop: removes the empty space below the terrain and lets it settle onto the ground.
• Mask by Height and Mask by Slope: restrict a node's effect to a height or slope range. Any node with this kind of Modifier can have a DataExtractor attached to pull out the automatically generated mask on its own.
• Blur: soften the transition when a mask is too hard and shows obvious cut edges. Use just enough; over-blurring loses the region the mask was meant to enclose.
• Warp: add a little fine disturbance to the mask edges to break up the regularity.

The Modifier Stack is the successor to the Post Process Stack in Gaea 1. It is also the main way to slim down a node graph: if a small adjustment can be solved with a Modifier, do not add another node to the graph.

Two uses are easily overlooked. The first is tidying up a mask before export: Autolevel to use the full available range, Clamp to keep values legal, Blur to soften hard edges, and Threshold to turn a soft mask into a clearer selection. All four steps can be done in Modifiers without changing the graph structure. The documentation warns that if the mask has a specific meaning in other software, do not casually apply Equalize or Autolevel, as that changes the value distribution. The second is using a DataExtractor to pull out a Modifier's change on its own: set its mode to modifier and you get "exactly which regions this change affected". For example, after applying Min or Max to an erosion result, output the difference as a separate mask for routing, layering or texturing. This suits cases where the terrain itself is already correct but you still need to reuse the affected regions.

Variables and Expressions

Variables are a mechanism for centralizing values. You can create variables in the Vars panel of the Data View, or choose Bind to > New Variable from a parameter's property binding menu to generate a variable directly from that parameter. If the parameter is a decimal, its own Min and Max are used as the variable range. Variables support Float, Int, Choice, Color, Range (float2) and String, plus an Undefined type for advanced uses and error handling.

After binding, the slider is replaced by a variable control that shows the variable name and its current value. Clicking the value changes the variable's value, which in turn affects every property bound to that variable. When unbinding, you can unbind just that property and keep the variable, or delete the variable as well; deleting a variable unbinds all properties that reference it.

Variable names should use only A-Z, a-z, 0-9 and the underscore, avoiding spaces and non-ASCII characters, so that command-line automation does not break. In the Grouped By Node view, variables bound to the same node are grouped together; if a variable is bound by two or more properties, it is placed separately in the MultiBound Properties group. Switching Edit Mode lets you change values, rename and reorder by dragging in bulk, and right-clicking opens an edit dialog to change the type and range. The documentation warns that changing the type can cause incompatibility; for example, changing an Int to a String may leave a node bound to it unable to handle the value. The Create Variable menu also offers two UI decorations, Separator and Group, for organizing control panels exposed to the outside.

Expressions are modifiers that apply to a single property only; they are not centralized and not reusable. Currently only Float and Int properties support expressions. Choose Expression from the property binding menu and the slider's value is referred to as x in the expression. If the property is already bound to a variable, x refers to that variable. This is a way to reshape a variable without creating a new one.

The example in the documentation is telling: bind the Height of Mountain and the Spacing of FractalTerraces to the same variable and write the expression x * 0.3, and the terrace spacing is always 30% of the mountain height. However tall the mountain is, the terraces fall in the same place. Other forms:

1 - x                                  reverse the value
x / Octaves                            divide by another variable
x * 0.01                               reduce to 1%
median(Octaves, Ridge, Scale, Seed)    use a function
random() + x                           add randomness
if(SomeVar, 0.3, 0.6)                  conditional branch

Expressions and the Math node share the same language. Operators include + - * / % ^, the comparisons = == <> != < <= > >=, the assignments := += -= *= /= %=, and logical operators such as and, nand, nor, not, or, xor, xnor, mand and mor. Numeric functions cover abs, sgn, floor, ceil, round, clamp, min, max, pow, sqrt, log, mod, erf and more; trigonometric functions include the direct and inverse trigonometric and hyperbolic functions as well as conversions such as deg2rad and rad2deg. Control structures include if-then-else, the ternary conditional, switch/case, while, for and repeat until, plus break and continue.

The Math node can be used alone as a generator, or take up to 3 inputs accessed as a, b and c; x and y provide the per-pixel coordinates. These names are predefined variables and cannot be used for anything else. The documentation also lists vector processing (axpy, sort, dot-product and others) and file read/write capabilities (open, read, write, getline), and recommends preferring Variables and Expressions for ordinary parameter work rather than reaching for File I/O first.

Variables can also be driven from the command line. The Commands section of Build Options offers Copy Command Line; the command it captures already contains all variables and their default values, and you can replace the values and hand it to Gaea.Swarm.exe. Variables can either be passed one by one with a repeated -v key=value, or written into an INI-style text file or a JSON file and referenced with -vars. This is also why the documentation repeatedly stresses using only letters, digits and underscores in variable names: the more regular the names, the less likely command lines and batch processing are to fail.

Functional Module Reference

Gaea 2 has 182 built-in nodes in total, distributed by family as: modify 40, simulate 25, primitive 23, surface 21, utility 20, derive 14, terrain 14, colorize 13, output 12. The sections below are organized by function, and parameter names always use the original English names as they appear in the interface.

Terrain Generation

Gaea's building blocks fall into three categories: Basic Primitives (noise, constants, file input, shapes), Geological Primitives (standalone mountains, hills, craters) and Landscapes (mountain ranges, fields, ridgelines, rolling hills). Primitives and Landscapes include a degree of natural processing of their own, most of which can be turned off, but the documentation states plainly that they are only a starting point; Erosion and Surface nodes are still needed afterwards to turn them into a believable environment.

The Style of Mountain determines the geological and visual style, while Bulk controls how thick the mass is; the easiest path is to pick a Scale, generate a Mountain and connect Erosion directly, which is the fastest way to produce distant assets in bulk. In Canyon, Slot governs the narrow slot at the deepest point, Valley governs how open the valley floor is, and Surrounding determines how much it blends with the surrounding terrain. Island requires you to open the Editor in the Properties panel and draw an outline first; drawing it coarsely works better. The flat slanted plates of Plates suit Displace-type nodes; Passes in Uplift controls the number of uplift passes; Definition in Ridge adds detail along the ridgelines. The general principle is to start with low detail: leave detail to the erosion and surface nodes. Piling detail into the base shape makes later tiled builds very hard to handle.

Erosion and Simulation

The Simulate family has 25 nodes. Erosion is the core, alongside snow (Snow, SnowField, Dusting, IceFloe), water (Lake, Sea, Rivers), vegetation (Trees, Shrubs) and Debris. The table below lists the parameters of the erosion-related nodes.

How Strength and Rock Softness interact. Both affect how violent the erosion is, and raising one may look similar to raising the other, but the mechanisms differ. A low Strength means the water has weak carrying capacity, so dissolved soil drops out sooner; a low Rock Softness means the rock erodes more slowly, but dissolved sediment is carried further. The result is a different sediment distribution and different gully shapes. A low Strength with a very high Rock Softness preserves the general shape, with few cracks and flow channels and some soft sediment piled on the slopes; a high Strength with a very low Rock Softness gives heavily eroded terrain covered in soft sediment. To tell the two effects apart, fix one and vary the other.

Downcutting and Inhibition. The job of Downcutting is to move sediment far away from its source. If you want short transport distances and frequent alternation between erosion and deposition, set Downcutting to 0.0, or raise Inhibition. A high Downcutting with a medium Inhibition produces many deep-cut flow channels along with surplus sediment running down the slopes; a high Downcutting with almost no Inhibition gives channels that are just as deep but with no surplus sediment. Base Level sets the lowest height downcutting can reach, and is used to fill large valleys and build valley floors.

Feature Scale. This controls the lateral size of erosion features, that is, the width between the largest valleys and ridges, in meters. The default given in the documentation is 2000 meters; setting it to 50 meters gives very fine, fragmented gullies. When Real Scale is on, the overall scale is determined automatically by the Terrain Definition; turning it off lets you change the "physics" of the erosion by hand, but the documentation does not recommend this in most scenarios.

Selective Processing. This is a strength unique to Erosion: it lets a bias mask drive Rock Softness, Erosion Strength and Precipitation Amount. This is not the same as "adding a mask to the Erosion node". Adding a mask limits the effect to inside the mask and is done by compositing, equivalent to Combine with a mask at 100% Blend; Selective Processing instead applies a correction amount within the mask region while processing outside it as usual. The mask can come from the Area input (any heightfield), or from the built-in Bias Type: Slope and Altitude. Both are normalized scales from 0 to the maximum, where 0% is the bottom and 100% is the top; to process only the top 10% of a mountain, enter 90% for the Altitude bias. Reverse inverts it. The driving relationship is linear: with Rock Softness set to 35%, the black end of the mask maps to 0% and the white end to 35%; Erosion Strength corresponds to the Strength slider and Precipitation Amount to the Duration slider.

Determinism. Deterministic forces single-core computation, making the result 100% reproducible at the cost of speed. When it is off, the main flow lines stay in the same place but fine features may differ slightly from run to run. Another approach is to make a mask for the flow starting points and feed it into Selective Processing, usually on a second Erosion node, while the first handles general erosion across the whole terrain.

Erosion and Wizard output three key data maps: Wear (the part removed by erosion), Deposits (where sediment finally comes to rest) and Flow (the path sediment takes from its original position to its endpoint). The documentation warns against overusing Flow for texturing, as it makes the terrain look very "CG".

The differences between the hydraulic erosion nodes: Erosion offers complete control but takes time to find a working combination; Wizard offers fewer options and various "recipes", with multi-pass erosion built in, where Phase 1 is fully customizable and Phase 2 is a lightweight recipe that can be used on its own or stacked. Selective Processing is available only in Erosion, though its common uses (such as eroding only the top to carve a river channel) are offered in Wizard as Phase 2 options. Bulk is used to prevent over-erosion: thickening the terrain slightly first keeps sharp peaks and fine parts from being eroded away. Erosion2 is the newer algorithm, with deterministic output, up to 10 times faster on CPU, and terrain rain shadow via Rain Shadow and Direction. EasyErosion and Wizard2 are aimed at "less tuning": the former offers 15 Style presets, the latter leaves only seven dropdowns.

On thermal erosion, Angle is the maximum slope at which material starts to slide, with lower values giving gentler slopes; Settling controls how quickly loose material accumulates (Thermal2 does not have this parameter); a higher Sediment Removal gives cleaner, crisper features. In Crumble, Horizontal biases the effect towards flow starting points or terminal deposition areas, Vertical biases it towards high or low altitude, Edge controls the strength of the effect on sharp edges, and Rock Hardness controls how resistant the material is to crumbling. Downcutting in Anastomosis is an enum; choosing Destructive carves aggressively.

HydroFix has only one parameter, Downcutting. It does not change the landform, only making small adjustments along flow lines to make the flow more coherent; the effect is obvious when used with FlowMap. It is not needed when using Rivers, because the algorithm includes it. The documentation's position is that erosion is not a mandatory last step: LookDev nodes such as Canyonizer, Stacks, Anastomosis and Shear already produce believable results on their own, and adding hydraulic erosion on top brings soft sediment that destroys the original non-hydraulic look.

Surface Shaping

The Surface family solves a long-standing problem: erosion or heavy filtering weakens or even destroys the overall shape. Surface nodes add and subtract shape at the surface level without touching the deeper structure, so volume is preserved, design volume and design surface can be separated, and assets already in a scene do not deform when their surface is modified.

The documentation is very specific about how to combine rock layers: Stratify > Sandstone > Stratify > Sandstone, or even the simple Stratify > Sandstone > Sandstone is enough; to add more fragmentation, run the terrain through an Erosion or a Rock node before the layering. What Stratify produces are sub-layers confined to local regions (for example between two fault blocks), each independent, which is closer to real rock strata; FractalTerraces offers lower-level control and suits complex graphs where you do not want Stratify or Sandstone to introduce too many features and prefer to control the erosion flow yourself.

Stones are randomly scattered, not physically driven like Debris; Oriented in Roughen gives the roughness a direction. Transpose transfers the surface features of the Reference terrain onto the Input while preserving the Input's volume and outline; its parameters are Mode, Amount, Extend, Flatten, Threshold, Boundary.

Data Maps and Masks

All of Gaea's coloring is built on masks: black-and-white masks are used to distribute gradients. Mapping the dark end of a CLUT to low altitude and the bright end to high altitude, with the greys in between distributed proportionally, is the color lookup table mechanism. If the same gradient is fed to FlowMap instead of terrain height, the texture follows the flow lines. Data Maps come in two kinds: Aspect Maps extract attributes from the terrain itself (Height, Slope, Curvature, Angle, Peaks), while Generative Maps run algorithms to generate them (FlowMap, Soil, RockMap, Occlusion, TextureBase, Texturizer).

Height and Slope are the core selectors for snow lines, vegetation belts, coastlines, mesa placement and biome zoning, with Falloff controlling the softness of the boundary transition. Peaks locates features by prominence (which the documentation calls inverse curvature), so it can find the individual summits and ridgelines of terrain of varying height, and Precise makes the detection hug the true tips more closely.

The documentation for Occlusion is very practical: use a high power to focus on large-scale gullies and a low value to focus on small crevices, which lets you separate occlusion regions for different materials. The higher the Power of Soil, the more dust-fall cycles are simulated; a low value lays down only a thin layer of dust. Multiple Soil Maps can be stacked with Combine set to Max, or merged with maps such as Flow and Velocity into masks for shading. TextureBase is a general-purpose mask that gives a believable base to color nodes such as SatMap and CLUTer, with Slope, Flows, Soil, Patches, Chaos and Peaks each introducing the corresponding feature.

Shading and Texturing

The goal of shading is not only to make the viewport look good, but also to produce usable production data: control maps such as albedo or diffuse, splat masks, erosion masks, vegetation masks and moisture masks.

The SatMap library holds more than 1400 color maps derived from real satellite data. Bias pushes the color map left or right, Rough scatters pixels to create chaos, and Hue, Saturation and Lightness provide the final fine tuning. The Synth workflow is to connect a static color map plus a Height or Texture input, choose the Samples, then click Synthesize Colors to get an editable gradient.

Mixer exposes three inputs by default and can be extended to as many as 15 layers; drag to change the blend order, and each layer carries an ID color for checking the blend result in Simplified View. With Preserve Masks enabled, the built-in Height or Slope masks are exposed as output ports. ColorErosion needs only two inputs: the color map to erode and the terrain heightfield. In most cases the default settings are enough. The documentation suggests connecting TextureBase or Texturizer first and then applying ColorErosion to get decent layered depositional flow; you can also use Mixer to change the color layers before eroding. The key point to understand is that "color placed high up will travel along the existing depositional flow".

Recommended order: first lay down large color blocks with Height, Slope or SatMap, then add features with masks from erosion, soil, flow, rock and occlusion, then stack secondary variation with Mixer or CLUT-type nodes, and finally apply ColorErosion for a natural sense of transport. Remember to export separately any masks that downstream stages need, and treat them as data.

Building and Exporting

Two tabs in Build Options form the basis of a build: Resolution determines how many pixels are used to represent the terrain, and Terrain determines the physical size of the world; together they determine how many meters each pixel covers. The Resolution page contains Region, Resolution (such as 2K, 4K), Subdivision (None, Faster, Balanced, Slower), Output (Single Image or Tiled Images), Tile Size and Blending. The Terrain page contains Width and Height (in meters) and displays Real Scale (how many meters per pixel at the current resolution) and the Height-Scale Ratio; the default world is 5000 meters wide and 2500 meters high.

On format trade-offs, Heightfield defaults to EXR, with RAW, TIFF and others available; Color Maps and Masks use PNG16 or another supported format. Displacement maps should use 32-bit precision; 16-bit produces stair-stepping or quantization banding where terrain slope changes sharply, and the troubleshooting documentation recommends switching to 32-bit and avoiding lossy formats such as PNG.

To mark something for export, right-click the node and choose Mark for Export, or press F3. The file naming rule is <Name or NodeName>_<PortName>.<extension>, and the _Out suffix on the main port can be turned off in Build Options. The export menu lets you choose specific ports (Enabled, Out, Flow, Wear, Deposits), or use Primary Only to export only the primary output. The Export node's parameters are Format, Location (Build Folder, Custom, Explicit), Output Path, If File Exists (Overwrite, Increment), plus the Prepare for Bridge command.

Mesher converts a heightfield into a structured mesh and supports OBJ, FBX, DAE and glTF, with topology options of Tris, Quads and the Sophia algorithm's Adaptive Tris. Grid topology is an evenly spaced mesh with an exact polygon count, support for quads and automatic LOD, but flat areas occupy just as many polygons; Optimized subdivides according to terrain complexity, giving higher quality with fewer polygons, reducing the count by 20% to 40% depending on the terrain and by up to 80% over large flat areas, at the cost of triangles only and no automatic LOD. Scale has two settings: Normalized forces all three axes into 0..1, while Metric means 1 unit equals 1 meter; the advantage of a normalized mesh is that you can enter a scale factor on import, for example 5000 for a default terrain 5000 meters wide. All mesh exports include UVs by default using simple planar mapping; turning UVs off can shrink the file by up to 30%.

The Unreal node autolevels 32-bit height data and then converts it to Unreal's 16-bit landscape format, avoiding wasted precision on unused height headroom. The viewport may look different; this is normal. Its parameters are Automatic Size, Target Size, Dont Resize Textures, Format, Unreal Friendly Naming, plus Height/Mask/Color/Weight assignment for Map 1 through Map 10; the Unity node mainly has Target Size. The documentation adds that RAW support is currently incomplete, while PNG and R16 are fully supported.

Tiled Build treats the terrain as a grid processed in blocks, reducing peak CPU, GPU and memory pressure, and the output is already in the tiled form engines need. The risk is that some operations only "see" part of the terrain and produce discontinuities at block boundaries. Typical sources are screen-space generators and transforms, filters with a very large sampling range, and details that are implicitly normalized or autoleveled per region. The solution is to bake the unfriendly parts into a stable base first, or to use Hybrid Build with a sufficient bucket size and blending. Hybrid Build keeps the final tiles small while building with larger buckets: for example, with 512×512 tiles and 4096×4096 buckets, one bucket yields 8×8, or 64 tiles. Subdivision can be None (usable when the world is within 8K or 16K), Faster, Balanced or Slower. If seams appear at bucket boundaries, increase blending; 25% is often a good starting point. The Tiles page also has options such as Tile Suffix Pattern, Add Leading Zeroes, Organization, Flip Y Axis and Overlap Pixels.

Regions enlarge a part of the terrain to a higher resolution on its own: a one-sixth region of an 8192×8192 terrain can be built at 8192×8192, for a pixel density close to 6 times. The number of regions is unlimited, each can be previewed separately, and both the full terrain and the regions come from the same procedural graph, so changing one place updates both automatically; the initial generators need to be baked before use. Profiles, by contrast, save a whole set of Build Settings as a named preset, which is convenient for switching quickly between multiple output configurations such as preview, final and engine-specific for the same terrain.

In Build Path Tokens, angle brackets are tokens and square brackets are variables; for example, <Builds>[Filename][+++] builds into a subfolder named after the current file with an incrementing number. The available tokens are <FileLocation> and <Builds>, and the variables are [Mutation], [Region], [Timestamp], [Filename], [Username], [Domain], [Machine], [Time], [Date] and [Resolution].

Graph Management and Automation

The graph itself becomes a design problem. Basic habits are to name important nodes, separate the main stages visually, use Portals for long-distance connections, and place a Chokepoint before branches. A Portal lets an output be consumed elsewhere without drawing a long line, which suits masks or stable intermediate results shared by several branches. A Chokepoint is a neutral pass-through node: when many downstream branches depend on one result and that upstream may be replaced later, connect them all to the chokepoint, and changing the upstream requires reconnecting only once. The documentation warns against hiding structures that are still changing rapidly inside a Portal.

Accumulator exists to clean up repeated connections: when the masks of several Snow, Lake or Debris nodes need to be merged, one Accumulator collects them, supporting Snow Mask, Snow Depth, Water Mask, Water Depth, Shore Mask, Debris Mask and Debris Color Index. It collects only nodes that have already been built; connecting the final node to be used as a mask to the Accumulator input ensures that the relevant nodes are all built.

Data View is the maintenance entry point. The Terrain page provides layer-level filters: Marked for Export, Requires Baking, Nodes with Errors, Heavy Nodes, Orphan Nodes, Bypassed Nodes, Has Modifiers, By Type. The Stats page gives each node's ID, build state and time, output resolution, channel count and data type, estimated size, and minimum and maximum values. Baking locks a node at a specified resolution to avoid recomputation, with resolutions of 1024, 2048 (the default), 4096 and 8192; Cache Previews to Disk can store previews on disk, with the options When Closing File and When Idle, and baking can be released at any time.

Automation starts from a .terrain file that already builds correctly in the UI: run it once in the UI to confirm that the graph, exports, resolution and output directory are all correct; expose the values the pipeline needs to control as Variables; configure Build Options, using Profiles or Regions where necessary; capture the complete command for the current file with Copy Command Line; replace the variable values with pipeline values, or move them into .json and .txt variable files; and finally execute with Gaea.Swarm.exe, then consume the exported files or the post-action report.

Build Swarm is the standalone command-line program Gaea.Swarm.exe. It is faster because it carries no UI overhead, and the UI also uses it in the background when building high-resolution terrain. Common parameters:

• -filename <filename>: the full path to the .terrain file; wrapping it in quotes is recommended.
• -ignorecache: when set to true, ignores the baking cache.
• -verbose, -safemode, -interactive: logging, diagnostics and interactive prompts.
• -seed <int>: the mutation seed used for the build.
• -profile <name> or -p <name>: specifies a Build Profile; quoting the name is recommended.
• -v or --v: the marker that starts variable key-value pairs, repeated once per variable, for example -v foo=bar -v value=0.35 -v erosion=1. It must always be the last parameter.
• --va <string>: comma-separated values ordered alphabetically by variable name; the count must match the number of variables declared in the .terrain file.
• -vars <filename>: reads variables from a file, supporting INI-style text or JSON.

Batch Builds is under the Build menu; it queues multiple profiles for execution and can also be saved as a .bat file. After a build, Gaea saves post-action reports in both human-readable and machine-readable form, which can be consumed in an automated pipeline.

Performance, Memory, and Large Projects

Gaea builds rarely fail because "the software is not fast enough". Most failures come from a wrong memory estimate. A terrain is a stack of high-precision images in memory, and the footprint grows multiplicatively with more nodes, higher resolution, and more output ports. This chapter collects the documentation on memory estimation, caching and baking, compute devices, large project organization, and storage paths.

Estimating Memory Requirements

Every node produces single-channel (heightfield) or multi-channel (RGB) data at a given resolution, and the real footprint is further multiplied by the number of output ports on that node. The documentation gives this per-node cache baseline:

Doubling the resolution quadruples the cache footprint, because the pixel count grows by the square. The port count multiplies in directly as well: at 4096 x 4096, single-port nodes such as Ridge, Adjust, and Shaper each take 64MB, while Erosion2 has 4 output ports and takes 256MB.

A typical 8K terrain with 20 nodes reaches a cache size of 5–8GB, plus the overhead of management and the process itself. The documentation concludes that 16GB of memory is only a theoretical floor and recommends 32GB to reduce the chance of "paging" (using the disk as memory when RAM runs out). The same 20 nodes at 16K need 20–30GB for the cache alone, and the peak can reach 96GB once overall processing and management are included, so a 16K build should have at least 64GB, and 128GB is better.

The status bar shows currently allocated memory in the lower right corner and refreshes every 5 seconds, but it counts only allocated cache, not temporary usage, so treat it as a reference only.

Exporting meshes adds vertex count to the calculation. Terrain meshes use an equidistant grid system with one vertex per pixel, so a 2048 x 2048 terrain produces roughly 4 million vertices. When exporting with the Mesher node, choose Optimized; the algorithm allocates polygons according to terrain complexity — more where the terrain is complex, fewer where it is flat — and can cut polygons by up to 60% in typical scenes. Another space-saving combination is to export a high-resolution displacement map with a low-resolution mesh.

Cache and Baking Strategy

Baking locks a node at a specified resolution and saves its current state, so it is not recomputed afterwards unless it is explicitly unbaked or modified. It is also the main lever for both preview speed and memory control. The relevant commands live under the Bake menu:

• Bake Selected: bakes the selected nodes.
• Bake Required Nodes: bakes the nodes that must be baked in a tiled build, so adjusting the terrain does not require recomputing the whole region every time.
• Force Load Baked Cache: forces a reload of the baked cache, for cases where a change in the system or project environment kept the cache from loading automatically.
• Unbake Selected / Unbake All: clears the baked state from the selected nodes or all nodes, making them editable again.
• Resolution Settings: the bake resolution can be 1024 x 1024, 2048 x 2048 (default), 4096 x 4096, or 8192 x 8192. A higher resolution gives a more accurate preview when working on detailed areas.

The biggest gain from baking comes from the Linchpin node mechanism. When loading a baked cache, Gaea loads only the "linchpin" — the baked node connected to unbaked nodes — and its ancestors are not loaded. In the documentation example, 4 of 5 baked nodes were unloaded and memory and cache usage dropped by about 66%. Unloaded baked nodes are shown with a dashed border and can be loaded manually from the properties editor; but to modify them, unbake first and then re-bake that part.

Cache Previews to Disk (formerly Session Cache) stores processed node previews on disk instead of keeping them in memory:

• When Closing File: writes all previews and in-memory build results to disk when the file closes, and reads them back on the next open. This option is saved with the file.
• When Idle: bakes automatically when the system is idle and a node has not been modified for several minutes. This option applies to the current session only and resets when Gaea restarts.

The Cache tab in Options centralizes temporary data and autosave handling: Delete after 45 days automatically clears logs and autosaves older than 45 days; Always Cache to Disk on Close forces a write to disk on close for a cleaner next start, at the cost of a slower close; Use Smart Cache unloads 2K or 4K caches that have been idle longer than the Idle Threshold (600 seconds by default) from memory to disk and loads them back instantly when needed; Cache Output sets the cache location, and when Save in Central Cache Folder is off the cache is stored in a \Cache subdirectory next to the project file; Baked Cache keeps baked results across sessions.

The documentation's trade-off advice: on an SSD, Smart Cache greatly reduces memory usage with almost no performance impact; on a mechanical hard drive it is safer to leave it off, to avoid the delay when reloading the cache.

Compute Options and Hardware

The Compute tab in Options decides which devices do the work. Available Devices lists every available compute device and API with a performance score (higher is faster), and each device has sub-options for choosing which technology to enable for it, such as OpenCL, Level Zero, or CUDA.

• Scan Hardware and Determine Speeds: scans all hardware and evaluates processing capability; when it finishes, every device and technology shows a score.
• Enforce Optimal Settings: automatically selects the best-performing combination of devices based on the benchmark results.

Usage advice: prefer CUDA on NVIDIA cards; use Native CPU mode when the GPU is unavailable or must be left for other tasks; turn off low-scoring devices so work is not scheduled onto slow hardware; rescan after updating drivers or changing hardware. If a device has driver problems, Gaea shows an error reading next to it, and depending on the problem the device may not load until the driver is updated.

CPU-only mode is started from the Start menu by launching Gaea Diagnostics, selecting "Run Gaea with CPU only", and clicking "Start". Once enabled, CPU mode stays on, including when running the Gaea Build CLI; to restore multiple devices, re-enable them in the Compute tab of Options. The documentation notes that CPU-only mode does not necessarily cost much performance, and that disabling the GPU and accelerators helps stability when you run into instability.

Hardware benchmarking runs in Gaea Diagnostics and tests the speed of the CPU, integrated graphics, discrete graphics, and other compatible devices. You can choose normal, High Accuracy, or Very High Accuracy; higher accuracy takes longer, and the score represents each device's performance coefficient. The documentation does not list thread-count controls item by item; what you can actually tune is the choice of devices and compute backends.

The documentation also suggests using Close and Build when building: both the Gaea UI and Gaea Build Swarm consume resources, so closing the UI before building frees resources for the Swarm and is the recommended approach in floating-license setups.

Organizing Large Projects

The first principle of a large project is to get the macro shapes clean first. Do not pile noise, breaks, and micro-ridges into the terrain at the start; build a macro shape with enough strength and very little detail, and leave believable detail to the Erosion and Surface nodes. Once the base terrain is "busy", later deformation, sculpting, and large-scale edits are masked by the existing noise, and the erosion flow no longer reads clearly.

For very large resolutions and tiled builds, the documented workflow is: build the base shape containing only large forms at a manageable resolution (such as 4K or 8K); bake those shape nodes; use TileGate to treat the baked result as a static input and scale it up efficiently during a large tiled build; then apply heavy detail, meaning Erosion, Surface, and the downstream detail and mask work. Baking micro-detail into the initial shape locks away the room for real erosion later and makes the tiled build slower and less predictable.

Audit before building with Data View. In the Terrain tab, filter for error nodes, heavy nodes, nodes that need baking, and orphan nodes: errors and nodes that need baking block the build outright, heavy nodes explain why iteration is slow, and orphan nodes are often old experiments mistaken for production logic. In the Build tab, check the nodes marked for export, output names, ports, and formats — a mask may look finished on the graph, but if it is not marked for export it will never leave the project.

The recommended audit order: errors first, then nodes that need baking (especially before a tiled or Hybrid build), then heavy nodes, then orphan nodes before handoff, and finally the Build tab, where you rename unclear outputs and run a small verification build.

Paths and Storage

Apart from project files, all Gaea application data lives in a central Data folder. In a standard installation (under Program Files) it is <UserFolder>\AppData\Roaming\QuadSpinner\Gaea\2.0; the default location for a portable installation is C:\Users\<username>\AppData\Local\Programs\Gaea 2.0, and when installed in a portable location the Data folder sits next to Gaea.exe, so an installation at D:\Programs\CG\Gaea\ puts Data at D:\Programs\CG\Gaea\Data\. On first run Gaea checks whether the installation directory is writable (whether administrator rights are needed): if it is writable, Data is created there, otherwise it is created under AppData.

The three default user file paths can all be changed in the Paths tab of Options:

The Builds location is written as the <Builds> token in build targets. The documentation explicitly requires that you do not put projects or user folders inside the Gaea installation directory; for example, if Gaea is installed at D:\Gaea\, do not set the path to D:\Gaea\Docs. Keeping installation files and data separate avoids conflicts during updates or reinstallation. Project files are light, but build output can be very large, so put builds on a separate drive or location.

Diagnostic Packages

Gaea Diagnostics (codename Watson) can generate a diagnostic package for technical support and developers to investigate crashes or abnormal behavior. Diagnostics take a little time, and the resulting .zip is placed on the desktop.

• Send Online: sends the Watson log directly to the official server and returns a Log Receipt code such as 0A7-20241113. When contacting support, provide the code along with a description of the problem. Sharing a diagnostic package publicly carries risk, but sharing this code is safe, because only authorized official staff can access the log.
• Send Manually: send the .zip as an email attachment or submit it through the support form.

The diagnostic package contains Gaea's execution log (time-ordered events, technical readings, and error stacks), a copy of your settings, hardware information (CPU and GPU model, driver version, firmware version, and so on), and an installation integrity check. The log is an editable zip, so you can remove anything you do not want to share before submitting.

Build Swarm and Batch Builds

Build Swarm is represented by Gaea.Swarm.exe and is the Gaea build engine. It is a standalone command-line program with no interface overhead, so it runs faster; the Gaea UI calls it in the background to build high-resolution terrains for maximum performance. All build options for a file are set in Build Options, and some additional options are available through command-line automation. After a build finishes, a post-processing report is saved in both human-readable and machine-readable files.

Profiles saves the complete build setup as a named preset, which suits producing multiple versions or multiple output types from the same terrain. To create one: open Build Settings, choose the settings, go to the Profiles tab, and click Save Profile. Load imports the selected configuration into the current build settings, Save As.. creates a new configuration from the current settings, and Delete removes the selected configuration. Use ASCII-friendly characters in profile names, because they may be used on the command line or in batch files.

Batch builds run from the Build menu > Batch Builds dialog: queue the configurations you want to build and then run them, or save the batch as a .bat file to run or modify later. On the command line, specify a profile with -profile <name> or -p <name>; wrap <name> in "" to avoid parsing errors.

Use Mutations to produce variations in batch. The most basic approach is to update the seed of every node in the terrain (except baked nodes); the command-line argument --Seed <int> increases every node's seed by that value. To pin certain nodes so they are unaffected, bake them first. The fastest setup is to queue mutations with the Add Mutation button in Build menu > Batch Build Manager, and save the batch as a Windows batch file for repeated builds. In build targets you can use the [Mutation] token to put the current variation number into a folder name, for example <Builds>\[Filename]\[+++]\[Mutation].

Build reports are saved in the build directory: report.txt is a readable summary containing the file name, build location, build type, resolution, profile, node count, result, start and end times, elapsed time, and the fastest and slowest nodes (nodes taking under 100ms are not counted). The same data is also available as report.json in a structured format suited to automation pipelines.

Keyboard Shortcuts and Common Operations

The local documentation records very few keyboard shortcuts and has no complete list; most official pages only mention that a command "can be triggered by a key". Every entry in the table below can be traced to the documentation, and nothing the documentation does not record is guessed here.

Keys Explicitly Documented

Node Short Codes

The documentation lists a short code for every node, for example p for Perlin, m for Mountain, b for Blur, t for Transform, w for Warp, c for Combine, h for Height, v for Voronoi, s for Shape, k for Constant, f for File, o for Object, and g for Gabor, plus multi-character codes such as df (Deflate), rsp (RGBSplit), hf (HydroFix), and rv (Rivers). In the Graph tab of Options, Allow Node Shortcuts Only When Cursor is Inside the Graph governs this set of "keyboard shortcuts for creating nodes"; see the node index for the complete mapping.

Most node shortcuts also work in Data View, either with the default settings or customized in Options > Graph.

Viewport Navigation

The documentation divides viewport navigation into three modes: Orbit, Free/WASD, and Orthographic. The viewport can be embedded in the main interface or used as a floating window; the toolbar also provides toggles for common elements such as the grid, bounds, and compass, plus camera save and load.

The Navigation tab in Options determines how the mouse behaves. Each of the three actions Rotate, Pan, and Zoom can be assigned to the left, middle, or right mouse button; Hold Alt is an optional modifier for each action, and once enabled the action triggers only when Alt is held with the corresponding mouse button, which prevents accidental navigation while doing something else. Each of the three actions has its own Sensitivity setting, 100% by default; lower values are slower and more precise, higher values are faster. Invert Y Axis reverses the vertical direction of rotation or panning; Flip Y Pan Direction for QE Keys changes the direction of Q (up) and E (down); Invert Zoom Direction reverses the wheel zoom direction, where the default is wheel up to zoom in. The documentation notes that this set of settings can match common workflows, such as the habits from Maya, Blender, and 3ds Max.

Lazy Menu

F1 opens the Lazy Menu. The Lazy Menu tab in Options decides how each entry is displayed: Hide removes it entirely, Muted shows it dimmed, and Bright highlights it (the default for most tools). The configurable entries include 2D Viewport, Lighting Options, Graph, Properties, Modifiers, Node Tree, Variables View, Build View, and Build Settings. The General tab in Options also has Move cursor to target when using the Lazy Menu, which moves the mouse to the target automatically when an entry is chosen.

Customizable Shortcut Behavior

The Graph tab in Options centralizes behavior related to shortcuts. When Allow Node Shortcuts Only When Cursor is Inside the Graph is enabled, node creation shortcuts work only while the cursor is over the graph canvas; when disabled, they work globally even when the cursor is not on the graph, and the documentation recommends enabling it to avoid creating nodes by accident while working elsewhere in the interface. Hide Bookmark Shortcuts hides the bookmark shortcut buttons on the canvas, Hide Graph Tabs hides the tab row at the top of the graph, and Grid Snap Size offers 10, 20, 25, 50, and 100, with 25 as the default.

Shortcuts from Other Software

The Shift+A → Mesh → Plane, N → Item → Dimensions, and Ctrl+A → Scale that appear in the Blender import workflow are Blender's own shortcuts, unrelated to Gaea; the documentation simply lists them while describing the import steps.

The documentation does not provide an exportable or printable shortcut sheet, nor does it list a separate key map for viewport operations. When you need to confirm a key, rely on the settings in the corresponding tab in Options.

Every one of the 182 built-in Gaea 2 nodes. Search matches node names and shortcodes exactly, and also matches purpose, effect and usage keywords.

Node names, shortcodes, parameter names and parameter descriptions come from the official Gaea 2 node reference. A few parameter descriptions in the official documentation are mistyped, swapped or missing; entries with no description are marked "not documented". Where something looks wrong, trust the software.

Build a Terrain from Scratch

Six complete case studies you can follow along with, from a first mountain built from three nodes to exporting into Unreal, Unity and Blender. Each one gives a goal, the node graph, step-by-step parameter values and the pitfalls.

The values given are suggested starting points, not official defaults. Adjust them to suit the result.

The six cases below are all written the same way: first the node connection order, then the parameters and suggested starting values node by node, and finally the result and the pitfalls that are easy to hit. All parameter names match the official English names in Gaea 2, and the values are suggested starting points given as a terrain artist, not software defaults, so you can move them up or down for your own terrain size.

Before you start, do two things: in the Terrain panel of Build Options, fill in Width (terrain width, in meters) and Height (maximum terrain height, in meters) with the real size of your target terrain, for example set Width to 5000 and Height to 2500; then set Resolution's Resolution to 1024 for previewing, and raise it to 2048 for the final build once the shape looks right. Simulations such as erosion, snow lines and dunes all depend on physical scale, so fixing the size before tuning parameters saves you rework.

Case 1: Your First Mountain (Absolute Beginner)

Goal: Walk the full pipeline with the fewest nodes and get a believable mountain with gullies and sediment-covered slopes, good for distant mountains, scene backdrops, and as a starting point for the later cases.

Node graph:

Mountain ──► Adjust ──► Erosion2 ──► Export

Steps:

1. Add Mountain (short code m). This node generates mountain shapes using a modulated Voronoi pattern plus distortion. Set Scale to 1.3 so the mountain fills the frame instead of shrinking in the middle; set Height to 0.8, not full yet, leaving room for the Shaper later to expand; choose Style Basic, because you will add erosion yourself next, so start with a clean shape; choose Bulk Alpine for larger volume and steeper slopes; turn on Reduce Details to suppress broken-up detail so Erosion2 has room to carve gullies into the slopes. Changing Seed once gives you a different mountain, so pick a silhouette you like first.

1. Add Adjust (short code fx). It works like a modifier stack in node form and can toggle several adjustments at once. Set Shaper to 0.35, which pushes the mountain outward and spreads the foot of the slope rather than flattening the peak; set Multiply to 1.15 to lift it slightly overall so the mountain does not look dull after erosion. Leave the other toggles off for now; Autolevel and Invert are the easiest way to make the image hard to judge at the beginner stage.

1. Add Erosion2 (short code e2) and connect it after Adjust. This is Gaea 2's hydraulic erosion node, turning abstract shapes into terrain with gullies and alluvial slopes. Set Duration to 0.4, meaning let the erosion run but not to excess; set Downcutting to 8 so water cuts into the slopes and forms clear gullies; set Erosion Scale to 1.2 to put the overall size of the erosion features in the medium-to-small range. Leave the three sediment parameter groups Suspended Load, Bed Load and Coarse Sediments alone for now; the default neutral behavior is fine.

1. If the gullies in the preview are too broken up and the slopes look sanded, set Shape to 0.2 to 0.3 and lower Shape Detail Scale slightly, making the detail scale larger and closer to a real mountain. Conversely, if the slopes are too smooth and show no sign of water flow, raise Downcutting to 10 first, then consider adding Duration; change only one parameter at a time.

1. Add Export (short code ex). Set Format to TIFF 32; this format keeps full precision, leaving you room whether you take it into Blender for displacement or compress it to 16-bit later. If you only want an image you can look at directly, PNG 16 also works, but it tends to show stair-step quantization artifacts when used as a displacement map.

1. Build. Set Resolution's Resolution to 1024 and leave Subdivision at None first, click build to see the result, and raise it to 2048 to rebuild once you are satisfied. The Erosion2 algorithm stays consistent across resolutions, so the main gully structure in the preview will correspond in the final build; iterating on parameters at low resolution is a safe way to work.

Result: A mountain with a main gully system, sediment at the foot of the slopes, and rounded ridge lines. Erosion2 carves denser gullies on the windward side and leaves a gentle sediment-bearing slope on the other.

Pitfalls:

1. Nodes that are not connected at all do not take part in the build. Gaea only evaluates the branches connected to the output node; placing a node on the canvas does not mean it is in effect.
2. Pulling Duration above 1.0 in one go often erodes the mountain into a lump of soft soil; starting from a small value and working up makes it easier to find the right spot.
3. Forgetting to set Width and Height in Build Options. When the size is wrong, the density and depth of erosion gullies are distorted and it looks like a miniature model.

Case 2: Canyons and Terraces

Goal: Produce an arid canyon with layering, rock steps, and a deeply cut river valley at the bottom, good for desert canyon scenes, ruin maps, or terrain that needs a clear read of rock strata.

Node graph:

Canyon ──► Erosion2 ──► Terraces ──► FractalTerraces ──► Sandstone ──► Erosion2 ──► Export

Steps:

1. Add Canyon (short code ny). It generates drainage-based river valleys and canyons. Set Style to Strata to bring in the read of sedimentary rock layers directly; set Scale to 1.1; set Depth to 1.5 so the downcutting is deep enough; set Slot to 0.3 to keep only a hint of a narrow slot and avoid turning the whole canyon into a slot canyon; set Valley to 1.4 to widen the valley mouth. To give the channel natural meandering, set Structual Warp to 0.8 and Detail Warp to 0.3.

1. Add Erosion2 (short code e2). The purpose of this pass is to carve tributary gullies into the valley walls, not to reshape. Set Duration to 0.6, Downcutting to 6, and Erosion Scale to 1.5. Keep the first erosion pass as fractal break-up before the strata; this is what the documentation suggests: if you want a more broken-up shape, introduce erosion or rock nodes before the layering pass.

1. Add Terraces (short code st). Set Terraces to 12 for roughly twelve steps; set Uniformity to 0.7 so the step heights are mostly consistent but still vary; set Steepness to 0.75 so the transitions between steps are definite; set Intensity to 0.6. This step establishes the main rock rhythm of the canyon.

1. Add FractalTerraces (short code ft). Its layering is multifractal, finer than Terraces, and it also gives more irregular results than Terrace-type nodes. Set Spacing to 0.6, Octaves to 6, Intensity to 0.5, and Shape to 0.4. Turn on Shapes Separation to separate the boundaries between individual step layers; set Macro Octaves to 3 to keep the large layers clear. The advantage of FractalTerraces is that your control over the layering is lower-level, and unlike Stratify it does not automatically stuff too many extra features into the terrain.

1. Add Sandstone (short code ss). It handles multi-layer detail at small and medium scales, doing both mechanical break-up and whole-block exfoliation, and it also often generates the interlocking steps common in nature. Set Passes to 2, Iterations to 8, Spacing to 0.5, Intensity to 0.7, Chaos to 0.4, and Convexity to 0.5. Turn on Chipped and set Chipping to 0.4 so the rock layer edges show erosion marks instead of knife-cut straight lines.

1. After Sandstone, add one more Erosion2: Duration set to 0.25 and Downcutting set to 4. This pass is very light, used only to remove the plastic feel from the steps and wear the layer edges slightly. Be careful not to raise Duration, or the rock-layer read you just built will be smoothed away.

1. Add Export (short code ex) with Format set to TIFF 32.

Result: Clear horizontal rock layers and steps on the valley walls, step edges slightly worn, a deeply and repeatedly downcut river channel at the valley floor, and an overall look of an arid plateau cut open.

Pitfalls:

1. Adding a heavy dose of hydraulic erosion after layering is the most common cause of failure. Layering builds a hard-material read, and excessive hydraulic erosion turns it into soft soil deposits.
2. Stacking Terraces and FractalTerraces too close together with both parameter ranges maxed out makes the steps fight each other. Terraces sets the main rhythm and FractalTerraces only refines the frequencies; their roles must stay separate.
3. When Sandstone's Direction does not match the channel direction of the Canyon before it, the rock layers cut across the river valley and look unnatural.

Case 3: Snow Mountains and Glaciers

Goal: Produce a high-altitude snow mountain with snow on the peaks, traces of glacier flow at higher elevations, and scree slopes at the foot, good for alpine scenes, cold-region maps, or aerial-style distant views.

Node graph:

Mountain ──► Adjust ──► Thermal2 ──► Snow ──► Snowfield ──► Glacier ──► Craggy ──► Erosion2 ──► Export

Steps:

1. Add Mountain (short code m). Choose Style Alpine for a young mountain shape with many steep faces and violent relief; set Scale to 1.4 and Height to 1.0 so the peak fills the height range; choose Bulk High, since high-altitude mountains usually have a thick base. Leave Reduce Details off; the break-up along the ridges is exactly the detail a snow mountain needs to keep.

1. Add Adjust (short code fx). Set Shaper to 0.4 to pull the ridges sharper; turn on Strong to boost contrast slightly. If the peak is too sharp and looks like a spire, lower Shaper to 0.25. Do not turn on Invert here.

1. Add Thermal2 (short code t2). It does thermal erosion and is responsible for scree slopes and debris accumulation. Set Duration to 0.5, Strength to 0.6, and Anisotropy to 0.3 to keep basic directionality; set Angle to 0.7 and Sediment Removal to 0.5 so the foot of the slopes piles up visible debris without smearing the mountain. Adjust Feature Scale to your terrain width; the wider the terrain, the larger this value must be, otherwise the scree slope scale looks like grains of sand.

1. Add Snow (short code sn). It simulates snowfall, melting and snow settling. Set Duration to 0.6, Intensity to 1.0, and Settle Duration to 0.4; choose Melt Type Directional, set Melt to 0.3 and Melt Remnants to 0.35 so scattered remnant snow appears on sun-facing sides; set Snow Line to 0.45 to raise the snow line above the mid-slope. The key parameter is Slip off Angle: set it to 0.65, so steep faces beyond that angle cannot hold snow, which is the core of why a snow mountain looks believable; set Adhered Snow Mass to 0.3 to leave a little adhered snow on steep walls. Leave Real Scale on so the node interprets these values according to the terrain's real size.

1. Add Snowfield (short code sf), which produces large areas of stable snow cover. Set Cascades to 3, Duration to 1.2, and Intensity to 0.9; turn on Taper Snowfall and set Taper Amount to 0.25 so later snowfalls contribute less, mimicking the rhythm of a real snow season; set Snow Line to 0.4. Turn on Flows and set Flows Depth to 0.3 to produce snow cornices and groove-like structures; set Surface Details to 0.3 to press fine relief into the snow surface.

1. Add Glacier (short code gl). It generates glaciers flowing from the summit. Set Scale to 0.9, Thickness to 0.6, and Height to 0.7; turn on Rough Edges to make the ice margins irregular; then turn on Secondary Breakage and Flow Breakage and set Flow Breakage Depth to 0.35 to make fracture lines where the ice body flows. If the ice body looks like a layer of frosting poured on, turn on Substructure, set Substructure Density to 0.5 and Substructure Depth to 0.4.

1. Add Craggy (short code cg) affecting only the rock areas. Set Size to 0.5, Depth to 0.35, and Shape to 0.3 to break the exposed rock surface into a field of rock chunks. Finally add a light Erosion2: Duration set to 0.2 and Downcutting set to 3.

Result: Summits and ridges covered in snow, dark rock exposed on steep walls, a clear snow line across the mid-slope, ice flowing down the valleys from above with fractures at the edges, and gentle debris slopes at the foot.

Pitfalls:

1. Setting Slip off Angle too high makes snow cling to vertical cliff faces, and the whole mountain looks painted with a layer of white paint. The test is: steep walls must show rock.
2. Forgetting that Real Scale depends on the terrain size. Parameters such as Feature Scale and Model Scale rely on the physical size of the terrain, and when the size is filled in wrong, snow thickness and scree scale all drift together.
3. Reversing the order of Glacier and Snowfield, laying snow everywhere first and then placing ice, makes the glacier scrape away the whole snow layer underneath, producing hard seams.

Case 4: Desert Dunes

Goal: Produce a dune field shaped by prevailing winds, with sharp crests and gentle interdune areas and a few wind-scoured rock outcrops, good for desert scenes, open-world sand regions, or hot-dry style maps.

Node graph:

DuneSea ──► Sand ──► WaveShine ──► DirectionalWarp ──► Sandstone ──► Thermal ──► Export

Steps:

1. Add DuneSea (short code du). It generates large-area dune terrain and is a sensible starting point for desert terrain. Set Scale to 1.4 to spread the dune field out; try Dune Type B first, since this dune type has a clear difference between long and short axes and looks more like an aeolian dune; set Chaos to Medium and Undulation to Low to avoid the whole ground undulating at once; set Height to 0.6 and Sharpness to 0.7; if Softness is a stepped value, put it in the middle so the crests stay firm. Direction is the backbone of this case: note down the value you choose, because every direction-related parameter later must agree with it.

1. Add Sand (short code sd). It generates sand ripples at medium and small scales and can also be used to simulate dunes. Set Scale to 0.8, Height to 0.35, Softness to 0.6, and Chaos to 0.3; keep Direction consistent with DuneSea's Direction; turn on Warp by Terrain so the ripples follow the existing dune surface instead of sticking to a horizontal plane.

1. Add WaveShine (short code ws). It generates wave-like undulating highlight and ripple patterns, providing the finest level of sand ripple here. Set Octaves to 4, Size to 0.5, Amplitude to 0.3, and align Direction with the main wind direction as well. The Brightness, Sun Azimuth and Sun Elevation in the Lighting group only affect the shading of the wave pattern itself, so you can leave them alone if you are using it as pure height data.

1. Add DirectionalWarp (short code dw). It uses a second guide input to push the first input along a fixed direction, which is exactly what you want for directional wind erosion stretching. Use the DuneSea branch as the Primary Input and a Noise (short code kn) as the Guide Input. Set Strength to 0.25 and Direction to 270, aligned with the main wind direction; choose Edge Behaviour Edge to keep the terrain edges from being pulled into visible seams. The value of this node is that it is directional, whereas an ordinary Warp is a directionless organic distortion; for aeolian landforms the former fits the cause of formation better.

1. Add Sandstone (short code ss) to handle rock outcrops between the dunes. Set Passes to 1, Iterations to 6, Spacing to 0.7, Intensity to 0.4, Convexity to 0.5, Tilt to 0.2, and set Direction to 0 to form an angle with the dune trend so the outcrops read like bedrock stripped out by wind. Set Chaos to 0.35 and change Seed a few times to pick a set that does not steal the scene.

1. Add Thermal (short code te) to finish. Set Duration to 0.3, Strength to 0.4, Angle to 0.35, and Sediment Removal to 0.6. A low Angle makes steep faces start sliding earlier, which rounds off crests that DirectionalWarp pulled too steep; give Feature Scale according to terrain width, since this kind of feature scale is smaller in deserts than in mountains.

1. Add Export (short code ex). Desert terrain relief is relatively gentle, so Format PNG 16 is usually enough; if the whole terrain will be used for displacement and inspected at high magnification, TIFF 32 is still safer.

Result: A dune field aligned along one direction, with sharp crests carrying fine sand ripples, scattered rock outcrops between the dunes, and a unified overall sense of direction.

Pitfalls:

1. Giving Sand too large a Scale turns the ripples into ground noise and the dune shapes can no longer be read. Sand ripples must always be an order of magnitude smaller than the dune forms.
2. When DirectionalWarp's Direction does not match the Direction of DuneSea and Sand, two sets of mutually perpendicular textures appear, as if blown by two different fans.
3. Using an ordinary Warp instead of DirectionalWarp. Directionless distortion kneads aeolian dunes into round hills and you cannot undo the loss of the original read of how they formed.

Case 5: Islands and Coastlines

Goal: Produce an island with river-cut valleys, inland lakes, and beaches and sea cliffs around it, good for maritime levels, survival maps, or terrain that needs a complete water system.

Node graph:

Island ──► Adjust ──► Rivers ──► Erosion2 ──► Sea ──► Lake ──► Sand ──► Slope ──► Height ──► Combine ──► CLUTer ──► Export

Steps:

1. Add Island (short code is). It generates an island starting from a rough land outline, and you can open the editor from the properties panel to draw the basic shape by hand. When drawing by hand, draw only the large outline and leave the detail to the algorithm. Set Size to 1.2 and Chaos to 0.4 so the coastline is not too regular, and change Seed a few times to pick a trend you like.

1. Add Adjust (short code fx). Set Shaper to 0.5 to push up the middle of the island and form a skeleton, and set Multiply to 1.1. The purpose of this step is to create a clear watershed inside the island, otherwise the rivers later have no sensible source.

1. Add Rivers (short code rv). It generates a complete river network and slightly adjusts the terrain to open clear channels for the rivers. Set Headwaters to 12; this value is the number of sources, and not all sources grow into main rivers, most become tributaries; set Water to 0.6, Width to 0.4, Depth to 0.3, and Downcutting to 0.35; choose River Valley Width Zero to leave the valley floor un-widened for now. Placing Rivers early is a usage the documentation explicitly supports: doing so lets the following Erosion2 take the channels into account from the start. If you need to lock the sources to specific areas, connect a mask to the Headwaters port and all rivers will only start inside the mask.

1. Add Erosion2 (short code e2). Set Duration to 0.5, Downcutting to 7, and Erosion Scale to 1.0. The channels already exist, so this pass deepens the river valleys and organizes the slopes into a form with drainage relationships.

1. Add Sea (short code sea). It is a multifunctional water surface generation and coastal erosion node. Choose Sea Global or Surrounding depending on whether you want a whole sea surface or only sea surrounding the terrain; set Level to 0.3 to press sea level down to the lower-middle part of the island; turn on Coastal Erosion, which generates beaches and sea cliffs. Then set Shore Size to 0.4, Shore Height to 0.25, and Variation to 0.5 so the coastline has natural bumps rather than a uniform-width band of sand. Turn on Extra Cliff Details to add cliff detail on the wave-facing side.

1. Add Lake (short code lk). It simulates rainfall and generates physically plausible lakes. When Type is Simple, use X and Y to specify where the lake sits, set Water Level to 0.35, and put Accuracy in the middle range; if you want several small lakes, switch to Advanced mode, set Precipitation to 0.5 and Small Lakes to 0.4, and turn on Flood Control to keep the lakes from joining into one. Water Floor sets the lake bed height, and Shore Size set to 0.3 gives the shoreline around the lake.

1. Add Sand (short code sd) for the beach. Set Scale to 0.5, Height to 0.15, Softness to 0.7, and Direction to 90. It acts on the ground surface, so the beach boundary has to be limited by the masks below.

1. Add Slope (short code sl) and Height (short code h) to divide the landforms. Slope uses Range to set the slope interval to select, with Falloff set to 0.2 and Type set to Accurate, and raise Micro Accent to around 0.2 when you need to catch fine broken rock faces. Height uses Range to frame an elevation interval, with Falloff set to 0.15. Both output selection masks: white is the hit area and black is the excluded area. Use Height to take the beach in the low elevation interval and Slope to take the sea cliffs in the steep slope interval, then connect the masks to Combine's Mask port so different landforms get different treatment.

1. Add CLUTer (short code clt) to color. Connect the terrain's high-level output to Gradient Data; turn Reverse on or off depending on your gradient direction; if the input only occupies a narrow range, turn on Autolevel Input to spread the gradient across the full range; Bias is used to push the color band position up or down overall, and Hue, Saturation and Lightness do the final tonal fine-tuning. For the water surface you can use WaterColor (short code wc) separately with Palette, Shallow and Deep to create the color difference between shallow and deep water.

1. Add Export (short code ex). For island-type terrain it is best to export height and color in two passes; format-wise, TIFF 32 for height and PNG 8 for color is enough.

Result: An island surrounded by sea, with beaches alternating with cliff walls along the coastline, a river network flowing from the watershed to the coast inside the island, and several inland lakes scattered among the valleys.

Pitfalls:

1. Setting Level too high drowns the island into a few rocks. The way to check is to see whether the low elevation interval of the Height mask still has enough land area; if not, lower Level first.
2. Not going back to adjust Erosion2's Downcutting once the river network is fixed. The channels are already on the terrain, and too strong a downcut digs the river valleys into deep trenches that do not match the surrounding gentle slopes.
3. Connecting the Slope and Height masks to Combine without setting Falloff produces hard edges on the beaches and vegetation areas, which become a clear jagged line when magnified.

Case 6: Output to Game Engines and 3D Software

Goal: Hand a terrain you have already tuned correctly to Unreal, Unity or Blender, avoiding a terrain that turns into a flat slab after import, flips inside out, or differs in size by dozens of times.

Node graph:

terrain output ──► Mesher ──► Export        (the mesh route)
terrain output ──► Unreal / Unity ──► Export (the heightfield and engine asset route)

Steps:

1. Decide the output type first. Gaea terrain has two ways to be consumed: mesh, output with the Mesher node as OBJ, FBX, DAE, glTF or GLB; and heightfield (that is, a displacement map), output with the Export node or an output node such as Unreal or Unity. If you need the engine to manage LOD itself and the terrain to be sculptable, hand over a heightfield; if you need a static model you can place anywhere, use Mesher to output a mesh.

1. Mesh route: add Mesher (short code me). Choose Format among OBJ, FBX, DAE, GLTF and GLB; Topology has three settings, Tris for ordinary triangles, Quads for quads, and Adaptive Tris for adaptive triangles, the last of which reduces the face count in flat areas and densifies it in complex areas, giving higher quality with fewer faces in most cases at the cost of supporting triangles only. Vertices Per Side sets the mesh density and should match your build resolution rather than being any large number you like. Create Normals must be turned on, and turn on Create U Vs as needed.

1. Set the mesh scale in advance. Scale has three settings: Normalized squeezes all three axes into 0..1, which is the least troublesome approach, and you just multiply by the terrain width once on import; Meter means 1 unit equals 1 meter; Kilometer means 1 unit equals 1000 meters. After choosing Normalized, in Blender set the X and Y scale to 5000 and Z to 2500 (corresponding to terrain 5000 meters square and up to 2500 meters high), then apply the scale once and the size is correct. With Meter or Kilometer you can import without scaling again.

1. Heightfield route: the choice of Format directly determines quality. 32-bit formats (EXR, TIFF 32, Float Raw) keep full precision and are the first choice for displacement maps; 16-bit formats (PNG 16, TIFF 16, Ushort Raw) show stair-step, quantized banding where the slopes change sharply. On resolution, 512 to 8192 is the range Gaea commonly supports, and starting from 1024 or 2048 is reasonable for beginners. Low resolution is not "blurry", it is a level of detail that is simply missing.

1. Unreal route: prefer the Unreal output node (short code ue) together with the Gaea2Unreal plugin, which reads the size and scale metadata Gaea exports and generates a Landscape in one click. For manual import, choose a Target Size closest to the Gaea build resolution, for example 2017, 4033 or 8129; Format PNG has the best compatibility, while RAW is currently not fully supported. Turn on Unreal Friendly Naming and the heightmap gets the H_ prefix, masks and textures get the T_ prefix, and weight maps are collected automatically by the import process using the W_ prefix. Note that the heightfield must be the first input. When importing manually into Unreal's Landscape, calculate the Z axis scale with this formula: terrain maximum height (meters) multiplied by 100 to convert to centimeters, then multiplied by 0.001953125. Also note that the Unreal node applies auto levels to the 32-bit height data before export, using the full height range and then converting to 16-bit, so the look in the viewport may differ slightly from Gaea; this is normal.

1. Unity route: use the Unity output node (short code un) and choose Target Size from 513, 1025, 2049, 4097 or 8193; these sizes are the specifications Unity terrain requires.

1. Blender route: for the displacement route, first set the scene unit to Metric and the length to Meters, create a plane 5000 meters square, then stack subdivision and connect the heightmap into displacement. After loading the heightmap, set its color space to Non-Color; on the Displacement node set Midlevel to 0.0 and Scale to 2500, so black corresponds to 0 meters and white to 2500 meters. For the mesh route, import the OBJ or FBX and add the scale from step 3.

1. Check once more before exporting: whether Width and Height in the Terrain panel of Build Options match the target project; whether every node you need output from is marked for export; whether the heightfield and masks use different formats and bit depths; and whether you have done one test build at low resolution first.

Result: The terrain appears in the engine or DCC at the correct size, the mesh normals face outward and the surface is smooth, the heightfield has no quantized banding, and the masks and heightmap are in place according to the engine's naming conventions.

Pitfalls:

1. The terrain looks like a flat slab. Most often the vertical displacement amount was not given, or the combination of Midlevel and Scale flattened the height away. In Blender check with Midlevel = 0.0 and Scale = 2500; in an engine check whether the Z axis scale was calculated with the formula.
2. The terrain flips inside out. The documentation states clearly that this is caused by inverted normals and usually happens during import. You can fix it in the application with a normal flip or smooth modifier, or re-import and confirm the relevant importer settings. If the mesh looks polyhedral with a strong faceted feel, it is most likely that the normals were not imported correctly; use smooth or auto smooth, or confirm on import that the normals are read.
3. The size differs by dozens of times. A Normalized mesh comes out as 0..1, so you must multiply by the terrain width on the importing side. Forget to multiply and you get a tiny block 1 meter square; multiply too much and the terrain stretches beyond the view.

General Build Principles

Pull out the process the six cases above share; the order is: fix the size and resolution first, then build the large form, then do erosion, then surface detail, and finally coloring and output.

Fix the size and resolution first because a great many parameters in Gaea are relative to the real world. Thermal erosion's Feature Scale, the snow nodes' Model Scale and Terrain Scale, and sea level's Level all depend on the Width and Height filled in the Terrain panel of Build Options. Tuning parameters before the size is set is like hunting for the right feel on an unknown scale. Resolution can start low; the Erosion2 algorithm stays consistent across resolutions, so the main erosion features in a low-resolution preview will correspond in the final build.

Building the large form means terrain and base shape nodes such as Mountain, Canyon, Island and DuneSea, plus overall adjustments such as Adjust. The goal at this stage is only one thing: whether the silhouette and volume are right. Do not rush to add detail; detail will be redistributed during the erosion and surface node stages. The path the documentation gives in Getting Started is the same one: establish the shape first, then adjust it, and finally handle it with simulations such as Erosion.

Doing erosion is the key step that turns this abstract shape into believable terrain. The most worthwhile thing to remember in practice is to process in passes: the first pass uses a larger Duration and higher Downcutting to establish gullies and flow paths, and the second pass uses smaller values to tighten the ridge lines and settle the terrain. The documentation's example of RadialGradient plus Warp followed by two passes of Erosion_2 demonstrates exactly this rhythm.

Doing surface detail is the most obvious difference between Gaea 2 and earlier tools. Surface-type nodes add and subtract at the surface layer without changing the terrain's overall volume and silhouette. Stratify suits large-scale layering, tilting and uplift; Sandstone does multi-pass detail, break-up and whole-block exfoliation at small and medium scales, and often generates interlocking steps too; FractalTerraces offers lower-level layering control, suited to cases where you want to control erosion directly and do not want Stratify or Sandstone to bring too many features into the terrain. The combination the documentation gives is to chain them repeatedly, for example Stratify > Sandstone > Stratify > Sandstone, or even the simple Stratify > Sandstone > Sandstone. To make the shape more broken up, add erosion or rock nodes before the layering pass.

Finally, coloring and output. Put coloring after the form has stabilized, because nodes such as CLUTer and SatMap map by height or mask, and once the form moves, the positions of the color bands all shift. For the output stage, work backward from the target software: if the engine manages terrain itself, hand over a heightfield and let it handle the size; for a static model, output a mesh and set the scale in advance. Settling resolution, bit depth and naming conventions before you start is far cheaper than redoing the work after export.

On the placement of erosion, the Misconceptions section of the documentation points out two widely spread misunderstandings that are worth remembering separately.

The first misunderstanding is that "erosion must be the last step". This practice comes from a technical limitation of more than a decade ago: at that time hydraulic erosion was the only process that could provide data maps such as flow paths and sediment for textures to use. Today Gaea can generate data maps anywhere in the graph, and Texture-related nodes can lay the groundwork for procedural color maps, while data maps such as Flow, Soil, RockMap and Occlusion can produce usable texture data without going through actual erosion. More importantly, real terrain rarely has clean flow lines one after another, and forcing erosion's flow paths to be the main driver of a texture instead makes the terrain look generated at a glance. Erosion can sit in the middle, using its results to influence the erosion and surface treatment that follow, which is exactly the reason Case 5 places Rivers early and lets Erosion2 consider the channels from the start.

The second misunderstanding is that "erosion is required". That is true in some cases, but if you are using LookDev-type nodes, adding an extra pass of hydraulic erosion instead destroys the non-hydraulic look you want, because it adds soft soil deposits and erosion flow marks. The documentation names nodes such as Canyonizer, Stacks, Anastomosis and Shear, which can produce believable results on their own and do not need to be processed with Erosion again. The reason the final Erosion2 pass in Case 2 only sets Duration to 0.25 is to remove the plastic feel while keeping the rock-layer read, rather than washing away the causes of formation accumulated earlier.

Troubleshooting

Work from the symptom. Find the closest match in the categories below, then follow the steps. Each entry states the cause as well as the fix; understanding the cause matters more than memorising the steps.

The problems below are grouped by category, and only those explicitly documented are listed. Each entry gives the symptom, the cause as documented, and the concrete steps to take. Where the documentation states no cause, none is supplied here.

1. Installation and Licensing

After startup, Gaea runs only as Community Edition

Cause: It has not been activated yet, or the license has been released. Solution: In the Activation Dialog, enter the License Key (format XXXX-XXXX-XXXX-XXXX) and click Activate; if you have a .lic file, drag it straight onto the dialog. The dialog can be opened from the Welcome window on first run by clicking "Have a license key?", and it is also available under Help > Manage License and Help > About. For bulk deployment, create activate.lic containing only the license key (no spaces and no blank lines), copy it to the Gaea Data folder, and Gaea activates automatically at startup. If the status comes and goes, check whether the Data folder holds more than one .lic file — multiple license files make Gaea read a different license depending on load order, so keep only one.

Activation reports that it cannot connect to the server

Cause: A firewall or other security software is blocking network access. Solution: Allow TCP for all subdomains of *.quadspinner.com and *.gaea.app, on ports 80 and 443. On a restricted network, enable Use Web Proxy on the General tab of Options and fill in the proxy. For a fully offline setup, use offline licensing: rename the offline license file to gaea2.lic and place it in the Data folder.

The license is stuck on an old machine, or you want to move to another computer

Solution: In Help > About, click "Release License" to deactivate this machine and fall back to Community Edition; the command-line equivalent is Gaea.exe -deactivate. If the original machine is no longer available, sign in to your QuadSpinner account, click Show in the License Dashboard, go to Activations, find that computer and click Release. The number of activations per year is limited, and a license activated too frequently will be disabled by the server. If a floating license reports "Maximum Clients Assigned", an old license seat has not been released yet — wait for the current heartbeat to finish (within 5 minutes) and try again.

Offline licensing stopped working after a motherboard or processor change

Cause: An offline node-locked license is tied to the hardware, so a major hardware change invalidates it. Solution: In Help > About, click the copy icon next to the Thumbprint reading to get the hardware fingerprint, and send it to technical support to exchange for a new license.

The problem persists after uninstalling and reinstalling

Solution: Reset first. Choose Factory Reset in Options, or launch Gaea Diagnostics from the Start menu and choose "Reset to factory defaults". If the problem persists, do a clean install: first click "Release License" in Help > About (to avoid the duplicate-licensing problems caused by a "double install"), close Gaea, uninstall it from Windows "Installed apps", then download the latest installer from the official site and reinstall. For a thorough removal of data, manually delete the installation directory (usually C:\Program Files\QuadSpinner\Gaea 2), the Data folder (C:\Users\<you>\AppData\Roaming\QuadSpinner\Gaea\2.0, or inside the installation directory for a portable install), C:\Users\<you>\AppData\LocalLow\QuadSpinner\, and the registry keys HKEY_LOCAL_MACHINE\SOFTWARE\QuadSpinner\Gaea\2.0, HKEY_CLASSES_ROOT\.terrain and HKEY_CLASSES_ROOT\Gaea Terrain Files.

2. Performance and Stuttering

The build fails halfway through, reporting out of memory

Cause: The terrain's real memory requirements far exceed the estimate. Solution: Recalculate from the per-node cache baseline: at 1024 resolution, 4MB for a single channel and 12MB for RGB; at 2048, 16MB / 48MB; at 4096, 64MB / 192MB; at 8192, 256MB / 768MB; at 16384, 1024MB / 3072MB. Then multiply by the number of nodes and output ports (at 4096, Erosion2 has 4 ports and takes 256MB, while Ridge, Adjust and Shaper take 64MB each). Doubling the resolution quadruples the footprint. 8K with 20 nodes needs 5–8GB of cache, and 16GB of RAM is only the lower bound while 32GB is recommended; 16K with 20 nodes needs 20–30GB of cache alone with peaks up to 96GB overall, so 64GB or more is recommended. The most direct fix is to lower the build resolution, or to bake first and streamline the node graph.

Previews and parameter tweaks have become noticeably sluggish

Solution: Use Bake Selected from the Bake menu to bake complex or finalized nodes, and use Bake Required Nodes for tiled workflows. On the Cache tab of Options, enable Use Smart Cache, which unloads 2K / 4K caches idle for longer than the Idle Threshold (600 seconds by default) from memory to disk. In Cache Previews to Disk, choose When Idle or When Closing File. Use Modifiers instead of nodes: 6 Modifiers cost the memory of 1, whereas 6 nodes of the same kind cost 6 times as much. Use the Orphan Nodes filter in Data View to clear branches that do not feed the output, and split the project into multiple files.

Changing one upstream node makes the whole graph recompute

Cause: That node is set to Lock Preview, so every node before the locked node is updated as well; Underlay has the same effect, and the documentation warns that modifying nodes before the Underlay updates all intermediate nodes, which becomes noticeably slow with previews above 2K. Solution: Look at the green lock icon at the top of Data View, hover over it to confirm which node it is, click it to jump there, then right-click and clear Lock Preview (or select the node and press F). For Underlay, confirm via the pink icon and, if necessary, right-click the node and clear Use as Underlay.

You want to know which node is actually the slowest

Solution: Open the Terrain tab in Data View and use the filter to select Heavy Nodes, which lists the nodes that consume the most build time based on the median. High values in parameters named Iteration, Strength, Cycles or Amount significantly lengthen processing time. After a build finishes, look at report.txt in the build directory, which contains the fastest and slowest nodes and the per-node timings (nodes under 100ms are not counted).

The GPU is not being used, or Gaea crashes and behaves erratically

Solution: On the Compute tab of Options, check Available Devices; a device with driver problems shows an error reading next to it, and that device may fail to load until the driver is updated. After updating the driver, click Scan Hardware and Determine Speeds to rescan, then click Enforce Optimal Settings to pick the best combination automatically. NVIDIA cards should have CUDA enabled first; use Native CPU mode when the GPU is unavailable or needed for other tasks, and switch off low-scoring devices entirely. When you hit crashes or instability, launch Gaea Diagnostics from the Start menu, choose "Run Gaea with CPU only" and click "Start" — disabling the GPU and accelerators improves stability, and re-enabling multiple devices means going back to the Compute tab.

3. Graphs and Nodes

A node turns red, or the whole graph fails to build

Cause: The node is reporting an error or failing validation, or a required bake is missing before the build. Solution: Open the Terrain tab in Data View and use the filter to select Nodes with Errors to locate the offending node; once selected, check build state, node errors and build messages on the Stats tab, where the error message is shown. If this is a Hybrid or Tiled build, use the Requires Baking filter as well to check whether any nodes still need to be baked first.

The terrain shown beneath the color or mask is not the one you want

Cause: When the graph branches, Gaea uses the nearest heightfield node as the Underlay by default and may pick the wrong branch. Solution: Right-click the correct heightfield node and choose Use as Underlay, or select it and press G. If the automatic choice is an intermediate node such as Shaper rather than the upstream erosion result, right-click that intermediate node and choose Exclude from Underlay, and Gaea skips it in favor of the parent node.

The mask appears to have no effect, or editing the mask rebuilds the whole node

Cause: A mask connected directly to a node's Mask port forces the entire node to rebuild when it changes. Solution: Use a standalone Mask node instead. The documentation states that the two give identical results, but the Mask node applies the mask as a post-process and is extremely fast. Connect the Mask node after the effect and it automatically takes the difference before and after the effect; when the effect consists of several nodes, connect the second input to the "before" node you want.

The Accumulator collects fewer node outputs than expected

Cause: The Accumulator only collects nodes that have already been built. Solution: Connect the output of the node ultimately used for masking to the Accumulator's Input. This does not affect the Accumulator's result, but it guarantees that the relevant nodes have all been built.

The graph is too messy and rewiring is error-prone

Solution: Insert a Chokepoint where you want to consolidate, then hold Shift and drag the Chokepoint onto the target node, and Gaea rewires all connections automatically. Converting connections into Portals allows links across long distances or even across graphs: right-click a connection and choose Convert to Portal, or select the connection and press Ctrl + P. Group things with Tabs and Groups, and use the Data View filters Orphan Nodes and Bypassed Nodes to clear branches that do not feed the output.

4. Terrain Quality

Banding or stair-step quantization artifacts on the displacement map

Cause: The heightfield was exported as 16-bit. Solution: Open the exported heightfield in a good image viewer and confirm whether it is 32-bit; re-exporting as 32-bit removes the banding, and avoid lossy formats such as PNG. The documentation recommends 32-bit formats such as EXR and TIFF for heightfields.

The mesh looks faceted, or the terrain is flipped inside out

Cause: In the first case the normals were not imported correctly; in the second the normals point the wrong way. Solution: Fix faceting with a Smooth / Autosmooth modifier, or re-import and make sure normals are imported; some DCC applications fail the import outright when a mesh has no normals, in which case use 30-degree auto-smoothing / auto-normals for a general import. Fix flipped geometry with a Normals or Flip Normals modifier, or re-import and check the importer settings.

The mesh is either very small or very large

Cause: The export used the Normalized scale, producing a mesh in the 0..1 range. Solution: In the OBJ importer, use Multiplier to multiply by the terrain width (for the default 5000-meter terrain, enter 5000), or scale it after import to the world size defined in Gaea; you can also simply export in Meters (1 unit = 1 meter) or Kilometers (1 unit = 1000 meters).

An imported DEM is too flat to show relief, or its height differs from what you expected

Cause: The data occupies only a very small height range, or its value system does not match Gaea's height convention. Solution: When the shape is correct but the terrain is flat, add an Autolevel modifier to stretch the current minimum and maximum to the full range. To specify the maximum elevation precisely, use a Constant + Match workflow: add a Constant node and set Height to the target maximum elevation (in meters), which Gaea converts automatically to the internal percentage height; import the DEM with a File node and leave it Unclamped; follow it with an Autolevel to normalize the range; then add Match, connecting the Autolevel output to the primary input and the Constant to the Reference Input.

Tiled builds are discontinuous at the tile seams

Cause: Nodes that depend on information outside the current tile are evaluated in isolation, which is common with generators that assume the full canvas and with detail normalized per region. Solution: Bake the upstream parts that are unfriendly to tiling into a stable base; Graph Menu > Bake > Bake Required Nodes bakes the required nodes automatically, and the bake resolution should be the step closest to the full world size — for example, 8 x 8 tiles of 512 means baking 4096 x 4096. Switch to Hybrid Builds, increase the bucket size and raise Blending (start at about 25%). Before the final build, build a small group of adjacent tiles as a seam test.

5. Export and Engine Import

A mask that should be exported does not appear in the output, or the file names do not match engine conventions

Cause: The node was not marked for export — a mask may look finished in the graph, but unless it is marked for export it will never make it into the build. Solution: Right-click the node and choose Mark for Export, or select the node and press F3; before building, open the Build tab in Data View to verify the nodes marked for export, the output names, the ports and the formats. The file name format is <Name or NodeName>_<PortName>.<extension>, and the primary port name can be dropped with Remove Primary port name in Build output on the Build tab of Build Options. When going into Unreal, use the Unreal node's Unreal Friendly Naming, which adds a T_ prefix to masks and textures and an H_ prefix to heightfields; the heightfield must be placed on the primary input.

The plugin or its toolbar icons are missing in Unreal, or World Partition import is very slow

Cause: The plugin was installed to the wrong path; slow import may be caused by Unreal's own import pipeline. Solution: Extract the zip to \Engine\Plugins\GaeaUnrealTools or <Project>\Plugins\GaeaUnrealTools — the folder must be named GaeaUnrealTools, otherwise Unreal may not recognize the toolbar icons; after installing, tick Gaea2Unreal in the Plugins window, and a restart may be required. Download the package from Gaea's Tools Menu > Plugins. For slow imports, import the same terrain using Unreal's standard World Partition workflow as a control; if that is slow too, the problem lies in the import pipeline rather than in Gaea2Unreal.

Weightmap import fails, or the Create Landscape button is grayed out

Cause: The importer parameters are incomplete, or the number of weightmaps does not match the number of material layers. Solution: Check that Weightmap Filenames, Landscape Material, Landscape Layer Names and Layer Info Folder are all set correctly. The number of entries in Weightmap Filenames must be one less than in Landscape Layer Names, because the first layer of the landscape layer system needs no mask; when the counts are equal, Create Landscape is disabled, so if you exported too many, delete the extra entries in Weightmap Filenames. On the material side, the number of Layer Blend nodes must match the layer count, layer names must be unique, and they must sit at the top level of the graph rather than nested inside a material function.

The terrain height is wrong after a manual import into Unreal

Solution: Use Import from File in Landscape mode; after choosing the heightmap under Heightmap File, calculate the Z scale with the formula: (heightmap maximum height in meters) × 100 (to convert to centimeters) × 0.001953125. When the result is inaccurate, use the Unreal node together with the Gaea2Unreal plugin instead, and Gaea handles these conversions — the Unreal node resamples the data to a UE-friendly resolution, so for example 2048 x 2048 becomes 2017 x 2017. As for export formats, both PNG and R16 are fully supported; the documentation recommends PNG for maximum compatibility, and RAW is not yet fully supported.

The exported mesh file is too large and imports slowly

Solution: Meshes include texture coordinates by default, and turning off texture coordinate generation can shrink the file by up to 30% and make OBJ import up to 33% faster; after import, simply apply a planar UV mapping to that object in your DCC. When you need fewer polygons, export with the Mesher's Optimized (adaptive triangles); the documentation gives a typical reduction of 20–40%, up to 80% in large flat areas, at the cost of triangle-only output with no quad support.

6. Color and Textures

Colors look washed out, gray, or too dark

Cause: Washed-out colors mean gamma was applied twice (duplicate sRGB encoding); too-dark colors mean sRGB decoding is missing and the color texture is being treated as linear data. Solution: Make sure color textures undergo sRGB handling exactly once along the entire pipeline, and import textures such as Albedo / BaseColor / Diffuse as sRGB. Do not "fix" a pipeline mismatch by baking gamma into the texture.

Masks look soft and thresholds do not line up

Cause: The mask is being treated as sRGB, or gamma decoding has been applied to it. Solution: Masks and data textures must stay linear. Data maps include Roughness / Metalness / AO, normal maps, height and displacement maps, and masks / weight maps / splatmaps. Export them as linear and import them as linear in the target tool or engine, which usually means turning off the sRGB option. The rule of thumb: anything representing visible color is usually sRGB, while anything representing numbers should be linear.

Splat maps or masks from tiled exports have the wrong colors in the engine

Cause: The pipeline treated the control textures as color data. Solution: Make sure the pipeline preserves linear values, and have the target engine import these textures as non-color data.

The SatMap's color range or distribution is not suitable

Solution: Bias shifts the color map to the left (negative values) or right (positive values); Clip takes only a segment of the whole color map; Roughness breaks up the color map pixels, adding random chaos and distortion; finally, use HSL to fine-tune hue, saturation and lightness. When you need a higher level of control, layer multiple SatMaps with a Mixer, then add ColorErosion to make the texture more realistic.

A gradient you adjusted by hand got overwritten

Cause: Re-synthesizing colors in the Synth node overwrites manual changes made in the Gradient Editor. Solution: Keep Synthesize Colors and manual editing separate — edit the gradient after synthesis is complete, not the other way around. To reuse it across projects, you can export the data as JSON or CSV.