What ArrayFire changes
Move from backend-specific plumbing to readable array code while retaining control over devices, memory, and custom kernels.
Write the algorithm once
Express linear algebra, image, signal, statistics, and elementwise operations through a stable multidimensional array API.
Fuse work before launch
ArrayFire's JIT engine combines compatible array expressions to reduce temporary storage and unnecessary kernel launches.
Choose hardware at deployment
Target NVIDIA, AMD, Intel, or CPU systems without rebuilding the application around a different high-level API.
Published project results
ArrayFire has been applied to real imaging, computer vision, and quantitative computing workloads. These published results provide concrete examples of what acceleration looked like for those specific systems.
Quantitative phase imaging
A red-blood-cell imaging workflow reported more than 200x acceleration with ArrayFire.
Read the projectORB feature description
An ArrayFire ORB implementation reported 21.6x speedup over the compared CPU code.
Read the benchmarkOption pricing
An ArrayFire stock-path workload reported 51.8x speedup over baseline CPU MATLAB code.
Read the case studyPerformance is workload, data-size, backend, and hardware dependent. These are historical project results, not guarantees for other applications.
Five-minute start
Readable C++. Accelerated execution.
Create arrays, compose operations, and let ArrayFire schedule the work on the active backend. The same core API is available through all supported language interfaces.
#include <arrayfire.h>
int main() {
af::array signal = af::randu(1 << 20);
af::array spectrum = af::fft(signal);
af::array energy = af::abs(spectrum);
af::print("peak", af::max(energy));
af::sync();
return 0;
}A practical backend model
Select the execution path that matches the deployment. Application-level array code stays consistent while backend libraries and kernels do the specialized work.
| Backend | Primary hardware | Best fit |
|---|---|---|
| CUDA | NVIDIA GPUs | Deep GPU optimization and the NVIDIA software ecosystem |
| OpenCL | AMD, Intel, and NVIDIA devices | Cross-vendor GPU and accelerator deployments |
| oneAPI | Intel GPUs and accelerators | Modern Intel heterogeneous systems |
| CPU | Multicore processors | Portable development, fallback, and CPU-only deployment |
Explore the architecture
The former hero stories now work as a guided product tour: language reach, backend portability, and native streaming throughput.
Accelerated AI in the language your team already uses.
Build array, tensor, vision, and signal-processing workloads from C++, Python, Rust, Julia, Java, and more. ArrayFire keeps the code expressive while the compute runs on optimized native backends.
Explore AI examples
One array API. Many execution backends.
Keep application code stable while choosing CUDA, OpenCL, oneAPI, or CPU at deployment. ArrayFire combines vendor libraries, custom kernels, and JIT-fused expressions behind a consistent programming model.
Compare backends
Keep data moving through native compute pipelines.
Process frames, samples, and tensors with a C++-native engine designed for sustained throughput, lower staging overhead, and predictable GPU/CPU execution paths.
Explore streaming workloadsReady to run ArrayFire?
Choose a platform installer or build directly from source.
Open source, with expert help available
ArrayFire is free and open source, including for commercial use. Consulting, performance engineering, and training help fund continued maintenance while giving teams a direct path to production support.
