UnrealPrototyping/Docs/Worklog.md

Worklog

One line per item, newest at the top of each section. What was done, what worked, what did not. Keep it terse; the reasoning lives in the specs, this is the memory.

Done

• 2026-09-20 - Phase 2 closed: seven layers, end to end. ULandscapeAuthoringLibrary::CreateLayerInfo built and the four layer infos created with the right LayerName. Verified per layer - layer info, parameter prefix and substance - plus weightmap_entries resolving 7 of 7, which is the call a level build makes per tile. The verification earned itself twice. LandscapeLayerInfoObject::LayerName turned out to have a public SetLayerName (the member is deprecated and goes private next release), so the first build's two C4996 warnings became a one-line fix rather than code that breaks on upgrade. And the check caught that the rock swap had silently done nothing: the pack prefixes its parameters by how it displays a layer, so Base_Layer's parameter is "Base Texture" and not "Base_Layer Texture" - and setting a parameter that does not exist is not an error, the instance just stores an override that drives nothing. The prefix is now read off each layer function rather than derived from the layer's name, and only three of them - the pack's - have to be written down at all, because LayerBlendInput.layer_input is exposed to MCP but not to Python.

• 2026-09-20 - Phase 2, most of it: the material blends seven layers now. build_ground_material.py extends the pack's material rather than replacing it - a new layer is a copy of an existing layer function with its six parameters renamed, which inherits the camera-distance colour blend that D-69a found load-bearing at 71 km and that a freshly built material would have thrown away. Verified: the LandscapeLayerBlend carries 7 layers, all wired, MF_Ground_Beach and friends carry uniquely prefixed parameters so they do not collide in the instance, and 20 texture parameters point the layers at the Fab substances. Run through the editor's own console over MCP, which is worth writing down: SlateInspectorToolset can type into the Output Log's command box, and py <one-liner> there runs the authoring script in the running editor - same code path as a commandlet, but no second process fighting over assets and no stale editor afterwards. sys.argv and __file__ are set explicitly in the one-liner because py guarantees neither. Two engine limits found the hard way, both silent. ObjectTools.set_properties over MCP does nothing on a Texture2D - returns success, changes nothing, no error - which nearly passed review because the read-back looked right: a _Normal suffix makes UE set TC_Normalmap and sRGB off by itself, so only the Roughness maps exposed it. And ULandscapeLayerInfoObject::LayerName is read-only, so the obvious duplicate-and-rename produces a layer info that silently keeps the name it was copied from and paints that substance wherever the new layer should be. That one is now ULandscapeAuthoringLibrary::CreateLayerInfo, in the editor module for the same reason CreateLandscapeFromHeightmap is - and it needs a build, so the four layer infos are still owed and the script says so rather than pretending.

• 2026-09-20 - The Fab substances, sorted and extracted (D-76). Eight Quixel sets arrived dropped straight into Content/Terrain/Textures/: 805 MB of 4K JPGs, no .uasset among them, so the Content Browser could not see any of it. Moved to RawContent/Terrain/Source/ and untracked - raw input belongs there, Content/Terrain is a product (D-69a), and they are re-downloadable. All eight were still untracked when found, so nothing had reached LFS yet; a commit first would have made this expensive. mapart substances now pulls three maps of nine at 2048 instead of 4096: 52 MB against 805. The resolution argument is not about the screen - a UTexture2D stores its source inside the uasset, so 4K would have been hundreds of megabytes of LFS for ground seen at grazing distance. Normals are renormalised after the downsample and written as PNG; colour and roughness stay JPEG. Reading the physical size from the metadata rather than typing it paid for itself immediately: every set is a 2 m scan except Snow, which is 0.30 m. One tiling number for every layer would have made the ice cap's grain nearly seven times too big, and nothing about that would have looked like a units bug. Seven layers now, one spare. Jungle was dropped rather than dressed with the mossy rocky ground, which is temperate where a tropical floor is leaf litter - the equator wears the remainder grass, generic but not wrong, and bringing it back is one manifest entry plus a substance. The rock is swapped for Layered_Rock_Cliff, which repaints every steep slope in the same pass. Re-verified after: seams 0 differing vertices, sums 255..256. Not done, and it needs the editor: nothing is imported yet. collect_terrain_assets.py only duplicates assets already in /Game and has no import-from-disk path, so that is the next thing, along with the five new material layers and their layer infos.

• 2026-09-20 - Phase 1 of the dressing: the biome reaches the tiles (D-75). Region.json's layers block now carries biomes and an ordered paint list - eight layers, five of them not enabled until there is a substance - and mapart biomes writes one blurred mask per biome that generate_region_tiles.py samples at the same global coordinates as the height. Three things had to be measured rather than assumed, and two of them changed the design. Orogen's class render is not a usable class source: it is the legend's colours double-encoded to sRGB, so exported desert sits 53 from legend ice and 60 from legend desert - nearest-colour matching against it is wrong, not approximate. The painting is exact, worst distance 0.0 over 29 M pixels, so it is the source. Tropical came out of koppen.js, which turned out to hold a real classification: the same sRGB encode reproduces every observed colour to 1.4/255 with 0.423% of pixels unmatched, which is the anti-aliased ring at class boundaries and nothing more - so jungle is Af+Am+Aw, 8.11% of the planet, rather than the latitude band I was going to fall back to. And the painting registers to the heightmap by identity in u,v despite 7738x3761 against 8192x4096: 98.09% land/sea agreement against 96.14% for the scaled alternative, winning in every latitude band including the polar ones. The blur is global rather than per tile, which is what keeps the seams: per-tile would need a 200-vertex margin at 400 m and 2 m quads, a third more area on all ninety-eight. Measured after: 0 differing vertices across all nine files on a shared column, weights 255..256 and never under, and the unchanged three-layer path reproduces the built world with height, rock and high rock bit-identical and meadow differing in 6 of 6 507 601 vertices by one - the deliberate change that lets the remainder absorb the rounding residual, which took the sum from 253..257 to 255..256. The classification is Go for the same reason Tools/MapArt is Go at all. Left for phase 2: the Megascans substances, rocky_meadows.LAYER_INFOS (which now refuses a layer it has no info for rather than dropping it silently), and the beach rule, which wants tuning against a real coast once there is sand to see it with.

• 2026-09-20 - Docs/World-Dressing.md: the plan for what the ground wears (D-74). Asked for as "materials works for the deserts, coasts, tropical, maybe even crater. Also skybox, ligthing and a selection of trees". No classification had to be invented, which is the finding that shaped the whole plan: Map5.legend.json is already ocean, deep, ice, lowland, highland, desert, crater with an RGB each, and that map exists at planet resolution in Plan/, in every bake and in Orogen Gens/, registered to the world by the same u,v as the heightmap. Tropical is the only one on the list that is not painted - it comes from the climate export

  • and forest is already a generated overlay mark. So this is a carrying-and-authoring job, not a design one. Eight layers is the budget and the budget is the design: Unreal packs four paint layers per weightmap texture per component and there are 9800 components, so the fourth is free and the fifth doubles the weightmap memory. Rock, grass, high rock, sand, beach, jungle floor, ice, regolith; anything past that displaces something. Trees are LandscapeGrassOutput rather than foliage actors (the only thing that scales to 2549 km², at the cost of no collision), and one planet gets one sky. Decided: dress Route A now rather than wiring Route C first - nothing authored for it is wasted, because Route C changes the layer rules' inputs and not the material, sky, grass or trees - and Megascans for the substances and trees. Phase 1, the biome carry into the tiles, needs no assets and is the next thing to build; Phase 2 onward waits on the Fab assets being added to the project.

• 2026-09-20 - Docs/World-Pipeline.md: the world pipeline written down in order. Asked for as "a docs file about how this all supposed to work, what order ... so terrain tool, orogen, what do we have to do to get it into unreal". The knowledge existed and was spread over CLAUDE.md, Terrain.md, Terrain-Next.md and two READMEs, none of which says what happens first. It owns no decisions - every one is linked to where it was argued - and the thing it makes visible is that there are three routes into Unreal and only one is live: Orogen's whole-planet PNG through the Python cutter (what L_World is), Orogen's direct tile export (built, better, unused), and terrain bake -> terrain tiles (the point of the generator, not wired). Writing it turned up two stale claims in RawContent/World/README.md: its "what it is today" table still described the 6 x 6, 30.60 km, 22.583 m/px window, where Region.json has been 14 x 7 over the whole 8192 x 4096 export at 8.7158 m/px since D-72 - 71.40 x 35.70 km, 9800 components. Corrected. And the second correction is not cosmetic: the "read flat" paragraph's 9.6% east-west stretch was true of a 1355 px window at latitude -24, and reading the entire cylinder flat stretches by 1/cos(latitude) at every row, which is unbounded at the poles. L_World's polar strips are smeared and always have been; the README now says so.

