Heat Transfer–Driven Voxel-Based Simulation: A High-Performance Framework for Urban-Scale 3D Fire Spread

1. Introduction

In recent decades, climate change has increased the frequency, intensity, and spatial extent of wildfires worldwide, making them one of the most destructive natural hazards (Jones et al. 2020,Xu et al. 2020). In the United States, tens of thousands of unplanned wildfires occur annually, burning millions of acres and increasingly affecting populated regions (McDowell 2003). Similarly, Australia’s 2019–2020 Black Summer burned over 24 million hectares, caused an estimated one billion animal deaths, and resulted in economic losses exceeding $4.5 billion (Christoff 2023,Filkov et al. 2020). These large-scale events pose compound threats to urban property and critical infrastructure, while endangering human health, emergency responders, and regional economies (Auer and Hexamer 2022). Such escalating risks require more accurate prediction of fire spread in urban environments to support evacuation planning, resource allocation, rescue prioritization, casualty reduction, and proactive fire prevention strategies (Moritz et al. 2014,Xu et al. 2025).

Accurate fire prediction in urban and wildland–urban interface (WUI) environments remains highly challenging due to structural and fuel complexity (Radeloff et al. 2005). Fire propagation is inherently three-dimensional, requiring frameworks that capture both vertical and horizontal spread. Urban environments include multi-storey buildings (Mell et al. 2007), vertically stratified fuels such as surface vegetation, shrubs, and tree canopies (Alexander and Cruz 2011), heterogeneous terrain and street networks with combustible and non-combustible materials (Mitchell 2013,Syphard et al. 2012), and elevated critical infrastructure such as powerlines and bridges (Khan et al. 2021,Syphard and Keeley 2015). Interactions among these elements create dynamic and nonlinear fire pathways, making 3D prediction substantially more challenging (Depietri and Orenstein 2020,Syphard et al. 2012).

Despite the need for fully 3D simulation, most existing models (e.g., SPARK, FARSITE, Prometheus) remain 2D or quasi-3D, with fire spread primarily modeled across surface fuels and limited vertical coupling (Finney 1998,Miller et al. 2015,Tymstra et al. 2010). Fully 3D physics-based models are comparatively scarce due to the computational demands of resolving coupled heat transfer, heterogeneous fuel structures, and fluid dynamic wind interactions (Pastor et al. 2003,Sullivan 2009c). As a result, current approaches reflect a trade-off between physical fidelity and computational scalability, where scalability refers to the ability to simulate larger spatial domains and complex dynamics within manageable runtime and memory constraints (Sullivan 2009c). High-fidelity CFD models explicitly resolve combustion and fluid dynamics but are computationally prohibitive for large urban domains at sub-meter resolution (Linn et al. 2002,Pastor et al. 2003). In contrast, 3D cellular automata models improve efficiency through rule-based transitions that approximate, rather than explicitly resolve, underlying processes (Alexandridis et al. 2008,Sullivan 2009c). This trade-off leaves a critical gap: physics-driven 3D fire simulation at sub-meter resolution across urban block and street-scale domains (approximately 200–1000 m), capable of capturing spread through vertically stratified fuels and critical infrastructure (Pastor et al. 2003).

Existing approaches are typically optimized for either building-scale (≤ 100 m) high-resolution CFD simulations (Xu and Peng 2020) or regional-scale ($>1$ km) modeling at coarse resolutions (Linn et al. 2002). Cellular automata models are more scalable at urban and regional scales but rely on predefined or probabilistic rules that approximate, rather than explicitly resolve, combustion and energy transfer processes (Alexandridis et al. 2008,Sullivan 2009b). As a result, they often exhibit limited physical interpretability and reduced flexibility when applied to new fuel types or environmental conditions (Sullivan 2009b). Simulation runtime remains a critical constraint. Many 3D fire simulation frameworks require hours per run Linn et al. (2002); Linn and Cunningham (2005), limiting their use in time-critical emergency response. In such settings, predictions must be generated within minutes and incorporate real-time or near-real-time fuel and weather data (Finney 1998,Sullivan 2009a). These limitations highlight the need for frameworks that deliver rapid predictions while maintaining physical interpretability and supporting dynamic environmental inputs.

Despite these challenges, recent advances in geospatial data acquisition and 3D modeling provide new opportunities. The increasing availability of voxel-based representations of cities and forests enables simulation of complex urban and environmental dynamics at fine spatial resolutions (Nebiker et al. 2010,Tyc et al. 2023). Voxel models have also gained prominence in computer graphics and gaming (e.g., Minecraft), demonstrating their scalability and intuitive structure (Anderson et al. 2018). Recent voxelization pipelines show how multi-source data can be transformed into structured volumetric grids for analysis and simulation (Fujiwara et al. 2025,Lewis 2024,Vonderach et al. 2012). These approaches integrate LiDAR, photogrammetry, and open geospatial data, and leverage standardized 3D models such as CityGML and IFC to generate semantically enriched voxel environments (Fujiwara et al. 2025, ,Li et al. 2024c). Voxel grids provide explicit spatial connectivity and neighborhood structure, making them a natural foundation for modeling 3D processes (Jjumba and Dragicevic 2015,Xu et al. 2026a). As fire propagation is inherently volumetric and governed by coupled heat transfer and combustion dynamics (Drysdale 2011,Morvan 2011), voxel-based representations are well suited for simulating 3D urban fire spread across heterogeneous fuels and built environments.

This paper presents a parallel high-performance computing framework for simulating 3D fire spread in complex urban environments represented using sub-meter voxel grids. The framework encodes physics-informed and empirical fire dynamics across structured voxel space, enabling volumetric modeling of heat transfer and wind-driven propagation through heterogeneous urban fuels and infrastructure. By leveraging parallel computation on high-performance architectures, the system achieves operational runtime performance at the urban block scale, supporting time-sensitive fire rescue and management decision-making. The remainder of this paper is organized as follows. Section 2 reviews related work on fire simulation and voxel-based urban modeling. Section 3 identifies gaps in 3D fire spread simulation and outlines the study’s motivation and contributions. Section 4 presents the conceptual framework, physical formulations, and simulation inputs and outputs. Section 5 details the technical contributions, including memory layout and parallel computing strategies based on structured voxel connectivity. Section 6 demonstrates the framework through a Liverpool, NSW case study, including fire simulations and performance evaluation. Section 7 discusses limitations and future work.

2. Literature Review

This literature review is organized in two parts. First, we examine the current state of 3D fire propagation simulators based on their theoretical foundations and modeling rationales, and analyze their limitations in supporting sub-meter resolution simulation at the mesoscopic urban block scale. Second, we review emerging data sources and construction pipelines for voxelized city models in order to establish the data foundation for the proposed voxel-based 3D fire propagation framework.

2.1. Current State of 3D Fire Propagation Modeling

Most existing fire simulation models are designed for two-dimensional or quasi-3D (2.5D) applications, where fire spread is modeled primarily across terrain surfaces with parameterized vertical effects (Sullivan 2009a,Sullivan 2009b). Notable examples include FARSITE, Prometheus, and SPARK, which rely on surface-based formulations and empirical crown-fire transition modules (Finney 1998,Miller et al. 2015,Tymstra et al. 2010). Although widely used for landscape-scale forecasting, these models provide limited representation of vertical fuel interactions. Fully 3D fire simulators operating on volumetric datasets are comparatively scarce due to historical limitations in large-scale 3D data availability and the high computational cost of resolving coupled thermodynamic and fluid dynamic processes (Xu et al. 2025). Consequently, many 3D models are developed for specific scenarios, such as compartment-scale building fires or controlled experiments. From a computational perspective, existing 3D simulators can be broadly classified into two categories: continuum physics-based models and 3D cellular automata (CA)-based models (Pastor et al. 2003,Sullivan 2009c).

2.1.1. Continuum Physics-Based Models

