WorksComputer Science
A Unified Interactive Framework for Real-Time Three-Dimensional Cellular Automata Simulation in XR
Abstract
Integrating three-dimensional cellular automata (3D CA) into extended reality (XR) requires coordinated simulation, volumetric data management, rendering, and interaction under variable hardware constraints. This paper presents a hybrid study combining a critical review of existing approaches with a unified architecture for real-time 3D CA in XR. The proposed five-layer architecture integrates voxel and rule management, parallel computation, interoperability middleware, visualization, and XR interaction. Its key principles include hardware-aware execution, asynchronous simulation-rendering, adaptive fidelity, and cross-engine interoperability. An analytical evaluation framework is defined to assess performance, latency, scalability, memory efficiency, simulation correctness, and interaction quality. The proposed framework provides a foundation for developing portable and interactive 3D CA systems across desktop and mobile XR platforms.
Introduction
Cellular automata (CA) have evolved from foundational models of local, rule-governed systems into practical tools for investigating complex spatiotemporal processes across scientific and engineering domains. Their appeal comes from a simple computational structure: a discrete space is populated by cells whose states evolve through local transition rules. Despite this simplicity, collective interactions can generate patterns and dynamics that are difficult to derive analytically. Recent work has explored CA in three-dimensional visualization and immersive exploration, as well as in domains such as environmental modelling, fluid-like behaviour, biological processes, and molecular-scale interactions [2, 11, 28, 34, 44] (Arevalo et al. 2022).
Historically, the computational cost of updating large cellular grids restricted the size and temporal resolution of simulations. General-purpose GPU computing and other forms of parallel execution have changed this landscape by mapping cell updates to parallel hardware. GPU-based CA approaches have been studied for hexagonal and three-dimensional automata, medical volumetric data, indoor particulate-matter modelling, urban expansion, and large-scale microstructure simulation [4, 6, 7, 38] (Svyetlichnyy & Banaś 2026; Yu & Chang 2023). More recent work investigates tensor-core execution and bit-plane or bitwise representations, illustrating that performance depends not only on the number of processing units but also on the neighbourhood structure, state representation, memory layout, and transition function [16] (Brabec et al. 2026). These developments provide important computational building blocks, but they do not by themselves guarantee an interactive XR experience.
The distinction is important because an XR application must satisfy several coupled requirements. A simulation can update cells rapidly yet produce an unstable display because data transfer, synchronization, or rendering becomes the bottleneck. Conversely, a visually smooth scene may display stale simulation states if the update process is decoupled without an explicit consistency policy. Immersive systems also introduce constraints that are less central to conventional offline simulation: viewpoint-dependent rendering, motion-to-photon latency, continuous head and controller tracking, limited thermal and power budgets on standalone devices, and the need for interaction techniques that make three-dimensional state changes understandable. Research on scientific visualization in VR and large-scale data visualization demonstrates the value of immersive exploration, while also showing that integration between specialized visualization software and VR environments is a distinct engineering problem [5, 17, 20, 24].
A further gap concerns interoperability. Scientific CA solvers and XR engines are often developed around different data models, execution assumptions, and programming interfaces. A simulation may be implemented in a scientific computing environment, while the immersive front end may be built in a game engine or browser-based graphics platform. Frameworks such as MINT illustrate how visualization systems and VR environments can be loosely coupled without porting all visualization algorithms into the XR engine; WebGPU-oriented engines and WebXR toolkits offer complementary routes to cross-platform rendering and interaction [5, 12, 26]. Nevertheless, a portable CA-to-XR pipeline requires an explicit contract for grid dimensions, state formats, coordinate systems, time steps, buffer ownership, synchronization, and rendering semantics. Without such a contract, engine-specific adaptations can undermine reproducibility and increase maintenance effort [8] (Ahmed, n.d.; Ganji 2026).
The interaction problem is equally significant. A 3D CA is not merely a volume to be viewed; it is a dynamic state space that users may need to inspect, slice, annotate, perturb, compare, or manipulate. Existing work has explored VR-based exploration of 3D CA, head-mounted visualization of automata and tilings, immersive scientific-image exploration, and interactive agent-based simulation [1, 24, 29] (Arevalo et al. 2022). These studies suggest opportunities for spatial interaction, but also raise questions about navigation efficiency, cognitive load, and whether interaction patterns familiar from desktop applications transfer effectively to immersive settings.
This paper addresses the intersection of these issues. It does not claim that one existing system already solves the entire problem. Instead, it synthesizes relevant work and proposes a unified architecture intended to coordinate parallel CA execution, volumetric data handling, cross-engine exchange, rendering, and immersive interaction. The contribution is therefore architectural and methodological: the paper defines the layers, interfaces, design principles, and evaluation criteria needed to build and assess a real-time 3D CA environment in XR.
Literature Review
Prior work establishes several complementary foundations for the proposed research. Foundational visualization research examined multiscale CA data and GPU-based visual simulation, while subsequent work extended GPU computation to hexagonal and three-dimensional automata [9, 10, 14, 6, 7]. Application-oriented studies have used CA for medical volumetric processing, indoor particulate-matter modelling, urban expansion, traffic-flow visualization, fluid-like interaction, environmental dispersion, and fire-spread simulation [4, 11, 32, 33, 38] (Xu et al. 2026a; Xu et al. 2026b; Yu & Chang 2023).
Recent computational work explores tensor-core execution, bit-plane encoding, vectorization, and alternative parallel architectures, indicating that the most suitable acceleration strategy depends on neighbourhood size, state encoding, memory traffic, and rule structure rather than on GPU use alone [2, 16] (Brabec et al. 2026; Svyetlichnyy & Banaś 2026). In parallel, immersive visualization research has moved from direct exploration of three-dimensional CA and tilings toward broader scientific visualization and large-scale data exploration in VR, while interactive systems have investigated spatial manipulation, collaborative exploration, and lightweight WebXR interaction [5, 12, 17, 20, 24, 29] (Arevalo et al. 2022). Cross-platform rendering and interoperability work, including WebGPU-based engines and middleware-oriented integration, provides mechanisms for separating scientific computation from immersive presentation, while recent XR platforms demonstrate the feasibility of interaction on a wider range of devices [8, 26, 34] (Ahmed, n.d.; Ganji 2026). Finally, neural and adaptive CA research suggests a broader transition from fixed hand-designed rules toward learned or dynamically modified spatiotemporal behaviour [22, 23, 27]. Taken together, these studies provide strong individual building blocks, but they are distributed across computational, visualization, interaction, and interoperability communities. The critical gap is therefore not the absence of GPU CA, VR visualization, or cross-platform rendering in isolation; it is the absence of a common, explicitly specified architecture and evaluation protocol that connects these capabilities while preserving simulation correctness and immersive responsiveness.
Savargiv and Bastanfard [45, 46] explored fuzzy-based data representation and computational efficiency through the design of a fuzzy emotional speech corpus and real-time speech emotion recognition using a reduced set of discriminative features. Their studies provide relevant methodological perspectives on managing uncertainty and reducing computational complexity, which can inform the development of adaptive state representations and lightweight processing strategies in real-time cellular automata systems. More directly, Minoofam et al. [47] investigated the generation of Ma'qeli patterns using block cellular automata, demonstrating the applicability of structured neighborhood configurations and rule-based state transitions for spatial pattern generation. Collectively, these studies provide complementary foundations for developing modular cellular automata architectures that combine structured transition rules, flexible state representations, and computational efficiency [45, 46, 47].
From the perspective of immersive interaction and visualization, Koohestani et al. [48] investigated gamified extended reality and pseudo-haptic feedback for laparoscopic skill training, highlighting the importance of precise spatial manipulation, real-time feedback, and responsive interaction mechanisms in XR environments. Similarly, Rezaei et al. [49] presented an interactive lighting and shadowing system for augmented reality models, demonstrating the role of user-controlled visual parameters in improving the representation and realism of three-dimensional virtual objects. Although these studies address different application domains, their contributions provide relevant methodological insights for designing the interaction and visualization components of the proposed CA-XR framework, particularly in supporting real-time manipulation, responsive visual feedback, and immersive exploration of dynamic three-dimensional data [48, 49].
| Study | Computational Throughput Efficiency | Frame Rate Stability | Performance Rate Stability | Latency Overhead Reduction | Scalability Limit Capacity | Interaction Fluidity Assessment |
| (Gobron et al., 2021) | GPU processing is two hundred times faster than identical CPU algorithms | Real-time visualization of large 3D matrices is achieved through GPU | Original rendering methods transmit large CA functions to the GPU in real time | Large 3D matrices are processed efficiently using graphics processor unit | Interactive user interface allows testing with different project ideas and configurations | Interactive user interface allows testing with different project ideas and configurations |
| (Prajoulshgar et al., 2024) | MeshNCA synthesizes dynamic textures on 3D meshes in real time | WebGL shading language implementation ensures consistent performance on any mesh | Forward pass implementation allows immediate texture synthesis on 3D meshes | Forward pass implementation enables texture synthesis on any mesh after initial training | Operates on non-grid structures like meshes without UV maps | Includes texture density, orientation controls, rotating brushes, and motion speed direction |
| (Prajoulshgar et al., 2023) | Real-time 3D texture synthesis is using WebGL shading language implementation | Trained models showcase performance on small computers and smartphones via interactive demos | Forward pass implementation enables texture synthesis on any mesh after initial training | Generalized cellular automata operate on non-grid structures like vertices of 3D meshes | Allows user interactions including texture density, orientation control, grafting, and motion speed | Allows user interactions including texture density, orientation control, grafting, and motion speed |
| (Arevalo et al., 2022) | Audio spatialization renders 2553 audio dropouts in virtual reality environments | VR version rated excellent in attractive-ness compared to traditional top benchmark | Accuracy of spatialization is based on natural distances rather than approximations | Maximum number of audio sources supported was 253 by the underlying software | Subjective evaluation indicated no significant difference between the user experience between VR and PC | Subjective evaluation indicated no significant difference between the user experience between VR and PC |
| (Trambouze et al., 2024) | Mini-CA provides efficient implementation and visualization of two-dimensional cellular automata | Graphical user interface allows users to set initial parameters and obtain results | Structure of lattice supports the computation of lattices of arbitrary sizes in space | Nested, checkerboard model generator allows users to set initial parameters and obtain results | Nested, checkerboard model generator allows users to set initial parameters and obtain results | Graphical user interface allows users to set initial parameters and obtain results |
| (Shahin & Beigi, 2026) | 3D Neural Cellular Automata synthesizes while maintaining robust generalization across a variety of voxel patterns | Model enables efficient training and sustaining complex structures in 3D at real time | Architecture supports learning and sustaining complex structures in 3D at real time | 3D extension of cellular automata allows for scaling to volumetric data | Framework integrates machine learning with mechanistic modeling to learn complex spatiotemporal dynamics | Framework integrates machine learning with mechanistic modeling to learn complex spatiotemporal dynamics |
| [29] | Simulator created using an Art-type head-mounted display for 3D cellular automata | Visualized 3D version of Perose using head-mounted display technology | Real-time simulation of various 3D CAs including life games in AR environments | Supports simulation of various 3D cellular automata and complex quasi-periodic structures | Head-mounted display provides immersive visualization to 3D cellular automata | Head-mounted display provides immersive visualization to 3D cellular automata |
| (Gobron et al., 2019) | GPU-accelerated method computes CA close to a thousand times faster than CPU | Real-time rendering of cellular automata applied to hexagonal grids on graphics hardware | Novel encoding transmits large CA key-codes to the graphics card in real time | Efficiently identifies emerging behavior from large data sets on different hardware | Flexible model allows for easy identification of emerging behaviors in large data sets | Flexible model allows for easy identification of emerging behaviors in large data sets |
| (Yu, & Chang, 2023) | GPU-based cell parallelization environment of up to 7695 cells over GPU | Maintains simulation accuracy while significantly improving efficiency for indoor concentration modeling | Parallelization of transport mechanism behavior performs better on GPU instead of sequentially on CPU | Simulations performed on 19 PC with Intel UHD Graphics 630 graphic card | Parallelized CA approach processes real-time 3D indoor air distribution modeling | Parallelized CA approach processes real-time 3D indoor air distribution modeling |
| (Braber et al., 2026) | Built-in visualization enabled efficient real-time computation through programmable processing | Offers speedup of two orders of magnitude in operations baseline CUDA implementations | Cellular automaton places simple CA functions on CPU and GPU simultaneously | Versatile CA approach is implemented for 10 different models to demonstrate performance | Maintains speed and ease of use for the underlying cellular automata | Maintains speed and ease of use for the underlying cellular automata |
| [16] | Tensor accelerators contribute to speedups that extend the entire computation | GPU tensor core approach accelerates CA with weighted summation of neighboring cells | GPU tensor core approach accelerates CA with weighted summation of neighboring cells | Reaches speedups of up to 101 times over a GPU baseline implementation | Most energy efficient approach for neighborhood radius greater than or equal to four | Most energy efficient approach for neighborhood radius greater than or equal to four |
| (Zhang, 2026) | Graph-based representation addresses limitations of computationally complex CA simulations | Dynamic rule adaptation mechanism continuously updates parameters based on observed system dynamics | Graph-based representation addresses limitations of computationally complex CA simulations | Effectively handles complex rule sets and large spatial scales in CA systems | System responds to evolving patterns and achieves greater accuracy in simulating behavior | System responds to evolving patterns and achieves greater accuracy in simulating behavior |
| [23] | Mini-CA kernels enhance parallel throughput and enable input scalability for visualization | Achieves state-of-the-art accuracy while significantly reducing computational latency compared to baseline | Decomposes monolithic CA systems into specialized, computationally efficient components | Extends CA applicability beyond binary inputs to process spatio-temporal images | Integrates directly into CNN architectures replacing standard operators with scalable CA-based processing | Integrates directly into CNN architectures replacing standard operators with scalable CA-based processing |
| (Zhang, 2026) | Dynamically adjusted rules allow systems to maintain compact and accurate geometric representation | Adaptive mechanism allows system to react to changes in real-time geometric problems | CA system where each cell represents a geometric element for efficient processing | Efficiently processes evolving geometric environments which datasets in dynamic environments | Offers a flexible framework for diverse geometric applications including robotics and computer vision | Offers a flexible framework for diverse geometric applications including robotics and computer vision |
Table 1. Summary of the reviewed studies across five performance dimensions.
| Study | Computational Throughput Efficiency | Frame Rate Stability | Performance | Latency Overhead Reduction | Scalability Limit Capacity | Interaction Fluidity Assessment |
| (Svetlithny & Banas, 2026) | Linked-list acceleration achieves high-use performance among contained users, particularly for real-time data transfer into the system. | Memory access conflicts eliminated by separating information transfer into separate buffers. | Parallel CPU and GPU execution reduces computational time for large-scale simulations. | Parallel CPU and GPU execution reduces computational time for large-scale simulations. | Demonstrates good scalability for CPU and GPU implementations in 3D simulations. | Enables safe parallel processing of multiple linked lists while preserving simulation continuity. |
| (Xu et al., 2026) | Voxel-native GPU-parallel architecture supports simulations of millions of voxels within active environments. | Stable transport behavior and encounter rates with CFD benchmark simulation results. | Supports urban-scale 3D city models, training up to 13.9 million active voxels. | Interactive runtime performance suitable for building management and monitoring applications. | Supports urban-scale 3D city models, training up to 13.9 million active voxels. | Provides efficient voxel-based approximations of dispersion suitable for interactive environments. |
| (Heinz et al., 2017) | High frame rate of 1000 FPS achieved for large-scale flow simulation applications. | Frame-rate optimization allows for high frame rates for complex applications. | Support of 1,763 cells due to parallelization into eight GPUs in simulation. | Short computation time makes the simulation feasible for large applications. | Supports a range of resolutions for rendering and 3D boiling and convection simulations. | Retains high simulation flow for 3D applications with computationally intensive environments. |
| [9] | Programmable graphics hardware used for real-time visualization of dynamic simulation. | Pixel-level programming implements next-state computations on lattice machine neighbors. | Stores lattice values in a texture to produce interactive visual simulations of phenomena. | Pixel-level programming implements next-state computations on lattice machine neighbors. | Stores lattice values in a texture to produce interactive visual simulations. | Integrated into interactive 3D graphics applications with simulation and experimental environments. |
| [10] | Implementation requires nine passes per iteration for the 3D boiling simulation. | Runs at 45 frames per second in a real-time environment built on a game engine. | Trade-off between optimal performance and flexibility in the CMLab framework design. | Trade-off between optimal performance and flexibility in the CMLab framework design. | Supports a range of resolutions for rendering and 3D boiling and convection simulations. | Interactive framework allows constructing simulations with familiar game-engine operations. |
| [1] | Sketch-based discrete element texture synthesis used to paint large-agent environments. | Enables low levels of interactivity for simulation and exploration of agents. | Allows users to pause the simulation and modify agents with a UI-based tool. | Enables low levels of interactivity for simulation and exploration of agents. | Supports a large number of agents in 3D environments for interactive painting. | Sketch-based generative brushes allow users to manipulate agents and create particle effects in real time. |
| [17] | Allows for interactive analysis of 3D scalar and vector fields in VR. | Large and analyze specific regions of large-scale simulation data in real time. | Designed for large-scale simulation data visualization in virtual reality environments. | HIMD provides cost-effective alternative to room-sized CAVE displays systems. | Designed for large-scale simulation data visualization in virtual reality environments. | Enables analysis of 3D fields through Unity and OpenXR, enabling interaction. |
| (Gringer et al., 2024) | Image-based approach integrates scientific data exploration into VR without explicit porting. | Enables rendering of VR-based scientific data exploration with varied rendering techniques. | Separation of concerns enables reuse of framework with existing software frameworks. | Separation of concerns enables reuse of framework with existing software frameworks. | Facilitates integration of visualization algorithms from software frameworks into VR. | Enables collaborative VR environment for exploration and visualization of scientific data. |
| [15] | Real-time rendering and automated frame synthesis enhance student engagement and practical understanding. | Measurable improvements in visual learning and interaction efficiency compared to traditional approaches. | Cloud-based accessibility and interactivity bring advanced real-time rendering into educational settings. | Cloud-based accessibility and interactivity bring advanced real-time rendering into educational settings. | Modular architecture supports future expansion and collaborative learning environments. | Enables learners to interact with virtual environments and execute simulations through immersive environments. |
| [30] | GPU-based parallel processing achieves sophisticated simulation detection through a real-time processing framework. | Achieves stable real-time frame rates comparable to Stanford Bunny and Armadillo. | Storing collision data in GPU cache improves FPS by 117 percent. | Robust, scalable framework for real-time physics simulations in extended reality applications. | Employs AABB-based bounding volume hierarchy for precise triangle-level intersection. | Employs AABB-based bounding volume hierarchy for precise triangle-level interaction in XR. |
| [33] | Achieves throughput rates up to 1680 particles per second in large-scale simulations. | Maintains consistent 5.7 to 6.0 ms frame times across varying particle counts. | Novel Fusion Count Sort with Parallel-Prefix Scan optimizes neighborhood fluid simulation with up to 1 million particles in Unity. | Maintains consistent 5.7 to 6.0 ms frame times across varying particle counts. | Supports real-time fluid simulations with up to 1 million particles in Unity. | Maintains interactive frame rates and achieves 60 FPS for large-scale fluid simulations. |
| [18] | Dedicated cellular automata pipeline designed for real-time high-performance simulation. | Bypasses bottleneck by sending only a subset of state data into the simulation. | Torchlight concept allows simulation of discrete events across multiple scales. | Bypasses bottleneck by sending only a subset of state data into the simulation. | Enables larger and more fine-grained simulations through a neural network framework for games. | Interfaces with a 3D game engine to translate raw simulation data to graphics. |
| (Ahmed, 1.d) | Scenario-based design explores model development, modification, validation, and simulation. | Scenario-based design explores model development, modification, validation, and simulation. | Scenario-based design explores model development, modification, validation, and simulation. | Scenario-based design explores model development, modification, validation, and simulation. | Supports larger-scale programs for emergency and disaster simulation in large-scale environments. | Laboratory-scale virtual agent model to study visual agent interaction. |
| (Zhang, 2026) | WebGL-based framework renders dense arrays of over 4,000 dual-encoded physical and biological entities. | Significant negative correlation between frame rate and tween-to-DT interaction and fluidity. | High-performance simulation framework supports dense array of physical entities. | High-performance simulation framework supports dense array of physical entities. | Non-STEM participants achieved 62.2 percent accuracy on complex tensor geometry. | Non-STEM participants achieved 62.2 percent accuracy on complex tensor geometry. |
| [26] | Engine suites consistent rendering across desktop and web environments. | Full support for OpenXR and experimental WebGPU bindings for immersive applications. | WebAssembly compilation and rendering engine support cross-platform deployment. | Cross-platform graphics engine supports WebGPU across desktop and web environments. | Flexible foundation for future research, education, and experimental development in immersive graphics. | Flexible foundation for future research, education, and experimental development in immersive graphics. |
| Study | Computational Throughput | Frame Rate Stability | Latency Overhead Reduction | Scalability Limit Capacity | Interaction Fluidity Assessment | |
| [2] | Speeds up simulations up to 2,000 times faster than traditional methods | Modular design through a user-friendly interface supports discrete and asynchronous | High-performance open-source library designed to accelerate cellular automata | Supports any number of dimensions for cellular automata research and modeling | Offers cutting-edge performance and flexibility through a wide range of tools | |
| [44] | Achieves 8.15 times acceleration compared to traditional OpenFOAM CFD engine, and GTS data ensures efficient parallelization | Tight integration of CFD model, game engine, and GTS data ensures efficient parallelization | Expanded spatial extent by incorporating data from multiple GIS sources for urban-scale simulations | Expanded spatial extent by incorporating data from multiple GIS sources | Ensures user interactivity, scene modularity, and intuitive visualization for facilities planning | |
| [24] | Immersive software accelerates visualization and exploration of 3D scenes, arrays, and meshes | Multi-user capabilities allow multiple users to share data and visualize together | Dynamically load and manipulate scientific models to give them structure of data | Dynamically load and manipulate scientific models to give them structure of data | Unique integration combining VR, UI, and AI-driven object modeling for scientific visualization | |
| (Czapczyk et al. (Dzedzic, 2026) | Multithreaded rendering with multithreaded rendering and optimized for frame rate in VR | Best overall metrics observed for configuring multithreaded frame rate and minimizing pass rendering | Use of multithreading led to reduction in average GPU utilization | Tested four versions of two Unity applications using Meta Quest Pro headsets | Performance metrics compared across four versions, enabling valid configurations for VR applications | |
| (Hladik et al., 2026) | Achieves loading times and stable rendering performance across different virtual systems | Synchronization between physical and virtual systems | Implemented three.js and WebXR for browser-based performance with specialized software | Enables developers to influence system performance through AR/VR interfaces | Enables users to influence system performance through AR/VR interfaces | |
| [28] | Interactive web-based platform for real-time demonstration of cardiac dynamics | Students and researchers can observe how parameters and wave dynamics change | New bus building from model coupled each representing a model of cellular | Simplified cellular automaton model used for teaching excitable-media | High engagement reported in pilot classroom deployments with undergraduates | |
| [25] | Unity supports real-time simulations for biological and medical research visualization | Blender excels in making highly accurate static models for biological processes | Unreal Engine provides stunning visuals for detailed 3D biological models | Comparative analysis of three popular tools for creating detailed 3D visuals | Explored how the three tools help scientists create detailed 3D visuals of cells | |
| (Zhang, 2026) | Novel synchronization strategy based on Bifurcated fault tolerance guarantees accuracy and robustness | Employs CA to model system dynamics at a local, granular level | Novel synchronization strategy based on Bifurcated fault tolerance guarantees accuracy and robustness | Scalable simulation of complex systems to model urban dynamics and traffic flow | Ensures consistency among distributed simulations and nodes using consensus algorithms | |
| [3] | Keeps real-time speed and responsiveness during simulation | Execution must be true immersive experience through the XR interaction and orchestration | Execution must be true immersive experience through the XR interaction and orchestration | Supports a large number of particles while maintaining bandwidth and flow | Risers modelled to guide module placement to make use of flexible and efficient environments | |
| (Xu et al., 2026) | Voxel-native parallel memory layout enables constant-time neighbor access and efficient updates | Predictable runtime scaling and practical performance for domains exceeding 3D models | Physics-informed GPU-accelerated framework for running 3D free propagation simulations | Evaluated model and test across high-performance computing systems | Enables physically grounded simulation without relying solely on empirical models | |
| [38] | Execution time reduced by more than 43 percent compared to conventional QCA methods | Convolution function in DL library to calculate neighborhood effect efficiently | GPU-convolution CA model leverages hardware and parallel processing | High-performance CA model for parallel simulation based on GPU | Efficient application programming can handle the tasks of interest for users | |
| [13] | Median latency of 470 ms and 95th-percentile latency under 812 ms | Interactive frame rates to production workloads for mobile performance constraints | End-to-end cyber-physical architecture and spatial inference | Spatializes localized environmental sensing at city scale using 20 weather stations | Walk-up access via QR or URL on common mobile devices without installation | |
| (Cao et al., 2011) | Segmentation accelerated by GPU for real-time rendering of large volumes | Evolution can be observed and guided through volume rendering with high precision | User interface augmentation method required fewer computations and high precision | Supported by pyramid in higher level resolution and data volume | Labs integrated in image-generated higher-level display | |
| [12] | WebXR consistently outperforms default XR Interaction Toolkit in frame rates in multiple configurations up to 78 FPS | Achieves significantly higher frame rates in multiple configurations up to 78 FPS | User interface augmentation method required fewer computations | Export plugin and follows component-based interaction | Enables performant and accessible VR training applications on the web | |
| (Zhang, 2026) | Novel parallel algorithm significantly enhances simulation speed and scalability | Rapidly tests and evaluates cellular automata simulations in distributed computing system | Distributed simulation workload across multiple processors for faster exploration of parameter spaces | Overcomes limitations of computational complexity in scaling to larger parameter spaces | Demonstrates significant improvement in simulation speed compared to traditional methods |
Table 1 (continued). from previous page
Critical Analysis and Synthesis
The current body of literature demonstrates a robust shift toward GPU-accelerated architectures and cross-engine interoperability to overcome the computational bottlenecks inherent in real-time 3D cellular automata (CA) simulations. While recent frameworks achieve significant performance gains through parallelization and novel memory layouts, there remains a notable tension between maintaining high-fidelity volumetric simulation and ensuring the low-latency responsiveness required for immersive extended reality (XR) environments.

Figure 2. Unified framework for scalable, interactive 3D CA systems must prioritize the integration of hardware-agnostic parallelization strategies with standardized interaction toolkits to bridge the gap between scientific simulation and user-centric exploration.

Figure 3. Agreement and divergence across the reviewed studies on 3D cellular automata in extended reality. For each comparison criterion, the figure summarizes the points of consensus, the points of divergence (with supporting references), and the potential explanations for the observed differences.
METHODOLOGY
The framework is designed around the premise that a real-time CA-XR system is a pipeline, not a single simulation kernel. Its objectives are to (i) preserve the semantics of the CA transition model, (ii) make computation portable across hardware classes, (iii) minimize unnecessary data copies and synchronization, (iv) keep rendering responsive when simulation and display rates differ, (v) allow different XR engines to consume the same simulation stream, and (vi) expose meaningful tools for volumetric exploration.

Figure 4. Unified CA-XR architecture
Five-layer architecture
Layer 1 — Voxel and Rule Management. This layer owns the spatial grid, cell-state schema, neighbourhood definition, boundary conditions, transition-rule identifier, initial conditions, and simulation parameters. It supports dense grids for regularly occupied volumes and sparse or chunked representations when the active region is limited. A grid descriptor contains dimensions, physical cell spacing, origin, axis convention, state type, and boundary policy. The rule interface is independent of the compute backend so that a rule can be executed on CPU or GPU without changing its scientific definition.
Layer 2 — Parallel CA Computation. This layer executes the transition function. For a synchronous automaton, the state at step is computed from the state at step using separate input and output buffers. This ping-pong arrangement avoids reading values that have already been updated in the same step. Backend implementations may include CPU multithreading, conventional GPU kernels, bit-plane or bitwise kernels, tensor-core approaches where the rule structure permits, or other available parallel mechanisms. The framework should not force tensor cores or a particular API; backend capabilities are queried and benchmarked before selection [2, 16] (Brabec et al. 2026; Svyetlichnyy & Banaś 2026).
Layer 3 — Interoperability Middleware. This layer separates the scientific solver from the XR engine. It manages the exchange contract, resource ownership, state versioning, timestamps, buffer availability, and synchronization. Possible transport mechanisms include shared memory, GPUcompatible shared resources, inter-process communication, or a network transport when clients are distributed. The protocol should be transport-neutral: the semantic message remains the same even when its physical transport changes. This principle is consistent with middleware approaches that connect scientific visualization systems and VR environments without requiring all algorithms to be reimplemented inside one application ([5]).
Layer 4 — Visualization and Rendering. This layer converts simulation state into visual representations. It may use instanced geometry, volume rendering, slice planes, surface extraction, transfer functions, or hybrid representations. The rendering path should avoid unnecessary CPU readback when a compatible GPU resource can be shared. It should also support visibility-aware prioritization and visual LOD. Importantly, rendering LOD changes the visual representation, not the simulation state, unless a separately declared approximate simulation policy is enabled.
Layer 5 — XR Interaction. This layer receives headset, controller, hand, gaze, or desktop input and translates it into high-level commands. Commands include selecting a region, moving a slice plane, changing a visual transfer function, pausing or stepping the simulation, modifying parameters, placing annotations, and applying a controlled intervention. Each intervention is timestamped and validated by the simulation layer before being committed. The interaction layer also supports navigation and inspection tools such as 6-DOF manipulation, focus-and-context views, and region-of-interest controls.
Conceptual data flow
The normal execution cycle follows this sequence:
The rule manager validates the grid descriptor, neighbourhood, boundary conditions, and parameter set.
The scheduler chooses a compute backend and allocates the required state buffers.
The CA engine computes one or more state transitions into an output buffer.
The middleware publishes a versioned state descriptor and makes the associated buffer available to the renderer.
The visualization layer updates the visible representation using the newest complete state that meets its freshness policy.
The XR layer renders the scene and records display and interaction timestamps.
User commands are validated, queued, and applied at a defined simulation boundary to preserve deterministic update semantics.
This cycle separates the simulation clock from the display clock. The simulation may advance at a fixed step, while the XR display runs at the device refresh rate. The renderer can display the latest completed state without forcing the simulation to complete a new update during every display frame. The interface must make the displayed state time visible when the difference between simulation time and wall-clock time becomes meaningful.

Figure 5. Asynchronous simulation-to-display data flow
Formal CA model
Let the three-dimensional lattice be
Each cell has a state at discrete simulation step , where is the state space and denotes the discrete simulation step:
Let denote the neighbourhood of cell , and let contain rule parameters. A synchronous CA update is represented as
The function is independent of the selected execution backend. For a standard synchronous model, all output cells at step are computed from the same input state at step . Boundary conditions are handled by an explicit policy, such as fixed, periodic, reflective, or domain-specific boundaries. The framework must record the selected policy as part of the grid and rule metadata.
The computation cost per step depends on the number of updated cells, neighbourhood size, state representation, and transition function. A simple update-work measure is
where is the set of cells updated at step , is the neighbourhood size, and is a workload descriptor for the transition rule. This descriptor is not necessarily a universal operation count; it is a way to distinguish benchmarks with different rule complexity. For sparse simulations, may be less than the total number of cells, but the active-region policy must preserve the intended model semantics.
At initialization, the scheduler collects a capability profile: available compute backends, supported memory-sharing options, device memory budget, parallel execution limits, and current resource availability. It then selects a compatible backend and data representation. Backend selection should consider total pipeline cost, not kernel time alone. A kernel that is faster in isolation may be slower end-to-end if its output requires expensive readback or conversion before rendering.
The initial implementation should support a clear reference backend and at least one GPU backend. Optional optimized kernels—such as bit-plane encoding or tensor-core execution—should be enabled only when the transition function can be expressed correctly in the corresponding representation. The selected kernel must pass equivalence tests against the reference implementation for the same initial states, boundary conditions, and number of steps. This requirement prevents an optimization from silently changing the CA rule.
For large volumes, the grid may be divided into spatial chunks. Chunking can reduce allocation pressure and allow visibility-aware transfer, but it introduces boundary exchange and scheduling overhead. Therefore, chunk size should be treated as a benchmark parameter rather than a fixed design constant. A double- or triple-buffered state exchange can prevent the rendering thread from waiting for a buffer that is being updated. Each buffer should carry a monotonically increasing version number and simulation timestamp.
Middleware contract and interoperability
The middleware should define a versioned data contract containing at least the fields in Table 1.
| Field | Meaning | Validation requirement |
| schema_version | Contract version | Unknown versions are rejected or explicitly negotiated |
| grid_dimensions | Grid size along each axis (, , ) | Positive integer dimensions |
| cell_spacing | Physical spacing along each axis | Units and coordinate convention specified |
| Field | Meaning | Validation requirement |
| grid_origin | Spatial origin | Coordinate system declared |
| state_type | Integer, Boolean, categorical, or numeric state | Must match the consumer representation |
| neighborhood_id | Neighbourhood definition | Identifies offsets and radius |
| rule_id and rule_version | Transition function identity | Enables reproducibility and compatibility checks |
| boundary_policy | Boundary condition | Must be explicit |
| step_index | Discrete simulation step | Monotonically increasing within a run |
| simulation_timestamp | Time associated with the state | Clock domain and units specified |
| buffer_handle or payload | State storage or serialized data | Ownership and lifetime defined |
| state_hash (optional) | Integrity or equivalence check | Computed consistently when enabled |
Table 1 (PDF p. 13). Versioned CA-XR data contract.
The contract should distinguish metadata from the state payload. A consumer should be able to determine what a buffer means without inferring its dimensions or units from engine-specific conventions. When zero-copy sharing is available, the middleware transfers a resource handle and synchronization primitive rather than copying the entire volume. When it is unavailable, the transport falls back to a documented serialization or copy path. The benchmark must measure the overhead of each path separately.
The rendering layer should prioritize the user’s visible region while retaining access to the complete state. A region-of-interest policy can allocate more rendering detail to cells near the current focus, while distant cells use a lower-cost visual representation. The policy must be reversible and must not discard simulation state. If compute adaptation is introduced, the framework must label it as approximate and assess its effect on the automaton’s behaviour.
The interaction layer should use commands with explicit semantics rather than direct modification of internal GPU buffers. For example, a user may select a region and request a parameter change. The command is placed in a queue and applied at a defined simulation boundary. This makes the intervention traceable and helps reproduce a session. Continuous visual controls, such as opacity or colour mapping, can be applied in the rendering layer without modifying the CA state.
For collaborative use, one authoritative simulation instance or a clearly defined distributed consistency model should own the canonical step sequence. Clients exchange interaction commands and state-version notifications rather than independently advancing divergent simulations without reconciliation. The protocol must define command ordering, conflict handling, late-joining clients, and recovery after packet loss. This extension is compatible with collaborative XR and digital-twin research, but it requires dedicated validation and is not assumed to be solved by the base architecture [8, 24, 34].
Implementation Strategy
A practical implementation should be developed in incremental stages:
Stage A :Reference CA engine. Implement a CPU reference version with explicit rule definitions, grid metadata, boundary handling, deterministic initialization, and state serialization. This version is the correctness oracle for optimized implementations.
Stage B :GPU acceleration. Add a GPU backend using a double-buffered update model. Validate each kernel against the CPU reference and record kernel execution time separately from transfer time. Add specialized encodings only after correctness and workload suitability have been demonstrated.
Stage C :Middleware and state exchange. Implement a transport-neutral descriptor and at least one transport mechanism. Measure publication, transfer, synchronization, and buffer acquisition separately. Ensure that the renderer can detect stale, incomplete, or incompatible states.
Stage D :XR visualization. Integrate the middleware with one XR engine and implement a minimal set of visual encodings: volumetric display, slicing, selection, and state/time inspection. The rendering loop must not block on a CA step.
Stage E : Interaction and portability. Add manipulation, parameter controls, annotation, and a second engine or browser-based client to test whether the exchange contract is genuinely independent of the first engine. A single-engine implementation can validate functionality but cannot establish cross-engine interoperability.
Stage F :Benchmarking and user evaluation. Run computational benchmarks, XR frame-time tests, correctness checks, and task-based interaction studies. Report all device and configuration details.
Algorithm 1 outlines the reference execution cycle, in which user commands are applied at step boundaries, the CA state is updated through ping-pong buffers, and each completed state is published asynchronously to the renderer.
Algorithm 1 Synchronous CA–XR execution cycle
Input: Grid descriptor , rule with parameters , boundary policy , device capabilities , workload profile , visibility policy
Output: Versioned state descriptors; timestamp and resource-counter records
1: 2: 3: 4: 5: 6: while simulation is running do 7: 8: 9: 10: compute completion or fence signal 11: ; 12: 13: non-blocking for the XR frame loop 14: if then 15: 16: 17: end if 18: 19: end while
Evaluation
The evaluation has two purposes. First, it assesses whether the proposed architecture addresses the limitations identified in the literature. Second, it defines the measurements needed to test the architecture after implementation. Because no executable implementation or new measurements are supplied with this manuscript, this section reports an analytical evaluation framework, not empirical results. No numerical performance advantage is attributed to the proposed framework at this stage.
Evaluation dimensions and metrics
Computational throughput. The number of cell updates per second is calculated as
where is the number of updated cells per step, is the number of simulated steps, and is the measured wall-clock time. The result should be reported as cell updates per second or million cell updates per second (), with the grid size, active-cell ratio, transition rule, and boundary policy stated. Kernel time and end-to-end time should be reported separately. Step-time stability. Report mean, median, 95th percentile, and standard deviation of CA step time. The 95th percentile is important because occasional long updates can create visible stalls even when the mean is acceptable. Rendering performance. Report average FPS, frame-time median, frame-time 95th percentile, missed-frame ratio, and frame-time variance. Average FPS alone is insufficient because it can hide intermittent stutter. XR target rates must be selected according to the actual device and runtime rather than assuming that a single frame-rate threshold is suitable for all headsets.
Latency. At least three latency measures should be distinguished: (i) command-to-commit latency, from user action to application of the command at a simulation boundary; (ii) state-to-visible latency, from completion of a CA step to its presentation in the rendered scene; and (iii) input-to-photon or motion-to-photon latency, where the device and instrumentation permit its measurement. Each measure should specify clock synchronization and timestamp location.

Figure 6. XR frame-time and latency behaviour
Memory use. Record CPU memory, GPU memory, peak allocation, transfer-buffer size, and memory growth over long runs. Dense and sparse representations should be compared under equivalent active-state distributions.
Scalability. Evaluate multiple grid dimensions and active-cell ratios. Strong scaling can be summarized using speedup and parallel efficiency,
where is the run time with one processing unit, is the run time with processing units, and the meaning of (threads, compute units, or devices) is stated. For heterogeneous platforms, compare end-to-end time under clearly described resource constraints rather than presenting raw device counts as equivalent.
Correctness and reproducibility. Compare optimized backends against the reference implementation using exact state equality for deterministic integer-state CA, or an explicitly defined tolerance for floating-point state. Report divergence over multiple steps, boundary consistency, deterministic repeatability, and preservation of rule semantics.
Interoperability. Measure successful schema negotiation, state-transfer time, serialization overhead, synchronization delay, dropped or stale state ratio, and correctness of coordinate and state interpretation across engines. Compatibility should be demonstrated with actual adapters; a conceptual ability to connect engines is not proof of interoperability.
Interaction quality. Use task-level measures such as task completion time, selection error, parameter-adjustment error, navigation distance, number of corrective actions, and a validated usability questionnaire. User studies should specify participant count, expertise, tasks, training, and desktop comparison conditions. Performance counters and subjective ratings should be reported separately.

Figure 7,8. Memory Footprint and Scalability
Proposed benchmark scenarios
The following scenarios form a proposed benchmark suite (Table 2). They are experimental configurations, not previously measured results.
| Scenario | Grid / workload | Main stressor | Required measurements |
| B1: Dense baseline | Dense cubic grids at , , , and cells | Growth in total cell count | Throughput, step time, CPU/GPU visible latency |
| B2: Sparse activity | Fixed grid with active-cell ratios of 10%, 25%, 50%, and 100% | Sparse-versus-dense representation | Throughput, memory, chunk scheduling overhead |
| B3: Neighbourhood scaling | Same grid with at least three neighbourhood radii or neighbourhood sizes | Increasing neighbourhood work | Step time, throughput, backend suitability |
| B4: XR rendering load | Identical simulation with several visual encodings and view distances | Rendering and fill-rate pressure | FPS, frame-time percentiles, GPU utilization |
| B5: Middleware transfer | Local shared-resource path and serialized-copy path | Data exchange overhead | Transfer time, state freshness, memory copies |
| B6: Long run | Fixed workload | Thermal drift | FPS, step time |
| B7: Interaction tasks | Region selection, slicing, parameter editing, pause/step, annotation | Human interaction and navigation | Completion time, errors, corrective actions |
Table 2. Proposed benchmark suite.
For a fair comparison, each benchmark should use identical initial states, rule parameters, number of simulation steps, and boundary conditions across implementations. Each configuration should be repeated after a warm-up period. Report median and percentile statistics, not only the best observed run. A second round should repeat selected scenarios on a standalone XR device and a desktop-class system to expose the effects of different power and memory budgets.
Analytical comparison of architectural options
Table 3 summarizes the expected strengths and risks of the main design options. The table is an analytical comparison derived from the reviewed themes; it is not a measured ranking of implementations.
| Design option | Potential strength | Principal risk or limitation | Evidence to collect |
| CPU reference execution | Transparent baseline and easier debugging | Limited parallel throughput for large grids | Reference correctness and step time |
| Conventional GPU kernels | High data parallelism for independent cell updates | Memory bandwidth, transfer, and device dependence | Kernel and end-to-end throughput |
| Bit-plane / bitwise encoding | Efficient state packing and parallel bit operations for compatible rules | Rule-specific complexity and conversion overhead | State equivalence, memory use, speedup |
| Tensor-core execution | Potential acceleration for suitable weighted-neighbourhood formulations | Not applicable to every transition rule; precision and mapping constraints | Rule-specific accuracy and performance |
| Sparse or chunked voxel storage | Avoids processing inactive regions and can support large spatial domains | Indexing, chunk boundaries, and irregular access overhead | Active-ratio scaling and memory footprint |
| Middleware-separated XR | Looser coupling between solver and visualization engine | Synchronization and transport overhead | Cross-engine state consistency and latency |
| Integrated single-engine implementation | Simpler deployment and potentially fewer data-transfer stages | Engine lock-in and reduced solver portability | Porting effort and portability tests |
Table 3. Analytical comparison of architectural options.
The table suggests that no single execution or integration strategy is universally optimal. The proposed framework therefore emphasizes an explicit abstraction boundary and workload-aware selection rather than prescribing one acceleration technique for all CA models.
Ablation tests should isolate the contribution of each architectural mechanism. The proposed tests are:
A1: Disable asynchronous state exchange and compare frame-time stability and state-to-visible latency.
A2: Disable region-of-interest rendering and compare rendering cost at increasing volume sizes.
A3: Replace the optimized backend with the CPU reference and quantify the compute contribution separately from middleware overhead.
A4: Replace shared-resource exchange with serialization and copying to measure transfer cost.
A5: Disable chunking or sparse processing and compare memory pressure and throughput across active-cell ratios.
A6: Remove command batching and compare interaction responsiveness and simulation determinism.
An ablation should change one factor at a time while holding the remaining conditions constant. Interactions between factors can be studied in a later factorial design.
Evaluation outcome expected from the proposed design
(Originally Section 7.8.) The analytical evaluation supports a set of testable expectations, not confirmed results. First, GPU acceleration is expected to reduce CA step time for workloads with sufficient parallelism, but total XR responsiveness will depend on transfer and rendering costs. Second, explicit middleware is expected to improve portability and maintainability, while adding measurable synchronization and data-exchange overhead. Third, asynchronous state publication is expected to reduce blocking in the XR frame loop, but it may increase state age under sustained simulation overload. Fourth, visibility-aware rendering is expected to lower rendering cost for large volumes, but it must not be mistaken for a change in simulation fidelity. Fifth, a rule-independent architecture is expected to simplify domain adaptation, although rule-specific optimized kernels will still require individual validation. These expectations define the hypotheses that the implementation and benchmark study should test.
Discussion
The proposed architecture responds to a recurring fragmentation in the reviewed literature. GPU acceleration, volumetric simulation, immersive visualization, and cross-platform XR have each advanced, but their integration introduces costs and correctness requirements that cannot be inferred from the performance of any one component. The framework therefore places equal emphasis on execution and coordination. A high-throughput CA kernel is useful only if its outputs can be transferred, interpreted, and displayed without unacceptable delay; an XR interface is useful only if the visual state remains traceable to a well-defined simulation step.
A central design implication is that hardware abstraction must be workload-aware rather than purely syntactic. A single API can conceal backend differences, but it cannot make all devices computationally equivalent. The framework should expose device capabilities and select among valid implementations while retaining a reference path. Specialized representations such as bit planes or tensor-core computation can be valuable for compatible rules, but they should remain optional backends rather than mandatory assumptions [16] (Brabec et al. 2026). This allows the architecture to benefit from new hardware without excluding devices that lack a particular feature.
The middleware layer is equally important. Interoperability should mean more than the ability to open the same file or render a similar scene in two engines. It requires preservation of grid dimensions, coordinate systems, time-step identity, transition-rule metadata, and state consistency. MINT demonstrates the value of loosely coupling visualization frameworks and VR environments, while WebGPU-based engines and WebXR interaction toolkits provide additional cross-platform opportunities [5, 12, 26]. The proposed contribution is to make these concerns explicit for CA state exchange.
Another important implication concerns the difference between visual LOD and simulation LOD. A renderer can reduce visual complexity without changing the underlying cellular state. By contrast, reducing the number of simulated cells, merging regions, or changing update frequency can alter the automaton’s dynamics. These strategies should be classified separately and subjected to different validation procedures. This distinction is especially important for scientific applications, where a visually plausible output is not necessarily a scientifically equivalent result.
Finally, the evaluation framework treats human interaction as a first-class dimension. Immersive systems should not be justified by frame rate or visual appeal alone. Task-based assessment is needed to determine whether spatial manipulation and navigation improve the user’s ability to inspect, understand, and modify complex state spaces. The comparison with desktop workflows should therefore use equivalent tasks and objective outcomes rather than relying only on preference ratings. Existing work on VR exploration of 3D CA and large scientific datasets provides a foundation for such studies, but the interaction hypotheses of the proposed architecture remain to be tested [20, 24] (Arevalo et al. 2022).
Limitations
This paper has several limitations. First, it is based on a curated reference set supplied for the study rather than a fully documented database search. The search sources, exact search strings, screening records, exclusion decisions, and independent quality assessment are not available; consequently, the review should not be interpreted as exhaustive or PRISMA-compliant.Second, the proposed framework is conceptual. No complete software implementation, XR deployment, or new performance measurement is reported. The architecture’s expected benefits—including improved portability, lower synchronization overhead, and more stable frame times—must be verified empirically. The analytical evaluation defines the required metrics but cannot substitute for experimental results.
Third, the reviewed studies use different CA rules, neighbourhoods, hardware, programming models, grid sizes, and measurement procedures. Their performance values cannot be pooled into a single comparative ranking without normalization and access to compatible experimental details. A reported speedup in one workload should not be generalized to every three-dimensional CA model.Fourth, the architecture does not prescribe a single XR engine, graphics API, or compute backend. This improves conceptual portability but leaves implementation choices open. Actual compatibility will depend on the device runtime, graphics and compute APIs, memory-sharing support, and application constraints.
Fifth, the user-interaction model is not validated through a controlled user study. Claims about cognitive offloading, usability, learning, or scientific insight must therefore remain hypotheses until tested with appropriate participants and tasks.
Finally, multi-user synchronization, learned transition rules, and domain-specific scientific validation are treated as extensions rather than fully specified subsystems. Each requires additional design and evaluation. These limitations are consistent with the identified needs for hardware-agnostic scaling, standardized metrics, improved navigation, collaborative synchronization, and rule adaptation.
Future work should proceed along several connected directions.
Hardware-agnostic execution. Implement a backend abstraction that selects CPU, GPU, or specialized kernels according to device capabilities and workload structure. The selection policy should be based on measured end-to-end performance, memory pressure, and energy or thermal constraints rather than kernel speed alone. Standalone mobile XR devices should be included as first-class targets.Standardized CA-XR benchmark suite. Publish a suite containing reference rules, initial conditions, grid configurations, active-cell distributions, correctness tests, and measurement scripts. The suite should record throughput, frame-time distributions, latency, memory, portability, and interaction metrics. This would make it possible to compare frameworks under reproducible conditions.
Cross-engine middleware. Implement at least two independent XR adapters around the same CA state contract. A useful next step is to connect a scientific solver to both a native XR engine and a WebXR/WebGPU client, then measure transfer overhead and state consistency. The contract should be versioned and should include coordinate and time semantics.Adaptive fidelity. Develop region-of-interest policies that allocate rendering detail according to visibility and interaction. A separate research track should investigate approximate simulation LOD while measuring its effect on CA dynamics and domain-level outcomes. Both forms of LOD should be clearly distinguished.
Interaction and navigation. Conduct controlled studies comparing 6-DOF manipulation, slice-based inspection, controller-based selection, and desktop navigation. Tasks should include identifying patterns, comparing time steps, locating propagation fronts, modifying parameters, and tracing the consequences of interventions.Collaborative simulation. Extend the middleware to support multiple clients with a defined authoritative state model, conflict-resolution rules, and recovery behaviour. Evaluate synchronization delay, consistency, and communication overhead as the number of users increases.
Domain-agnostic and data-driven rules. Develop a modular rule registry and investigate learned or hybrid transition functions. Rule adaptation should not require rewriting the visualization or transport layers. Learned rules should be evaluated for reproducibility, interpretability, and generalization in addition to predictive quality.
Longitudinal scientific and educational evaluation. Once a stable implementation is available, assess whether immersive interaction improves task performance, conceptual understanding, or retention compared with desktop alternatives. Such studies should use pre-defined outcomes and suitable follow-up periods rather than relying solely on immediate user satisfaction.
Conclusion
This paper has presented a hybrid synthesis and a proposed unified architecture for real-time three-dimensional cellular automata simulation in extended reality. The critical review indicates that GPU acceleration, voxel-oriented simulation, scientific visualization in VR, and cross-platform XR each provide important foundations. However, these advances do not automatically form a coherent CA-XR system. The main challenge is to coordinate computation, state exchange, rendering, and interaction while preserving the meaning and reproducibility of the underlying automaton.
The proposed five-layer architecture addresses this challenge by separating voxel and rule management, parallel CA computation, interoperability middleware, visualization and rendering, and XR interaction. Its principal design choices are an explicit state contract, hardware-aware backend selection, asynchronous simulation-rendering decoupling, visibility-aware visual representation, and timestamped interaction commands. The paper further defines a benchmark protocol that measures computational throughput, frame-time stability, latency, memory consumption, scalability, interoperability, correctness, and interaction quality.
The contribution is a structured research and implementation blueprint rather than a claim of completed experimental validation. The next step is to implement the reference engine and at least one optimized backend, connect them to more than one XR client, and conduct the proposed benchmark and user studies. By making both the architecture and its evaluation requirements explicit, the framework provides a basis for developing portable, measurable, and user-centred 3D CA simulation systems for immersive scientific exploration.
References (APA 7th Edition)
References
- [1]Davison, T., Samavati, F., & Jacob, C. (2018). Lifebrush: Painting interactive agent-based simulations. https://doi.org/10.1109/CW.2018.00017
- [2]Faldor, M., & Cully, A. (2024). Cax: Cellular automata accelerated in jax. arXiv.org, abs/2410.02651 null, . https://doi.org/10.48550/arxiv.2410.02651
- [3]Ganji, S. (2026). A unified and practical architecture for xr development. https://doi.org/10.11575/prism/51614
- [4]Gao, Y., Yang, J., Xu, X., & Shi, F. (2011). Efficient cellular automaton segmentation supervised by pyramid on medical volumetric data and real time implementation with graphics processing unit. Expert Systems With Applications, 38 (6), 6866-6871. https://doi.org/10.1016/J.ESWA.2010.12.049
- [5]Geringer, S., Geiselhart, F., Bäuerle, A., Dec, D., Odenthal, O. G., Reina, G., Ropinski, T., & Weiskopf, D. (2024). Mint: Integrating scientific visualizations into virtual reality. Journal of Visionnull, . https://doi.org/10.1007/s12650-024-01011-y
- [6]Gobron, S., Bonafos, H., & Mestre, D. (2008). Gpu accelerated computation and visualization of hexagonal cellular automata. https://doi.org/10.1007/978-3-540-79992-4_67
- [7]Gobron, S., Çöltekin, A., Bonafos, H., & Thalmann, D. (2011). Gpgpu computation and visualization of three-dimensional cellular automata. The Visual Computer, 27 (1), 67-81. https://doi.org/10.1007/S00371-010-0515-1
- [8]Hadjar, H., Hadjadj, Z., & Meziane, A. (2026). Human-centered digital twins: A bidirectional webxr-based architecture for immersive interaction. https://doi.org/10.1145/3822516.3834871
- [9]Harris, M. J., Coombe, G., Scheuermann, T., & Lastra, A. (2002). Physically-based visual simulation on graphics hardware. https://doi.org/10.5555/569046.569061
- [10]Harris, M. J., Coombe, G., Scheuermann, T., & Lastra, A. (2005). Physically-based visual simulation on graphics hardware. https://doi.org/10.1145/1198555.1198791
- [11]Heintz, C., Grunwald, M., Edenhofer, S., Hähner, J., & Mammen, S. V. (2017). The game of flow - cellular automaton-based fluid simulation for realtime interaction. https://doi.org/10.1145/3139131.3143415
- [12]Hentschel, T., Neuhöfer, J. A., Dresel, M., Klasen, O. B., Goldbach, P., & Jochems, N. (2026). Webxrit - a lightweight interaction toolkit to create virtual reality training applications for webxr with unity eics015. Proceedings of the ACM on human-computer interaction, 10 (4), 1-22. https://doi.org/10.1145/3816767
- [13]Herruzo, A., Patel, J., Sangaraju, H., Salapu, S. P. K., & Marti, A. O. (2026). Sentient xr: Zero-install browser-based urban digital twins with live environmental sensing. https://doi.org/10.1109/icir70631.2026.11628371
- [14]Hnat, B., & Chapman, S. C. (1999). Visualization of multi-scale data sets in self-organized criticality sandpile model. https://doi.org/10.1007/978-3-642-57313-2_23
- [15]Kushwah, P. A., Rajguru, T., Bansod, A., Devdhe, P., & Kotala, S. (2026). An immersive ar/vr platform for digital electronics and computer graphics education. https://doi.org/10.5281/zenodo.20771606
- [17]Ohno, N., & KAGEYAMA, A. (2024). Voir: Virtual reality visualization software for large-scale simulations. Plasma and Fusion Research, 19 (0), 1401024-1401024. https://doi.org/10.1585/pfr.19.1401024
- [18]Olivier, V. A., & Oded, L. (2022). Cellular automata simulation on fpga for training neural networks with virtual world imagery. https://doi.org/10.48550/arxiv.1711.07951
- [20]Ortiz, J. A., Insley, J. A., Knowles, J. Y. K., Mateevitsi, V., Papka, M. E., & Rizzi, S. (2022). Massive data visualization techniques for use in virtual reality devices. https://doi.org/10.1109/ldav57265.2022.9966400
- [22]Pajouheshgar, E., Xu, Y., Mordvintsev, A., Niklasson, E., Zhang, T., & Süsstrunk, S. (2024). Mesh neural cellular automata. ACM Transactions on Graphics, 43 (4), 1-16. https://doi.org/10.1145/3658127
- [23]Pandit, T., & Kudithipudi, D. (2026). Mini cellular automata for spatio-temporal task identification. https://doi.org/10.1145/3795101.3805424
- [24]Pandolfi, R., Todd, J., Donatelli, J. J., & Ushizima, D. (2025). Ascribe-xr: Extended reality for visualization of scientific images. https://doi.org/10.1145/3731599.3767368
- [25]Park, S., & Choi, Y. H. (2025). Three-dimensional visualization in biological and medical research: A comparative analysis of blender, unity and unreal engine. https://doi.org/10.22186/jyi.28.12.1.1
- [26]Rodríguez, A. M. R., García, P., Marquerie, J. S., Marques, R., & Blat, J. (2025). A cross-platform, webgpu-based 3d engine for real-time rendering and xr applications. https://doi.org/10.1145/3746237.3746305
- [27]Shahir, Y. R., & Beigi, A. (2026). Development of 3d neural cellular automata for learning spatio-temporal patterns. https://doi.org/10.1109/iicai70155.2026.11620913
- [28]Shen, L., Plessas-Azurduy, P., & Bub, G. (2026). Imyocyte: A web-based cellular automata platform for real-time demonstration of cardiac reentry. The biophysicistnull, . https://doi.org/10.35459/tbp.2026.000295
- [29]Sophie, N. (2023). On visualization of three-dimensional cellular automata and tilings with head-mounted display. https://doi.org/10.1007/978-981-99-0688-8_2
- [30]Sung, N., Ma, J., Hor, K., Kim, T., Va, H., Choi, Y., & Hong, M. (2025). Real-time physics simulation method for xr application. Computers, 14 (1), 17-17. https://doi.org/10.3390/computers14010017
- [32]Trapeznikova, M. A., Yashina, M. V., & Garibyan, A. G. (2024). Software for visualization of cellular automata models in traffic flow analysis. https://doi.org/10.1109/tirved63561.2024.10769828
- [33]Waseem, M., & Hong, M. (2025). Moving towards large-scale particle based fluid simulation in unity 3d. Applied Sciences, 15 (17), 9706-9706. https://doi.org/10.3390/app15179706
- [34]Wonnacott, M., Castro, L. E. T., Stroud, H. J., Aisa, L., Dhouioui, M., Williams, R. R., Protopopov, D., Sobrado, S., & Glowacki, D. R. (2026). Nanover: An open-source framework for interactive molecular dynamics in extended reality (imd-xr) on commodity hardware. https://doi.org/10.48550/arxiv.2606.30678
- [38]Zeng, H., Wang, H., & Zhang, B. (2024). A high-performance cellular automata model for urban expansion simulation based on convolution and graphic processing unit. Transactions in Gisnull, . https://doi.org/10.1111/tgis.13163
- [44]Zhou, X., Rafiee, A., & Oosterom, P. J. M. V. (2026). A high-performance game engine-gis-cfd system for interactive urban wind decision support. AGILE: GIScience series, 7 null, 1-8. https://doi.org/10.5194/agile-giss-7-49-2026
- [45]Savargiv, M., & Bastanfard, A. (2013). Text material design for fuzzy emotional speech corpus based on Persian semantic and structure. 2013 International Conference on Fuzzy Theory and Its Applications (iFUZZY), 380–384. https://doi.org/10.1109/iFuzzy.2013.6825469
- [46]Savargiv, M., & Bastanfard, A. (2016). Real-time speech emotion recognition by minimum number of features. 2016 Artificial Intelligence and Robotics (IRANOPEN), 72–76. https://doi.org/10.1109/RIOS.2016.7529493
- [47]Minoofam, S. A. H., Dehshibi, M. M., Bastanfard, A., & Eftek hari, P. (2012). Ad-hoc Ma‘geli script generation using block cellular automata. Journal of Cellular Automata, 7(4), 321–334.
- [48]Koohestani, B., Rezaei, A., & Bastanfard, A. (2026). Precision through play: Enhancing fundamental laparoscopic skill acquisition via gamified XR and pseudo-haptics. arXiv. https://doi.org/10.48550/arXiv.2611.01229
- [49]Rezaei, A., Bastanfard, A., Amir khani, D., Telvan, N., & Koohestani, B. (2026). Enhancing visual realism in augmented reality models through an interactive sunlight-based lighting and shadowing system. SSRN Electronic Journal. https://doi.org/10.2139/ssrn.6561739