Open · device-agnostic · HPC & AI
Code once.
Execute on all.
ParaS Ecosystem is an open-source software stack for portable, high-performance computing — one source, compiled and tuned across CPU, GPU, NPU, FPGA and QPU targets, without rewriting for every backend.
Getting started
Three steps in
Hardware support varies by component — pick the one you need and go straight to its commands below.
Check supported hardware
CPU and NVIDIA GPU are public for the compiler; CLAP and the PyTorch integration additionally support AMD GPU today.
See supported hardware →Clone the component you need
The compiler, the CLAP math library, and the PyTorch integration are separate repositories — clone the one your workflow needs.
Browse projects →Build and run
Real install and compile commands, straight from the project READMEs — for the compiler, CLAP, and the PyTorch framework.
Jump to commands →About
One codebase, every accelerator
HPC and AI teams increasingly target a mix of hardware — CPUs from different vendors, GPUs, NPUs, FPGAs, and emerging quantum accelerators. ParaS Ecosystem exists so portability doesn't cost performance, and performance doesn't cost you five versions of the same kernel. It spans the full stack — compiler, math libraries, and framework integrations — so every project in the ecosystem shares the same "code once, execute on all" foundation instead of solving portability on its own.
Why ParaS
Built on four principles
Portable
A single source targets every supported backend — no forked kernels per vendor, no duplicated tuning effort.
Performant
Portability is validated against native toolchains — not offered in exchange for giving up throughput.
Open
Development, design discussion, review and roadmap happen in public, under a published Technical Charter.
Modular
Compiler, runtime, and libraries are independently useful and independently versioned.
Supported hardware
What's public today
Hardware support isn't one-size-fits-all across the ecosystem — each project has its own backend maturity. Switch between components to see what's public.
CPU
x86 (Intel & AMD) and ARM, via the OpenMP runtime.
NVIDIA GPU
CUDA-enabled GPUs, via the CUDA runtime and -parasdevice cuda:sm_x.
AMD GPU
ROCm-based support is planned as part of the ecosystem's backend roadmap.
NPU · FPGA · QPU
Emerging accelerator targets, added at the backend interface as they mature.
CPU
x86 and ARM, via OpenBLAS — selected at runtime with -cpu.
NVIDIA GPU
CUDA-enabled GPUs, via cuBLAS — selected at runtime with -cuda.
AMD GPU
ROCm-enabled GPUs, via rocBLAS — selected at runtime with -rocm.
CPU
PyTorch workloads route through the ParaS CPU backend.
NVIDIA GPU
PyTorch workloads route through the ParaS CUDA backend.
AMD GPU
PyTorch workloads route through the ParaS ROCm backend.
Architecture
The stack, top to bottom
Each layer is a real boundary in the system — this is the path your code actually takes on its way to silicon. Click a target below.
- Applications of HPC-AI — domain applications built on the ecosystem
- AI framework & workflows — integration with established scientific-computing and AI frameworks
- ParaS libraries & developer tools — CLAP, math libraries, profiling and build tooling
- Compiler, runtime & hardware abstraction — backend interfaces shared across targets
- Targets — CPU, GPU, NPU, FPGA, QPU and emerging accelerators
Try it
From clone to compiled, in a few commands
Straight from the project READMEs — build the compiler, pick a backend for CLAP, or wire the PyTorch integration into your environment.
# requirements: Linux, Clang/LLVM v21.1.0, CMake 3.28+ git clone https://github.com/ParaS-Ecosystem/ParaS-Compiler.git cd ParaS-Compiler mkdir build && cd build # configure (Unix Makefiles) cmake -G "Unix Makefiles" ../ \ -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \ -DCMAKE_C_COMPILER=clang \ -DPARAS_BASE_COMPILER=clang++ \ -DPARAS_INSTALL_PREFIX=/path/to/install/dir \ -DCMAKE_CXX_FLAGS="-std=c++17" make -j$(nproc) make install # add parascc to your environment export PATH=/path/to/install/dir/bin:$PATH export LD_LIBRARY_PATH=/path/to/install/dir/lib:$LD_LIBRARY_PATH # compile — CPU (accepts any Clang/LLVM v21.1.0 flag) parascc program.cpp <compiler flags> -o executable # compile — GPU (xx = compute capability, e.g. sm_80) parascc -parasdevice cuda:sm_xx program.cpp -o executable# 1. clone git clone https://github.com/ParaS-Ecosystem/CLAP-Library.git cd CLAP-Library # 2. build with CMake — see the repo README for full build options cmake -B build cmake --build build # 3. compile against CLAP parascc example.cpp -I/path/to/include -L/path/to/lib -lclap -o example # 4. pick a backend at runtime — same binary, no rebuild ./example -cpu # OpenBLAS ./example -cuda # cuBLAS — NVIDIA GPU ./example -rocm # rocBLAS — AMD GPU# 1. clone the framework integration git clone https://github.com/ParaS-Ecosystem/Framework-Torch-ParaS.git cd Framework-Torch-ParaS # 2. see the repo README for build & integration steps — # exact setup depends on your PyTorch version # once installed, PyTorch workloads route through the ParaS # CPU, CUDA (NVIDIA), or ROCm (AMD) backend — see the README # for the exact device API for your PyTorch version
Projects
What's in the ecosystem
ParaS Compiler
A SYCL 2020 implementation for architecture- and vendor-neutral programming — the engine behind "Code Once, Execute on All."
CLAP Library
Cross-platform Linear-algebra And PDE library — unified BLAS, LAPACK, FFT and PDE kernels across CPU and GPU backends.
Framework-Torch-ParaS
Hosts HPC-AI frameworks enhanced with ParaS backend support, for unified execution across heterogeneous computing architectures.
All repositories
Browse every project, including community-health files and what's incubating, in the ParaS-Ecosystem GitHub organization.
Governance
How decisions get made
The ecosystem is governed by a Technical Steering Committee that sets overall technical direction, while each project's maintainers retain day-to-day autonomy over issues, reviews, and releases.
The full model — scope, decision-making, voting, and maintainer process — is written down and versioned like the rest of the code.
Read the Technical CharterContribute code
However you want to take part
Already up and running? Here's how to go from user to contributor.
Contribute code
Pick up an open issue, propose a feature, or improve documentation. Reviews and roadmap discussion happen directly on GitHub.
Read the contributing guide →Use it in your project
Adopt ParaS, CLAP, or framework integrations in your own HPC or AI workloads and target multiple backends from one codebase.
Explore the projects →Built in the open, built with contributors
Issues, discussions, and pull requests happen directly on GitHub — that's also where the roadmap lives.