TerraForge Get TerraForge
A snow-streaked alpine range with eroded ridges and drainage valleys, rendered in TerraForge

A world of possibilities. Yours to shape.

Build worlds
from a graph.

From the first ridge to the last ray of light.
Procedural terrain, natural erosion and rich environments — together in one native studio.

Free for noncommercial use · Source available

01 / ALPINE RANGECreated in TerraForge · 3840×2160 viewport capture, photoscanned PBR layersExplore the landscapes ↓
Procedural terrainPhysical erosionPBR materialsPlanet-scale worldsPath-traced output

01 / The creative toolkit

Think like an artist.
Build like nature.

Connect a few nodes. Follow the water. Let the landscape tell you where the materials belong. Every part stays yours to refine.

01 / Shape the land

Start with fractals. Let nature do the rest.

Build ridges, dunes, craters and strata. Carve drainage with hydraulic and stream-power erosion; soften slopes with thermal weathering. Sculpt directly onto the terrain in a separate, editable node layer.

Fractals / Erosion / Sculpting
02 / Give it a surface

Materials with a reason to be there.

Use erosion, altitude, slope and facing to place rock, scree, grass and snow. Blend up to six layers with height-aware transitions, then add field-driven roughness, bump and displacement.

PBR / Erosion masks / Displacement
03 / Build the environment

A landscape goes beyond the ground.

Set the sun by location and time. Shape volumetric clouds, atmosphere and haze. Add water with depth color and shoreline foam, then scatter imported trees and rocks across point clouds.

Sky / Water / Instancing
04 / Find the shot

From a live view to the final frame.

Compose with physical camera controls and film looks. Preview in OpenGL, render through optional path tracers, export render passes, or capture a panorama and an animated fly-through.

Cameras / Render passes / Animation

02 / Inside TerraForge

Your entire world.
One connected workspace.

See the landscape and the decisions behind it. Dock panels, open multiple node editors, arrange up to eight viewports and save the layout that fits your workflow.

TerraForge terrain workspace with a live landscape, node graph and properties
Terrain / Trace the landscape from generator to erosion to output.Actual application screenshot

Keep every decision editable. Bypass nodes, publish controls from reusable groups and undo changes across the scene.

Move between scales. Combine heightmaps with resolution-independent fields that compile to GPU shaders.

Bring your own world. Import heightmaps, SRTM tiles, uncompressed GeoTIFF DEMs and mesh assets.

04 / Your growing collection

Start with a library.
Make it your own.

Build up a personal collection of surfaces, terrain recipes and reusable nodes. Keep what works and carry it into your next scene.

Photoscanned surfaces

Browse and download ambientCG CC0 PBR sets up to 8K: albedo, normal, roughness and ambient occlusion. Downloads are optional and cached locally.

RockGroundGrassSnow

Your material library

Save material graphs with preview thumbnails. Load an independent copy into another scene and tune it without changing the original.

Explore layered materials ↗

Reusable nodes & presets

Group a network into a MetaNode, expose its key controls and save it under My nodes. Begin with terrain style presets or the included example projects.

Browse the node reference ↗

Beyond the heightmap

From a patch of ground
to a whole planet.

Build spherical worlds with their own surface graphs. Combine procedural fields and eroded terrain, shape the horizon with a real radius, and explore the surface from close-up to orbit.

Point clouds and paths extend the scene: distribute mesh instances, carve a river route or send a camera along a spline.

Explore planets & infinite terrain ↗
A procedural planet with continents, lakes and a snow cap, captured in TerraForge
A procedural planet with its own surface graph · Application capture

05 / How it actually works

Named algorithms.
Measured behaviour.

Nothing here is a black box. The solvers are the ones from the literature, the numbers are the ones the application reports, and the source is open to read.

Two domains in one graph

The raster domain holds buffers — neighbour-aware, where erosion lives. The field domain evaluates a single point in 3D and is therefore resolution-independent. Rasterize and Sample bridge them, so a procedural field can be baked for erosion and an eroded heightfield read back by a field graph.

A field network is transpiled to GLSL and evaluated on the GPU, sharing its noise implementation with the planet renderer. CPU and GPU results are verified to agree within 1.3 × 10-5 across 20,480 samples.

Raster · Field · Point cloud

Erosion that models the physics

Six independent solvers, each reporting what it did as reusable masks:

  • Particle-droplet hydraulic — inertia, carry capacity, evaporation; outputs erosion, deposition, standing water, exposed bedrock and signed change.
  • Shallow-water pipe model — a virtual-pipe solver for flowing water.
  • Stream-power fluvial incisionE = K·Am·Sn, explicit or implicit (Braun–Willett) with tectonic uplift and rock hardness.
  • Thermal weathering — talus to an angle of repose given in real degrees (scree settles near 35°).
  • Aeolian — windward abrasion, leeward deposition, dunes.
  • Priority-Flood basin filling — floods closed basins to their outlet height, so D8 routing no longer dead-ends in pits.
