Yellowstone

Rotate the terrain, pick a river section, or follow a saved temperature run. The 3D view combines USGS elevation, mapped rivers and pools, LiDAR canopy detections and model results.

The full view uses 1,050,625 elevations at 4 m spacing. A closer view uses a 2 m mesh with 1 m shading detail. Drainage lines follow slopes in the elevation data and can include dry gullies.

River temperature has three color scales: the full run, a fixed 0.10°C window around a selected section, and change since the start. Playback reads saved values, so it works without a running simulation server.

Additional layers show outflow temperature, temperature-based microbial classes and residual canopy cover. Draw a transect to inspect an outflow profile and download its values, compare matched cooling scenarios, or play back saved weather. The forest view uses approximate trees to show canopy structure.

• Project scope and run instructions
• Stored-data explorer contract

The river model transports temperature downstream and calculates heat exchange. Its tests cover numerical refinement, conservation and restarting a saved run. Discharge is prescribed, so the model does not solve momentum or simulate a dam break.

HydroSim runs separately as a small surface-water model. Its example sends a rainfall pulse over a synthetic terrain grid and plots runoff, storage and the water balance.

In the 24 × 24 cell example, 8.64 m³ of rain produces about 0.04118 m³ of runoff and 8.59882 m³ of added storage. That checks the calculation on a known input; a real catchment would still need calibration.

• Transport implementation
• Numerical benchmark assertions
• HydroSim package and example

cd yellowstone_python
python -m pytest -q tests/river/test_benchmarks.py

cd yellowstone_python
python examples/portfolio/river_checks.py --out ./new-river-checks

hydrosim --out ./new-synthetic-run

The analysis store puts model records into SQLite so they can be queried by location, section and time. Tests compare those queries directly with the input JSON, including missing values and unit conversions.

The examples use small, repeatable datasets. They cover the query results and time alignment rather than making a claim about production throughput.

• Analysis store implementation
• SQL and missing-value tests
• Time-alignment tests

cd yellowstone_python
python -m pytest -q tests/test_analysis_store.py tests/river/test_obs_frame.py

python examples/portfolio/analysis_store.py --out ./new-analysis-example

The Godot prototype uses the same terrain and model exports as the data tools. Input settings support remapping, persistent preferences and switching between a live service and a stored release.

The controls integration script passed 31 assertions in a headless Godot 4.5.1 run. Cursor behavior and visual performance need an interactive run; a headless test cannot show how the controls feel.

The separate park-runtime repository contains a runnable synthetic scene for testing terrain streaming. Its small bundled world makes the streaming code usable without downloading Yellowstone’s full datasets.

• Input settings implementation
• Engine integration assertions
• Live-service and stored-release selection
• Reviewed-controls integration script
• Standalone terrain-streaming demo

Data exports carry file hashes. The browser checks those hashes before loading an asset, and the test runner records which source files and inputs produced a result.

The receipt tests change source files, inputs and output logs to check that stale results are caught. Restoring the original files restores the match. This tracks which calculation was run; scientific accuracy still depends on the model and its inputs.

• Receipt implementation
• Execution-evidence regression tests
• Claim-gate tests

cd yellowstone_python
python examples/portfolio/evidence_checks.py --out ./new-receipt-example

The conifer generator builds connected branch graphs from a seed. Reusing a seed reproduces the same tree; changing it produces another branching structure.

Fish-swim generates an animated GLB from a small jointed fish model. Its example has 15 joints and three clips, with exported poses checked at 61 times per clip.

Wildlife-motion provides reusable gait and animation tools. Blender mesh-budget checks exported meshes against size limits before they go into the world.

These tools make repeatable geometry and animation. The example trees and fish are procedural assets, not reconstructions of individual organisms.

• Seeded branch graph source
• Graph and repeatability tests
• Conifer generator
• Fish animation exporter
• Wildlife motion tools
• Blender mesh-budget checks

Terrain-pages prepares tiled height data for rendering. LiDAR canopy tools find crown candidates and calculate their height and extent. Both can run separately from Yellowstone.

A canopy detection is an estimated crown, not a species identification or a complete tree census. The explorer keeps those detections separate from the terrain and mapped waterways.

• Pipeline sources and model limits
• LiDAR canopy tools
• Terrain tiling tools

I use Python for the models and data pipeline, Godot for the walkable world, and JavaScript for the browser explorer. AI coding tools are part of the implementation workflow; source selection, design decisions and review remain my responsibility.

The source repository documents the datasets, numerical assumptions and run commands. Observed geography, calculated drainage and simulated temperatures are labeled separately throughout the explorer.