Continuum physics-based wildfire models represent fire behavior using coupled conservation equations for mass, momentum, energy, and chemical species transport (Drysdale 2011,Pastor et al. 2003). These are formulated as systems of partial differential equations (PDEs), including the Navier–Stokes equations coupled with energy and species transport equations governing combustion, heat transfer, and chemical reactions (Kirkpatrick and Kuo 2024,Turns 2012). This formulation enables explicit representation of buoyancy-driven flow, wind–flame interaction, turbulent mixing, plume dynamics, and radiative heat transfer, supporting detailed simulation of fire–atmosphere coupling (Mell et al. 2007,Morvan 2011). In practice, these equations are discretized using finite-volume or related methods within computational fluid dynamics (CFD) solvers (McGrattan et al. 2013a).

Several frameworks implement this paradigm, including the Fire Dynamics Simulator (FDS) and its extension WFDS, FIRETEC, FIRESTAR3D, and CFD-based solvers such as FireFoam built on OpenFOAM (Accary et al. 2020,Frangieh et al. 2018,Linn et al. 2002,McGrattan et al. 2013b,Mell et al. 2010,Morvan 2011,Sedano et al. 2017). These models typically represent vegetation as porous or thermally reactive media within computational meshes and simulate fire–atmosphere interactions using turbulence-resolving or large-eddy simulation approaches.

Table 1 summarizes representative models and their computational characteristics, including parallel performance and runtime behavior.

Despite their high physical fidelity, continuum models are computationally intensive due to fine spatial discretization and the need to solve coupled PDE systems. As a result, applications are typically limited to small domains, such as laboratory experiments, building-scale fires, or localized WUI studies. Scaling CFD approaches to urban or landscape-scale wildfire simulation remains challenging due to computational cost and model complexity. Because simulations often require hours to days, they are not well suited for real-time emergency response, especially when incorporating dynamic fuel and weather data. Additionally, many CFD frameworks rely on structured or unstructured meshes derived from CAD or surface geometries, making integration with voxelized or GIS-based datasets nontrivial and often requiring substantial preprocessing to incorporate terrain, vegetation, and urban structures.

2.1.2. 3D Cellular Automata (CA)-Based Models

Cellular automata (CA)–based wildfire models represent fire spread as discrete state transitions across spatial grid cells governed by predefined local rules (Alexandridis et al. 2008,Sullivan 2009c). Unlike continuum models that solve conservation equations, CA approaches simulate propagation through neighborhood-based interactions, where each cell updates its state (e.g., unburned, burning, burned) based on local conditions such as fuel properties, wind, slope, and probabilistic ignition criteria (Singh et al. 2024). Because they rely on rule-based updates rather than coupled PDE solutions, CA models are computationally efficient and well suited for large-scale simulations (Sullivan 2009c).

Most CA wildfire simulators are developed for two-dimensional or quasi-3D (2.5D) surface-based modeling, where spread occurs primarily across terrain surfaces and vertical structure is represented indirectly through elevation or aggregated fuel parameters (Hua-guo et al. 2024). Fire spread is typically governed by empirical or semi-empirical rules calibrated from experimental data or existing models (Encinas et al. 2007,Karafyllidis and Thanailakis 1997,Xia and Cheng 2025). Recent work incorporates data-driven components, such as machine learning and deep learning, to improve prediction accuracy and adapt transition probabilities to evolving conditions (Li et al. 2024a,Singh et al. 2024,Sun et al. 2024,Zhou et al. 2025).

Extensions to fully 3D CA frameworks have been explored to incorporate vertical fuel stratification and canopy interactions. For example, volumetric CA models using LiDAR-derived data represent stratified fuels with stacked cells and simulate spread using rule-based ignition thresholds influenced by wind, slope, and fuel properties (Byari et al. 2022). Other approaches integrate semi-empirical models within CA frameworks to simulate ignition and propagation across 3D terrain grids (Li et al. 2024b). However, these models still rely on empirical transition rules rather than explicit conservation equations.

Table 2 summarizes representative CA-based models and their computational characteristics. Runtime evaluation is not included, as these models are generally efficient, with simulation times ranging from seconds to minutes for domains of approximately one million cells.

Despite their efficiency and scalability, CA-based wildfire models have several limitations. Transition rules and ignition probabilities are often calibrated for specific fuel types, environmental conditions, or regional datasets, making them scenario-dependent and difficult to generalize across heterogeneous landscapes (Alexandridis et al. 2008,Sullivan 2009b). Incorporating new fuel types, moisture regimes, or dynamic atmospheric conditions typically requires re-calibration or redesign of rule sets. In contrast, physics-based models treat fuel properties, moisture, temperature, and wind as continuous variables within governing equations (Linn et al. 2002,Morvan 2011). This enables new scenarios to be incorporated through parameter specification rather than rule redesign, providing greater adaptability across diverse fire regimes and environmental conditions (Linn et al. 2010,Morvan 2011).

2.2. Computational Challenges in 3D Fire Simulation

From a scientific computing perspective, simulating fire propagation in 3D environments introduces significant challenges due to the large domains and fine resolutions required to represent heterogeneous fuels, built structures, and atmospheric interactions. Voxel-based 3D models are particularly computationally intensive at sub-meter resolution, and relatively few studies have leveraged optimized computing architectures for scalable simulation of complex 3D process propagation (Xia and Cheng 2025).

A key challenge is the rapid growth in memory requirements with increasing resolution. In structured volumetric grids, the number of cells scales cubically, leading to substantial storage demands when multiple environmental and thermodynamic variables are maintained per voxel (Singh et al. 2024, ). This is especially pronounced in urban or landscape simulations requiring millions of voxels to represent terrain, vegetation, and buildings.

In addition, voxel-based simulations rely on stencil computations, where each cell is updated based on neighboring cells (Henretty et al. 2013,Sun et al. 2024). These operations are typically memory-bandwidth bound, as performance is dominated by data access rather than arithmetic intensity (Williams et al. 2009). Extended neighborhoods, required for processes such as radiative heat transfer or wind-driven convection, further increase computational workload and data movement (Henretty et al. 2013).

Parallel execution across large voxel domains introduces additional challenges, including synchronization and numerical consistency across millions of concurrently updated cells. Efficient data structures and update strategies are required to avoid race conditions and ensure stable computation (Khan et al. 2021). These constraints highlight the need for simulation frameworks that balance physical realism with scalable computing strategies for large-scale 3D fire dynamics.

3. Motivation and Contribution

The literature review indicates that, despite advances in wildfire modelling and computational fluid dynamics, a physics-informed fire simulation framework capable of resolving three-dimensional fire propagation at sub-meter resolution across urban block scales (approximately 200,m–1000,m) remains largely absent. Existing simulators are typically either (i) empirical or quasi-empirical surface-based models operating in two dimensions, or (ii) high-fidelity CFD models designed for building- or laboratory-scale studies with substantial computational cost. Moreover, current fire simulation software often requires extensive preprocessing, data conversion, and custom adapters to integrate emerging large-scale 3D voxel datasets derived from LiDAR, photogrammetry, and standardized 3D GIS platforms. Operational fire management also requires predictions within minutes to support time-critical decision-making. This underscores the need for frameworks that enable rapid prediction while maintaining physically interpretable fire dynamics and integrating temporally evolving environmental data, such as weather and fuel conditions. As voxelized representations of cities and landscapes become increasingly available, a computational framework that natively operates on structured volumetric grids and bridges sub-meter resolution with urban block–scale extents remains lacking.

In response to the identified gaps, this work makes the following contributions:

• Physics-informed 3D voxel fire modeling. We develop a 3D voxel-based fire propagation model that represents fire spread as a thermally driven process governed by discretized heat transfer mechanisms, including conduction, radiation, and wind-driven convection. The framework operates directly on structured volumetric grids, enabling the simulation of volumetric fire dynamics within heterogeneous urban environments containing terrain, buildings, and vegetation.
• Scalable voxel-centric parallel computation. We develop an approach using a scalable voxel-native parallel computing that integrates voxel-centric memory layout and parallel processing techniques. The framework employs a deterministic neighbor indexing scheme and a row-major memory layout to improve memory locality and cache efficiency. GPU-enabled parallel updates then execute voxel-level computations concurrently, enabling efficient updates of voxel states and physical properties across the simulation domain.
• Urban-scale, time-efficient simulation capability. The proposed framework is designed to support urban block-scale simulations comprising approximately 5–10 million voxels, achieving runtimes on the order of minutes. This capability enables practical deployment for time-critical applications, such as emergency response, scenario analysis, and rapid decision support under dynamic environmental conditions.

