Task-based programming models offer a promising path toward efficiently exploiting increasingly heterogeneous and distributed extreme-scale platforms. However, their broader adoption remains limited by fragmentation across runtime systems, lack of interoperability, and sustainability challenges related to maintainability and shared infrastructure. Our collaboration seeks to identify common low-level primitives and develop unified tasking interfaces that enable cross-runtime composability while avoiding performance issues such as oversubscription.

Over the past year, the project has advanced several interoperability efforts, including the porting of StarPU and PaRSEC to nOS-V and evaluations of their interaction with OpenMP, as well as discussions around the Reconverse redesign of the Charm++ Converse layer to reduce technical debt and support modern communication libraries. Building on these activities, this BOS will combine short scientific presentations with open discussions. Topics include API-level interoperability through applications such as Chameleon and TTG, scheduling challenges in multi-queue environments inspired by Converse, and ongoing OpenMP standardization efforts. The session will also foster community exchange on memory management and ownership models, and on techniques for expressing and coordinating task dependencies across runtimes. Participants from UIUC, BSC, Inria, and the broader JLESC community are invited to contribute to shaping future interoperability directions.

Scientific libraries for molecular dynamics must operate at sub-millisecond latency to be practically useful, requiring efficient strong scaling across many GPUs. At scale, even moderately sized systems reduce to only thousands or hundreds of particles per device, and extracting parallelism from these small work sets demands a detailed understanding of the underlying algorithm. We present two case studies from our CUDA optimisation of the Fast Multipole Method, each illustrating how identifying the right atomic work unit transforms GPU utilisation. In the far-field phase, we initially assigned one thread per box-box tensor contraction, which starved the GPU at upper octree levels where few boxes exist. By decomposing each contraction into p^2 fully independent operations, each assignable to a separate thread with no communication overhead, we recovered utilisation at coarse levels and gained an additional dimension for tuning occupancy across all levels, yielding roughly 15 to 20% faster wall-time M2L performance on a 7000-particle sodium chloride system. In the near-field phase, parallelising over particles is inherently limited and load-imbalanced, as the number of pairwise interactions can scale as N^2 while work is distributed over only N threads. Parallelising naively over interactions instead introduces memory inefficiency and many redundant costly atomic force updates. We resolve this by tiling the interaction space into warp-sized blocks, enabling efficient local processing while asymptotically parallelising over N^2 interactions, and opening a natural path to tensor core acceleration in future work. This alone reduces near-field runtime by nearly 50% on the same system compared to either approach.

We present a visualization and data transmission pipeline that directly connects ParaView's scientific data‑processing capabilities with Unreal Engine's photorealistic, interactive rendering environment, enabling real‑time exploration of large‑scale simulation results without intermediate disk I/O. The pipeline is enabled by JuSync, a middleware component that facilitates the workflow. In our implementation, a point‑based simulation is generated on‑the‑fly using Catalyst's in‑situ processing across multiple compute nodes on the JURECA HPC system. The simulation data is ingested by ParaView on the JURECA nodes, processed using filters, and prepared as mesh data (glyphs). ParaView with ANARI‑SDK streams the processed data as USD‑ASCII (USDA) scene graphs generated by ANARI‑USD by individual ranks acting as workers, which connect to a broker process on the same JURECA HPC system. The broker forwards these USDA streams to Unreal Engine via the ANARI‑USD device integrated into JuSync. ZeroMQ (ZMQ) handles the broker‑worker communication on the HPC as well as the communication to the Unreal Engine instance.

Within Unreal Engine, JuSync parses the USDA streams, extracts mesh geometry and attributes, and converts them into Unreal‑compatible real-time mesh formats using multiple Realtime Mesh Component (RMC) clients to accommodate higher vertex counts. This enables efficient rendering of large datasets. The converted meshes are dynamically updated in the DaVinCo application—a VR‑enabled Unreal Engine client—allowing interactive exploration on desktop workstations, large‑scale displays, or VR headsets.

