XPACE (Disambiguation)
- XPACE refers to three different projects: xPACE for requirements engineering, XPACE for embodied robotics, and SPACE for exascale astrophysics. Each has a distinct domain and function.
- The requirements-engineering application xPACE provides data-driven automation for pairwise analysis of context elements. It is designed to support requirements engineers in identifying contextual combinations.
- In robotics, XPACE models both world and action, leveraging heterogeneous human and robot activities. The unified model predicts executable robot behavior and generates visual simulations.
XPACE is an ambiguous designation used for distinct research and software projects. In requirements engineering, xPACE denotes the eXtended Pairwise Analysis of Contextual Elements, a data-processing component for automated, data-driven context modeling (Falcão et al., 2022). In embodied robotics, XPACE denotes a unified world-action model and world simulator that learns from heterogeneous human and robot experience (Wei et al., 15 Sep 2026). In high-performance astrophysical computing, the designation appears in the SPACE Centre of Excellence, whose full name is Scalable Parallel Astrophysical Codes for Exascale (Shukla et al., 21 Dec 2025). These projects are unrelated in purpose, methodology, implementation, and application domain.
1. Terminological disambiguation
The three uses of XPACE and SPACE can be distinguished by domain and function.
| Designation | Domain | Principal function |
|---|---|---|
| xPACE | Requirements engineering | Pairwise analysis of contextual data |
| XPACE | Embodied robotics | Joint world and action modeling |
| SPACE | Astrophysics and HPC | Redesign of scalable parallel codes |
The requirements-engineering system is written as xPACE and expands its name as eXtended Pairwise Analysis of Contextual Elements. It operates with TASC Modeler to identify contextual combinations that may influence a user task and to generate a task-specific context model (Falcão et al., 2022).
The robotics system is written as XPACE and is titled “XPACE: Joint World and Action Modeling from Heterogeneous Experience.” It jointly predicts executable robot actions and future video while also supporting action-conditioned visual simulation (Wei et al., 15 Sep 2026).
The astrophysical project is consistently called SPACE in its paper, although the supplied terminology associates it with XPACE. Its full name is Scalable Parallel Astrophysical Codes for Exascale. It is a Horizon Europe/EuroHPC initiative for preparing European astrophysics and cosmology software for exascale and post-exascale systems (Shukla et al., 21 Dec 2025).
No organizational, algorithmic, or historical relationship among these three projects is established in the supplied material. Their shared or similar names are therefore terminological rather than conceptual.
2. xPACE for data-driven context modeling
2.1 Purpose and requirements-engineering context
xPACE is the contextual-data-processing component of an automated approach to context modeling. Its companion tool, TASC Modeler, generates graphical context models from xPACE’s output (Falcão et al., 2022).
Context modeling is an early requirements-engineering activity concerned with understanding application contexts and how they influence user tasks. A requirements engineer normally identifies contextual elements, determines whether they are accessible through data sources, assesses their relevance to a task, and analyzes combinations of elements. The number of possible combinations increases rapidly as the number of contextual elements grows, making the activity time-consuming, unintuitive, and error-prone.
The xPACE approach replaces exclusive reliance on expert intuition with analysis of existing contextual data associated with a user task. Its conceptual workflow consists of three stages:
- Analyze the user task of interest.
- Collect contextual data related to that task.
- Process the data to identify relevant combinations and generate a context model.
xPACE implements the third stage. TASC Modeler presents its results in a form that requirements engineers can inspect while eliciting context-aware functionalities.
2.2 Contextual elements and instances
A contextual element is an abstract dimension of context, such as location or time. A contextual-element instance is a concrete value of such an element, such as:
location = HOME;location = WORK;time = MORNING;time = AFTERNOON.
The central analytical distinction is between relationships among abstract elements and relationships among their concrete instances. It is insufficient to establish only that location and time are associated. The result should identify particular associations such as location = WORK related to time = AFTERNOON.
xPACE searches for relationships between contextual elements, identifies the concrete values involved, orders relationships directionally, and returns the results in a standardized data structure. A conceptual directed relation is represented as:
where and are instantiated contextual elements. The supplied description does not specify the exact correlation statistic, significance test, threshold, or edge-orientation rule.
2.3 Pairwise analysis and graph construction
xPACE first examines pairs of contextual elements and applies statistical methods to search for correlations. Each directed pairwise relation is then inserted into a graph . Conceptually:
where is the set of contextual-element instances and is the set of directed pairwise relations.
The graph is interpreted through paths. In the context-model representation, the final structure is a directed acyclic graph (DAG) with one root node. Each path from the root to a leaf represents a relevant combination of instantiated contextual elements found to influence the task.
For example, a path for the task “Prepare a coffee” might express:
When
location = WORKandtime = AFTERNOON, the user prepares coffee.
The supplied paper does not describe a formal proof of acyclicity, a cycle-removal procedure, or the exact root-selection mechanism. It also does not reproduce the statistical formulas, thresholds, or detailed algorithmic labels referenced by an activity diagram.
3. xPACE architecture, workflow, and evaluation
3.1 Separation from TASC Modeler
xPACE and TASC Modeler have distinct responsibilities. xPACE performs contextual-data analysis, whereas TASC Modeler invokes xPACE and converts its standardized output into a graphical task-specific context model.
Their interaction is:
The standardized task-specific contexts data structure decouples analysis from model generation. Consequently, a different context-model generator could consume xPACE’s output if it understands the standardized layout. Conversely, TASC Modeler could use another contextual-data processor if that processor exposes the required output through a REST API.
3.2 Implementation and deployment
The xPACE analysis core is implemented in the R programming language. Its principal source file is main.R; supporting files include load_libraries.R, util.R, and load_data.R. A Java-based Web API exposes the R-based processor. TASC Modeler sends the task name, contextual dataset, and metadata to this API, which invokes xPACE and returns a standardized task-specific contexts file.
TASC Modeler is a single-page application implemented using TypeScript and the React library. The requirements engineer supplies the dataset file, metadata file, and task name through a web-based form and presses “Generate.”
Both tools are containerized with Docker. The approximate memory requirements reported are 600 MB of RAM for the TASC Modeler container and 300 MB for the xPACE container. More memory may be needed as the dataset grows.
3.3 Inputs and outputs
xPACE receives:
- a user-task name, such as
create a commentor “Prepare a coffee”; - a contextual dataset supplied as a CSV file;
- a metadata file supplied as a CSV file.
The metadata configures both how xPACE analyzes the dataset and how TASC Modeler presents the resulting contexts. The supplied material does not reproduce the metadata schema, column definitions, data types, configuration keys, or complete example files.
The principal output is a standardized task-specific contexts file represented as JSON. The supplied material does not provide the JSON schema, field names, nesting structure, or formal serialization grammar.
3.4 Demonstration in DorfFunk
The tools were evaluated in the context of DorfFunk, a live communication application developed and maintained by Fraunhofer IESE. The application has approximately 25,000 active users. The selected task was “create a comment.” The dataset contained approximately 56,000 tuples describing 15 contextual elements.
A controlled experiment involved professional software engineers. The treatment group received the data-driven context model, while the control group received only the list of contextual elements available for describing context-aware functionalities. Treatment-group participants, on average, elaborated functionalities combining more contextual elements than control-group participants. Participants also reported that the model was valuable for supporting elicitation.
The researchers assessed the hypothesis that the data-driven context model is perceived as a useful instrument for eliciting context-aware functionalities. Acceptance and usefulness were assessed with UTAUT, particularly performance expectation and attitude toward using the technology. The supplied material does not provide participant numbers, group sizes, statistical test values, effect sizes, confidence intervals, or questionnaire items.
3.5 Scope and limitations
xPACE depends on the availability, quality, and representativeness of contextual data. The supplied description does not specify mechanisms for missing-value imputation, outlier removal, normalization, temporal alignment, duplicate elimination, discretization, feature selection, or noise filtering.
Its pairwise strategy may limit detection of relationships that arise only through higher-order interactions. Correlations should be interpreted as associations relevant to context modeling, not as causal effects. The exact statistical tests, thresholds, direction-selection rules, graph-pruning procedures, cycle-handling mechanisms, and data-type transformations are unspecified.
The demonstration used one software-development context and one task. Scalability and capacity were identified as future evaluation topics, as were applications in additional projects, quality-attribute assessment, time behavior, and substantially larger datasets.
4. XPACE as a joint world and action model for robotics
4.1 Problem setting
The robotics XPACE addresses general-purpose robot learning from heterogeneous experience. Its data sources have complementary properties:
- action-unlabeled human video provides broad behavioral and visual coverage;
- human demonstrations with motion labels provide manipulation supervision for another embodiment;
- robot teleoperation supplies executable controls but covers relatively few tasks, objects, and environments;
- successful robot demonstrations provide limited supervision for recovery after policy deviation.
XPACE jointly learns a world action model and a world simulator. The world action model predicts executable robot actions and future video from visual history, robot state, language, and embodiment information. The world simulator predicts future video given visual history, prescribed action-skeleton controls, and camera poses (Wei et al., 15 Sep 2026).
The model was evaluated on XPENG’s IRON humanoid robot.
4.2 World action model and world simulator
The world action model receives visual history, current robot state, a language instruction, and an embodiment identifier. It jointly predicts a future-video representation and an executable action chunk:
Here, is an observed anchor latent, are preceding visual chunks, is the current state, is the task instruction, selects embodiment-specific action projections, is a predicted future-video chunk, and is the predicted executable action chunk.
The world simulator is action-conditioned rather than instruction-conditioned:
It receives visual history, a prescribed 2D action-skeleton sequence , and camera poses . It predicts the visual consequences of those prescribed actions rather than selecting actions itself.
The shared video backbone connects the two modes. Video prediction allows action-unlabeled experience to contribute to the representation used for action learning, while the simulator generates corrective training data for policy improvement.
4.3 Heterogeneous experience pyramid
XPACE organizes approximately 5,000 hours of embodied video into four experience layers:
- L1: action-unlabeled egocentric video containing interaction-rich manipulation clips;
- L2: human video-action data paired with hand and wrist poses;
- L3: bridge data consisting of task-aligned and appearance-aligned clips;
- L4: robot teleoperation demonstrations containing video and native robot actions.
Human and humanoid robot motions use a shared schema containing end-effector poses, hand articulation, torso poses, and camera poses. Embodiment-specific input and output projections account for differences in kinematics and action dimensions.
A separate failure set, , contains unsuccessful, low-progress, and recovery trajectories. It is used only for simulator training and not for policy imitation, preventing the simulator from learning an unrealistically successful world in which incorrect actions always succeed.
Language conditioning includes episode-level task instructions, dense scene and action descriptions, atomic local action commands, and paraphrased task instructions. Training samples one text condition per example.
4.4 Architecture and conditioning
XPACE uses an asymmetric mixture-of-transformers architecture. A causal Video Transformer is shared between policy and simulator modes. A frozen video VAE encodes each clip into an initial anchor latent and future chunks. Each chunk contains four latent frames corresponding to 16 video frames. Attention is bidirectional within a chunk and causal across chunks.
The Action Transformer reads multi-level visual features from video blocks 16–30. Action tokens serve as queries, while action and projected visual tokens serve as keys and values. The action branch does not alter video features in the forward pass, although action-loss gradients propagate through the visual readout into the shared video backbone.
The action chunk is:
where is embodiment-specific. The normalized current state token is prepended to 16 noisy action tokens. The state-token output is discarded, leaving a 16-step prediction. The state condition is randomly omitted with probability 0.5 during training.
In simulator mode, rasterized skeleton tokens are added elementwise to video tokens:
The skeleton patch embedding is zero-initialized. Camera poses are provided as explicit inputs in addition to skeleton controls. An ablation compared AdaLN, cross-attention, channel concatenation, and token addition; token addition performed best overall without increasing inference cost.
4.5 Training curriculum and objectives
XPACE uses flow matching for future-video and action prediction. Let denote the video flow-matching loss and the action flow-matching loss. For video latents, noise and flow time define:
with target velocity:
Video-action examples optimize:
with equal loss weights. Simulator examples optimize only . Action-unlabeled clips contribute only to video prediction, and the failure set contributes only to simulator updates. No separate reconstruction, inverse-dynamics, reinforcement-learning, or behavior-value loss is described.
Training proceeds in three broad stages. Stage I performs video-only pretraining on human and robot video. Stage II jointly trains video-action and simulation modes, sampling each with probability 0.5 while changing the source-data mixture from broad co-training to increased bridge and robot supervision and finally to target-robot co-training. Stage III adapts the simulator and fine-tunes a separate policy with synthesized recovery data.
The coarse-to-fine curriculum retains human demonstrations, bridge data, and action-unlabeled video during target-robot training. On robot-absent, human-dense behaviors, co-training reduces held-out action loss by 22.7%; on robot-dense, human-dense behaviors, it reduces held-out action loss by 10.0%.
4.6 Simulator adaptation and recovery supervision
XPACE uses self-gradient forcing to reduce the mismatch between teacher-forced simulator training and autoregressive deployment. A simulator copy is adapted using generated visual prefixes, with subsequent context detached and re-encoded with gradients. Sampling cost is reduced from 50 ODE steps per chunk to 8.
For 193-frame rollouts, self-gradient forcing increases ID PSNR from 16.94 to 17.83 and OOD PSNR from 17.74 to 18.75. Inference becomes approximately 3.00 times faster on ID data and 3.30 times faster on OOD data, while memory remains essentially unchanged.
For recovery supervision, XPACE perturbs an expert trajectory around a selected pivot frame. It selects the arm with the largest cumulative end-effector displacement, samples a deviation direction, chooses deviation magnitude and horizon, moves the selected end effector away from the expert, and then returns toward the pivot pose. Generated trajectories are filtered using DINO similarity, depth-weighted PSNR, and depth-weighted SSIM. Eligible examples must become more similar to the expert pivot after recovery and meet absolute similarity thresholds.
A filtered recovery dataset, , is used for policy fine-tuning. A separate policy copy initialized from the target-robot training checkpoint is fine-tuned using 8% filtered recovery examples and 92% of the original data mixture. The simulator remains frozen.
5. Robotics results, deployment, and limitations
XPACE was deployed on the IRON-R01-1.11 humanoid using streaming VAE encoding, asynchronous action execution, 16-step action plans, approximately 10 Hz command publication, and overlapping-horizon plan stitching. New plans are generated while previously queued commands continue executing; overlapping prefixes are discarded and a decaying correction smooths the join.
The primary real-robot benchmark used 20 trials per task:
- banana pick-and-place across five positions;
- pouring water from a bottle;
- bowl stacking.
The average success rate was 68.3%, with average progress of 0.84. The comparison systems reported success rates of 40.0% for DreamZero and 6.7% for GR00T. XPACE achieved 16/20 successes for banana pick-and-place and 15/20 for bowl stacking. Pouring achieved 10/20 successes with progress of 0.78.
Compared with a robot-only model, heterogeneous training increased banana-position robustness from 50% to 80% success and from 0.70 to 0.93 progress. With distractors consisting of a cucumber, flower, and toy duck, success increased from 30% to 50% and progress from 0.48 to 0.74.
Qualitative human-to-robot transfer was reported for drawer pushing, bread transfer from a toaster to a plate, and sequential three-bowl nesting. Bowl stacking was absent from robot demonstrations but present in human and bridge data.
Recovery-data fine-tuning increased average progress from 0.81 to 0.93 and average success from 61.7% to 86.7% across banana pick-and-place, water pouring, and cola handover. The comparison is a before/after fine-tuning study and does not fully isolate the effect of recovery data from the additional optimization budget.
The principal limitations are long-horizon and contact-rich reliability, the absence of explicit uncertainty modeling, local rather than broad recovery synthesis, dependence on a shared human–robot kinematic schema, and the relatively small real-robot evaluation. Similarity-based filtering may reject valid recoveries that produce visually different outcomes. The benchmark demonstrates transfer from human and bridge data rather than behavior unseen in every source, because bowl stacking was absent from robot data but present elsewhere.
6. SPACE for exascale astrophysics and cosmology
6.1 Mission and scientific scope
The SPACE Centre of Excellence prepares European astrophysics and cosmology software for exascale and post-exascale computing. It is funded through the EuroHPC Joint Undertaking under grant agreement No. 101093441, with support from Belgium, the Czech Republic, France, Germany, Greece, Italy, Norway, and Spain (Shukla et al., 21 Dec 2025).
The project addresses the increasing resolution, physical complexity, parameter-space size, and observational fidelity required by astrophysical simulations, together with the heterogeneity and energy constraints of modern supercomputers. Its activities include scientific code redesign, GPU and heterogeneous-hardware porting, scalable algorithms, communication optimization, hardware/software co-design, profiling, energy analysis, high-performance visualization, machine learning, workflow infrastructure, data standards, training, and community integration.
Targeted scientific applications include plasma and relativistic-fluid calculations, black-hole and neutron-star mergers, cosmological structure formation, galaxy formation, large-scale particle simulations, and adaptive-mesh simulations.
6.2 Code redesign and programming models
SPACE targets codes for Newtonian and relativistic hydrodynamics, magnetohydrodynamics, resistive relativistic MHD, general-relativistic MHD, particle-in-cell plasma physics, N-body gravity, smoothed-particle hydrodynamics, meshless methods, adaptive mesh refinement, and cosmological gas, dark matter, stars, black holes, radiative processes, and feedback.
The project does not impose one universal programming model. Its software strategy includes:
- MPI and nonblocking communication for distributed memory;
- OpenACC for Pluto, OpenGadget3, and BHAC;
- CUDA and HIP for PIC3D;
- OpenMP for Ramses, FIL, and OpenGadget3 offloading;
- Charm++ for ChaNGa;
- Kokkos for the GRACE infrastructure supporting FIL;
- ParaView/Catalyst for in-situ visualization.
The objective is not merely to compile legacy applications on new systems, but to redesign computational kernels, data structures, communication patterns, algorithms, and software layers while retaining scientific correctness and, where feasible, backward compatibility.
6.3 Flagship codes and reported results
Pluto is a modular multiphysics framework for high-Mach-number astrophysical flows. It supports Newtonian hydrodynamics, relativistic hydrodynamics, MHD, relativistic MHD, and resistive relativistic MHD. Its Godunov-type numerical framework follows reconstruction, a Riemann problem at zone edges, and a final update. The redesigned version is written in C++, uses OpenACC, supports asynchronous MPI communication, and includes a fourth-order finite-volume scheme for advanced relativistic-MHD applications.
OpenGadget3 is a collisionless N-body and Lagrangian cosmological code combining particle-based gravity, tree-based gravity, SPH, meshless finite-mass methods, cosmological expansion, radiative cooling, star formation, feedback, radiative transfer, and magnetic fields. Its spatially grouped particle “bunches” improve tree-walk coherence and vectorization; a proof of concept achieved an approximately 10× speedup relative to the existing approach. OpenGadget3 scales to a few thousand GPUs. A Magneticum Pathfinder Box3 visualization contains approximately particles in a region approximately 180 Mpc across.
Ramses is an adaptive-mesh-refinement code for astrophysical fluid dynamics and cosmic structure formation. Its hybrid MPI+OpenMP model reduces the number of MPI boundaries and improves memory efficiency by a factor of 10 while reducing MPI overhead. The project studies compiler-specific vectorization across x86_64 and AArch64, including NEON and SVE2.
PIC3D is an implicit three-dimensional particle-in-cell plasma code with particle mover, moment gatherer, and field solver kernels. Its implicit method permits time steps and spatial grid sizes 10 to 100 times larger than those typically used in traditional explicit PIC codes. CUDA and HIP implementations achieve more than 90% weak-scaling parallel efficiency on LUMI-C. The moment gatherer consumes approximately 80% of total runtime and is the principal optimization target.
ChaNGa is an N-body and smoothed-particle MHD code using Charm++ overdecomposition, dynamic load balancing, asynchronous task-based execution, and tree-piece replication. It scales to 65,536 CPU cores. A preliminary GPU implementation of radiative cooling produces speedups between 4× and 20× depending on the test case.
BHAC, the Black Hole Accretion Code, is a general-relativistic MHD code for accretion flows around compact objects. Its primitive reconstruction and Riemann solver have been ported to GPUs with OpenACC. For a three-dimensional magnetized torus around a Kerr black hole, BHAC achieves approximately 95% weak-scaling efficiency up to 1,024 GPUs and approximately 20× speedup over the CPU version.
FIL is a GRMHD code for relativistic fluids on curved, dynamically evolving spacetime, including black-hole–neutron-star collisions and binary-neutron-star mergers. SPACE is replacing the Einstein Toolkit functionality used by FIL with GRACE, a Kokkos-based infrastructure intended to support heterogeneous hardware, multiple GPU models, multiple coordinate systems, and problem-specific symmetries.
6.4 Hardware, energy, and data analysis
SPACE targets systems including Leonardo, MareNostrum 5, MeluXina, LUMI-C, Piz Daint, NVIDIA Grace platforms, Intel Xeon Max/Sapphire Rapids systems with HBM, and future SiPearl Rhea systems associated with the European Processor Initiative and EUPEX.
Energy is treated as an optimization variable. For Pluto, reported Grace energy efficiency rises from 628 MFLOPs/W at default settings to 805 MFLOPs/W at 2.9 GHz and 964 MFLOPs/W at 2.1 GHz. The 2.9 GHz configuration saves 22% energy with runtime at 101% of baseline, while the 2.1 GHz configuration saves 35% energy with runtime at 122%. The broader discussion reports up to 22% node-energy savings without meaningful runtime impact in selected configurations.
The project also addresses exascale data volumes through in-situ visualization, machine learning, workflow management, metadata, and data access. Its visualization activities include Hecuba-based in-situ analysis, cinematic volume rendering with Blender, and VisIVO workflows managed through StreamFlow.
Machine-learning activities include representation learning for exploration of large cosmological simulations, inference from observables, and ML surrogates for radiative-transfer effects. Workflow and repository services address continuous integration, issue tracking, data archiving, continuous deployment, and machine-specific software recipes.
SPACE is also defining common I/O standards and data models based on FAIR principles—Findable, Accessible, Interoperable, and Reusable—and building on International Virtual Observatory Alliance work. These standards are intended to support data exchange among simulation codes, metadata-based discovery, reuse, and combination of simulations with observational archives.
6.5 Remaining challenges and expected impact
Remaining challenges include scaling all codes to exascale concurrency, completing GPU implementations for dominant kernels, reducing CPU–GPU transfers, improving ARM and SVE portability, validating performance on SiPearl Rhea, determining when HBM provides application-level benefits, deploying software under differing national-centre security policies, standardizing I/O and metadata, validating machine-learning surrogates, and balancing energy savings against runtime and throughput.
The expected scientific effects include higher-resolution magnetic-reconnection calculations, more detailed relativistic plasma and black-hole accretion studies, improved synthetic black-hole observations, larger cosmological volumes, more realistic galaxy-formation models, broader kinetic-plasma scale separation, binary-neutron-star and black-hole–neutron-star simulations, faster parameter inference, and incorporation of otherwise prohibitive radiative-transfer physics through ML surrogates.
In contrast to the requirements-engineering and robotics uses of XPACE, SPACE is not a context-modeling tool or an embodied policy model. It is a coordinated redesign of astrophysical simulation infrastructure spanning numerical algorithms, runtimes, hardware mappings, energy policies, visualization, machine learning, workflows, repositories, data standards, and training.