The proposed framework aims to provide a flexible computational environment with parallel computing capability in which researchers can adapt and extend physics-informed fire dynamics formulations directly within structured 3D voxel domains, supporting scenario-based analyses in complex urban environments, as well as digital twin applications for real-time hazard mitigation and emergancy response Niloofar et al. (2023).

4. Methodology

Our earlier prototype and preliminary experiments were reported in Xu et al. (2026b), demonstrating the feasibility of voxel-based fire simulation at community scales. Building on this foundation, the present work advances the model by incorporating more explicit physics-informed representations and improving parallel computing optimization for large-scale voxel simulations (Figure 1a). This section provides a high-level overview of the conceptual formulation, including the physical processes considered, their discretization within the voxel lattice, and the structure of input and output data. Detailed implementation and optimization strategies are presented in Section 5.

4.1. Conceptual Model Framework and Physical Formulation

The proposed framework adopts a physics-informed, voxel-discretized modeling strategy to simulate 3D fire propagation in complex urban environments. Instead of resolving full computational fluid dynamics equations, fire spread is modeled as a thermally driven process governed by fundamental heat transfer mechanisms operating on a structured volumetric grid (Chassaing et al. 2025). Each voxel stores thermal state variables and fuel attributes, enabling explicit representation of localized energy exchange. Heat transfer is governed by temperature gradients: voxels with elevated temperatures, resulting from combustion, ignition, or preheating, transfer thermal energy to neighboring cooler voxels (Bergman 2011,Morvan 2011). This gradient-driven exchange forms the basis of localized thermal propagation across the structured grid (Patankar 2018).

The formulation incorporates conductive, radiative, and convective energy transport. Conduction is represented through direct exchange between face-adjacent voxels, radiation is modeled as a distance-dependent influence over surrounding regions, and convection accounts for wind-driven directional transport. Together, these mechanisms determine the evolution of temperature and moisture within each voxel, and their detailed formulation and transfer pathway are elaborated in the following subsections. As energy is transferred outward from burning regions, adjacent fuel elements experience heating and moisture reduction due to thermal drying. Combustion thresholds are defined by fuel properties, including material type, density, and moisture characteristics. Ignition occurs when temperature exceeds the fuel-specific threshold and moisture falls below a critical level, enabling physically interpretable fire progression without reliance on empirical transition rules.

By grounding propagation in discretized thermal transport and fuel-dependent ignition criteria, the framework maintains physical interpretability while leveraging the regular indexing and explicit connectivity of the voxel grid to enhance memory efficiency and computational performance. This approach enables sub-meter resolution simulation at the urban block scale while remaining computationally tractable. Moreover, the physical formulation is implemented within a modular and extensible software architecture integrated with the voxel data structure, allowing future incorporation of more complex processes such as ember transport and spotting.

4.2. Active Burnable Voxel Identification

At the beginning of the simulation, voxels are classified according to their material or fuel type to distinguish burnable and non-burnable elements. Burnable voxels—including vegetation, buildings, and other combustible infrastructure components—are eligible to enter combustion states (e.g., heating, igniting, burning). In contrast, non-burnable voxels (e.g., air, roads, water, and inert materials) do not undergo combustion but may still participate in heat transfer processes. This initial differentiation constitutes the first step of the simulation and provides an optimization strategy that reduces computational burden and memory usage by restricting combustion-related updates to physically relevant voxels. Detailed implementation of this filtering and activation strategy is described in Section 5.

4.3. Temperature-Driven Heat Transfer Activation

Following voxel classification, a further screening step identifies regions where active heat transfer occurs. Although non-burnable voxels may participate in thermal exchange, many regions exhibit negligible temperature variation and therefore do not contribute meaningfully to energy propagation. To reduce unnecessary computation, heat transfer activation is restricted to voxel pairs exhibiting significant temperature differences across their connectivity relationships. For each active voxel, neighboring elements are identified through structured voxel connectivity. When sufficient temperature gradients exist between adjacent voxels, conductive, radiative, or convective transfer pathways are activated. This temperature-driven activation mechanism localizes thermal exchange to physically relevant regions, improving computational efficiency while preserving interpretable gradient-driven energy propagation across the volumetric grid.

4.4. Voxel Connectivity-Driven Thermal Propagation

Heat transfer within the proposed framework is implemented through a discrete thermal transport model operating over a structured and customizable voxel adjacency graph. The voxel lattice defines explicit connectivity relationships among neighboring voxels, where adjacency templates can be configured according to directionality (e.g., axial alignment or wind-oriented bias) and neighborhood range (e.g., direct-contact conduction versus non-directional radiative transfer with distance-dependent heat decay). These connectivity patterns determine how thermal energy is exchanged locally across the grid, enabling heat propagation to emerge from structured voxel-to-voxel interactions. By adjusting the connectivity templates (as shown in Figure 1b), the model can represent different spatial influence patterns to model different heat transfer types, as elaborated through the reminder of this subsection, while maintaining computational efficiency within the structured lattice.

4.4.1. Conduction

Heat conduction refers to the transfer of thermal energy through direct physical contact between materials and is recognized as one of the primary heat transfer mechanisms in wildfire propagation (Morvan 2011). In the context of fire propagation, it describes how heat moves from a hotter voxel to an adjacent cooler voxel through their shared interface (Bergman 2011,Ezekoye 2016). Unlike radiation or convection, conduction does not require airflow or long-range interaction; it occurs locally between directly touching regions.

In our framework, conductive heat transfer is modeled as a discrete approximation of Fourier’s law (Ezekoye 2016). At the continuous scale, heat diffusion is governed by:

$${\displaystyle \frac{\partial T}{\partial t}}=\alpha {\nabla }^{2}T,$$

(1)

where T is temperature and $\alpha ={\displaystyle \frac{k}{\rho c}}$ is the thermal diffusivity, with k denoting thermal conductivity, $\rho$ density, and c specific heat capacity. Within the voxel lattice, this formulation is discretized using a 6-point finite-difference stencil corresponding to face-adjacent neighbors (von Neumann neighborhood). For a voxel located at $(i,j,k)$, the Laplacian is approximated as:

$${\nabla }^2{T}_{i,j,k}\approx {\displaystyle \frac{1}{\Delta x^2}}\sum _{\left(n\right)\in {\mathcal{N}}_6}\left(T_n-T_{i,j,k}\right),$$

(2)

where $\Delta x$ is the voxel size and ${\mathcal{N}}_6$ represents the six neighboring voxels along the positive and negative x, y, and z directions.

The conductive contribution to the temperature update is therefore computed as:

$$Q_{\mathrm{cond}}=\alpha {\displaystyle \frac{1}{\Delta x^2}}\sum _{\left(n\right)\in {\mathcal{N}}_6}\left(T_n-T_{i,j,k}\right).$$

(3)

where $Q_{\mathrm{cond}}$ denotes the conductive contribution to the temperature change of voxel $(i,j,k)$. $T_{i,j,k}$ represents the temperature of the current voxel, while $T_n$ corresponds to the temperature of a neighboring voxel n. The summation term ${\sum }_{\left(n\right)\in {\mathcal{N}}_6}(T_n-T_{i,j,k})$ provides a discrete approximation of the Laplacian operator, capturing the local temperature gradients that drive conductive heat transfer.

Voxel-level material properties, including temperature, thermal conductivity, density, and heat capacity, govern thermal diffusion and are defined according to the fuel type assigned to each voxel, where they are stored as environmental parameters. Conduction is applied only between face-connected neighboring voxels, reflecting the short-range, contact-based nature of the physical process while preserving computational efficiency within the structured grid.

4.4.2. Radiation

Radiative heat transfer is modeled based on the Stefan–Boltzmann law, which states that thermal radiation emitted by a hot body is proportional to the fourth power of its absolute temperature (Montambaux 2018,Wellons 2007). In the voxel framework, each burning or igniting voxel is treated as a volumetric radiative emitter whose outgoing radiative intensity depends on its local temperature field. This assumption reflects the physical principle that high-temperature combustion zones emit significant thermal radiation independent of physical contact (Patankar 2018).