Deterministic · Multithreaded · Mask outputs

Terrain analysis you can wire into a material

D8 flow accumulation measures how much water passes through each point. The wetness indexln(a / tan b) — is the standard measure of where water collects: high in flat hollows fed from above, low on steep ground. Both are ordinary graph outputs, so a moss or vegetation mask sits where hydrology says it should.

ErosionLayers turns a simulation's side channels into a priority-ordered stack of masks — bedrock, scree, soil, grass, sediment, riverbed, snow — that always sum to one, and packs them into two splat textures.

D8 · Wetness · Splat maps

Adaptive tessellation, crack-free

The terrain is subdivided to what the camera needs, not to a fixed grid: 64×64 patches, each edge subdivided by that edge's length in pixels, from an effective 512 across — exactly the fixed grid it replaces, so it is never coarser — up to 2048 where the camera is close.

Levels are chosen per edge from its two endpoints, so adjacent patches always agree and no crack can open. Spacing is fractional, so a patch's level changes continuously rather than popping.

Per-edge LOD · No cracks · No popping

Materials that read the displaced surface

A layer's distribution answers where the material belongs — by altitude, steepness and which way the ground faces, each with a soft band. The criteria multiply, so a material sits where every condition holds: "rock, on the steep bits, below the snow line."

Because distribution reads the surface after displacement, slope and facing come from the shaded normal — so the material follows detail finer than the heightmap carrying it. Each layer carries its own albedo, normal and roughness, and decides whether its relief adds to the layer beneath (lichen on rock) or replaces it (snow flattening what it covers).

Altitude · Slope · Orientation · Normals

Planets as functions, not meshes

A planet is a pure parameter block — radius, relief, seed, sea level, snow line, colours, atmosphere — generated on the GPU every frame. No textures, no meshes, no caches, so a hundred planets cost the same memory as one.

Radius is a real length from a tenth of a millimetre to a billion kilometres. Single-precision positions resolve a globe to about a millionth of the tile width — 1 cm at the default 5 km tile. Sub-pixel planets are skipped, sphere meshes swap through three LODs with hysteresis so they never flicker, and surface shading always evaluates two octaves finer than the geometry.

GPU-generated · Continuous zoom · LOD hysteresis

232 nodes, 31 categories

The full graph vocabulary, from a noise primitive to a render pass. Every node reports its own timing and preview, and any node that turns terrain into terrain takes a mask input from the graph itself.

Read the node reference ↗
21Primitive23Filter11Erosion22Material14Mask10Field Convert9Field Input9Points8Export8Transform8Render7Effect7Path7Scene6Animation6Camera6Field Math6Light6Logic5Analysis5Field Color4Atmosphere4Cloud4Field Displace4Operator3Field Noise3Texture2Field Bridge2Hydrology1Field Material1Group

Specifications

Terrain resolution
64 to 8192, dirty-tracked evaluation with per-node previews and timings
Viewport
OpenGL 4.3 (4.1 on macOS); up to 8 dockable 3D views, each floatable to another monitor
Shading
PBR with roughness, metallic, specular, sky reflection, translucency, transparency and true displacement
Volumetrics
Clouds raymarched with Perlin–Worley noise; stratus, cumulus and cumulonimbus, with self-shadowing
Sun
Positioned manually, or from a real latitude, longitude, date and time
Terrain import
SRTM .hgt tiles, uncompressed GeoTIFF DEMs, 8- and 16-bit PNG heightmaps
Mesh import / export
OBJ, STL (binary and ASCII), PLY, OFF — read and written directly, with no dependency
Mesh diagnostics
Eleven checks with counts, severity and location, plus volume, surface area, Euler number, genus and a 0–100 readiness score
Offline engines
Mitsuba 3, Blender Cycles, LuxCoreRender — optional, installed separately
Render output
Beauty plus depth and world-normal EXR passes; 360° equirectangular panoramas; PNG sequences
Automation
Python API, JSON action documents and an MCP server; every scripted edit is one undo step
Language
C++20, built with CMake 3.20+ and Ninja

05 / Under the surface

Serious tools.
An open view of the technology.

A native C++20 application with a local project workflow, deterministic terrain solvers and an inspectable source code repository.

Interactive rendering

OpenGL PBR shading, adaptive tessellation, per-vertex displacement, shadows, volumetric clouds and a live camera preview.

OpenGL · GLSL · CPU workers

Offline render bridges

