ORNL debuts JACC for performance-portable Julia for HPC systems

Researchers from the Department of Energy's (DOE) Oak Ridge National Laboratory (ORNL) have developed a new open-source software framework that significantly advances performance portability for the Julia programming language across heterogeneous high-performance computing (HPC) architectures. The framework, known as Julia for ACCelerators (JACC) enables a single Julia codebase to execute efficiently on CPUs and GPUs from multiple hardware vendors, such as NVIDIA, AMD, Intel and Apple, addressing a long-standing challenge in the Julia HPC ecosystem.

Julia has seen growing adoption in scientific computing due to its expressive syntax, high-level productivity, and strong performance characteristics. However, its use at scale on leadership-class HPC systems has been constrained by limited support for performance portability, or the ability of a software application to run efficiently using a single source code across diverse accelerator architectures. In practice, Julia developers seeking GPU performance have often been forced to rely on vendor-specific programming models, undocumented workflows, or duplicated code paths. This creates barriers to productivity, sustainability and broader adoption in DOE computing environments. JACC was designed to remove those barriers.

"Our team is exploring how to write production Computational Fluid Dynamics (CFD) codes for tomorrow's architectures, with four key requirements: performance, portability, ease of use, and a low barrier to entry," said Jean-François Boussuge, Advanced Aerodynamics and Multiphysics Team, European Center for Research and Advanced Training in Scientific Computing (CERFACS). "Julia is a promising path and JACC is a key enabler. Our flagship Lattice Boltzmann code BLAST was quickly running on NVIDIA, AMD, Intel and Apple GPUs and multi-threaded CPUs, with competitive performance and without maintaining separate backend-specific kernels. The write-once, run-anywhere approach of JACC fits perfectly with our vision: HPC portable code that remains accessible to domain scientists."

A unified programming model for Julia HPC

JACC introduces a unified programming model for Julia that is conceptually aligned with established performance-portable approaches used in other languages, such as Kokkos, RAJA and SYCL in C++ and OpenMP and OpenACC in C/C++ and Fortran. With JACC, developers can write a single Julia application that targets heterogeneous architectures, including CPUs from Intel, AMD and Arm, as well as GPUs from NVIDIA, AMD, Intel and Apple.

JACC keeps up with hardware evolution, advancing the programmability of multi-GPU nodes, shared memory to exploit fast-memory caches, and asynchronous kernel execution. This allows scientists to run complex code faster and more efficiently across different types of hardware without rewriting it. These features are not necessarily available in the listed portable programming models in C++ or Fortran, but available through Julia's just-in-time and rich metaprogramming compilation model on top of the widely adopted a low-level virtual machine, or LLVM, compiler framework.

"DOE has a long track-record of contributions to vendor-neutral computing," said Patrick Diehl, research scientist at Los Alamos National Laboratory. "JACC continues this tradition as Julia becomes adopted for new science cases in AI and quantum computing"

This capability directly addresses a central challenge in DOE's HPC environments, where scientific applications must be prepared to run on rapidly evolving, vendor-diverse systems. By eliminating the need for architecture-specific code paths, JACC reduces software complexity, improves maintainability and lowers the cost of adapting applications to current and future leadership-class platforms.

Balancing productivity and performance

At the core of JACC is a simple but powerful application programming interface built around three abstractions: array, parallel_for and parallel_reduce. These abstractions allow developers to express parallelism, which is the execution of multiple tasks simultaneously in order to speed up processing, and data movement in a way that is portable across architectures while remaining natural for Julia users.

For non-expert users, JACC automatically selects reasonable execution strategies and data layouts, enabling CPU and GPU execution with minimal configuration and no accelerator-specific programming. For performance specialists, the framework exposes optional low-level controls that allow fine-grained tuning to extract maximum performance on specific architectures.

This layered design reflects ORNL's long-standing emphasis on balancing usability and performance in scientific software. By shifting the complexity of performance portability into the library itself, JACC allows domain scientists to focus on scientific discovery rather than hardware-specific optimization.