For a radiating source voxel j with temperature $T_j$, the emitted radiative power density is approximated as

$$q_{emit,j}=\sigma T_j^4,$$

(4)

where $\sigma$ denotes the Stefan–Boltzmann constant. Radiative energy received by a target voxel i is then attenuated according to geometric spreading. Assuming isotropic emission and neglecting atmospheric absorption and scattering, radiative intensity decays with the square of separation distance. The received radiative flux is therefore approximated as

$$q_{rad,i}=\sum _{j\in {\mathcal{N}}_r}\sigma T_j^4{\displaystyle \frac{w_{geom}}{r_{ij}^2}},$$

(5)

where ${\mathcal{N}}_r$ denotes the set of source voxels within the prescribed radiative influence radius, $r_{ij}$ is the Euclidean distance between voxels i and j, and $w_{geom}$ is a geometric weighting factor accounting for discretization effects and effective view interaction.

To account for wind-driven flame tilt and directional enhancement of thermal radiation, an anisotropic correction factor is introduced based on the alignment between the local wind vector ${\mathbf{R}}_j$ and the source-to-target direction vector ${\widehat{\mathbf{d}}}_{ij}$ (Albini 1981). The directional amplification term is defined as

$${\beta }_{ij}={\displaystyle \frac{1}{2}}+{\displaystyle \frac{1}{2}}max\left(0,{\displaystyle \frac{{\mathbf{R}}_j·{\widehat{\mathbf{d}}}_{ij}}{\parallel {\mathbf{R}}_j\parallel }}\right),$$

(6)

so that radiation is enhanced in the downwind direction while remaining non-negative in other directions. The final radiative heat gain formulation becomes

$$q_{rad,i}=\sum _{j\in {\mathcal{N}}_r}\sigma T_j^4{\displaystyle \frac{w_{geom}}{r_{ij}^2}}{\beta }_{ij}.$$

(7)

This formulation captures three essential physical mechanisms: temperature-dependent emission following Stefan–Boltzmann behavior, geometric attenuation via the inverse-square law, and wind-induced anisotropy reflecting flame deformation and preferential heat transfer. While simplified relative to full radiative transfer equation (RTE) models, the proposed formulation preserves the dominant thermodynamic mechanisms governing thermal radiation while remaining fully compatible with the structured voxel-connectivity data structure. This design enables efficient stencil-based parallel computation over large voxel domains, as described in Section 5.

4.4.3. Convection

Convective heat transfer is driven by meteorological inputs such as wind speed and direction, which introduce directional bias into voxel connectivity. A wind-aligned voxel connectivity template is constructed by transforming base neighbor offsets according to the wind vector, forming an anisotropic propagation kernel. The template extent is further expanded by a distance buffer proportional to wind speed to represent downwind heat advection across heterogeneous landscapes.

At the voxel level, convective exchange is modeled using a Newtonian heat transfer formulation, where heat flux is assumed proportional to the temperature difference between burning source voxels and neighboring recipient voxels (Bergman 2011,Çengel and Ghajar 2025). Following Newton’s law of cooling, the convective heat flux is expressed as:

$$q_{\mathrm{conv},ij}=h_{\mathrm{eff}}(T_j-T_i),$$

(8)

where $h_{\mathrm{eff}}$ is an effective convective heat transfer coefficient representing plume-driven heat exchange at voxel scale.

To capture wind-driven flame tilt and directional plume transport, an anisotropic amplification factor is introduced based on the alignment between the local wind vector ${\mathbf{R}}_j$ and the source-to-target direction ${\widehat{\mathbf{d}}}_{ij}$:

$${\beta }_{ij}={\beta }_0+(1-{\beta }_0)max(0,{\widehat{\mathbf{R}}}_j·{\widehat{\mathbf{d}}}_{ij}),$$

(9)

so that convective heat transfer is enhanced in the downwind direction and suppressed upwind. The final convection formulation becomes

$$q_{\mathrm{conv},i}=\sum _{j\in {\mathcal{N}}_{\mathrm{upwind}}}{h}_{\mathrm{eff}}(T_j-T_i){\beta }_{ij}.$$

(10)

where, $q_{\mathrm{conv},i}$ denotes the total convective heat gain of voxel i, and ${\mathcal{N}}_{\mathrm{upwind}}$ represents the wind-aligned neighboring voxels contributing to heat transfer. $T_j$ and $T_i$ are the temperatures of the source voxel j and recipient voxel i, respectively. The parameter $h_{\mathrm{eff}}$ is an effective convective heat transfer coefficient representing plume-driven heat exchange at voxel scale. The factor ${\beta }_{ij}$ is a directional amplification term based on wind alignment, enhancing downwind heat transfer while reducing upwind influence.

This formulation approximates wind-driven advective heat transport without explicitly solving the Navier–Stokes equations, ensuring computational efficiency and compatibility with structured voxel-based parallel computation. Two-way fire–atmosphere coupling, such as buoyancy-induced airflow modification, is not explicitly resolved. Instead, the framework embeds physically grounded heat transfer and combustion formulations in a scalable voxel structure, providing a foundation for future integration of more advanced fire–flow interactions.

4.4.4. Thermal & Moisture Update

The total heat gain of a voxel is computed as the sum of radiative, convective, and conductive contributions:

$$q_{\mathrm{total}}=q_{\mathrm{rad}}+q_{\mathrm{conv}}+q_{\mathrm{conductive}}.$$

(11)

Voxel temperature is updated according to energy conservation. Over a timestep $\Delta t$, the absorbed heat produces a temperature increment governed by the voxel’s thermophysical properties:

$$\Delta T={\displaystyle \frac{q_{\mathrm{total}}\Delta t}{\rho c_{p}V}}·f_m,$$

(12)

where $\rho$ is fuel density, $c_p$ is specific heat capacity, V is voxel volume, and $f_m$ is a moisture-dependent damping factor. This formulation ensures that temperature rise is proportional to the received heat and inversely proportional to the material’s thermal mass.

Fuel moisture content is simultaneously reduced as a function of accumulated heat input. Following an energy balance formulation, a portion of the absorbed heat is allocated to moisture evaporation, representing latent heat consumption during thermal drying. The mass of evaporated water is governed by the latent heat of vaporization:

$$\Delta m_w={\displaystyle \frac{q_{\mathrm{evap}}\Delta t}{L_v}},$$

(13)

where $q_{\mathrm{evap}}$ denotes the fraction of total heat contributing to evaporation, $\Delta t$ is the timestep, and $L_v$ is the latent heat of vaporization of water. The corresponding reduction in voxel moisture content is expressed as

$$\Delta M={\displaystyle \frac{\Delta m_w}{\rho V}},$$

(14)

where $\rho$ is the voxel material density and V is voxel volume.

In the present implementation, this evaporation process is incorporated through a moisture-dependent scaling factor applied during the temperature update. As long as moisture remains above a critical level, part of the absorbed heat is effectively diverted to latent heat consumption, thereby moderating temperature rise while progressively decreasing voxel moisture content. Once moisture is sufficiently reduced, a greater fraction of the incoming heat contributes to sensible heating, accelerating temperature increase toward ignition thresholds.

4.4.5. Combustion State Determination

For result presentation and visualization purposes, five discrete combustion states are defined at the voxel level: unburned, heating, igniting, burning, and burned. These categories provide an interpretable representation of fire evolution while the underlying temperature and moisture fields remain continuous variables governed by physical heat transfer processes.

If no temperature gradient exists between a voxel and its surroundings and no burning or igniting voxels are present in its vicinity (except for user-defined ignition points), all voxels remain in the unburned state. When $q_{\mathrm{total}}>0$ due to the presence of nearby burning voxels and a valid heat transfer pathway (radiation, convection, or conduction), the voxel enters the heating state.

The transition from heating to igniting is governed by fuel-specific combustion thresholds. Each fuel type is assigned an ignition temperature $T_{\mathrm{ign}}$ and a critical moisture content $M_{\mathrm{crit}}$. A voxel transitions to the igniting state when

$$T_i\ge T_{\mathrm{ign}}\mathrm{and}{M}_i\le M_{\mathrm{crit}},$$

