NATURA -- a pocket-universe framework of composable natural systems

Working name: Natura (the engine), sibling to the Terrain Engine. Operator steer, 2026-08-02:

"you did geology/terrain but now you need day night week month year decade century cycles, realistic dynamic weather that actually changes the world it falls upon in realistically small ways, life cycles of creatures, spreading or shrinking of biomes, groups of animals that form ecosystems, rich detailed simulation aspects that can be called together or individually, and also the ability to make bigger grander worlds that arent just islands... any force of the natural world should be something that belongs in some sort of system that you can draw upon. even to the scale of planets and moons orbiting the galaxy if we zoom out far enough in time and space... a framework for capturing everything that should be a system... detailed extensible systems... from the branching of rime on a leaf in a storm to the battle of two moose in a forest to the slow cooling of a sun over billions of years. in a way it will be its own pocket universe but very different from the last approach."

The last approach (A World, Whole) was a STATIC DATA SPINE -- one seed, a world at one moment, read many ways. Natura is the opposite axis: DYNAMIC SIMULATION across TIME and SCALE, systems that evolve and interact. The Terrain Engine (a composable PIPELINE of geological processes on a heightfield, tested, deterministic) is the PROVEN TEMPLATE and becomes Natura's first-and-foundational system family. The ontology of WHAT to simulate is in ONTOLOGY.md (from the operator's sim.png); this file is the STRUCTURE.

The five core principles

1. Multi-SCALE. Every system declares the space+time scale it lives at, from Planck-ish/leaf to galactic/eon. You can dial a viewpoint in space and time; systems above set boundary conditions, systems below add detail. The organizing spine of the whole framework (the SCALE LADDER, below).
2. Composable. Like the Terrain Engine's presets/pipeline: a "world" is a chosen STACK of systems. Run frost-on-a-leaf ALONE for a tiny art piece, or stack planet+climate+weather+ecology+minds for a living world. Each system stands alone AND composes. "Called together or individually."
3. Clock-driven. ONE universal clock; every cyclic process derives its phase from it (day, season, century, eon are phase functions at different cadences). "day night week month year decade century."
4. Coupled. Systems expose FIELDS and EVENTS; a coupler wires outputs to inputs. Weather's rain feeds erosion and plant-growth; climate drives biome shift; a fire eats fuel and is fanned by wind. The ontology's EDGE VERBS (nutrition, predation, reproduction, care) are the coupling channels. This is the operator's "weather that actually changes the world it falls upon in realistically small ways."
5. Recursive ("as above, so below"). The same process, defined once, applies at any scale and to any aggregate: "dissolving" is rime on a leaf and karst over eons; "collapsing/organizing" is a dune, a star, and a society. A SOCIETY is an entity made of LIVES the way a rock is made of MINERALS. Define a process once, apply it everywhere. This is what makes it a pocket universe, not a pile of special cases.