By leveraging USD as a common interchange format and the ANARI abstraction layer with ZMQ, the pipeline eliminates the traditional workflow of writing large data files to disk, transferring them, and loading them into a rendering engine. It decouples scientific data processing from rendering while preserving metadata and hierarchical structure. The middleware receives data from HPC via ZeroMQ, with the broker‑worker logic implemented in the ANARI‑USD component on the HPC side, ensuring robust operation on systems such as JURECA, while not being limited to this system.

We demonstrate the pipeline with a point‑based particle dynamics simulation generated in situ via Catalyst and visualized in real time on a VR setup. Initial tests show the pipeline can handle datasets with tens of millions of points, with glyphs (tested with arrow and sphere meshes) applied to them. The approach is simulation-independent: any simulation that can render USDA files within the ParaView ANARI‑SDK interface using ANARI‑USD will work with Unreal Engine, regardless of the underlying simulation code.

Overall, the ANARI‑based pipeline from ParaView to Unreal Engine, enabled by JuSync, provides a practical foundation for real‑time scientific visualization in immersive environments, bridging the gap between high‑performance computing and modern game‑engine rendering. By eliminating disk I/O and leveraging USD‑based streaming, the pipeline delivers high‑fidelity visual feedback, enabling scientists to interactively inspect evolving simulations across a variety of platforms.

Context
The stability of the power grid relies on a perfect equilibrium between the total production and the total
consumption. Today, the majority of the electricity production worldwide still comes from thermal
generators, and the production can easily adapt to the power demand, but the tipping point is close.
With the rapid development of intermittent and non-controllable renewable energy sources, such as
solar panels and wind turbines, and their increasing part in the electricity mix, the production is
becoming less and less controllable. For example in France, the total part of renewable energy sources
is planned to account for about 2/3 of the installed power in 2035 [4]. This introduces a new challenge
for the stability of the electrical grid: the need to better control the electricity consumption.
In the same time, the electricity demand of many sectors will greatly increase (e.g., industry, transport,
heating) partly due to the electrification of usages resulting from the abandon of fossil energy sources.
In the Information Technology sector, the increase in the electricity demand is highly impacted by the
ever increasing development of large computing platforms. This trend is expected to worsen in the
coming years due to the adoption of Artificial Intelligence everywhere, and it is forecasted that the
sector will play the biggest part of the total electricity demand increase of the tertiary sector towards
2035 in France [4] as well as in many other countries such as the U.S. [2].
This rapid growth puts pressure on the operation and development of the power grid with numerous
challenges. The new connection requests to the power grid for computing platforms ask for more
power, ranging from dozens of megawatts up to one giga watt for the largest, with a total power of the
pending connection requests reaching about ten giga Watts in France. The development of the power
grid and the production groups must follow these new loads.
On the consumption side, operators of the power grid are looking for ways to gracefully shift the load
away from temporal windows where the electricity consumption is forecasted to supplant the production,
and to windows where the production would be abundant. This mechanism, called flexibility,
has been studied in many different contexts, such as the operation of water boilers [3] or the charging
of electric vehicles [1], where the load on the power grid could easily be shifted from periods of peak
consumption (in the evening) to periods of low consumption (the middle of the night). In our work we
study the flexibility capabilities of large computing infrastructures.

While high-performance computing traditionally consisted of CSE and large scientific applications, modern applications like data analytics and machine learning have now become more prominent. These new applications contain some of the same challenges as previous HPC workloads, including a need to deal with runtime variability and adaptation. As the focus in ML shifts from model-building via massive training to inference and large-scale serving, and as issues such as energy consumption and resource utilization gain importance, runtime adaptivity will become important for these domains as well. The increasing use of cloud infrastructure also emphasizes resource elasticity as well as resource heterogeneity, along with multi-tenancy. To solve these issues, we propose the use of Charm4Py, CharmTyles, and CharmNumerics, which build off the proven capabilities of the Charm++ parallel runtime system, but target data science and machine learning, along with Python-based CSE applications.