(15)

where $T_i$ and $M_i$ denote the voxel temperature and moisture content, respectively.

The burning state represents sustained combustion characterized by continuous fuel consumption and heat release. After a voxel satisfies the ignition criteria, it transitions from the igniting state to the burning state based on a prescribed fuel-type-dependent combustion formulation.

For each fuel type, a characteristic mass-loss rate ${\dot{m}}_f$ is defined empirically. The initial fuel mass contained within voxel i is given by

$$m_{f,i,0}={\rho }_f{V}_{\mathrm{voxel}},$$

(16)

where ${\rho }_f$ denotes the fuel density associated with the voxel’s fuel type and $V_{\mathrm{voxel}}$ is the voxel volume. The characteristic burning duration is then computed as

$$t_{\mathrm{burn},i}={\displaystyle \frac{m_{f,i,0}}{{\dot{m}}_f}}.$$

(17)

During the burning phase, the remaining fuel mass decreases at the prescribed rate,

$${\displaystyle \frac{d{m}_{f,i}}{dt}}=-{\dot{m}}_f.$$

(18)

Once the available fuel mass is exhausted ($m_{f,i}\to 0$ or $t\ge t_{\mathrm{burn},i}$), the voxel transitions to the burned state. Burned voxels no longer act as heat sources, although they may continue to participate in heat transfer as thermally inert materials.

Although combustion states are represented using discrete categories for clarity and visualization, state transitions are not governed by rule-based neighbor-state logic as in classical CA models. Instead, transitions emerge from continuous temperature, moisture, and fuel fields computed using physically motivated heat transfer and combustion formulations. This distinction enables physically grounded fire evolution while maintaining computational efficiency at large spatial scales.

4.5. Simulation Inputs and Outputs

Both simulation inputs and outputs are structured around the voxel-based data representation. The following subsections describe the input datasets used to construct the 3D voxelized environment, including the characterization of fuel properties and meteorological conditions. We also outline the primary simulation outputs generated within this voxel framework.

4.5.1. Voxel Data and Environmental Parameterization

The proposed framework adopts a standard voxel data structure in which each volumetric cell is defined by its 3D spatial coordinates. When explicit voxel indices are not provided in the source dataset, grid indices are computed based on spatial resolution and coordinate alignment. These indices establish structured spatial connectivity, enabling efficient neighborhood querying and heat transfer computation across the 3D domain.

Fuel properties are parameterized at the voxel level to enable the implementation of the physically grounded heat transfer formulations introduced in the previous subsections. The associated voxel-level parameters are summarized below:

• Voxel-Level Attributes, State, and Environmental Fields

  -

  $voxel\_index$$(i,j,k)$: Structured grid identifier computed from spatial coordinates and voxel resolution, used to establish spatial connectivity and enable efficient neighborhood querying within the 3D domain.

  -

  $fuel\_type$: Categorical fuel or material type identifier, designed to be extensible for additional classes. A value of $-1$ denotes air voxels, 0 represents non-burnable materials, and other values correspond to distinct combustible fuel types (e.g., vegetation classes, infrastructure elements, or building materials).

  -

  T: Voxel temperature (T_voxel).

  -

  M: Voxel fuel moisture content.

  -

  $\mathbf{R}$: Local wind / spread-rate vector field generated using an Oseen–Lamb wind model. The model produces spatially distributed wind vectors defined in two-dimensional (horizontal) or fully 3D form to represent wind direction and magnitude. The framework allows replacement with real-time observational data or CFD-simulated flow fields in future implementations.

  -

  Combustion state (state): Unburned, Heating, Igniting, Burning, Burned.

  -

  State duration variables (heating/igniting/burning_age).

• Fuel-Dependent Thermophysical and Combustion Parameters

  -

  $\rho$: Fuel density (LUT_rho).

  -

  $c_p$: Specific heat capacity (LUT_c).

  -

  $k_{\mathrm{eff}}$: Effective thermal conductivity (LUT_k_eff or default value).

  -

  $\alpha ={\displaystyle \frac{k_{\mathrm{eff}}}{\rho c_p}}$: Derived thermal diffusivity.

  -

  $T_{\mathrm{ign}}$: Fuel-type-specific ignition temperature.

  -

  $M_{\mathrm{crit}}$: Fuel-type-specific critical moisture content for ignition.

  -

  Moisture damping factor applied during temperature updates to scale effective heat input, accounting for sensible heating and latent heat of vaporization during pre-ignition fuel drying.

  -

  Fuel-type-specific empirical parameters governing heat absorption and combustion behavior.

• Ambient Environmental Parameters

  -

  $T_{\mathrm{ambient}}$: Ambient temperature (uniform across the domain).

The proposed framework serves as a computational skeleton in which physical formulations and associated parameters can be readily modified or extended. The parameterization adopted in the present study is therefore not fixed, but can be adapted to incorporate refined thermodynamic models, alternative combustion formulations, or more advanced fire–atmosphere coupling mechanisms. This flexibility enables the modeling of customized fire spread scenarios with increasing physical fidelity while maintaining computational scalability.

4.6. Outputs, Visualization, and Qualitative Validation

The simulator generates both abstracted and fully resolved voxel-level outputs. Combustion state transitions at specified timestamps provide a clear representation of fire progression and can be visualized using a customized 3D viewer developed with vtk.js, enabling interactive exploration of spatial fire dynamics in web browsers (Figure 2). In addition to discrete states, the framework exports full environmental and thermal fields over time, including voxel-level temperature, moisture content, and individual heat transfer components (radiative, convective, and conductive fluxes). These outputs support detailed analysis of energy transfer processes and spatiotemporal fire evolution. The exported formats are interoperable and platform-agnostic, enabling integration with web-based visualization frameworks, game engines (e.g., Unity or Unreal Engine), and virtual or mixed reality environments. This supports advanced interactive visualization, immersive analysis, and integration into digital twin and decision-support systems. Beyond visualization, the outputs enable qualitative assessment of the physical plausibility of simulated fire dynamics. Controlled scenarios were designed to evaluate model behaviour under varying environmental conditions. In particular, comparative experiments with and without ambient wind show that wind accelerates fire spread, drives directional propagation aligned with wind vectors, and increases the spatial extent of burned areas. These patterns are consistent with established wildfire dynamics, where wind-driven convection enhances heat transfer and promotes faster propagation.

To further assess realism, domain experts from Fire and Rescue New South Wales (FRNSW) were invited to qualitatively evaluate selected simulation outputs through visual inspection of fire progression patterns and spatial spread characteristics. Feedback from these expert reviews indicated that the simulated behaviours were consistent with practical expectations and exhibited credible fire dynamics in comparable scenarios (as shown in Figure 2d).. While these assessments do not constitute formal validation against empirical datasets, they provide initial evidence supporting the interpretability and plausibility of the proposed framework.

5. Computational Approach

While Section 4 introduced the conceptual modeling framework and physical formulations governing fire propagation, their practical realization requires an efficient computational architecture for large three-dimensional voxel domains. This section describes the computational approach for the realization of the framework, including the voxel-centric GPU memory layout and the structured voxel connectivity–based computation scheme that enable efficient neighbor access and scalable parallel updates across large voxel grids, address the computing challenges mentioned in Section 4.

5.1. Voxel-centric GPU Memory Layout

Dense 3D voxel grids exhibit cubic scaling with spatial resolution. For a domain discretized into $N_x\times N_y\times N_z$ cells, the total number of voxels is

$$N=N_x{N}_y{N}_z,$$

(19)

which grows as $\mathcal{O}\left(N^3\right)$ under uniform refinement. Each voxel stores multiple state variables and environmental attributes, including its grid index $(i,j,k)$, temperature T, combustion state, wind vector $\mathbf{R}$, moisture content M, and fuel-type-dependent thermophysical properties. The total memory requirement is on the order of

$$\mathcal{O}\left(N·n_f\right),$$

(20)