The SCALE LADDER (the framework's backbone)

Log-scaled tiers of (space, time). A system is pinned to one; coupling flows mostly DOWNWARD (big sets boundary conditions for small) with some UPWARD aggregation (many creatures -> a population; erosion over eons -> terrain). Each tier lists the DOMAINS (from ONTOLOGY.md) active there and what to build on.

The operator's two poles -- "branching of rime on a leaf" (MICRO) and "cooling of a sun over billions of years" (COSMIC) -- are the top and bottom rungs. The middle is where a living world happens.

The SYSTEM interface (generalizing the Terrain Engine's PROCESS)

Every system is a module with a common shape. The Terrain Engine's PROCESS registry is this minus the clock and coupling; Natura adds time-stepping, scale, and fields:

{
  name: 'weather',
  domain: 'physical',            // from ONTOLOGY: physical | life | mind | society
  scale: 'weather',             // a rung on the ladder
  init(seed, params) -> state,  // deterministic, seeded
  step(state, ctx, dt) -> state,// ctx = { clock, fields(from coupled systems), rng }
  fields() -> { moisture, wind, temp, ... },  // what others may read (grids or values)
  events() -> [ {kind:'storm', at, ...} ],    // discrete happenings others may react to
  params: { ... }               // like the Terrain Engine's preset params
}

Deterministic, node-testable, composable -- the exact discipline that made the Terrain Engine trustworthy (36 assertions, presets, pipeline). A system that does not time-step (a one-shot generator, e.g. a continent) simply has step be a no-op after init; a pure field (e.g. gravity) exposes fields only.

Coupling, the clock, entities, worlds

• Clock: ctx.clock gives absolute t plus phase helpers dayPhase(t), seasonPhase(t), yearsSince(t0), etc. -- one time, many cadences. Deep-time systems read t at Gyr scale; a flame reads it at ms scale. (NOTE the sandbox constraint from the workshop: no Date.now()/Math.random() in resumable scripts -- Natura takes its clock and seed as INPUTS, which also makes runs reproducible.)
• Coupler: wires systemA.fields().rain -> systemB inputs, per the ontology's edge verbs. A world declares its couplings; a system never reaches for a global. This is where "weather changes the world" is literally implemented -- rain accumulates into a moisture field that the erosion and growth systems read.
• Entities (ONTOLOGY section A): an entity = STATE bag + the set of processes it is subject to. Not a class hierarchy -- an animal is matter (OBJECTS) running LIFE, with a MIND, in a SOCIETY. Layers, not types.
• A WORLD = { clock, seed, a chosen set of systems (across scales), their couplings, the entity set }. Composability is just: pick the stack. Natura({ systems:['terrain','climate','weather','vegetation'] }) runs exactly those; Natura({ systems:['frost'] }) runs one micro art-piece.

Bigger, grander worlds (not just islands)

Generalize the Terrain Engine's island-mask upward: a planet (a sphere, or a large plane with poles

• continents + oceans), continents generated by plate tectonics rather than a radial mask, latitude-driven climate bands, real ice caps. The Terrain Engine becomes the REGIONAL-DETAIL layer under a PLANETARY generator. Zoom: the planet sets each region's boundary conditions; a region runs the terrain engine + weather + ecology; a spot runs a tree + a creature + frost. Same framework, every rung.

The build plan (the week -- bottom-up by domain, tested at each step)

The ontology says build BOTTOM-UP (each layer rests on the last): Physical -> Life -> Mind -> Society. Cross with scale. Order, each a deep+tested+composable system like the Terrain Engine:

0. Natura CORE (first): the clock, the system interface + registry, the coupler, the scale ladder, a Natura(worldSpec) runner, and a tiny test harness. The skeleton everything plugs into.
1. WEATHER (the operator's headline; PHYSICAL/weather): pressure+wind+fronts+precip, deterministic, exposing moisture/temp/wind fields -- and COUPLED to the terrain (rain->erosion, wind->transport) so it demonstrably "changes the world it falls on." Proves the coupling model end to end.
2. TIME & SEASONS (clock cadences + orbit-lite): day/night, the year, seasons driving temperature and daylight -- the cycles that gate Life and Weather.
3. VEGETATION & LIFE-CYCLES (LIFE/ecological): plants grow/spread/die by climate+season+moisture (L-systems for form); creature life-cycle state machines (origin->growth->metabolism->death->decay).
4. ECOSYSTEMS (LIFE/society coupling): populations, predator-prey (hunting/fleeing), reproduction (mating/pollinating), herds/migration (boids) -- the "battle of two moose", the food web.
5. BIOME DYNAMICS (REGIONAL): biomes spread/shrink as climate shifts over time -- forest advances, desert creeps. Couples climate -> vegetation -> biome.
6. SCALE UP (PLANETARY/COSMIC): continents+plate tectonics (bigger worlds), then orbits + stellar evolution (the sun cooling over eons; day/night/seasons derived properly).
7. MICRO (wrap existing craft as Natura systems): frost/rime (dielectric/DLA), a flame, a droplet, reaction-diffusion -- the "rime on a leaf" pole, each a standalone system that also composes (frost forms in Weather's cold + on a Vegetation leaf).
8. A SHOWCASE WORLD: stack a meaningful subset into one living, watchable world that visibly changes over time -- and a few tiny single-system art pieces (frost, a storm, a herd) proving each stands alone.

The discipline (why the Terrain Engine worked, kept)

• One tool, many processes, composable. Presets + a pipeline/stack; call all or one.
• Deterministic + node-tested + deep. Each system seeded, assertion-driven, genuinely modelled (not faked) -- the Terrain Engine's 7 real geomorphic processes, not a noise texture. Depth AND breadth.
• Reusable, not re-derived. Build on the Terrain Engine, fluids-and-flow, boids, L-systems, the dielectric/DLA and vortex-blob craft, the walkable-scene generators. Grep the library first, always.
• Verified by number AND by looking (and by the motion-eye for anything that moves). A frozen sim passes every static check.
• Bit by bit, committed, never "done". Each system lands on tested ground; this doc + a STATE section track progress so the next session continues, not restarts. Many rungs; always more below.

Where we are

• Framework DESIGNED (this file) + the ontology transcribed (ONTOLOGY.md) -- the operator's "figure out a framework" deliverable.
• CORE (step 0) DONE -- natura.js (+ 22 assertions): the clock (day->eon cadences), the system interface, the registry, the World runner, and the coupling (pre-step field snapshot in ctx.fields). Composable + deterministic.
• WEATHER (step 1) DONE -- weather.js (+ 10 assertions): drifting pressure systems -> geostrophic wind + a prevailing westerly; Stam semi-Lagrangian advection of temp & humidity; orographic + saturation RAIN; moisture ACCUMULATES into a field for coupling. The emergent RAIN-SHADOW is proven (windward 1.84x the lee). Storm events fire. This is "weather that changes the world it falls on" -- it produces the moisture the ground will read.
• NEXT: close the loop visibly -- wire the Terrain Engine in as the coupled terrain system (weather reads its elevation; erosion/soil reads weather's moisture), so the world demonstrably CHANGES under the rain. Then TIME/SEASONS driving it, then VEGETATION + LIFE-CYCLES consuming the moisture, then ECOSYSTEMS. The Terrain Engine is the template and the first foundational system to wrap in.