Specification

Technical Overview

A common technical model for accelerated computing

oneAPI is an open, cross-architecture technical model for accelerated computing. It gives developers a common way to express parallel work and use performance libraries across CPUs, GPUs, and other accelerators while allowing implementations to optimize for different hardware.

The oneAPI specification provides the shared foundation for this model. UXL maintains it dynamically: this website describes the durable concepts and project relationships, while each library’s published documentation is the canonical source for current interfaces, requirements, and supported configurations.

One model, two programming approaches

Library programming

For established problem domains, developers can call libraries that package high-performance algorithms behind well-defined interfaces. The six UXL libraries cover math, analytics, deep learning, collective communication, parallel algorithms, and task-based parallelism.

Direct programming

When an application needs custom parallel algorithms or finer control, developers can express parallel work directly in C++ with SYCL. SYCL is an open Khronos standard for heterogeneous programming and provides a consistent way to discover devices, manage data, and execute code across supported accelerator environments.

Goals of the oneAPI technical model

Source portability: Help applications and middleware move across supported environments through recompilation and tuning.
Performance transparency: Give developers enough control to optimize for the characteristics of the target hardware.
Open collaboration: Develop interfaces, implementations, and documentation together in open UXL projects.
Composable building blocks: Allow developers to combine library programming and direct programming according to application needs.

How the pieces fit together

Applications can use UXL libraries, direct SYCL programming, or a combination of both. Individual projects may use SYCL, system runtimes, third-party libraries, and hardware-specific optimizations as appropriate. Their published documentation defines current behavior and support.

A dynamic specification

The oneAPI technical model evolves with the projects that implement it. Instead of waiting for a bundled specification release, UXL maintains the shared concepts on this website and develops the current technical definitions within each project.

Project documentation is the canonical source for current APIs, requirements, compatibility, and supported configurations. Project repositories contain the implementation and provide the place to propose changes, report issues, and contribute.

Start building and contributing

UXL welcomes collaboration on the oneAPI technical model and the open source projects that implement it. Explore the libraries, use their current documentation, and join the community to help shape future work.

Explore oneAPI libraries Become a member

Useful links

Learn more and get started

Project GitHub Documentation Slack Space Working Groups

Start building with open source tools that use oneAPI elements

All open source

dpNP

NumPy-like API accelerated with SYCL

Data Parallel Extension for NumPy (dpnp) is a Python library that implements a subset of NumPy and can be executed on any data-parallel device. The subset is a drop-in replacement of core NumPy functions and numerical data types. dpnp is the core part of a larger family of data-parallel Python libraries and tools for programming on XPUs.

DPCTL

Python bindings for SYCL classes

Data Parallel Control (DPCTL) is a Python library that allows users to control the execution placement of a compute kernel on an XPU. The library is built on the SYCL standard and provides Python bindings for a subset of the standard runtime classes, allowing users to query platforms, discover and represent devices and sub-devices, and construct contexts and queues. The library helps authors of Python-native extensions written in C, Cython, or pybind11 access DPCTL objects representing SYCL devices, queues, memory, and tensors.

DPC++

C++ compiler (clang++/LLVM based) with support for SYCL

DPC++ is an LLVM-based compiler project that implements compiler and runtime support for the latest SYCL standard. The project is hosted in the SYCL branch and synced with the tip of the LLVM upstream main branch on a regular basis.

PyTorch

Deep learning framework

PyTorch is a Python package that provides tensor computation (like NumPy) with strong GPU acceleration and deep neural networks built on a tape-based autograd system. You can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed.

oneDPL

Apache MXNet

Deep learning framework

Apache MXNet is a deep learning framework designed for both efficiency and flexibility. It allows you to mix symbolic and imperative programming to maximize efficiency and productivity. At its core, MXNet contains a dynamic dependency scheduler that automatically parallelizes both symbolic and imperative operations on the fly. A graph-optimization layer on top of that makes symbolic execution fast and memory-efficient. MXNet is portable, lightweight, and scalable to many GPUs and machines. *NOTE: This project has retired, and the repository is now read-only.

Ginkgo

High-performance linear algebra library, integrated into significant applications in the scientific domain such as deal.II, MFEM, OpenFOAM, HyTeG, Sundials, XGC, HiOp, and OpenCARP.

Ginkgo is a high-performance linear algebra library for many core systems, with a focus on solutions for sparse linear systems. It is implemented using modern C++ (you will need at least a C++17 compliant compiler to build it), with GPU kernels implemented in CUDA for NVIDIA devices, HIP for AMD devices, and SYCL/DPC++ for Intel devices and other supported hardware.

hipSYCL++

Library-based implementation of SYCL

AdaptiveCpp (formerly known as hipSYCL / Open SYCL) is an independent, community-driven compiler for C++-based heterogeneous programming models targeting CPUs and GPUs from all major vendors. AdaptiveCpp lets applications adapt themselves to all the hardware found in the system, even at runtime.

Explore implementations

All Case Studies