• 2026-09-20 - A world map, in the game and in the editor, from one widget (D-73). Asked for as "can we make a map view or something we can use either ingame or as its own window in editor, based of either the generated world in unreal, or the python ones, or then we have also orogens map". The three sources are one. Region.json's window is the whole 8192 x 4096 export with no crop, so L_World is the planet map and world-to-map is u = (X/100 + 35700) / 71400, one multiply and one add. No scene capture, no render target, no minimap actor - and a capture would have been wrong as well as expensive, because a world-partitioned level only ever has the streamed-in region loaded and a map is the thing that must show ground nobody is standing on. The numpy pipeline's L_Canvas_Proto shares nothing with this and was not targeted. Checked that the colormap is the same planet: orogen-colormap-14733759 against orogen-heightmap-7945 reads as two worlds because Orogen numbers each export rather than each planet, and it is one - 97.5 % land/sea agreement over a 16 px grid, against satellite's 96.8 % and climate's 87.7 % (ice scores lower without being wrong). mapart check is that test kept, and it is agreement rather than a hash because every layer is a different render of one planet. One SWorldMap, three ways in. Slate rather than a UUserWidget because the editor tab has no UWorld at all; UWorldMapWidget wraps it for UMG, the tab hosts it directly, bs.WorldMap puts it over the viewport with no content asset needed. Wrapping, pan, zoom about the cursor, a scale bar and a cursor readout are in the widget, so all three get them. Tools/MapArt renders the art, in Go, because the engine's Python cannot decode 33 megapixels of RGB - heightmap_io.py is greyscale-only with a per-byte unfilter loop. Four layers in 6.0 s: relief 2.1 s, colour 1.4, satellite 1.3, climate 1.0. relief is derived rather than exported - hillshade plus a hypsometric tint off the heightmap the landscape was cut from - and is the default, because a colormap shows biome where a player needs landform. Land tops at 3810 m, deepest -850 m, 4096 x 2048 at 17.43 m a pixel. Two real bugs go vet caught in the manifest struct: X, Y int \json:"x"`gives *both* fields the tag, sowindow.yandwindow.heightwould never have been read. **Built, tested and imported.**SaltyEditorcompiles clean across all three modules; 10 of 10Salty.Core.*tests pass;build_world_map.shwrites four 4096x2048 textures andDA_WorldMap_L_WorldintoContent/World/Maps/ and reads them back. Three things cost time and are worth knowing. **EditDefaultsOnlycannot be written from Python**, because it means edit-on-default-only and aUDataAssetis an *instance* - so every property on the definition isEditAnywhere, which is right for an asset a script authors: the flag guards a placed actor's copy of something and there is no such copy here. Direct setattris not a way round it; it routes to the same checked setter, so the fallback that looked like a fix was deleted rather than left in place implying a path that does not exist. **AnFSoftObjectPathreprs as{}in Python whether it is set or not**, because its fields are notUPROPERTYs. A first verification pass reported levelempty and it was never empty -export_text()says/Game/Maps/L_World.L_Worldand the asset registry lists/Game/Maps/L_Worldas a dependency of the definition. Comparing a Python enum withstr()lied the same way:str(TA_WRAP)is"<TextureAddress.TA_WRAP: 0>", not the name. Both traps are now inside create_world_map.py: it reads every property back and **refuses to save** if one did not take, because a property set that silently does nothing looks exactly like one that worked, and a save is not evidence that the value is there. My first test also failed for its own bad arithmetic - -3569900 cm` is 1 m from the map edge, not 100 - so it asserted 200 m where the answer is 2.

• 2026-09-20 - One world level: L_World is the region now (D-72). Called as "we shouldn't have a secondary level anyway, it all should be working on L_World including the world we built". Region.json's level is /Game/Maps/L_World; World.json's is /Game/Maps/L_Canvas_Proto. Nothing else was entangled - L_World was named only by World.json and world_manifest.py's default, no gameplay code refers to either level, and both default maps are L_Gym - so this was two keys and a rebuild. Rebuilt rather than renamed: a world-partitioned level owns 475 external actor packages plus two HLOD assets, the editor fixes those up on a Content Browser rename and headless is not a path walked here, and a half-fixed rename is worse than an hour of unattended batches. Three things that had to move with the name. The tile PNGs are named after the level (tile_name is its last segment plus the coordinates), so changing level made all 98 tile sets look missing and would have regenerated 208 MB that already existed - the 392 files were renamed instead. build_region.sh reads the level out of the manifest now, the way it already read the grid, because a name written into the driver goes stale the moment the manifest changes and the lock probe would then guard the wrong file. And the numpy pipeline's own PNGs became L_Canvas_Proto_*.png, because L_World_Height.png in Heightmaps/ beside L_World_x0_y0_Height.png in RegionTiles/ is two files differing by a tile suffix. The old canvas is repointed, not deleted, and the different name is the point: create_world.py empties whatever level it is handed, so a manifest still saying L_World would replace 98 landscapes with a 14 km square on one run. Kept because it is still the only path carrying the erosion pass's flow, wear and deposit maps into Unreal. Verified on the rebuild: L_World emptied to 9 actors and the sweep removed exactly 256 stale packages, the old landscape's 16 x 16 proxies, and nothing else.

• 2026-09-20 - The sea wears a placeholder grey. Reported as "the sea material is abit bugged right now, make it a testing grey". /Game/World/M_Sea_Proto - opaque, default-lit, base colour 0.18 - replaces the engine's single-layer water on World_Sea_Proto. The water material is a lake shader stretched over a whole planet and reads at every scale as something it is not; rocky_meadows.SEA_GREY is the switch back and the water path is unchanged behind it. Authored on demand rather than picked out of /Engine, because nothing there is the right value: BasicShapeMaterial is the near-white that once read as an ice sheet to the horizon (2026-09-16) and WorldGridMaterial puts a metre grid on a plane 70 km across. The part worth keeping: ensure_dressing spawns the sea only when the level has none, which is the right rule - a rerun must not leave two suns - and it means a material change cannot reach a world that already exists. ensure_sea now re-applies the material on every run, and fix_sea_material.py repaints a finished level and saves it, so changing one material reference does not cost a rebuild of 98 landscapes. Applied to L_Region and read back out of the asset to confirm the value landed rather than defaulting.

• 2026-09-20 - Off the ladder: World Orogen exports Unreal landscape tiles directly (D-71), and a locked level is refused before it is emptied (D-71a). The export. Asked for as "can you make it so we can export from orogen as intended … its the 2m/px type exports, whatever unreal needs". Orogen's two exports are a picture and one flat 8192 x 4096 PNG with no scale on it, which is why D-69's metres_per_pixel had to be invented. The new Unreal Landscape panel (in the export card on both pages) renders a window of the planet straight into the tile set the importer wants: a 16-bit height at 255*N+1 vertices and three 8-bit weightmaps per tile, plus the Region.json that describes them, written into a folder through the File System Access API - so the files land in RawContent/World/RegionTiles/ and create_region_world.py reads them unchanged. The window is sampled once into a float raster and every tile is cut out of it by global vertex position, which is what makes the seams exact: measured 0 of 1021 vertices differing on both the east-west and the north-south seam, heights and paint. The paint only closes because tiles carry a one-vertex margin for the slope's central difference - the same defect D-69 hit in numpy, hit again here. Heights ride heightmapColor's -5..6 km ramp but are read out of the float target rather than quantised, so precision is a millimetre against the 16-bit PNG's 17 cm. What the panel is for is the number you have not typed yet. It re-plans on the keystroke and prints ground, components, file count, sample spacing and the flat reading's cost. It earned that immediately: D-69's own numbers - 936 km2 on a 100 km planet - are a window 110 degrees on a side, stretched 74.7 % at its edge, because a 100 km circumference is a 3183 km2 world and 936 km2 is 29 % of it. The projection is cosine-corrected at the centre latitude so the error splits between the two edges instead of landing on one, and the defaults are 4 x 2 tiles: 208 km2 at 5.4 %, which a sphere this small can hold. Not <input type="number"> - it parses in the browser's locale, so on a comma-decimal machine 0.17 shows as "0,17" and .value returns empty, making the setting NaN and the export a tile set of nothing. Caught in the first screenshot. An existing Region.json is never replaced - most of that file is the reasoning behind its numbers, and D-56 already settled that a generated save must not eat an author's commentary - so a second one lands as Region.generated.json and the status line says so; the tiles are data and are overwritten. Verified in a real browser over the DevTools protocol, 28 checks including the encoder's own scanlines inflated back out and the button wiring itself up on both pages with no console errors. This does not retire generate_region_tiles.py, which is the path that will read terrain tiles. The locked level. Reported as "currently the map IS BUGGED OUT somehow, super glitchy, nothing left". Nothing was corrupt and nothing was lost. A full rebuild had been run with the editor holding L_Region open: batch 0 emptied the level, batches 0-3 built twelve tiles, and batch 4's save died on MoveFile … (Error Code 32), a sharing violation. The run aborted loudly and correctly - but the wipe had already happened, and the twelve survivors were all of row y=0, the northern polar strip, which on this planet is nearly all ocean. The level opened on 71 km of sea. A failure detected only after the destructive step is indistinguishable from data loss, so both the script and the driver now probe the .umap with open(path, 'r+b') before anything is emptied. Refilled with --append; the twelve good tiles were kept.

• 2026-09-20 - L_Region: the spawn was 180 m underground and the fog was the pack's 8 km fog on a 30.6 km world. Reported as "when spawning in the world i am under the landscape" and "i cant see the world in the editor, its just some random fog on the ground". The spawn. ensure_player_starts traced straight down for the ground. In a commandlet the landscape's collision is not reliably present but the sea plane at Z 0 is - it keeps collision so a walk off the coast is a walk - so the trace hit the sea and returned 0.0, which is not None and so went straight past the guard written to catch exactly this case. The starts were saved at 1.20 m with the ground at 181.83 m. The pad height is read out of the heightmap now: the window's centre vertex is the [0, 0] pixel of the middle tile, because half of six tiles is a whole number of them. Existing starts are moved rather than skipped, so a rerun repairs a level instead of leaving it wrong. No trace anywhere in the path. The fog. PACK_FOG is Rocky Meadows' demo tuning for an 8 km map; density is per unit distance, so on 30.6 km it is opaque - a capture looking straight down from 25 km was pure white. rocky_meadows.scale_fog divides the density by how much bigger the world is than the 8 km demo (0.027143 -> 0.0071 here, 0.0152 for L_World) and sets the height falloff to the engine's 0.2 so fog thins with altitude instead of reaching the top of the sky. PACK_FOG is left as read; the scaling returns a copy. What is still not visible, and it is not the fog. Measured: trace_world straight down at the origin hits at Z = 0, the sea plane. The 36 Landscape actors are always-loaded and carry zero components; ChangeGridSize moved every component onto 144 LandscapeStreamingProxy actors, which are spatially loaded. World Partition knows all 190 actor descriptors and reports the right world bounds (+/-16384 m), so nothing is lost - the proxies are simply never loaded, in the editor or (apparently) in PIE at the spawn. Everything in the diagnostic captures was the sea plane lit through the cloud-shadow light function, not terrain. L_World has the same symptom (open item 2), and it also splits into proxies, so this is the project's landscape path rather than anything about this world. Measured on one tile: grid size 0 leaves 100 components on the Landscape actor, grid size 5 leaves 0. Unresolved; the choice is to load a region in the World Partition window, to build HLODs so unloaded ground still draws, or to stop splitting.

• 2026-09-20 - Off the ladder: Generate marks is a button on the studio's overlay tab (D-70). internal/studio/overlaygen.go + a handler in page.html. Every press is a fresh seed, so it is a re-roll; the server remembers what the last generation put down and clears exactly that first, so drafts replace each other instead of silting up and hand-painted work is never touched. It runs before the first bake on the painting alone (flat height, nil drainage) and says which path ran, because a sketch that knows nothing about rivers or slope must not be read as one that does. Two defects found by pressing it: settlement placement had no seed dependence at all, so two presses gave byte-identical drafts - fixed with a seeded score jitter, since the forest count is a quantile and therefore invariant by design; and Map3's bake was silently accepted for Map5, because CheckBake compares only how a heightmap is encoded and two paintings of one planet agree on all of it - BakeIsOfThisPainting now compares the recorded template and falls back with the reason printed. The sheet is replaced rather than stroked, so undo history is dropped and the status line says so. Verified headless over the DevTools protocol: hidden on the class sheet, shown on the overlay, two presses differ, wrong bake named and ignored, zero page errors. Tests: TestASecondSeedMovesTheSettlements.

• 2026-09-20 - Off the ladder: 900 km2 of ground in Unreal, cut from the Orogen planet export and tiled (D-69). RawContent/World/Region.json + Scripts/Authoring/region_manifest.py, generate_region_tiles.py, create_region_world.py, build_region.sh; the Rocky Meadows kit moved out of create_world.py into rocky_meadows.py so both worlds are dressed by one set of numbers. 6x6 landscapes of 2551 vertices at 200 cm, 10x10 components of 255 quads each: 30.60 km a side, 936 km2 of map holding 905 km2 of land, -510 to 2972 m, nothing clipped. Tiles in 134 s and 208 MB (untracked). The planet's scale had to be invented. The export carries none, and at Planet.json's 100 km circumference the planet is 31.8 km across, so a flat 30 km square does not fit on it. Searched the land mask over scale and position: 22.583 m a pixel (a 185 km circumference) is the finest reading whose best window still clears 900 km2 of land. Read flat rather than unprojected, which at latitude -24 stretches the ground 9.6% east-west; cos-correcting the crop would stretch its own edges by +/-35% across the latitudes it spans. Heights are Orogen's normalised metres, not the generator's - terrain bake makes this same continent a 116 m plain - so the relief is art; sea_scale 0.17 is the only correction, and only to the sea. Seams are exact by construction: every vertex is sampled from its global position in the window, so a shared column is computed twice from the same coordinates and comes out bit-identical, heights and all three weightmaps. That did not hold for slope until the tiles were sampled with a one-vertex margin - np.gradient takes a one-sided difference at an array edge, and every tile boundary was a one-vertex line of different paint. Resampling is Catmull-Rom clamped to its two central taps, because an 11.3x upsample of a source whose steps are its coastlines rings otherwise. Three walls hit, all in the engine rather than the data:

  1. Memory. A landscape of a hundred components costs about a gigabyte the editor never gives back, so one process asked for all thirty-six reached 14.7 GB by the ninth tile with 0.3 GB of commit left on a 31.9 GB machine. Killed twice. The builder is incremental now - it adds the tiles it is told to, saves and exits - and build_region.sh runs it in batches of three. Six peaked at 13.6 GB and left 1.2 GB of commit, which is why the default is three.
  2. Arguments never reached the script. UPythonScriptCommandlet::Main reads -Script= as one quoted string and hands the whole thing to the Python plugin, which splits it into a filename and arguments; anything after it on the command line is the engine's. Passed the wrong way the script saw no arguments and silently built all thirty-six - the exact run the batching exists to prevent.
  3. A commandlet with the editor open and a relative project path writes nothing at all and exits zero, which reads as success. Absolute paths and -abslog throughout. UnrealEditor-Cmd also exits non-zero whenever anything logged an Error, and this project logs three on every start (no GameFeatureData asset rule; the open editor already holds MCP's port 8000), so the driver gates on the script's own "saved" line instead of the exit code. Fixed on the way past: the sea plane's material is /Engine/EngineMaterials/WaterMaterial.WaterMaterial, the full object path - the package path alone resolves in the editor but not under -run=pythonscript, so L_World's sea has been a grey shape material rather than water. Not yet re-verified by a rebuild.

• 2026-09-20 - Off the ladder: Content/Terrain/ collects the ground out of the asset packs (D-69). RawContent/Terrain/ground.json names fourteen assets - six textures, three layer functions, the master material, its instance and three layer infos - and Scripts/Authoring/collect_terrain_assets.py copies them in, idempotently. Copies rather than moves, so a pack stays as it shipped. A copy is not ownership: a duplicated material function still samples the pack's textures, because the reference is inside the graph, so every copy is walked and repointed at its siblings and the asset registry is then asked what still points outside Content/Terrain - that report is the answer to whether a pack can be deleted. Only Rocky Meadows has real ground today; HouseForge's stone is architecture and its grass is a foliage card. Getting there took four corrections, each found by the report rather than reasoned: Expressions is protected on UMaterial and absent on UMaterialFunction, so it has to come from MaterialEditingLibrary; a function needs get_material_function_expressions, since get_material_expressions refuses one outright, which is what left all three layer functions still sampling the pack; the registry must be rescanned before the report, or the new assets come back with no dependencies and an empty answer was being read as clean - the first run claimed the folder stood on its own while the master was still calling the pack's functions; and a material caches the textures it and its functions reference, so every copy is recompiled and force-saved at the end or the stale cache outlives the repointing. Final state: 21 graph references and 13 instance references repointed, one left - MI_Ground_RockyMeadows still names the pack's T_Rock_Shade_Variation, which is not one of its parent's parameters and is not in its override array, so neither pass reaches it. Everything renders from Content/Terrain; the pack cannot be deleted until that one is cleared.

• 2026-09-20 - Off the ladder: terrain overlay proposes an annotation layer from a bake (D-68). internal/overlay/generate.go + generate_roads.go + internal/planet/overlaygen.go, and a generate block per mark in the overlay legend. Four kinds: forest (noise-broken, treeline from a quantile of the land's own heights), settlement (scored on drainage, flat ground and distance to the sea, one spacing rule across tiers), road (minimum spanning tree on least-cost paths, water impassable so each landmass has its own network), coast (supported, deliberately not shipped enabled - coast_jitter changes the next bake). Generation fills blanks and never touches a painted pixel, so the round trip runs both ways. Three defects found by running it: the no-overwrite rule blocked every kind after the first (a coast band took 21 % of the world and the towns inside it painted nothing); settlements were scored onto painted ground where they could not be stamped, so a city and six villages were placed, reported and then dropped by the feature pass; and forest grew on both ice caps until not_classes existed. Measured on Map3 against Bake_022: 17 s, 3.88 M painted px kept, 2.48 M added, and terrain plan reads it back with 0 unmatched pixels and counts matching the run exactly. Tests: internal/overlay/generate_test.go - painted pixels survive, marks without a block are never generated, nothing lands at sea, spacing holds across tiers, roads never cross water, two runs are identical, and a generated sheet classifies back to itself.

• 2026-09-20 - Off the ladder: World Orogen reads the planet's own files (D-67). Three ports from Tools/Terrain, each one a question an author has while typing a number. (1) js/painted-report.js is plan.go's angle functions exactly - the class table shows the typical median hillslope and what it reads as, with the divide angle and P90 in the tooltip and a "clamped" flag past the angle of repose; verified against RawContent/World/Plan/plan.json on Map3, five land classes and the clamp ceiling all to 1e-9. (2) js/painted-overlay.js + painted-overlay-view.js carry the annotation layer: same classifier rule (alpha is blank, no-match dropped and counted), drawn as a texture on the globe's triangles and on a map quad rather than voted onto regions, with an Overlay Sheet toggle, an Overlay inspect layer and export type, and the mark named in the hover. Marks are voted only for coast_jitter, which pins or roughens the shore. (3) Planet.json is read directly and outranks a legend's planet block, bringing the pipeline constants the angles need. Plus Tools/Terrain/internal/studio/share.go: the studio serves the painting, both legends and the manifest with a CORS header on GET and HEAD only and no preflight, so "Load from studio" brings the whole planet in 4.0 s and no page can ever start a bake. Measured headless: overlay painted px identical to plan.json (3,875,832, 0 far), 200 steps in 7.3 s, marks on 45,745 regions, zero page errors; mobile at 390 px has no horizontal scroll and 44 px targets. Tests: internal/studio/share_test.go (CORS is read-only on five methods; the served file is the text on disk). Not carried, same reason as D-66: faults, craters, the coast pass, the detail passes, the slope histograms.

• 2026-09-19 - Off the ladder: World Orogen (Tools/Orogen/, GPL, plain ES modules) has a Painted Map source on its import page that reads the same painting and *.legend.json as terrain plan and solves the uplift into terrain on its sphere mesh (D-66): js/painted.js (legend, nearest-colour classify with a 6-bit colour cache, majority vote per region, stroke dissolve / pole strokes to edge_class, coast roughening on the signed hop distance, massif and rock fields cut at planet quantiles, coastal-plain ramp, swell, Braun-Willett implicit solve with a per-step priority flood, relief scaled to a Peak Height slider), js/painted-layers.js (class, uplift, erodibility, drainage, slope, basin colours for globe, map and export), worker handler, six inspect layers and export types, an editable legend table with Download, a planet block in the legend for the Planet.json numbers, assets/painted-legend.json and a quarter-size assets/painted-demo.png made from Map3. Verified headless (Chrome over the DevTools protocol from node): Map3 at 204K regions classifies in 0.45 s, solves 200 steps in 12.3 s, 25 s with climate, no page errors; dendritic networks with trunk rivers on every landmass, massifs standing out of the lowlands, 16-bit heightmap and the six painted PNGs export. Not carried: faults, craters, overlay, plates, repose clamp, detail passes (44 km cells). Uncommitted, with the rest of the working tree.

• 2026-09-19 - Off the ladder: the laser-carved flanks were D8's, and drainage area is multiple-flow now (D-65). Reported as "streaks going down the side of the mountains making them look like laser carved", against the x4 bake. Terrain-Next.md 4.B3 blamed the ridged-fBm initial relief; it was wrong, and the test that ruled out grid locking - "the ribs are oblique, not axis-aligned" - was not a test, because D8's parallel-flow grooves run in whatever direction the slope faces. The grooves are channels: present in map_flow.png, absent from map_uplift.png, and the network is pinnate rather than dendritic - 25 sources and no confluences in a 12.8 km window. The pitch is 18 cells in both Bake_x4 at 32 m and Bake_020 at 8 m, which no mechanism fixed in metres can produce. Isolated with no erosion at all on a planar ramp: D8 gives the most-drained cell in a contour band 769x the median and leaves 29.5 % of the grid draining nothing, where the true answer on a plane is 1 and 0. Freeman MFD for Accumulate only, D8 receivers kept for the implicit update, Kahn order rather than an elevation sort: 1.34 and 0.4 %. 101 ns a cell against D8's 17. Three repairs alongside - the repose clamp jitters its pop order and allowance, DiffuseNonlinear goes to the isotropic nine-point stencil because the clamp cuts across eight faces and a five-point smoother cannot transport across a diagonal one, and field.SmoothEdgePreserving is ported from the World Orogen browser generator, off by default. Tests: flow_test.go, smooth_test.go, the clamp isotropy and bucket-order pair, and a benchmark - which is what caught the first version of the MFD precondition returning a silently wrong area on a second call (D-65a).

• 2026-09-19 - Off the ladder: the ocean was thirty metres deep (D-64). Reported as "it is just a landmass and no oceans really", against the exported heightmap. Bake_020 measured: the legend paints ocean and deep at 512 m over 55.9 % of the planet and 17 % of it gets there, while 40 % of the world is water between 0 and 30 m - one 26.8 % spike at -20 m. At -1024..2048 m that is 1 % of the 16-bit ramp from sea level, so shelf and land encode to the same grey and the shelf halos fuse the continents. One number, taken from the other canvas. coast.Build wants a BreakM, the depth at the shelf break, and both call sites read -pipeline.continent.sea_floor_m.hi() = 30 m - a square-canvas default whose own comment says it is not a shelf break, since on a 14.28 km canvas a real one does not fit. AbyssM has been per-cell from the painting since D-60; the break never was. What hid it: the derived margin reaches shelf_km.hi() + slope_km = 4.6 km from every shore, and 1069 km of shoreline against a 3111 km2 sea is 4917 km2 of margin over a smaller ocean, so the painting is never consulted in any strait. The profile is monotone and correct at any break depth, which is why the profile tests all passed and this had to be found in a histogram. pipeline.coast.break_m is a key; ShelfBreakM() falls back to the old reading so the square canvas is unchanged (verified, still 30 m), and a planet defaults to 130 m - the depth the template's own shelf class is painted at. The 4.6 km margin is unchanged: 512 m over it is a 6.3 deg slope, which is right. Two more of the same read in tiles.go, both commented "the shelf break": restoreSeaFloor would have staircased the new shelf and the tile hillshade would have flattened it. Also: a bake prints its sea floor's three numbers, and how much of the 16-bit ramp the world used - 28 %, land 7 %. Too wide a range clips nothing, so clip_fraction never saw it. Planet.json untouched; ~-576..320 would be 3.4x the contrast, and that is the author's call. Measured at unit scale, 9.6 km of sea painted at 512 m: 33 % -> 8 % of it left shallower than 50 m, and a sea painted at 20 m still 20 m deep. The whole-planet re-bake was killed by memory pressure (the coastal pass peaks near 8.3 GB) before it wrote anything - its numbers are still owed.

• 2026-09-19 - Off the ladder: a fault set saturates, and the initial relief stops reading the faults (D-63). Reported as "the mountains seem to be streaking horizontally like someone just cut the mountains apart with a knife", in Bake_018, bottom right. Both mechanisms are D-62's, and D-62 missed them because it was verified on region 8, which two traces reach. Faults stacked. FaultDelta accumulates with +=. That was harmless at a 600 m reach because two faults almost never met; at 6 km they meet constantly, and a set is sub-parallel by construction - traces within one cell of the orientation grain share a strike, a belt fault takes its from the margin - so where they meet they all push the same way. Region 11 is 22 km across with 13 traces at strikes spanning 14 degrees. Measured on a 200 m grid: 75 % of the faulted ground had two or more faults on it, the sum a median 1.77x the largest single contribution and up to 4.46x, 13 % of it over the repose ceiling on its own - so the hard clamp fired on 160 289 cells, 4.1 % of the region, against 0.15 % planet-wide before, and a hard clamp makes plateaus. Now softStack: a soft knee per cell keyed to the largest single contribution at that cell. A planet-wide throw would not bite - the biggest throw on this template is 744 m and the biggest single contribution in the region is 209 m once taper and falloff have had it. Identity below the knee, so a lone fault is untouched and D-62's "the step across a fault is its throw" still holds; above it the excess bends onto 1.6x the knee. Continuous (a max of continuous functions, gradient 1 either side of the join) and frame-independent, which is what keeps TestTwoFramesAgreeAboutTheSameFaults true - and it runs unconditionally, because skipping it when one trace reached a frame would make a cell's value depend on which frame asked. And the initial relief was reading the finished rate. painted.go scaled the symmetry-breaking noise by rate/maxClassRate with the fault delta in it and no bound, so D-62 took the stamped amplitude from ~39 m on unfaulted foreland to ~166 m on a 6 km footwall, on a landmass whose whole relief was 221 m. A thousand steps cannot erase initial relief the size of the landscape, so the ridged fBm stopped breaking symmetry and became the texture - the ribs are 250-300 m, octave five of a 4.2 km ridged fBm. Pre-fault rate now, bounded at one. Measured, region 11 re-baked at the same seed and steps, Bake_018 -> Bake_D63: max 221.4 -> 115.6 m, repose-clamped cells 160 289 -> 2 865, median slope 6.26 -> 1.79 deg, slope-area exponent -0.938 -> -0.599 (theory -0.500), drainage 0.58 -> 0.60 /km, stacking median 1.77 -> 1.50 and p90 2.87 -> 1.60. The corduroy is gone. The wall time went 1m34s -> 12m56s and that is the right direction: the old run was cheap because unbounded negative stacking had driven whole aprons to zero uplift, and dead flat ground costs one hillslope sub-step instead of twenty-four. Not fixed: the residual ribbing is Terrain-Next 4.B3, which is visible in Bake_013 too and is now diagnosed there rather than fixed. ClampToRepose's raster-order facets were checked and ruled out as the cause - its facets are grid-aligned and these ribs are oblique - and recorded as 4.B4.

• 2026-09-19 - Off the ladder: a fault is a range front rather than a welt (D-62). Raised as "each fault line makes a rough line of mountains that just doesn't look realistic", and asked as "is it a json setting that is too low". It was not: the legend says how many faults, how long and how much they throw, and nothing in any manifest said what shape one is. The shape was faultSteepM = 200 and faultGentleM = 2000 in painted_faults.go with a step between them - the whole throw one side of the trace, the whole throw negated the other, one 8 m cell apart. Measured on the designed field: 2 x throw across one cell, 89 degrees, inside an upthrown flank that reached zero 600 m out. Two things are wrong with that and they are the same thing twice. A discontinuity in the rate is a painted cliff - the surface can only put it into a scarp at the angle of repose, so the trace facets at any throw and turning throw_m down just lowers the artefact. And 600 m is narrower than one hillslope: Bake_013's drainage density is 0.45 channels per km, so a divide sits 1.1 km from its channel, and nothing can cut a valley into a block that width. The uplift profile is therefore printed onto the surface rather than eroded into a landform, which is exactly what the hillshade shows - a smooth ruled ridge with no drainage on it at all, running through terrain dissected everywhere else. Now: an odd saturating ramp across the trace (d/sqrt(R^2+d^2), R = 900 m, about one hillslope) times a flank envelope with finite support and zero gradient at its edge ((1-u^2)^2, 6 km footwall, 4 km hanging wall). Zero on the trace, which is the honest reading - a rate difference across a line says one side rises relative to the other and the two average to the regional rate at the line. Algebraic rather than transcendental on purpose: it runs at a few hundred million cells a planet, and the reach is unchanged so the box is too. tipTaper was a flat top over the middle two thirds, which extrudes the cross-section along most of every trace; it is a bell now. And throw_m is normalised to mean the whole step across the fault rather than a full throw on each side, which is what the old one built - the normaliser is measured off the profile so changing a width cannot silently change what the legend's number means. Measured, 400 m throw: steepest cell in the rate field 89 -> 17.4 degrees, step across the fault 400 m over 2.66 km (8.5 degrees mean) against 800 m over one cell, footwall above half its crest for 3.7 km against 0.6 km. Solved for 1000 steps on the same synthetic landscape, old against new: a ruler-straight cliff with a dead apron and 43 m of relief (45 m with no fault at all) against a dissected range front with its own valleys at 97 m. TestAFaultIsSolvableRatherThanPrinted is the three properties as assertions - continuous, zero on the trace, and wide enough for three hillslope lengths of footwall.

• 2026-09-18 - Off the ladder: the studio's canvas becomes a GPU texture (D-61). The template is 7738 x 3761 and every pointer event pushed all of it through the 2D canvas: a full-width putImageData band, then a high-quality downsample of the whole image once per repetition across the seam. Neither cost is a function of what the stroke touched, so a 24 px brush and a 400 px one both measured about 105 ms an event at fit zoom, worst case a 1.4 s p90 at 1:1 from the canvas read-back stall. Now: one WebGL2 texture per sheet, a stroke uploads only its own rectangle through UNPACK_ROW_LENGTH with no copy, drawing is one quad, and the seam is REPEAT rather than a tiling loop - which also fixed the blur at the wrap, where each repetition's own texture coordinates gave the wrong derivative and so the wrong mip. Measured after on the same machine: 6.0-6.3 ms flat at fit zoom with a 400 px brush, at 1:1, at 4x and panning. Input is off the drawing path (one rAF loop, getCoalescedEvents keeps every sub-frame position), mips rebuild at most ten times a second while the brush is down, both offscreen canvases are gone (230 MB, and the sheets are encoded only when pushed), and a lost GPU context re-uploads instead of going black. Added: a brush ring in the brush's colour, eased zoom anchored under the cursor, f to fit, 1 for 1:1, space to drag, rendering at device pixels, and shortcuts that stay out of input fields - o had been swapping the sheet under a half-written number. Verified live over the DevTools protocol against the running studio: sheet and GPU agree on a painted pixel, a seam stroke uploads as two rectangles and both ends take the colour, all 200 control columns and both sides of the wrap map exactly at 1:1, the eraser restores alpha, plan round-trips both sheets, and no GL error on any path. The 12.1 % of rows that disagree across the seam are the painting's own, which plan's SEAM check already reports. And ctrl+z takes back a stroke (ctrl+shift+z or ctrl+y puts it back). Same constraint, same answer: a sheet is 116 MB so a stack of snapshots is not a stack, and the unit is one stroke rather than one frame. A step is copy-on-write over a 256 px tile grid - a tile is kept the first time a stroke writes into it - so a dab costs one tile and 256 KB, a 60 px drag two and 512 KB, a 400 px brush dragged 800 px 42 tiles and 9.1 MB, against a 192 MB cap that bounds both stacks. keepTiles sits at the top of stamp, the only writer, so nothing can be painted that undo has not recorded; undo and redo are one swap in opposite directions. The test caught a bug reading would not have: 7738 is not a multiple of 256, so the tile grid does not line up with itself across the seam, and cutting the stamp's unwrapped rectangle into tiles before wrapping the indices kept columns 30 and 0 for a brush that had also written into 29 - every sampled pixel restored, only a whole-sheet hash disagreed. Wrap into runs first, then cut, which is pushRect's own order. Verified live: bit-for-bit restore of sheet and texture, four undo/redo cycles exact, four strokes back in order, a seam stroke whole again, one sheet's undo leaving the other alone, the eraser undone back to its mark, a new stroke dropping the redo future, mid-stroke ctrl+z ignored and the stroke still undoable after, and ctrl+z in a text field still the field's own.

• 2026-09-18 - Off the ladder: a planet has a shore (D-60). internal/coast ran on a flat grid, so a bake laid the painted sea floor and stopped - no shelf, no surf platform, no beach, no sediment, no exposure anywhere. Four primitives to wrap, three of them one loop: boxBlur's running sum, fetch's ray march, shelfWidth's inland march, and the distance-field gradient both marches take their direction from. The abyss is a field now, because a painted planet's sea classes carry their own depths and a derived slope bottoming out at one global number would step to the painting wherever they disagreed. It also fixes the shallow case honestly: the break cannot be deeper than the water it is a break in, so a strait painted at 20 m against a 30 m break is shelf all the way across rather than a trench. Memory. Geometry.Ref holds a waterline slot rather than a cell index, so the sediment supply is a few hundred thousand entries instead of 76 million - 608 MB gone. Measure holds one distance transform at a time instead of two: the waterline comes straight off the mask, and a sea cell's shore is the shore its nearest land cell already found, so the second pass reads Ref rather than the first pass's index. boxMean's coverage is separable (cx(x)*cy(y), exactly, any pass count) so it is two vectors rather than a field plus a second blur, and the before snapshot is taken into the change map and subtracted in place. A latent NaN fell out of the last of those. deposit does math.Pow(1-exposure, 1.5), so an exposure over 1 by 5e-5 - which the new float64 divisor produced where the float32 one had not - is NaN, and one NaN spreads through the drift kernel into the whole budget. 1720 cells of a 200x40 test. Clamped at the point of use; relying on a smoother a hundred lines away to bound its output is not an invariant. Measured: 7.9 s over the whole 76 M cell cylinder, and the seam step in the sea floor went from a mean of 9.1 m (worst 523 m) to 0.32 m, which is what an ordinary interior column is - checked against six of them. What is left is the template's own 9.4 % wrap disagreement, which is an author's to fix. The pass is now the memory peak of a bake at about 8.3 GB working set; the solve's was 3.6.

• 2026-09-18 - Off the ladder: a planet can be judged now (D-59). internal/stats sorted a copy of every land cell in four different places, so a planet bake printed its elevation range and nothing else - no slopes, no per-uplift-class breakdown, no drainage density, no slope-area fit. It cost twice today alone: the lowland slope distribution and the fault scarp measurement both had to be taken by hand in Python off a PNG, because the tool could not answer questions about its own output. Fixed-bin histograms replace all of it, and the property that matters is not the speed but that they add: two regions' bins summed and quantiled give exactly what one pass over both would. A median of medians would not. Each region accumulates while its own grid is alive - the composited planet has no uplift field or flow topology left to recover them from - and they merge in region order, because the bins are integers but the sums are floats and float addition is not associative. Extent and ground are measured in different places on purpose. Regions carry overlapping ocean margins, so pooling "cells" double-counts water and reports a meaningless land fraction; AddExtent runs once on the composited cylinder, Add runs per region over the land that region owns. Found the consequence by running a partial bake: drainage density came out an order of magnitude low because it divided three islands' worth of channels by a planet's worth of land. It divides by the land actually walked now and says PARTIAL. field.SlidingMin and field.LocalRelief join SlidingMax, so local relief stops being 1.1e11 comparisons at a 500 m window on 28 M cells. Measured: 1.09 s for a 9 M cell region, ~120 ns a cell, a few seconds for a planet at the end of a two-hour bake. generate and bake share the code now, so their numbers are comparable - which they were not before, and nobody had noticed because one of them printed none.

• 2026-09-18 - Off the ladder: the seed re-rolls what the painting does not fix (D-58). Asked for as "different faultlines and stuff". Half of it already worked and was worth measuring before building anything: seed 7 against 9342 on one painting moves 13.6 % of the uplift map, because the massifs, the swell, the initial relief, the crests and the coast jitter are all seeded. The other half did not exist - faults and lithology were procedural-path only - so map_erodibility.png was a recolour of map_class.png and two seeds differed on it only where the coastline had moved. It is 24.9 % now. Neither ported as it stood. The old lithology takes f.Percentile() of the grid it is given and the old fault centres are Float() pairs read as fractions of it: both are exactly what D-53's per-landmass decomposition forbids. The rock cut is a quantile of the planet now, from the probe the massif fabric already uses (measureFabric went generic), and the fault set is drawn once in world metres with each region filtering to the traces that reach its frame. A class says faults: {per_1000km2, throw_m, length_km} and lithology_mix, so an author says which ground is faulted and which rock shows through. Wrote the faults fresh rather than porting: 4.A2's four defects (polygonal parabola, stamped tips, no en-echelon step, strongest throws flattened by a global clamp) and 4.A3's single strike angle are all fixed in the new one. The softening of a rock boundary is pointwise in rank space and not a blur, because a blur near a region edge reads cells another decomposition would not have given it. One defect found by arithmetic rather than by looking. A hard cut-off at three gentle lengths leaves 5 % of the peak - 0.013 mm/yr on a 400 m throw, a fifth of a lowland's entire rate - as a step at a line 6 km from every fault, which the solve would have carved into a straight scarp nobody placed. Subtracting the floor and renormalising fixes it and makes the box a real optimisation: with per-segment boxes hoisted out of the cell loop, 5.2 s to 1.5 s on a 6.3 M cell region. --seed on plan, bake and tiles (fs.Visit, not a sentinel - every sentinel is a seed somebody wants), and a seed box with a Re-roll button in the studio. Faults cost 1.5 s on a 6.3 M cell region and the rock field nothing measurable; the trace geometry goes into the bake's meta.json. Baked region 15 to check the faults survive the solve (Bake_008, 12 min): five traces with throws of 139..399 m left scarps of 2.7..50 m and five of five face the side the fault raises. A small fraction of the throw is the right answer - the rivers cut it down about as fast as the rate rebuilds it, which is the whole reason a fault is a rate and not a painted step. TestAFaultLeavesAScarpAfterTheSolve is that in miniature, nine seconds, because everything in internal/uplift tests the rate field and none of it says the solve leaves anything behind.

• 2026-09-18 - Off the ladder: a second painting, for everything that is not geology (D-57). Asked for as "select which coastlines not to give jitter to" and "a layer for forest generation, where a city/town/village is, spline roads" - two requests with one shape, so one mechanism. internal/overlay is a sheet the same size as the template with a legend of marks; blank is alpha, not a reserved colour, and an opaque pixel matching no mark is dropped and counted rather than snapped to the nearest, which is the class legend's rule inverted on purpose. One mark property is read by anything. coast_jitter scales D-56's waterline roughening per pixel: 0 pins a hand-drawn shore exactly as painted, 2.5 makes a fjord coast out of one brush stroke. An unmarked cell is uninstructed rather than 1 and takes its instruction from the far side of the waterline, or a stroke painted on the land would be overruled by the water beside it. Checked exactly rather than by eye: pinning every pixel gives a map_class.png byte for byte identical to --coast-jitter 0. Everything else is inert. Marks come out as an 8-bit index raster beside every detail tile (indexed, not one mask each - marks cannot overlap on one painting, so 254 fit in one file) and as features in world metres in overlay.json: areas get a centre, an area, a radius and an extent; paths are thinned to their geodesic diameter and get an ordered polyline, because what is built from a road on the other side is a spline. A blob across the seam is one feature with a circular centroid; a tile samples through world metres, which is rule 1 for a raster. A fork is one path and loses its third arm - stated, and plan prints the piece count. The studio grew a second tab (o), the marks as brushes, an eraser, and the sheet composited over the painting at full strength while you are on it and dimmed while you are not. And the class table stopped lying. It printed the divide angle - the steepest ground a rate can make - as if it were the landscape. Measured on 600² of 8 m cells at 1000 steps with the manifest's own numbers: median slope is a third of the divide angle in tangent, and the ratio is flat (0.34, 0.33, 0.33, 0.32) across 0.012 to 0.250 mm/yr; P90 drifts 0.59 to 0.40. Both columns print now and reads as comes from the median, so highland is hill country at 11.7° rather than alpine at 32°. D-55's defect one level up. And the picture lies the same way, which is where the complaint actually came from. Baked the real continent to settle it - region 12, 45.9 x 19.8 km, 9.0 M land cells, 27 min - and it is 0..47 m with a median slope of 0.61°, 4.4 % over three degrees and nothing over eight. A plain. What made it look like an alpine massif is that preview.png's hypsometric ramp tops out at a percentile of the world being drawn, so green-to-snow was stretched over its 32 m and the 40 m hills got white caps. Redrawn at a fixed 400 m ceiling it is flat green with four pale massifs. palette.land_top_m is that ceiling, and every run now prints which one its preview used. The percentile stays the default - absolute over a world with no mountains is a green shape with nothing legible on it - so what was added is the sentence, not the option.

• 2026-09-17 - Off the ladder: the coastline stops being a drawn line, and the template gets a tool (D-56). coast_jitter_px was in the manifest, documented and defaulted, and nothing read it - three grep hits, all in manifest.go - so every painted shore went to the solve exactly as drawn. It is now a mask on the signed distance to the waterline: add fractal noise to the distance, re-read the sign, and land juts out where it is positive and the sea reaches in where it is negative. A domain warp was built first and binned: a smooth warp of a smooth boundary cannot cut a bay. A cell that changes sides takes its class from the distance transform's nearest-feature index; the amplitude is capped per cell at two thirds of the widest land within reach, or a wavelength bigger than an islet takes the islet whole - measured, 2 of 12 gone without the guard, and field.SlidingMax (monotonic deque, O(1) a cell) exists because the naive window is seven billion comparisons at planet scale. The mask exposed a classifier bug and made it load-bearing. A JPEG blend of surf and lowland is (186,219,174), which is 53.8 from desert and 77.9 from either parent - so every temperate coast carried a 1 px ribbon of desert, 1607 px of it, and the mask made those strays the nearest land to open water and gave their class to an 11 px band of new shore. The colorimetric fix was built, measured and thrown away: it moved 943 000 real shelf pixels, because shelf sits 10 units off the ocean-surf line. The spatial one works - 5x5 majority, kills a 1 px ribbon, leaves a 2 px band - and moves 0.068 % of the map, 1607 -> 0. terrain studio: a painting tool on loopback where the brushes are the legend's classes and the panel shows the divide angle each rate buys as you type it. Hard-edged exact colours only (an antialiased brush manufactures the blend the despeckle pass exists to remove), the canvas wraps at the seam, plan is a button (7.5 s round trip), and it saves by patching the text of the legend and manifest so their commentary survives - MarshalIndent over a map returns the file alphabetised. Then two notes from using it. Saves are versioned and never overwrite - Map3_001.png, Map3_002.png, as Bake_NNN already is, with the manifest repointed; the base map is a hand-made input with no undo outside the process, and writing back over a JPEG would recreate the blend artefacts on every save. And plan is cached: 7.0 s cold, 0.37 s when only a legend number changed, because the classification, despeckle, coast mask, projection and region cuts depend on the painting and the class colours alone. Low-res maps were the obvious guess for making it quick and they do nothing - prepare is flat at 6.5 s from a 400 px map to 2400 - because the cost is region.Build at 2.68 s on the 76 M planet grid (classify 0.09, strokes 0.93, despeckle 1.52, coast 1.62, project 0.05). The four maps have keys now, served from the code that drew them rather than reimplemented in the browser. And a Bake button that can be watched. BakeOptions.OnRegion fires as each region's land is composited, holding a new composite lock so the hook can read the whole planet without racing the workers still solving; the studio draws a preview there, so the world fills in a landmass at a time and the first continent out answers "is this what I meant" an hour before the last one. Zero-copy views over res.Height/res.Flow rather than Painted(), which allocates 300 MB a call. fluvial.Grid.SetCancel checks once a step, so a bake can be stopped - and a cancelled run is written to Partial_NNN, not thrown away: the solve is per landmass, so a region that finished is finished, and losing fifteen of eighteen because the last three were slow is not what a cancel button should do. Outside the Bake_NNN namespace on purpose, since tiles --bake takes the newest of those by default.

• 2026-09-17 - Off the ladder: a painted class becomes two rates and a fraction (D-55). The first planet's landmasses came out uniformly dissected - every divide on a continent at the same angle, coast to summit, no flat ground anywhere - and that is D-49 read one step further: a class was one rate, n is 1, so one class was one landscape. lowland 0.08 mm/yr is 11.3 degrees on every divide it touches. Now massif: {floor_mm_yr, fraction} per class, cutting one upland fabric for the whole planet (planet.massif_wavelength_km, 7 km against landmasses of 20-45 km; 12.5 put a whole island above the cut). The threshold is a quantile of the planet, never of the region - a percentile of the grid is exactly what FromTemplate exists not to do, and two regions would have disagreed along every boundary - so it is a fixed 1024-column probe binned into a histogram, ~10 ms, identical everywhere by construction; the ramp is cut in probability, so fraction means what it says whatever the noise's distribution is. map_uplift.png had to learn the fabric too, at the image's resolution, or the one diagnostic that would show this would have gone on drawing a flat continent. Legend retuned: lowland 0.08 over a sixth with a 0.012 plain, highland 0.25 over three tenths with a 0.045 foreland, desert 0.10 over a seventh with a 0.015 sand sea. Also corrected the misreading that set the old numbers - internal/stats calling under 0.1 mm/yr "plain" is a reporting bucket, not terrain, and 0.1 is a 14 degree hillslope - so terrain plan prints what a class reads as from its angle, and coastal_floor_mm_yr defaults to 0.02 not 0.06. Five tests in internal/uplift, and the first version of the fraction test measured nothing: the test planet was narrower than the probe, so both sampled the identical grid and every number came out exact. Measured on Bake_004 against Bake_001/003, same region boxes: lowland continent median slope 3.7 -> 0.7 deg and 7% -> 93% of it under 2 deg; highland island 6.7 -> 2.0 deg and 4% -> 49%, keeping a p90 of 8.9 and a 167 m core. Peak elevation fell 71 -> 41 m on the lowland although the massifs still reach the same rate, because relief is the integral of slope along the whole flow path - so max elevation cannot see this change and nearly reported it as a regression. map_flow.png point-samples every fourth cell at 3000 px on a 12500 grid, so channels read as disconnected stubs and only the divides survive: it looks like broken drainage and is not, and Bake_001 shows the identical pattern.

• 2026-09-17 - Off the ladder, three things the legend could not say (D-54), all three from looking at the first whole planet rather than from the plan. coastal_plain_km: for n=1 the uplift rate alone fixes the hillslope angle, so a uniformly painted island is at the angle of repose right down to the water - fjords end to end. The rate now ramps from a floor at the waterline up to the class rate over a stated distance, smoothstepped so the plain meets the range without a crease. This is D-52 read carefully, not reversed: that removed a hidden taper that went to zero and flattened the strip the surf works in; this is opt-in and the waterline keeps a real rate. A crater cannot be an uplift rate - the priority-flood raises every depression to its spill level every step, so a basin built from negative uplift is filled within a hundred steps, and an impact is an event rather than a rate anyway. It is stamped on the finished terrain after the solve, shape derived from the painted blob: distance in from its own boundary normalised by its widest point, so four numbers describe every crater whatever size it was drawn, and one across the seam is one crater. A desert is not a low uplift rate - a wet lowland has one too, and at the geology grid the only lever is k_mult. A class can now override what the detail passes do on it (droplets_per_cell, strata_contrast, amplitude_m), which is where the difference actually lives: measured over identical terrain, 43634 droplets moving 84 km of material against 2148 moving 4.1 km - a dendritic gully network against a few isolated wadis. snow is a display and material hint no pass reads: the hypsometric ramp tops out by elevation, so a polar cap fifty metres above the water was coming out the same green as a meadow. And the thing chasing "too mountainous" turned up: the mountains were flat polygonal facets - the repose clamp doing all the shaping, because highland at 0.9 mm/yr is 66 degrees at a divide against a 35 degree repose angle. The ceiling is U = tan(talus)Kcell = 0.280 mm/yr at an 8 m cell; terrain plan prints the angle per class now. Did not work, in order: blamed the strata hardness (turned it off, nothing changed), then the tile hillshade (WriteThumbnail saturates to black and white at 2 m a cell - a real bug, now a proper DEM hillshade, but not the cause). What settled it was tiles --no-detail, which writes the geology upsampled and nothing else, so "the solve or the detail passes" is a twelve-second question. Bakes are versioned Bake_NNN now, because ninety minutes is too long to spend on a change you cannot then compare. And the preview palette is a file: the ramp, the water, the rivers, the ice and the light, pointed at from the planet manifest, defaulting to what was hard-coded. Separate from the legend because the legend is about the world and a palette is about the picture - it changes no height, so two bakes under two palettes are the same terrain. Written by hand rather than by MarshalIndent, which re-indents a custom marshaler's output and will not keep a colour on one line.

• 2026-09-17 - Off the ladder, the first whole planet baked: 18 regions, 49 M of 76 M cells, 44m41s of wall time (8805 s of solve) at 1000 steps with four regions in flight, land 0..741 m, nothing clipped. The painted classes do exactly what they say - the lowland island is 45 km of 31 m plain, the highland islands are 741 m of mountain with dendritic drainage to both coasts - which is the legend's numbers to tune rather than the tool's. Measured, and it is the input rather than the tool: the template's left and right edges are the same meridian and disagree on 9.4 % of rows, 261 of them land against water. The crater island crosses the seam perfectly; islets drawn touching x=0 with nothing to meet them at x=W-1 do not, and a JPEG halo two pixels wide on the outermost columns classifies as shelf and puts a 400 m ledge down the whole height of the map. terrain plan measures the wrap now, because it is the one defect an author cannot see by looking at their own picture - the two edges are as far apart on screen as they can be. Also measured: cost per cell varies eighteen-fold with the painted uplift rate (72 s per million cells at 0.08 mm/yr, 350 at 0.9, 1278 at 1.6), because the nonlinear hillslope sub-steps up to its budget of 24 on steep ground and once per step on a plain - so raising an uplift rate changes the bake time as much as it changes the terrain, and the wall time is set by the slowest single region rather than by the total.

• 2026-09-17 - Off the ladder, the detail passes and tiles (D-53 continued). Passes 8 to 12 and 14 in internal/detail and internal/tile, ported from heightmap_erosion.py with every brake by name, plus terrain tiles: 5 km tiles of 2500 samples at 2 m, about twelve seconds each, heightmap plus hillshade plus flow, wear and deposit. The thing worth remembering: the tile margin is measured, not reasoned. Taken literally it would be rounds x lifetime, 640 cells against a 2500-cell tile; measured against the same ground in one whole run it is 7.97 m of difference at the cut edge, 0.72 at eight cells, 0.03 at 24 and zero by 32, so three lifetimes plus the brush is the margin - 122 cells, five per cent of a tile. At one round the match is bit-for-bit, which is the test. Did not work, and none of it would have failed loudly: the droplets' round count derived from the droplet total, so a droplet landed in a different round in a tile than in the whole map and the seams never closed (it is a manifest number now); the derivative maps normalised by a percentile of the tile, which is a statistic of the piece being looked at and the same mistake the coastal exposure had already had withdrawn; the detail noise on the world period, which wants a 12500-squared lattice and a gigabyte and a half for one octave (a kilometre period instead, and what repeats has no shape); the sea left in place through the upsample, which rings at every coast and lets thermal pour the shore into the water

  • the mirror image of the first coast run eroding land to 174 m below sea level; and the droplet stencils straddling the waterline, quietly deleting the sediment that should have built a beach. Also: the per-band scatter was partitioned by core count, and floating-point addition is not associative, so determinism failed by one ulp - field.FixedBands is a partition fixed by the grid rather than the machine.

• 2026-09-17 - Off the ladder, painted planets (D-53). The generator's source stops being a seed: a hand-painted flat cylindrical world map plus a JSON legend saying what each colour means in uplift mm/yr and erodibility, and the simulation makes the terrain. X wraps, Y does not. New internal/world (the cylinder and the frame), internal/dt (the exact distance transform moved out of coast and given a cylinder), internal/template (image, legend, classifier), internal/region (the partition) and internal/planet (the driver), plus terrain plan and terrain bake. First template: 7738x3761, nine classes, 100 km round at the 8 m geology cell = 12500 x 6076, 18 regions, 49 M cells of 76 M, largest 14 M at 0.8 GB, about two hours at 1000 steps. The thing worth remembering: the fluvial solve cannot be tiled but it can be decomposed per landmass, exactly, because ocean cells are fixed at sea level and nothing in the solve can move them, so no flow path crosses open water - TestOceanCellsAreUntouchedByTheSolve now asserts that premise directly. The coastal pass is deliberately not decomposed: it costs 26 ns a cell against 80 ns a cell per step for the solve, and cutting it up would truncate the fetch across every strait and split the sediment budget whose conservation is the one thing in it not derived from something already measured. Decompose the solve, not the map. Did not work: clustering landmasses by overlapping dilated bounding boxes - transitively closed, and one 70 km landmass collapses a 100 km planet into a single region; dilating the mask itself and connected-componenting it is exact, wrap-aware and the same code the stroke fill needs. Also rejected: hanging a world origin on field.Field, because a Field is used for masks and scratch that have no position and would all quietly claim to sit at the origin. Also: the router jitter moved from a hash of the grid index to a hash of the world position (rule 1 of the tiling plan), done first and on its own because it re-baselines every measured number on the square canvas; and every image writer turned out to be silently square, which is invisible at 1:1 and squashes a 2:1 planet.

• 2026-09-17 - Off the ladder, the coast, part two: the uplift field stops being multiplied by the continent mask (D-52), so a range that reaches the water rises at range rates right up to the waterline instead of being tapered to nothing across the shore. Surf cut 23.3 → 38.9 Mm3 on seed 7 and 22.4 → 30.4 on seed 9342; high ground now meets the water in the detail crop where it previously had a uniform low fringe in front of it. New TestBorderIsAlwaysOcean in internal/check, because the margin that keeps land off the map border was relying on that same multiplication as a side effect: the border is still all ocean on three seeds, so there is no frozen rim. Did not work, and it was mine: the "mean cliff" statistic measured the drop from a cell to its seaward neighbour and called it a cliff. That is a gradient - one cell of a 10 m grid at the angle of repose is 7 m - so it could not exceed 7 whatever the coast did, and it read 2 m on a plain coast and 3 m on a cliffed one. It is why yesterday's brief claimed there were no sea cliffs anywhere; the replacement, backshore height at one to two surf reaches inland, shows the old build already at 88 m P90. A cliff is how far you fall, not how steep the first cell is. Also measured: the slope-area fit is too noisy at five or six bins to judge one change on one seed - the same code gives -0.480 on seed 7 and -0.698 on seed 9342 - and 14 to 15 % of every coastline is drawn by the map margin rather than by the noise, which is a straight line parallel to the map edge and is pre-existing.

• 2026-09-17 - Off the ladder, the coast. internal/coast, running after the fluvial solve, on the terrain the solve produced. An exact signed distance transform with a feature index (Felzenszwalb, two 1-D passes) is the coordinate everything is written in; on it sit a continental shelf whose width is read off the relief behind each stretch of shore, a surf that planes the land to a shore platform within a reach set by how open the water is - the cliff is the step where the reach ends - and a sediment budget that carries what the surf cut a drift length along the shore and lays it in sheltered shallow water, with river mouths delivering their own load. uplift.Result.Bathymetry is gone: the coast pass owns the sea floor, and ocean cells stay at sea level for the whole solve. New: map_exposure.png, map_coast.png, a coast block in meta.json and in the summary, --no-coast and six other overrides, nine tests, and the determinism test now covers the pass. The measured finding was the coastline outline: at five octaves its finest feature is 450 m, which is a blob, and the fetch called the median stretch of coast fully open. Swept, seed 7 at 1400: shoreline 64/81/96/114 km and median exposure 1.00/0.98/0.84/0.51 at outline gain 0.50/0.58/0.62/0.66. D-51 sets 8 octaves at 0.62. Whole pass 83 ms. Did not work: a percentile stretch for exposure (degenerate on an even coast, and a global statistic two tiles would disagree about); casting fetch in every direction rather than seaward only (it counts the land behind the shore as shelter, so a straight coast scored more sheltered than a bay); a cut fraction read as a fraction of the height above the platform (15 % of a 120 m headland is 18 m, which is not a platform); dep = blur(supply) * want / blur(want), which looks like a normalised convolution and lost 68 % of the sediment budget - the supply blurred onto land and deep water where nothing wants it was silently dropped, and the conserving order is to divide by the blurred want first, then blur; and one kernel for both jobs - the sediment needs zero padding to stay symmetric and a carried value needs edge clamping, and using the mass-preserving one on the shelf width shrank every shelf near the border to nothing.

• 2026-09-17 - Off the ladder, the plains problem. The lowlands read as shrunken mountains because they were being uplifted at mountain rates: S = U/(K*A^m) applied down to one cell puts a 0.25 mm/yr divide at 28 degrees and the 0.9 mm/yr swell past the 35 degree repose clamp, so the clamp was the surface of the continent (81 % of land in the >0.5 mm/yr class, the plain class 1 % and all sea cliff). Built stats.UpliftBuckets first, to measure per uplift class rather than map-wide - that is what made it visible. Then D-49 (intraplate 0.25 to 0.03, swell 0.9 to 0.08, relief lo 50 to 15 m) and D-50 (hash-jittered flood epsilon and D8 tie-breaks, for the flat ground the fix exposed). Plains are now 42 % of land at 0.8 degrees and 9 m relief; slope-area R2 0.06 to 0.46. Then Roering nonlinear hillslope diffusion in internal/fluvial/hillslope.go, running after the repose clamp each step so the clamp's D8 pyramid facets get rounded off: mountains 31.1 to 28.5 degrees and 44 % to 33 % pinned at talus, at 8 % more runtime. Four tests on it. A run now also writes uplift, erodibility, slope, relief, flow and basin maps. Did not work: critical_area_m2 1e4, re-measured after the uplift fix and still failing (plains back to 7 degrees, 79 % of mountains at the clamp) - it needs a hillslope transport law to pair with; clamping once at the end of the run instead of in the loop (facets returned). Still open: half the land is still in the mountain uplift class; fault traces and the range grain are still visibly straight lines; MFD accumulation unbuilt.

• 2026-09-17 — Off the ladder, build-order steps 3 and 4 of Terrain.md: the Go core exists and the stream-power solver works. Tools/Terrain/ (module salty/terrain, Scripts/build-terrain.sh, binary and RawContent/World/Preview/ gitignored): field (the one array type, vertex-convention resampling, Catmull-Rom upsample, greyscale PNG through image/png, hillshaded thumbnails, and field.Rows as the only place goroutines are made), manifest (World.json over Go defaults, the same height contract as world_manifest.py, and a validator that refuses a resolution the importer would turn into thousands of components), noise, uplift (the continent, now producing an uplift rate rather than terrain), fluvial (priority-flood, D8 receivers, stack, accumulation, implicit Braun & Willett update, sub-stepped diffusion), stats and two integration tests. The proof: the analytic check K*A^m*S^n/U measures 1.0000 over 822 channel cells, and on the continent the slope-area exponent is -0.498 against -0.500 at R2 0.996 with drainage density 1.33 /km. Determinism is asserted across five values of GOMAXPROCS, not assumed. Nothing in the editor was touched (it was open), so steps 1 and 2 are still first and still open; the numpy pipeline still builds L_World and is unchanged. Three bugs, all of which produced plausible-looking terrain and none of which could have been seen by looking: slope-area measured with the topographic gradient instead of the channel gradient read -0.78 where the truth was -0.50; cells at a local minimum were skipped entirely including their uplift, which froze exactly the basins that differential uplift was forming; and the fix for that then uplifted the outlets, because a map border is an outlet but is not ocean, so base level rose 2 m a step and the steady-state ratio read 0.03. The last one was invisible in real runs, where the border is ocean, and only the test caught it.

• 2026-09-17 — Off the ladder, no code: an incoming procedural terrain specification (tectonics, faults, lithology, stream-power erosion, a Go core, an editor bridge into a Landscape edit layer) reconciled against the built pipeline in Terrain.md, and the Go core taken as D-47. What the reconciliation found: the spec's 7113 canvas is a trap, because 7112 divides by 127 and not by 255, so the importer's own rule gives 3136 components rather than the spec's 784 — the 4033 mistake again (D-45); 7141 at 200 cm gives 28x28 components of 255 quads with the same 14.28 km side the manifest already has. The spec's Z scale 400 is exactly a 2048 m elevation span, so its canvas is expressible in the manifest's own metres contract, at the cost of dropping the crests from 2800 m to 1536 m (Q2). The spec's uplift/K parameter ranges and its elevation budget are not jointly consistent at their corners: steady state puts slope at U/(K*A^m), and the aggressive corner overshoots 1536 m badly, so U/K is the one relief knob and the clip fraction is the check. The spec has no coast at all and leaves base level open, where this world has one and a sea plane (Q1). Lithology (plan view) and strata (vertical) are orthogonal and both kept. The spec's §8 DEM escape hatch is already built and better specified than the spec's version. Deferred with triggers: the preset gallery widget, UTerrainPreset, river splines, build-zone volumes, any GPU port. The five open questions were put to the user the same day and all five went the recommended way (D-48): the coast stays and sea level is the base level, the ceiling drops to 1536 m, the canvas goes to 7141 at 200 cm, and a full run holds the five-minute bar. Go 1.25 turned out to be installed already, on 16 cores, so the toolchain cost was zero. Nothing is built; the ladder is untouched.

• 2026-09-17 — Off the ladder, third pass: geological simulation in the generator (D-46). heightmap_erosion.py, numpy only: particle hydraulic erosion in vectorised batches, a coarse pass on the 4x-downsampled map for the valleys and a fine pass at full resolution for the gullies; mass-conserving thermal weathering at a 35° angle of repose; strata hardness scaling the erosion; flow, wear, deposition and curvature maps written as PNGs and used by the layer rules. The uplift gained Worley cellular crest lines through the same domain warp. The manifest's erosion block drives it; "enabled": false for a real DEM. Two things the smoke test caught: droplets stepping together in a batch and crowding one cell run away to infinity without a per-step cap, and thermal weathering that sheds half the mean excess converges far slower than half the largest excess.

• 2026-09-16 — Off the ladder, second pass: the world's terrain is now a manifest, RawContent/World/World.json (D-44). world_manifest.py derives the landscape's Z scale and Z offset from an elevation range in metres so world Z 0 is sea level; heightmap_io.py reads 16-bit PNG and raw r16 with numpy alone and resamples; heightmap_noise.py builds the continent in metres (retuned: 80 % of the land under 15°, ranges on a fifth of the map); generate_heightmap.py takes either the noise or a real heightmap named in the manifest and derives the three Rocky Meadows layers from the height by slope and altitude, so a real heightmap needs no weightmaps. create_world.py dresses L_World with the pack's kit as dump_level.py (new, dumps any level's actors to JSON) read it from Rocky_Meadows_01: sun with the cloud-shadow light function, skybox dome, sky light, height fog, fixed exposure and saturation; plus World_Sea_Proto, a plane with the engine's water material. Resolution moved from 4033 to 4081 so the engine's importer picks 16x16 components of 255 quads instead of 64x64 of 63 (D-45): the import takes two minutes instead of forty.

• 2026-09-16 — Off the ladder, at the user's request: L_World, a world-partitioned ~200 km² landscape from a seeded heightmap. Scripts/Authoring/generate_heightmap.py (numpy, in Scripts/Authoring/.pylib via bootstrap-pylib.sh) writes 16-bit height and 8-bit weight PNGs to RawContent/World/Heightmaps/; create_world.py rebuilds the level from them through ULandscapeAuthoringLibrary in the new SaltyEditor module, because the engine exposes no landscape creation to Python. Elite_RockyMeadows' landscape material and three layer infos. Swap the terrain by replacing the PNGs and rerunning. Nothing in gameplay references it.

• 2026-09-16 — Step 2: ITelemetrySink with null, log and JSON Lines sinks; FTelemetryEvent, the envelope and Telemetry::ToJsonLine; TelemetryEvents with the four session names; UTelemetrySubsystem; ASaltyGameMode minting the session id into ASaltyGameState; bs.TelemetryTest; the git hash in the build string (D-42); four Core tests. Proved standalone, and with a headless -server plus -game client sharing one session id.

• 2026-09-16 — The editor's MCP: the engine's experimental plugin only listens when bAutoStartServer is set, so .mcp.json refused until DefaultEditorPerProjectUserSettings.ini set it (D-43). Enabled the Editor, AutomationTest, GameplayTags, ConfigSettings and LiveCoding toolsets; before that the only toolset was skills. Reconnect with /mcp after the editor is up. Live Coding must be closed before a shell build.

• 2026-09-16 — Step 1: Salty.uproject (UE 5.8) at the root from the Third Person template, renamed from ProjectSomething with class redirects; SaltyCore and Salty modules; SaltyServer.Target.cs (unbuildable on the launcher, OD-04); USaltyAssetManager calling InitGlobalData; Config/Tags/ with 23 root namespaces; Gameplay Abilities, CommonUI and Python enabled; Scripts/run-tests.sh, build.sh, Authoring/create_gym.py; Git LFS attributes; the placeholder test. Template variants kept as reference (D-41). Four Fab packs in Content/, none used yet (D-39).

• 2026-09-15 — Spec/Stats.md: one stat block on every body, every outside influence an effect, counters on the receiver (D-37, D-38). Replaced the movement component's own speed-multiplier map, which was the first strand of the spaghetti this exists to prevent; enemies and kits now carry FStatBlockDefaults; step 5 builds it.

• 2026-09-15 — The documentation set written for Unreal from the two earlier projects' docs: Design.md, Steps.md (fifteen rungs, the first six in full), Ideas.md, Decisions.md (D-01 to D-36, OD-01 to OD-08), and the eight specs under Spec/. No code, no project yet; step 1 is next and waits on OD-01 and OD-02.

Worked

• (nothing built yet)

Did not work

• 2026-09-17 — "fill_every": 50 in the terrain spec, written to protect the five-minute budget, silently destroyed the stream-power solve. Uplift reaches 5 mm/yr, which at dt 1500 is 7.5 m a step, so fifty steps is up to 375 m of differential uplift between floods: basins close and sit unrouted while everything above them stops eroding. Measured at 512² over 3000 steps the fitted exponent goes -0.500 (R2 0.992) at every step, -0.277 at every fifth, -0.121 at every tenth, noise beyond. Even every fifth step is broken, and the saving was 93 s against 38 s. The budget came back from the step count instead: 1000 steps, not the spec's 5000, because at this K the trunk response time is about 45 000 yr and the exponent stops moving after 500.

• 2026-09-17 — The heap in the priority-flood was the wrong data structure. The flood pops in non-decreasing elevation and never pushes below the current front, which is exactly when a monotone bucket queue is valid; swapping the binary heap for one took 1.6x off the whole solve at identical output. 22 comparisons and as many cache misses per operation, on two thirds of the runtime.

• 2026-09-17 — Relief from the stream-power solve is strongly resolution-dependent: the same seed and uplift field give 1020 m of land relief at 512² and 2605 m at 1786², because finer grids resolve smaller drainage areas near the divides and S goes as A^(-m/n). Tuning U/K on a --size preview will therefore overshoot the elevation ceiling at full resolution. Judge shape on the preview; confirm the elevation budget at the real geology grid, where the clip warning is the check.

• 2026-09-16 — The first L_World rebuild of the evening died at twelve minutes with no error: it was run under a tool with a ten-minute timeout, which killed the commandlet mid-import and left an empty level. Long commandlets are launched detached (Start-Process) and watched through their log.

• 2026-09-16 — A rebuild while the editor had ever loaded L_World ended in a nameless /Temp/Untitled world whose save went nowhere: deleting and recreating the level resaves L_World_HLODLayer_Instanced and _Merged, and the open editor keeps those two files locked. create_world.py now loads and empties an existing level instead of recreating it, checks the world's package name before building, and sweeps leftover proxy packages after the save. Check the editor's current level (SceneTools.get_current_level over MCP) before a rebuild; never rebuild the level the editor has open.

• 2026-09-16 — Epic's recommended 4033 resolution gives the engine's importer 64x64 components of 63 quads, because 4032 does not divide by 127 or 255 and the importer prefers one section per component: 4096 components, over 8000 textures to build, forty minutes. 4081 divides by 255: 256 components, two minutes.

• 2026-09-16 — The noise stacked eight octaves at gain 0.5, so every octave was as steep as the last and a third of the land stood above 50°. Lower gains, no octave finer than about 50 m, a percentile-thresholded range mask and a 38° thermal pass brought it to 80 % under 15°; measured with a slope histogram, not by eye.

• 2026-09-17 — Cellular (Worley) crest lines at 30 % of the mountain height turned the ranges into a honeycomb of polygon walls with flat floors in the hillshade. Kept at 12 % through a stronger warp; the ridged noise and the erosion make the divides.

• 2026-09-17 — The first eroded map had the meadows brushed with rills: land under 15° fell from 64 % to 38 %. A stage-by-stage slope histogram (uplift, coarse pass, fine pass, thermal) put most of it on the coarse pass: the slope gate sat at 7°, the median lowland slope, and one droplet could cut 7 m per step at 14 m cells. Gate at 14°, cut capped at a fifth of a cell per step. Attribute by measurement before turning knobs.

• 2026-09-17 — Spreading droplet deposits through a 3x3 brush built mounds: a pit's rim rises faster than its floor, the pit never fills, and every droplet draining into it adds its load to the rim. Cuts go through the brush (no one-cell rills), deposits land on the droplet's own cell, and a droplet's load is capped, since capacity scales with the drop per step and a cliff hands a droplet a hundred cell-heights.

• 2026-09-16 — The first L_World with the manifest pipeline showed rock everywhere: Elite_RockyMeadows' layer names mislead. Its Base_Layer function samples the rock textures, Layer_02 the grass, Layer_03 the high rock, and the meadow weightmap had gone to Base_Layer. Read a pack's layer functions before mapping layers.

• 2026-09-16 — The retuned noise overshot into flat land with small hills; the user wanted aggressive ranges. Ranges now come from an elongated, warped, percentile-thresholded band (about two fifths of the land with foothills), ridged noise sampled through the same warp, crests to about 2600 m.

• 2026-09-16 — AActor.set_is_spatially_loaded does not exist in Python; the property is set with set_editor_property("is_spatially_loaded", False).

• 2026-09-16 — Positional unreal.Rotator(a, b, c) is (roll, pitch, yaw), not (pitch, yaw, roll). Both authoring scripts pitched the sun 25 to 30 degrees upward, every map rendered as night, and the viewport's "cached lighting is going to be clipped" warning was the auto exposure at EV -8.5 saying so. Keyword arguments from now on.

• 2026-09-16 — A landscape imported from a commandlet had collision but no visible surface: edit layers are always on in 5.8, the render heightmaps come from a GPU merge, and a commandlet reports it can never render unless launched with -AllowCommandletRendering. ULandscapeAuthoringLibrary now forces the full layer update and create_world.py documents the flag.

• 2026-09-16 — The asset library cannot delete a folder of world-partition streaming proxies (their packages do not load on their own); create_world.py removes the folder on disk instead.

Open

• World, next time (2026-09-17, the user's verdict: "still somewhat rough"). Three items, none started:
  1. Sculptable terrain. Today create_world.py empties the level and re-imports the heightmap into a fresh landscape, so any hand sculpting dies with the next rerun. Wanted: the generated height applied to the level as its base, with sculpting on top that survives a regeneration. The engine's shape for this is edit layers: import the PNG into a named Generated layer and leave a Sculpt layer above it for hand work, then make a rerun re-import into Generated only (ALandscape edit-layer API, FLandscapeEditDataInterface, or ULandscapeEditorObject::ImportHeightmap per layer) instead of destroying the actor. Needs a C++ change in ULandscapeAuthoringLibrary (a ReimportHeightmapIntoLayer beside CreateLandscapeFromHeightmap), so a rebuild of SaltyEditor with the editor closed; the weightmaps follow the same path. Check first whether the proxies' edit-layer data survives ChangeGridSize.
  2. Not visible in the editor. The rebuilt terrain shows in PIE but the user reports it not visible in the editor viewport. Most likely cause, to verify: the level is world-partitioned and the 256 landscape proxies are spatially loaded, so the editor loads none of them until a region is loaded in the World Partition window; only the always-loaded dressing shows. Candidates: World Settings → World Partition → turn "Enable Streaming" off for now (everything loads, editor and runtime; 256 components is fine for a prototype), or save loaded regions with the level, or have create_world.py load the regions after the build. Also confirm the editor reloads L_World from disk after a rebuild rather than a stale in-memory copy.
  3. No greenery on the floor. The meadow layer is a flat grass texture; nothing grows. No pack in Content/ has a grass mesh (Elite_RockyMeadows ships textures only, HouseForge's foliage folder holds one mushroom and a cover-plant material). Wanted: landscape grass on the meadow layer (ULandscapeGrassType fed from a LandscapeGrassOutput node, which means a child or copy of M_Landscape_Main since the pack's material has none), driven by the erosion's deposit and flow maps once the material samples them, plus a foliage pass for trees and bushes from a pack still to be chosen. Distance culling matters at 200 km².
• Step 1's last proof is a person's: Play In Editor in L_Gym, two players, "Run Dedicated Server" on, two pawns in the gym. Until it is ticked the step is ◐.
• The default camera mode (OD-03) is deliberately undecided until step 8.
• The numbers in every spec are the earlier projects' guesses in centimetres and seconds. None has been played.