Charm4Py is a Python-based runtime system based on overdecomposition, which builds on top of Charm++. Charm4Py, like Charm++, is targeted towards traditional HPC applications, but combines the use of popular Python libraries with dynamic load balancing and computation-communication overlap. Charm4Py can also be used as an alternative to existing Python runtimes. In particular, we have developed an implementation of the Ray core API on top of Charm4Py, which allows existing Ray programs to use dynamic load balancing by representing Ray actors as Charm4Py chares, all without requiring any modification to existing Ray programs.

CharmTyles also builds upon Charm++, but in the direction of domain-specific abstractions. CharmTyles consists of a Python frontend and a Charm++/C++ backend. Operations from the Python frontend are represented by the backend as an abstract syntax tree, allowing for lazy evaluation and low-latency execution of operations. The Charm++ backend provides a set of libraries that are targeted towards data science applications, including CharmStencil (a library for stencil computations) and CharmPandas (an implementation of the Pandas library in Charm++).

Additionally, we propose CharmNumerics, a NumPy alternative built on top of the CharmTyles framework. CharmNumerics supports the same wide variety of matrix operations as NumPy, but with overdecomposition and load balancing that will particularly benefit sparse matrix operations.

Along with supporting Charm++ features, Charm4Py, CharmTyles, and CharmNumerics also support the use of heterogeneous computing resources. Our libraries support execution on NVIDIA, AMD, and Intel GPUs, enabling device scaling that is necessary on modern supercomputers. Additionally, we have added new communication abilities to the Charm runtime that allow for direct device-to-device communication on GPUs. On top of this, we also now allow for Charm++ and Charm4Py programs to be run on cloud providers and orchestrators such as AWS and Kubernetes, and we also support resource elasticity by allowing the number of nodes to be changed during execution.

This talk presents DMR, a communication library enabling dynamic resource management for MPI-based applications running on Slurm-managed clusters. Built on top of Open MPI, DMR allows jobs to expand or shrink their node allocations at runtime in response to system demand, eliminating idle time and reducing queue wait. We demonstrate the approach through a malleable Monte Carlo Pi estimation example and describe the full deployment stack, from a containerized Docker-based cluster that runs on a laptop for rapid development and testing, to production deployment on MareNostrum5

Quantum Computing (QC) systems are being increasingly explored as the next high-impact extension to the computing spectrum, particularly in terms of their integration into supercomputers and cloud environments. The successful interoperability between classical and quantum systems depends on middleware that can interact with heterogeneous hardware technologies and their associated software stacks and data management methods. Today, approaches to high-level hybrid programming remain limited.

Workflow abstractions and workflow management tools have proved successful in overcoming the challenge of heterogeneity in tasks, data, and computational resources across multiple scientific domains. This opens up an exciting new area at the intersection of workflow research and the integration of QC into classical environments. However, adopting workflow abstractions and workflow management tools in hybrid use cases leads to significant challenges. These include adapting workflow scheduling and management methods to incorporate quantum resources and probabilistic critical paths in hybrid algorithms, modelling and supporting quantum-classical data dependencies, and acquiring and analysing hybrid workflow metadata.

Current works on the integration of QC into existing computing ecosystems focus on the interoperability and performance of algorithms without considering data-oriented optimisations (e.g., data encoding, arrangement, locality, or mapping to high-level data abstractions), and workflow-specific challenges (e.g., task-resource mapping, data partitioning, transfer and placement) are rarely explored, particularly in the context of practical applications and realistic deployments. We hypothesise that a better understanding of the key role of data management in hybrid workflows will improve our ability to effectively and efficiently interoperate QC and HPC environments. To date, few studies have addressed the systematic collection of hybrid workflow motifs, and there is no comprehensive literature covering task profiling, data characterisation, and hybrid workflow behavioural modelling. In addition, no data-oriented methodologies exist to assess the effectiveness of software integration for hybrid workflows, and breakthroughs in hybrid workflow characterisation are required to understand the next steps towards interoperability between QC and HPC systems.