where N is the number of voxels and $n_f$ denotes the number of stored fields per voxel. For million- to multi-million-voxel domains, dense CPU-based implementations using conventional array data structures (e.g., NumPy and MATLAB default arrays) can place substantial pressure on system memory, particularly when multiple time-dependent fields and intermediate buffers (e.g., double-buffering and flux arrays) are allocated (Ferziger and Perić 2002,LeVeque 2007a). At sufficiently high resolutions, such allocations may lead to out-of-memory errors or severe performance degradation. Traditional dense allocation strategies not only increase memory footprint but also intensify memory-bandwidth pressure, potentially leading to out-of-memory errors or severe performance degradation.

To mitigate these challenges, the proposed framework leverages the Python Taichi programming model, which enables structured memory layout, sparsity-aware voxel activation for reduced memory allocation, and automatic parallel execution across CPU and GPU architectures. We further employ a memory-efficient voxel organization strategy that preserves index-enabled spatial connectivity while optimizing 3D voxel data storage directly in GPU memory. In theory, storing voxel data in GPU memory enables substantially higher computational throughput compared to CPU-only implementations due to massive thread-level parallelism and significantly greater memory bandwidth. GPU architectures are optimized for SIMD-style execution and coalesced memory access, which align naturally with stencil-based (voxel-connectivity) update patterns that require frequent neighboring data reads. As a result, large-scale voxel simulations benefit from improved memory access efficiency and parallel scalability.

Specifically, the framework leverages Python Taichi fields to map structured voxel information (e.g., indices, coordinates, and attributes) directly into GPU memory under a data-oriented design. The 3D voxel index space $(i,j,k)$ is linearized into a one-dimensional row-major memory representation, preserving spatial connectivity while enabling contiguous memory access and efficient parallel stencil computation. In details, the 3D voxel indices $(i,j,k)$ is mapped to a 1D linear memory index I using a row-major (C-style) linearization scheme:

$$I=i+N_x\left(j+N_{y}k\right),$$

(21)

where $N_x$ and $N_y$ denote the voxel counts along the x- and y-directions, respectively. For a predefined stencil offset $(\Delta i,\Delta j,\Delta k)$, the neighboring voxel index is computed directly as

$$I_{\mathrm{neighbor}}=I+\Delta i+N_x\left(\Delta j+N_y\Delta k\right),$$

(22)

which enables deterministic, constant-time ($\mathcal{O}\left(1\right)$) neighbor access without pointer dereferencing or indirect lookup. By aligning spatial adjacency with contiguous memory layout, this index mapping enhances cache locality and supports coalesced memory access during GPU-parallel stencil updates, thereby improving overall memory efficiency for large-scale voxel simulations (Guide 2013,Khan et al. 2021).

As an example application of our appraoch, in a row-major linearized layout, neighboring voxels along the i-direction are stored in adjacent memory locations, such that consecutive GPU threads accessing $(i,j,k)$ and $(i+1,j,k)$ retrieve data from contiguous addresses. This enables coalesced memory reads on GPUs and improves cache-line utilization on CPUs (Sun et al. 2024). In contrast, non-linear or pointer-based storage schemes may scatter neighboring voxels across memory, increasing cache misses and memory transaction overhead (Guide 2013,Khan et al. 2021). By ensuring that spatially adjacent voxels are also memory-adjacent, the framework reduces memory latency and enhances throughput in stencil-based heat transfer updates.

In our farmework, voxel attributes are organized using Taichi fields under a data-oriented design, enhancing memory coherence and supporting efficient stencil-based parallel computation, as shown in Algorithm 1

. In addition, sparse voxel algorithms are employed to reduce unnecessary allocation and computation, particularly for air and non-burnable voxels. Conditional switching of computational rules based on voxel type avoids redundant heat-transfer updates in inactive regions, thereby reducing effective memory usage and computational workload. The combination of structured GPU memory layout, linearized index mapping, and sparsity-aware computation significantly enhances scalability while maintaining physical consistency.

Algorithm 1  Parallel voxel memory access and update

Require:   Voxel fields $(T,M,\mathbf{R},\mathrm{state})$, grid dimensions $(N_x,N_y,N_z)$, stencil offsets $\mathcal{S}$ Ensure:   Updated voxel temperature and combustion state 1: Launch parallel kernel over all voxels 2: Each thread is assigned to one voxel $(i,j,k)$ 3: Compute linear index $I=i+N_x(j+N_{y}k)$ 4: if the assigned voxel is burnable then 5:     Initialize heat flux accumulator $q\leftarrow 0$ 6:     for all offset $(\Delta i,\Delta j,\Delta k)\in \mathcal{S}$ do 7:         Compute neighbor index: $$I_n=I+\Delta i+N_x(\Delta j+N_y\Delta k)$$ 8:         Read neighboring voxel attributes 9:         Accumulate conductive, radiative, and convective contributions 10:     end for 11:     Update voxel temperature 12:     Update combustion state 13: end if

5.2. Structured Voxel Connectivity and Stencil-Based Computation

As described in Section 4.4, fire propagation processes—conduction, radiation, and wind-driven convection—are formulated as localized heat transfer mechanisms over voxel connectivity. Conduction uses a six-neighbor Laplacian operator, radiation an extended distance-based neighborhood, and convection an anisotropic wind-aligned neighborhood. These formulations map naturally to stencil-based updates on a structured 3D lattice. In traditional CPU implementations, stencil operations are executed via nested loops over spatial dimensions and neighborhood offsets. As the stencil radius increases (e.g., for radiation or wind-driven transport), the number of neighbor evaluations grows, resulting in computational complexity of $\mathcal{O}(N·k)$, where N is the number of voxels and k the stencil size. For million- to multi-million-voxel domains, such implementations become computationally prohibitive, limiting scalability and practical applicability.

To address these challenges, the framework adopts a voxel-centric structured memory layout with stencil operators defined as fixed offset matrices. Instead of dynamically traversing neighbors, stencil offsets are precomputed and applied directly to voxel indices using a row-major linearized representation (Equations Section 5.1Section 5.1). This deterministic index arithmetic enables constant-time neighbor access without pointer-based lookup or graph traversal. Each neighbor index is computed in $\mathcal{O}\left(1\right)$ time from predefined offsets, yielding a stencil update cost of $\mathcal{O}\left(N_{a}k\right)$ per timestep (or $\mathcal{O}\left(N_a\right)$ for fixed stencil size k). In contrast, pointer- or hash-based traversal introduces an additional overhead factor L, resulting in $\mathcal{O}\left(N_{a}kL\right)$ due to pointer dereferencing, irregular memory access, and cache-miss penalties. By avoiding indirect memory access, the framework improves memory contiguity, enhances cache locality and coalesced GPU transactions, and enables scalable, bandwidth-efficient stencil updates across large voxel domains.

By leveraging Taichi fields and their data-oriented GPU execution model, voxel attributes, including heat flux components, moisture content, and temperature, are updated in parallel across the entire domain.

The combination of structured connectivity, pre-defined stencil operators, and GPU-parallel execution allows efficient large-scale updates while preserving the physical fidelity of heat transfer processes, please see Algorithm 2.

Algorithm 2  Parallel Stencil-Based Voxel Heat Transfer and Moisture Update

Require:   Active voxel set ${\mathcal{V}}_a$, stencil offset set $\mathcal{S}$, voxel fields $(T,M,\mathbf{R},\mathrm{state})$, grid dimensions $(N_x,N_y,N_z)$ Ensure:   Updated voxel temperature, moisture content, and combustion state 1: Launch parallel kernel over active voxels 2: Each thread processes one voxel $(i,j,k)$ 3: Compute linear index $$I=i+N_x(j+N_{y}k)$$ 4: if voxel is burnable then 5:     Initialize heat flux accumulator $q\leftarrow 0$ 6:     for all stencil offset $(\Delta i,\Delta j,\Delta k)\in \mathcal{S}$ do 7:         Compute neighbor index $$I_n=I+\Delta i+N_x(\Delta j+N_y\Delta k)$$ 8:         Read neighboring voxel attributes 9:         Compute conductive, radiative, and convective heat transfer contributions 10:         $q\leftarrow q+q_{\mathrm{cond}}+q_{\mathrm{rad}}+q_{\mathrm{conv}}$ 11:     end for 12:     Update voxel moisture content $$M_i^{t+1}\leftarrow f_M(M_i^t,T_i^t,q)$$ 13:     Update voxel temperature $$T_i^{t+1}\leftarrow f_T(T_i^t,M_i^{t+1},q)$$ 14:     Update combustion state according to ignition and burning criteria 15: end if

