Skip to content


Subversion checkout URL

You can clone with
Download ZIP
ATTENTION: main repository moved to the AccelerateHS organisation — this is only a fork!
Haskell C
Pull request Compare This branch is 767 commits behind AccelerateHS:master.
Fetching latest commit...
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
accelerate-backend-kit @ 62d0de9
accelerate-buildbot @ 43fdf02
accelerate-cuda @ 9a2a93c
accelerate-examples @ b6caf20
accelerate-io @ d4d0af5

An Embedded Language for Accelerated Array Computations

Data.Array.Accelerate defines an embedded language of array computations for high-performance computing in Haskell. Computations on multi-dimensional, regular arrays are expressed in the form of parameterised collective operations (such as maps, reductions, and permutations). These computations are online-compiled and executed on a range of architectures.

For more details, see our recent paper Accelerating Haskell Array Codes with Multicore GPUs. There are also some slightly outdated slides and a video of a talk that I gave at the Haskell Implementors Workshop 2009 (in Edinburgh): Haskell Arrays, Accelerated (Using GPUs).

A simple example

As a simple example, consider the computation of a dot product of two vectors of single-precision floating-point numbers:

dotp :: Acc (Vector Float) -> Acc (Vector Float) -> Acc (Scalar Float)
dotp xs ys = fold (+) 0 (zipWith (*) xs ys)

Except for the type, this code is almost the same as the corresponding Haskell code on lists of floats. The types indicate that the computation may be online-compiled for performance — for example, using it may be on-the-fly off-loaded to a GPU.


Package accelerate is available from

  • Hackage: accelerate — install with cabal install accelerate
  • GitHub: AccelerateHS/accelerate - get the source with git clone

Additional components

The following supported addons are available as separate packages on Hackage and included as submodules in the GitHub repository:

  • accelerate-cuda Backend targeting CUDA-enabled NVIDA GPUs
  • accelerate-examples Computational kernels and applications showcasing the use of Accelerate as well as a regression test suite (supporting function and performance testing)
  • accelerate-io Fast conversion between Accelerate arrays and other array formats (including Repa arrays)
  • accelerate-backend-kit Simplified internal AST to get going on writing backends
  • accelerate-buildbot Build bot for automatic performance & regression testing

The following additional components are experimental and incomplete:


  • Glasgow Haskell Compiler (GHC), 7.0.3 or later
  • Haskell libraries as specified in accelerate.cabal
  • For the CUDA backend, CUDA version 3.0 or later

Examples and documentation

The GitHub repository contains a submodule accelerate-examples, which provides a range of computational kernels and a few complete applications. To install these from Hackage, issue cabal install accelerate-examples.

  • Haddock documentation is included in the package and linked from the Hackage page.
  • Online documentation is on the GitHub wiki.
  • The idea behind the HOAS (higher-order abstract syntax) to de-Bruijn conversion used in the library is described separately.


The maintainer of this package is Manuel M T Chakravarty (aka TacticalGrace on #haskell and related channels).

Both user and developer questions and discussions are welcome at Sorry, this mailing list is currently unavailable.

Bug reports and issues tracking are on the GitHub project page.

What's missing?

Here is a list of features that are currently missing:

  • The CUDA backend does not support arrays of type Char and Bool at the moment.
  • Preliminary API (parts of the API may still change in subsequent releases)
Something went wrong with that request. Please try again.