In this short talk we explore pathways for profiling and characterising data access and transfer patterns in hybrid quantum-classical workflows, introducing the fundamental obstacles that can be overcome through collaborations within the JLESC framework.

Dynamic resource management (DMR) offers a promising path to converge High-Performance Computing (HPC) and Quantum Computing (QC) by enabling hybrid applications to adapt their resource usage at runtime. In this work, DMR is integrated with malleable MPI applications to dynamically resize the set of allocated classical resources according to the current phase of a hybrid HPC-QC workflow. During classical phases, the application can expand to exploit multiple nodes, while in quantum phases it shrinks, releasing unused classical resources while waiting for quantum execution. This phase-aware adaptation reduces idle time on HPC nodes and improves overall system utilization in scenarios where quantum resources are scarce and accessed as accelerators. The proposed approach targets transparent integration with existing batch schedulers and MPI codes, paving the way for more efficient execution of hybrid workloads and making HPC-QC convergence practical from the resource management perspective.

As quantum computing hardware rapidly evolves, traditional metrics like gate fidelity and Quantum Volume are insufficient for predicting real-world utility. Researchers and industry users need objective, application-centric benchmarks to gauge when quantum processors will be ready for practical tasks. However, the lack of standardized infrastructure often leads to non-reproducible performance claims and makes it difficult to track progress across different hardware generations and technologies.
We present the JUNIQ Benchmark Suite (https://go.fzj.de/juniq-benchmark-suite-page),
a large collection of benchmark problems and a vendor-agnostic, open-source initiative provided by an independent research lab, designed to track quantum technology readiness over decades. Unlike suites focused on synthetic benchmarks, the JUNIQ Benchmark Suite emphasizes application domains. Examples include computational biology and remote sensing (Quantum SVM), logistics (Tail Assignment, TSP), and hardware diagnostics (Effective Qubit Temperature) etc. By benchmarking the same relevant problems on systems ranging from the earliest publicly available QPU devices (e.g. IBM Q Experience in 2016 and D-Wave 2000Q systems in 2017) to the latest state-of-the-art devices such as Advantage2 (2025), we provide a clear, overview of hardware maturation.
A key innovation of our work is the standardized benchmarking workflow, a CLI-based toolchain along with CI pipelines, developed to ensure strict reproducibility. This setup facilitates the entire benchmark lifecycle (setup, generation, verification and execution) while aiding dependency management and enabling CI testing. This ensures that previously generated problems remain reproducible in the future, solving the "dependency drift" problem common in the fast-moving quantum software ecosystem.
The JUNIQ Benchmark Suite hosts benchmark instances from various domains and is actively tracking performance on the latest analog and digital quantum processors available through the JUNIQ cloud platform and beyond. To foster a transparent ecosystem, we include templates and tooling that lower the barrier for community to contribute new problem instances.
Keywords: Quantum computing, Benchmarking, QPU, Quantum computing applications,

We are conducting the JHPC Quantum project to design and build a quantum–supercomputer hybrid computing platform by integrating multiple on-premises quantum computers — namely, an IBM superconducting quantum computer and a Quantinuum trapped-ion quantum computer—with several supercomputers, including Fugaku and GPU-based systems. Our platform is now in operation and is providing services to test users of our test user program. We expect a wide range of outcomes from QC–HPC hybrid computing using this platform. In this presentation, the overview and current status of the JHPC Quantum project, along with our perspective on quantum–HPC hybrid computing.

This work describes a unified identity and access design for the Quantum–HPC hybrid platform that integrates quantum computers and supercomputers. The platform adopts OAuth2.0-based access tokens to enable workflows to securely access multiple computing systems. Job submission to HPC resources is performed via Slurm REST interfaces under token-based authorization. The user management component enforces identity verification procedures, partially automated through digital credential mechanisms. Separately, user information is subject to screening processes aligned with export control and security compliance requirements. The design supports secure and practical hybrid computational environments.

Large Language Model (LLM) serving systems increasingly face heterogeneous workloads with strict deadline constraints, yet existing frameworks such as vLLM primarily optimize throughput and average latency.
We study deadline-aware admission control and scheduling for LLM inference in a non-clairvoyant online setting, operating at the granularity of individual forward passes.
Our approach estimates request urgency from remaining slack and required decode throughput using an empirically calibrated performance model that captures concurrency effects.
Requests at risk of missing their deadlines are prioritized, while infeasible requests are dynamically deprioritized.
Experimental evaluation shows that our method significantly improves deadline satisfaction under high contention while maintaining competitive throughput.

Agentic scientific workflows require vector databases to act as real-time, high-performance AI memory layers, yet most existing systems are designed for cloud environments rather than leadership-class HPC. This work evaluates the HPC readiness of representative vector data platforms by examining multi-core scaling, RDMA, and GPUDirect utilization and behavior across complex memory hierarchies. Our results expose key performance bottlenecks and provide a foundation for systematically deploying and comparing vector databases in supercomputing settings, informing the design of next-generation ANN services optimized for streaming ingest and low-latency query at scale.

Drug discovery is amongst the most pioneering areas of scientific research and constitutes a cornerstone of the pharmaceutical industry. Despite its importance, it remains slow and complex: according to the National Institutes of Health, approximately 50 new drugs are approved each year, and requires 10-15 years to take a drug from concept to market. Nearly four of these years are dedicated to early discovery. This work focuses on that stage, specifically small-molecule drug discoverywhich often offers advantages such as oral bioavailability and the ability to cross cell membranes, allowing to modulate intracellular protein targets.

Traditionally, after identifying a protein target, researchers relied on high-throughput screening (HTS), experimentally testing hundreds of thousands of molecules. Promising “hits” are refined through iterative cycles of synthesis and biological evaluation to improve potency, selectivity, safety, and pharmacokinetics. While effective, this paradigm is costly, time-intensive, and limited by the number of compounds that can be physically screened.

Virtual screening (VS) was introduced as a computational alternative: instead of testing compounds in the laboratory, computational models predict how well molecules bind to a target protein, enabling the evaluation of millions of candidates at a fraction of the experimental cost. Recent advances in machine learning (ML) have accelerated this transition, expanding screening campaigns from millions to hundreds of millions of compounds, with the latest advancements beginning to operate at the billion-molecule scale. As computational capacity grows, the availability of well-curated, scalable, and chemically accessible libraries has become a key bottleneck. Relying on a single ultra-large database risks restricting structural diversity and biasing the explored chemical space.

To overcome this limitation, we developed a composite ultra-large molecular database integrating complementary resources within a unified framework. The database combines commercial make-on-demand libraries of readily synthesizable compounds, including Enamine REAL, SAVI, MCule, MolPort, WuXi GalaXi, and ZINC22, with curated resources such as ChEMBL, PubChem, and SureChEMBL, alongside specialised academic collections (SCUBIDOO, CHIPMUNK), natural product databases (COCONUT, NPAtlas), and the proprietary ChemistriX library designed to maximise scaffold diversity. Before curation, the aggregated resource comprised approximately 188.6 billion molecular entries (~5.5 TB).

Processing data at this scale required a distributed, memory-efficient infrastructure to manage hundreds of billions of entries. All molecules were standardized and globally deduplicated to ensure chemical validity and remove redundancy. The curated dataset, comprising approximately 173 billion unique molecules, and is organized into scalable heavy-atom-count (HAC) partitions. This structure allows seamless integration with ML-based screening workflows such as ScoreFormer, an in-house physics-informed docking surrogate model.

By unifying synthetic feasibility, structural diversity, and scalable data engineering within a single platform, this composite database establishes a robust foundation for next-generation billion-scale VS and early-stage drug discovery.

The SAGE-HPC project seeks to develop a scalable, open, and interoperable software platform for multi-fidelity optimization of complex physical systems in exascale high-performance computing (HPC) environments. Such optimization problems are scientifically challenging due to the intricate nature of the underlying physics and the prohibitive cost of high-fidelity simulations. To address these difficulties, SAGE-HPC combines the coordinated use of variable-fidelity models—where inexpensive, approximate models guide exploration and costly, high-accuracy simulations are used selectively for refinement—with the massive parallelism enabled by exascale HPC architectures.

The targetted applications are in fluid dynamics and aerodynamics, geophysical wave propagation, and microswimmer dynamics. These domains rely on hierarchical modeling approaches, ranging from fast but approximate low-fidelity models to highly accurate, computationally intensive simulations. A central challenge is therefore to design optimization methods capable of efficiently and adaptively exploiting multiple fidelity levels.

SAGE-HPC tackles this challenge by integrating a range of optimization paradigms, including Bayesian optimization, deep reinforcement learning, deterministic methods, and hybrid strategies. The goal is to identify and deploy the most suitable optimization approach based on the characteristics of the problem, its complexity, and the available computational resources and scalability of the solvers. The project is organized around four main pillars: (1) the development of optimization methods specifically designed for multi-fidelity contexts; (2) the creation of an open benchmark library spanning multiple physical domains and fidelity hierarchies; (3) a comparative analysis of optimization strategies, with attention to parallel performance and neural network architectures; and (4) deployment and integration on exascale HPC platforms.

Overall, SAGE-HPC aims to advance the convergence of AI and HPC by delivering open, reproducible, and scalable tools for intelligent optimization at extreme scale.

The University of Illinois' National Center for Supercomputing Applications (NCSA) Engagement Directorate is currently collaborating to make advances in several areas of High-Performance Computing (HPC) that align with topics of interest to JLESC attendees. These include advances from our Center for Artificial Intelligence Innovations (CAII) and our new Quantum Programming Office (QPO) which is focused on advancing quantum computing as part of an HPC system’s overall architecture.

Vector databases are used to store the embeddings used by modern AI models and are a critical part of AI for science workflows. Their performance, however, varies depending on the workload used and the resources they run on. In this presentation, we will describe a measurement scheme for vector databases. We will describe the key drivers of their peformance behavior and connect that to the behavior of shared HPC systems. We will present results from a structured strategy of applying a spectrum of workloads to the database, including synthetic cases and a case from a cancer investigation. We will then present results from the use of a previously-developed performance prediction model to the performance of the vector database on a shared resource, which poses a very challenging prediction problem.

The end of Moore’s Law compels the exploration of new approaches to the future of computing. One promising direction is heterogeneous architecture, which integrates reconfigurable devices such as field-programmable gate arrays (FPGAs) and coarse-grain reconfigurable architectures (CGRAs), alongside AI accelerators including Cerebras, Groq, and SambaNova. These systems exploit hardware specialization and dataflow-oriented computation to achieve higher efficiency.

In this breakout session, we will explore key topics and opportunities in hardware–software co-design, simulation and emulation methodologies, AI-assisted chip design and prototyping, emerging accelerators and architectures, programming paradigms, and relevant application domains. The talks will showcase recent research in these areas. We will also foster the exchange of ideas among participants, encouraging collaborative discussion on the scope and future direction of the JLESC collaboration.

I will present a hybrid quantum–HPC workflow that turns a shallow, NISQ-realistic constrained quantum core into end-to-end approximation pipelines for structured combinatorial optimization. The target problem class live the CE–QAOA kernel. Such problems admit a block one-hot (fixed-Hamming-weight) encoding, a diagonal objective, and a structured penalty Hamiltonian built from squared affine one-hot/degree/capacity constraints with bounded integer coefficients and strong pattern symmetries (block permutations and symbol relabelings). The quantum core uses a normalized block-XY mixer that preserves the encoded sector and a uniform one-hot product initialization (W-state per block), and is assumed to provide an instance-independent, dimension-free inverse-polynomial optimum hit probability.

The HPC layer then performs two structure-aware steps: (i) deterministic feasibility repair via Hamming-nearest projection and (ii) heavy-hitter extraction exploiting block factorization to shrink the retained candidate set dramatically before scoring. A total-variation robustness bound converts device noise and compilation/approximation error into explicit shot budgets, thresholds, and depth-compression rules. I will close by posing concrete open problems for JLESC collaborations on workflow integration, compiler–noise co-design, scalable repair beyond permutations, and cross-site benchmarking protocols.

Pattern recognition for track reconstruction at future particle colliders presents a highly combinatorial challenge. The problem is formulated as a Quadratic Unconstrained Binary Optimization (QUBO) model, where candidate track segments are constructed from grouped detector hits in a classical preprocessing stage.

The QUBO encodes geometric compatibility between hit groupings and penalizes mutually conflicting combinations. Depending on event complexity, QUBO sizes range from a few hundred up to about 10⁵ variables. The study is based on 10,000 simulated events from a muon collider detector scenario, characterized by around 10⁶ background hits per event, with segment construction and QUBO generation parallelized across HPC resources.

Preprocessing and QUBO construction are executed on classical clusters. Due to current hardware size constraints, large QUBOs are decomposed into subproblems of 100 variables. These subproblems are solved either on the D-Wave Systems quantum annealer or with classical solvers such as Gurobi Optimization within the same workflow. The QUBO coefficients can additionally be tuned using machine learning techniques to improve discrimination between compatible and incompatible hit groupings. This enables a direct comparison of quantum annealing and classical optimization for identical problem instances.

A state-vector simulator of quantum computers has been developed for use on supercomputers. Our simulator, RIKEN-braket, removes the conventional limitations on the number of MPI processes and the size of the state-vector data array imposed by commonly used parallelization methods. We demonstrate that our simulator scales efficiently up to 46 qubits on the supercomputer Fugaku, using up to 55,296 computing nodes. We also describe recent enhancements to the simulator, including gate fusion and support for multiple circuits to enable simulations of variational algorithms.

Near-term quantum computing is expected to rely on distributed quantum computing (DQC) across multiple interconnected quantum processing units rather than on monolithic devices. Such systems inherently depend on quantum interconnects and require substantial classical computation for coordination, control, and error correction. As a result, meaningful hybrid quantum classical computing in the near term is fundamentally a hybrid DQC-HPC problem.

In this work, we present an ongoing effort to simulate hybrid DQC-HPC workflows using a software-driven, system-level approach. Building on our existing distributed quantum computing simulation framework implemented using the SeQUeNCe quantum network simulator, we have developed abstractions for DQC nodes that integrate data qubits, communication qubits, and non-local quantum operations such as teleportation, teledata, and telegate. Using this framework, we have successfully simulated distributed Grover’s algorithm across networked quantum nodes with full correctness.

We propose to extend this work toward end-to-end simulation of hybrid DQC-HPC applications by explicitly modeling three interacting components. First, quantum interconnects are simulated to capture entanglement generation, communication latency, and error behavior across QPU boundaries. Second, distributed quantum programs are modeled at the level of execution structure and inter-node dependencies rather than detailed hardware timing. Third, classical HPC resources are introduced as first-class participants responsible for distributed compilation, execution coordination, classical control, and in particular distributed quantum error correction (dQEC) decoding, which is computationally intensive and latency sensitive.

The goal of this effort is not to predict quantum hardware performance, but to expose software and systems challenges that arise when quantum networks, distributed quantum programs, and classical HPC runtimes interact at scale. By enabling simulation of hybrid DQC-HPC workflows, this work aims to support exploration of scheduling strategies, communication patterns, classical control and coordination with quantum execution, and resource trade-offs across architectures.

This contribution aligns directly with JLESC’s focus on hybrid QC-HPC software challenges and is intended to seed cross-institution collaboration on system-level abstractions for scalable, networked quantum computing.