Aethon

A Jac-powered wildfire simulator that transforms real terrain, fuel, and weather data into interactive fire-spread visualizations on a photorealistic 3D globe.

Comment

Inspiration

Wildfires are shaped by a combination of fuel, terrain, moisture, and wind, but most fire-spread tools are difficult for the public to understand or limited to static maps. We wanted to make wildfire behavior more visual and approachable by letting anyone select a location on Earth and watch a physically informed fire scenario unfold directly on the terrain.

Aethon was built to connect real environmental data, the Rothermel fire-spread model, and an immersive 3D globe through a backend written in Jac.

What it does

Aethon is an interactive global wildfire simulation platform. A user can explore a photorealistic Cesium globe, select a location, configure wind and moisture conditions, and run a fire-spread simulation.

For every ignition, Aethon:

  • Builds a local 64 × 64 fire field with 10-meter cells
  • Loads location-specific fuel and terrain information
  • Uses live weather data or manual scenario controls
  • Sends the complete environmental field to the Jac backend
  • Runs the Rothermel spread calculation in Jac
  • Returns an arrival-time field showing when the fire reaches each cell
  • Replays the result as an animated fire front with volumetric flames
  • Displays burned area, spread time, direction, and environmental provenance

Users can switch between 2D and 3D views, scrub through the simulation timeline, and compare different wind, moisture, fuel, and slope conditions.

Aethon is a simulation and education tool rather than an operational wildfire forecast.

How we built it

The frontend is built with JavaScript, Vite, CesiumJS, Cesium ion, and Google Photorealistic 3D Tiles. Cesium provides the global terrain and camera system, while custom GPU materials, particle systems, and billboard layers visualize the simulated fire directly over the landscape.

The backend is written in Jac. The frontend sends the Jac service a compact fire request containing:

  • Per-cell fuel models
  • Terrain elevation
  • Wind speed and direction
  • Dead and live fuel moisture
  • Ignition location
  • Simulation duration and cell size

Jac runs the Rothermel surface-fire calculations and propagates the fire through the field as an arrival-time problem. The browser does not use a second local fire solver: Jac is the authoritative simulation backend.

Environmental inputs are assembled from several sources. Aethon prioritizes LANDFIRE fuel data within the United States and uses ESA WorldCover for global coverage. Terrain comes from Copernicus GLO-90, weather comes from Open-Meteo, and OpenStreetMap data helps identify roads and structures that may block or alter the local fire field.

We also added bounded provider timeouts and explicit provenance so an unavailable public dataset cannot leave the interface loading forever. When data falls back to another source, the interface reports that clearly.

Challenges we ran into

The hardest challenge was keeping the simulation physically meaningful while making it visually understandable. A real 10-meter fire cell is almost invisible when viewed from a globe, so we separated physical scale from visual scale. Jac still calculates the real grid, while the renderer enlarges flames and highlights the active front without changing the underlying result.

Integrating fire with photorealistic 3D terrain also created several rendering challenges. Low-detail depth samples could place the camera or flames underground, orbital camera altitude could accidentally select a regional simulation field, and terrain height is measured relative to the ellipsoid rather than the visible surface. We added height validation, local-scale framing, terrain-aware placement, and distance-based fire detail to solve these problems.

We also had to combine asynchronous fuel, terrain, weather, and OpenStreetMap providers without allowing one failed service to block the Jac simulation.

Accomplishments that we're proud of

  • Built the authoritative fire-spread backend entirely in Jac
  • Connected real fuel, terrain, wind, and moisture data to the Jac model
  • Created a global click-to-simulate workflow
  • Rendered Jac arrival fields over Google photorealistic terrain
  • Added animated volumetric flames and a continuous fire front
  • Implemented both 2D and 3D exploration modes
  • Removed the browser-side solver fallback so every production run uses Jac
  • Added deterministic tests for the frontend-to-Jac contract
  • Made public data-provider failures visible and recoverable

What we learned

We learned that connecting a scientific model to a visual interface requires more than implementing the equation. Coordinate systems, data resolution, terrain height, fuel classifications, API reliability, and visual legibility all affect whether the final experience feels trustworthy.

We also learned how Jac can serve as the central computational layer for an interactive geospatial application. Keeping the model in Jac gave us one authoritative simulation path and a clear contract between environmental data, fire physics, and visualization.

What's next for Aethon

Next, we want to add time-varying forecast conditions, larger multi-resolution fire fields, evacuation and suppression scenarios, saved simulations, and cloud deployment of the Jac service. We also want to validate more scenarios against historical wildfire perimeters and expose uncertainty ranges so users can compare multiple possible outcomes instead of seeing only one deterministic run.

Built With

Share this project:

Updates