Send terrain, materials, cameras, lights and instances to Mitsuba 3, Blender Cycles or LuxCoreRender. These optional engines require a separate installation.

Beauty · Render passes · 360° output

Mesh tools built in

Import OBJ, STL, PLY and OFF. Inspect mesh issues, repair geometry, reduce triangle counts, split shells and export — with measured before-and-after diagnostics.

Import · Diagnose · Repair · Export

An assistant you can direct

Use an optional local Ollama model to turn a description or reference image into editable scene actions. Automate the same workflow through Python, JSON actions or the MCP server.

Local AI · Editable nodes · Undo

Scriptable, and honest about it

The same actions the interface performs are available as JSON documents, a Python API and an MCP server — so an agent, a build script or a batch job drives the studio exactly as a person would.

Every scripted edit is a single undo step, and the graph can be read back as well as written: nodes(), links() and state() return what is actually in the scene, which is what makes automation debuggable rather than write-only.

Developer guide ↗
Python — build, erode, shade and render a range
from studio_api import Studio

s = Studio()
s.graph({"nodes": [
    {"id": "n",  "type": "Noise",          "attrs": {"type": 1, "octaves": 9}},
    {"id": "hy", "type": "Hydraulic",      "attrs": {"particles": 1400}},
    {"id": "sp", "type": "StreamPower",    "attrs": {"method": 1, "uplift": 0.008}},
    {"id": "el", "type": "ErosionLayers",  "attrs": {"snowline": 0.86}},
    {"id": "out","type": "TerrainOutput"},
], "links": [["n","output","hy","input"], ["hy","output","sp","input"],
             ["sp","output","el","input"], ["el","output","out","heightmap"]]})

s.set_resolution(2048)
s.set_sun(azimuth_deg=118, altitude_deg=12, intensity=5.2)
s.render(engine="mitsuba", width=2560, height=1440, samples=256)
The libraries behind the studio

TerraForge is C++20 and links a deliberately small set of permissively licensed components. Every licence here is MIT, BSD, Apache-2.0, zlib, MPL-2.0, CC0 or public domain: no GPL or LGPL code is present anywhere, because a copyleft licence must grant downstream commercial freedom that a noncommercial licence cannot.

Dear ImGui MIT
The entire user interface
imgui-node-editor MIT
The node graph canvas
GLFW zlib/libpng
Windows, input and OpenGL contexts
glad WTFPL/CC0 + Apache-2.0
OpenGL function loading
GLM Happy Bunny or MIT
Vector and matrix mathematics
nlohmann/json MIT
Every JSON document read or written — projects, macros, automation
stb_image / stb_image_write public domain
Image loading and saving
miniz MIT / public domain
ZIP and PNG compression
Manifold 3.5.2 Apache-2.0
Guaranteed-manifold solid reconstruction in the mesh module
QuadriFlow BSD-3-Clause
Quad retopology in the mesh module
Eigen 3.4.0 MPL-2.0
Linear algebra for QuadriFlow only, built with EIGEN_MPL2_ONLY
pcg32 Apache-2.0
Random numbers for QuadriFlow only

Manifold and QuadriFlow are optional: the application builds and runs without either, reporting that stage as unavailable. The offline renderers — Mitsuba 3, Blender Cycles and LuxCoreRender — are separate installations, not bundled code. Material sets downloaded from ambientCG are CC0 and are fetched at your request, never redistributed.

Read third-party notices ↗

Built by Geekatplay Studio

A love of landscapes.
A tool built to create them.

TerraForge is created by Vladimir Chopine, co-founder of Geekatplay Studio. It brings the procedural landscape workflow behind years of environment-art teaching into a connected native application.

The inspiration comes from the classic landscape studios artists grew up with: the joy of shaping terrain, experimenting with light and finding a world inside a few connected ideas.

Your next landscape starts here

Make something
worth exploring.

Free for personal, hobby and educational use.
Commercial work requires a separate license.

Windows · macOS · Linux — see the install guide for platform setup and available builds.

What do I need to run it?

A supported 64-bit desktop system and OpenGL 4.3 graphics, or OpenGL 4.1 on macOS. Building from source needs CMake 3.20+, Ninja and a C++20 compiler. Python and external renderers are optional additions; consult the install guide for your platform.

Can I use it for paid projects?

A commercial license is required for paid production and business use. See the commercial licensing information. Personal and educational use is covered by the PolyForm Noncommercial license.

Does the studio require AI or a cloud account?

The terrain studio works locally. AI assistance is optional and uses a separately installed Ollama model. Material downloads need an internet connection; scripts and third-party integrations may have their own requirements.

Keep in touch

Ideas, questions,
worlds to share?

We’d love to hear what you’re making.

For reproducible bugs and feature requests, open an issue on GitHub ↗