6. Simulation Experiments

This section demonstrates the application of the proposed framework for simulating fire propagation in voxelized WUI environments, highlighting its ability to capture heat transfer processes and wind-driven spread. It then evaluates the computational performance and scalability of the framework in larger, more complex domains.

6.1. Experimental Setup

To evaluate performance and scalability, experiments were conducted using voxel datasets from two urban areas in New South Wales, Australia: Newcastle and Liverpool (Sydney). These datasets were derived from high-resolution LiDAR sources provided by NSW Government Spatial Services and processed using the VoxelMates platform to generate standardized voxel representations. An early prototype demonstrated feasibility on a Newcastle community using a $130\times 128\times 35$ grid at 1 m resolution (Xu et al. 2026c). The present study extends this work to larger and more complex environments to assess scalability at higher resolutions (Figure 3).

The enhanced framework is applied to a significantly larger voxel grid of approximately $336\times 368\times 153$, representing a suburban area of Liverpool, Sydney, and comprising roughly 18 million voxels. At a voxel resolution of $0.8\times 0.8\times 0.8$ m, this corresponds to a physical domain of approximately $268.8\times 294.4\times 122.4$ meters.

The standardized voxel data structure provided by VoxelMates includes basic segmentation that enables voxel-level fuel type classification, supports consistent urban-scale simulation, and facilitates future expansion to broader geographic regions.

Atmospheric influence is modeled using synthetic wind fields generated by the Lamb–Oseen vortex model. Given prescribed mean wind speed and direction, the model produces spatially varying 2D or 3D wind vectors across the voxel grid (Figure 3). These voxel-aligned wind fields are directly coupled with the convective heat transfer formulation. While synthetic winds are used for controlled evaluation, the framework can be readily extended to incorporate real-time observations or outputs from numerical weather models.

6.2. Process Propagation Demonstration in 3D Voxel Space

Figure 4 demonstrates the proposed voxel-based simulation framework applied to an urban environment in Liverpool, New South Wales. The simulation captures 3,600 seconds of fire spread under turbulent wind conditions. Both the total simulation duration and time step are user-defined, allowing flexibility across different application scenarios. Selected time steps are presented to illustrate the temporal evolution of the fire front within a fully 3D voxelised digital earth representation.

The top-down views show horizontal expansion of the fire front over time, illustrating spread across terrain and vegetation and interaction with the built environment. The pattern is anisotropic, reflecting the influence of turbulent wind and urban morphology on fire direction and rate of propagation. From 30 s to 240 s, the fire front expands outward and increasingly interacts with nearby structures and vegetation, and by 1800 s the affected area has grown substantially within the urban context. The perspective views highlight the volumetric nature of the simulation. Unlike traditional 2D models, the voxel framework represents vertical structure, enabling fire propagation in 3D space around buildings and trees. This allows the model to capture occlusion, channeling between structures, and vertical interactions among terrain, vegetation, and the air layer. Together, the planar and volumetric views demonstrate how a dense voxel-based digital earth representation supports physically plausible 3D fire propagation in heterogeneous urban environments, highlighting its value for scenario generation, training data production, and digital twin–based decision support.

The propagation dynamics are partially visualized in the outputs. In this framework, heat transfer and fire spread are modeled as wind-driven processes, where local wind speed and direction influence inter-voxel energy propagation. In Figure 4, the wind field is shown using blue arrows, while voxel colors represent thermal and combustion states: yellow indicates heat transfer, orange indicates ignition, and red indicates active burning across different fuel types. The wind field primarily affects convective heat transfer, with both the direction and spatial extent of heat propagation (i.e., the number of downwind neighboring voxels receiving heat) aligned with the local wind vector at each burning voxel. These interactions are implemented using parallel stencil-based computation, where each voxel updates its state based on neighboring voxels and local wind conditions. This stencil-based framework is generalizable and can be extended to simulate other physical processes influenced by directional environmental drivers.

7. Computational Performance Evaluation

To assess the computational approach of the proposed simulation framework, the performance evaluation is designed around the computer environments available to end-users. These include emergency management personnel who typically rely on commodity laptops for rapid decision support, as well as wildfire researchers with access to high-performance computing (HPC) resources. We therefore evaluate the computational scalability and feasibility of the framework across voxel grids of increasing size, with particular attention to runtime scaling and executability on both laptop-class GPUs and single-node HPC GPU systems.

7.1. Runtime Performance and Scalability on Commodity Laptop GPUs

In this study, computational scalability is defined with respect to total voxel grid size, which determines memory allocation and dominates computational workload. Voxels are classified by fuel properties as burnable (e.g., terrain, buildings, vegetation) or non-burnable (e.g., air and roads) using the active filtering method. Scalability is therefore evaluated by measuring runtime as voxel grid size increases. To characterize scene composition and sparsity, we also report the number and proportion of active burnable voxels, which undergo more complex physical processes than non-burnable voxels. Runtime is reported as total simulation time (s), including initialization and execution under identical settings. To assess stability and repeatability, each scenario is run multiple times and summarized using descriptive statistics (mean, median, and standard deviation). Runtime distributions are visualized using boxplots in Figure 5.

To evaluate practical deployability in time-critical operational settings, we conducted performance experiments on a commodity laptop representative of devices used by emergency response agencies for real-time or near-real-time decision support. Such environments involve constrained computational resources but require rapid simulation turnaround during active wildfire events. The test system was equipped with an NVIDIA RTX 500 Ada Generation Laptop GPU (4.29 GB VRAM, 3.40 GB available), 32 GB system RAM, and ran Windows 11 Enterprise (64-bit) on an Intel® Core™ Ultra 7 165H processor (22 logical CPUs, 1.4 GHz base frequency). Compared to the Katana HPC node, this platform has substantially lower GPU memory and computational throughput, providing a realistic approximation of resource-constrained field or office deployment environments.

Due to VRAM limitations, local simulations were restricted to a coarser voxel resolution (80 cm). Attempts to run larger burnable voxel scenarios at finer resolution (20 cm) resulted in GPU out-of-memory errors. Consequently, three scenarios with 54,706, 145,177, and 255,088 burnable voxels were evaluated locally (Figure 5B), each repeated ($n=36$). Mean runtimes increased from 87.47 s to 218.21 s as voxel counts grew, with variability also increasing at larger scales (standard deviation up to 65.70 s). This variance reflects memory pressure and reduced GPU efficiency as VRAM limits are approached. Despite these constraints, results show consistent monotonic runtime scaling, consistent with trends observed on HPC platforms. Importantly, even on limited hardware, the framework achieves execution times on the order of minutes, indicating suitability for near-real-time fire spread estimation in operational contexts. These findings confirm that the simulator can be deployed on both high-performance computing systems and widely accessible laptop-class devices used in emergency management workflows.

7.2. Runtime Performance and Scalability on HPC GPU Systems

To evaluate the capability of the proposed framework for large-scale scientific analysis, we conducted performance experiments on a HPC platform representative of resources commonly available to wildfire researchers and academic institutions. Such environments enable high-resolution simulation and exploration of complex urban and wildland–urban interface (WUI) scenarios that exceed the capacity of commodity hardware. The scalability evaluation was performed on the UNSW Katana HPC system using a single GPU-enabled node. Compute resources were allocated via PBS interactive scheduling, providing a configuration with 8 CPU cores, 1 GPU, and 96 GB RAM. This setup enables controlled and repeatable benchmarking under consistent hardware conditions while reflecting typical single-node GPU usage in research workflows.

Five voxelised environments were evaluated, with burnable voxel counts ranging from 54,706 to 1,001,757. These represent the actively simulated portions of the domain (i.e., vegetation, buildings, and ground surfaces), while surrounding air voxels remain computationally inactive. The proportion of burnable voxels remains consistently sparse across scenarios (0.918%–1.596% of the dense grid), reflecting realistic urban occupancy conditions and supporting efficient sparse computation. The measured runtimes demonstrate clear and stable scaling behaviour with respect to burnable voxel count (Figure 5A). For the smallest environment (54,706 burnable voxels), the mean runtime is 10.79 s ($n=36$, median 10.65 s, std 3.52 s). Runtime increases to 20.02 s at 145,177 voxels, 32.61 s at 255,088 voxels, 80.18 s at 569,636 voxels, and 145.18 s for the largest evaluated domain of 1,001,757 burnable voxels ($n=27$, median 142.84 s, std 39.60 s). Across all scenarios, median runtimes remain close to mean values, and variability remains within expected bounds for GPU workloads, indicating stable execution and strong repeatability.

These results demonstrate that the proposed framework scales predictably and efficiently for urban-scale simulations on single-node HPC systems. Notably, domains exceeding one million active burnable voxels can be simulated within minutes without requiring distributed computing, highlighting the practicality of the approach for research applications. This level of performance supports high-resolution scenario analysis, sensitivity studies, and large-scale experimentation, making the framework well-suited for fire science research, digital twin development, and advanced urban analytics workflows.

7.3. Implications for Voxel-Based Digital Earth Simulation

The evaluation demonstrates that urban-scale dense voxel process propagation is computationally feasible using single-node GPU execution. Although active voxels per timestep remain sparse ( 1%), a dense volumetric grid is required to maintain a consistent 3D modelling space and support generalized propagation across heterogeneous media (air, vegetation, terrain, and built structures). Feasibility at grid sizes up to 109.1M voxels provides a practical foundation for applications such as urban-scale scenario testing, synthetic data generation for AI surrogate modelling, and digital twin decision-support pipelines.

Table 3 shows that increasing voxel counts correspond to proportional growth in spatial extent while preserving a fixed aspect ratio. At a uniform resolution of 0.8 m, domain size expands from approximately $152\times 166.4\times 68.8$ m (3.43 million voxels) to $481.6\times 527.2\times 219.2$ m (109.1 million voxels), scaling from neighborhood- to urban block-scale environments. This consistent geometric scaling ensures that increases in computational cost are driven by domain size rather than spatial configuration, providing a controlled basis for evaluating runtime performance across simulation scales and computing platforms.

Beyond performance, these findings have broader implications for voxel-based Digital Earth simulations. Digital Earth initiatives increasingly emphasize high-resolution volumetric representations of urban and environmental systems. Our results show that simulations with more than one million active voxels can be executed on a single GPU-enabled HPC node with stable, predictable runtimes, confirming the computational viability of voxel-based modelling at urban district scales. They also support the transition from static data repositories to dynamic, process-based digital twins. Efficient volumetric mass–energy simulation demonstrates that Digital Earth systems can incorporate physically meaningful processes rather than relying solely on surface-based or empirical approximations. The observed monotonic scaling between voxel count and runtime further enables predictable trade-offs between model resolution and computational cost.

The contrast between laptop and HPC performance suggests a practical deployment architecture: lightweight devices for scenario setup and small-area simulation, and GPU-enabled HPC infrastructure for urban-scale modelling. Although demonstrated for urban fire spread, the voxel-based mass–energy transfer framework is domain-agnostic and applicable to other Digital Earth simulations, including urban heat transport, air pollutant dispersion, flood propagation, and infrastructure risk modelling. Together, these findings support voxel-based, physics-aware modelling as a viable computational foundation for next-generation urban and environmental digital twins.

8. Discussion: Implications, Limitations, and Future Work

This work introduces a parallel voxel-based simulation framework that bridges the increasing availability of high-resolution 3D urban data and the limited scalability of existing environmental models. While most approaches remain surface-based or restricted to small domains, the proposed framework enables physics-driven process propagation directly within volumetric voxel environments. Although wildfire spread is used as a demonstration, the architecture is domain-agnostic. By modifying governing formulations and inputs (Section 4.5 and Section 4.4), it can support applications such as heat transport, pollutant dispersion, flood propagation, and multi-hazard interactions within a unified digital earth context.

8.1. Limitations

Despite its scalability and flexibility, several limitations remain:

• Limited real-time data integration. Although designed to support temporally evolving inputs (e.g., fuel properties and meteorological conditions), the current framework lacks an automated data provisioning pipeline for real-time integration. Preparation of voxel attributes—such as fuel type, moisture, and environmental parameters—remains partially manual, limiting scalability for large geographic domains. Integration of real-time or near-real-time geospatial data streams (e.g., weather observations, remote sensing, environmental monitoring) is not yet implemented.
• Simplified fire behavior representation. The system provides a computational framework for volumetric simulation but currently employs a simplified representation of wildfire dynamics based on fundamental heat transfer processes. Advanced mechanisms—such as detailed combustion chemistry, heterogeneous fuel interactions, and coupled fire–atmosphere processes (e.g., fire-induced winds and plume dynamics)—are not explicitly modeled. In particular, pyroconvection and plume-dominated behavior remain outside the current scope. The implementation should therefore be viewed as a scalable computational foundation rather than a fully calibrated wildfire prediction system.
• Lack of calibration and validation. The wildfire simulation component has not yet been systematically calibrated or validated against benchmark datasets or real-world observations. While the current thermal formulations demonstrate volumetric fire propagation, predictive accuracy has not been established through comparison with empirical data or existing wildfire models.

Overall, this work represents an initial computational framework with simplified physical formulations. Future work will focus on model refinement, incorporation of advanced fire behavior processes, and validation against real-world data. The framework is intended as a modular platform for integrating more sophisticated physical and data-driven models within a scalable voxel-based environment.

8.2. Future Work

Future work will address the limitations identified above and expand the framework’s capabilities:

• Automated and real-time data provisioning. Future research will develop automated pipelines for dynamic voxel attribute generation at scale. These will support the discovery, retrieval, and harmonization of geospatial data, including LiDAR-derived terrain, building information models, land cover, and environmental monitoring data. Integration with real-time streams, such as meteorological observations and remote sensing, will enable continuous updates of fuel conditions, wind fields, and moisture levels, supporting time-evolving simulations.
• Advanced fire dynamics and multi-physics coupling. The framework will be extended with advanced wildfire behavior models and multi-physics coupling, including detailed combustion, fire–atmosphere interactions, and structural fire dynamics in urban environments. Its modular voxel-based design allows new physical formulations to be integrated without modifying the core computational framework.
• AI-assisted simulation and surrogate modeling. The framework enables integration with data-driven approaches. Large volumes of simulation data can support machine learning and generative AI surrogate models, enabling accelerated approximation of complex processes and supporting real-time digital twin applications for hazard assessment and resilience planning.
• Calibration and validation. Systematic calibration and validation will be conducted using benchmark datasets and observational records. Incorporating empirically derived parameters and performing controlled comparisons will improve predictive reliability and support operational applicability.

9. Conclusion

This study presents a physics-informed, voxel-based computational framework for urban-scale 3D fire propagation simulation in WUI environments. By integrating physically motivated formulations of conduction, radiation, and wind-driven convection with a structured voxel connectivity model, the framework enables thermodynamically grounded process propagation while maintaining computational efficiency. A key technical contribution lies in the development of a GPU-accelerated, stencil-based implementation that leverages row-major memory linearization, deterministic index arithmetic, and sparsity-aware voxel management. These design choices enable constant-time neighbor access, preserve memory locality, and support scalable parallel execution over million- to multi-million-voxel domains. Performance experiments conducted on representative target-user hardware, including both standard laptops and HPC infrastructure, demonstrate that the proposed framework remains computationally feasible for large volumetric scenes, supporting its applicability in Digital Earth and urban digital twin contexts.

Unlike traditional cellular automata approaches that rely purely on discrete state-transition logic, the proposed method embeds physically interpretable heat-transfer mechanisms within a structured voxel computing skeleton. While the current study focuses on scenario-based simulation and synthetic data generation rather than predictive validation against field measurements, the framework establishes a modular and extensible foundation for incorporating more advanced thermo-fluid coupling, real-time meteorological data, and higher-fidelity combustion models in future work. Overall, our work contributes a scalable computational backbone for 3D fire spread simulation and provides a practical pathway toward integrating voxel-based physical modeling into next-generation urban resilience and emergency management systems.