diff --git a/accelerate-fftw.cabal b/accelerate-fftw.cabal
--- a/accelerate-fftw.cabal
+++ b/accelerate-fftw.cabal
@@ -1,10 +1,10 @@
 Name:             accelerate-fftw
-Version:          1.0.0.1
+Version:          1.0.1
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
 Maintainer:       Henning Thielemann <haskell@henning-thielemann.de>
-Homepage:         http://hub.darcs.net/thielema/accelerate-fftw/
+Homepage:         https://hub.darcs.net/thielema/accelerate-fftw/
 Category:         Math
 Synopsis:         Accelerate frontend to the FFTW library (Fourier transform)
 Description:
@@ -15,21 +15,21 @@
 Build-Type:       Simple
 
 Source-Repository this
-  Tag:         1.0.0.1
+  Tag:         1.0.1
   Type:        darcs
-  Location:    http://hub.darcs.net/thielema/accelerate-fftw/
+  Location:    https://hub.darcs.net/thielema/accelerate-fftw/
 
 Source-Repository head
   Type:        darcs
-  Location:    http://hub.darcs.net/thielema/accelerate-fftw/
+  Location:    https://hub.darcs.net/thielema/accelerate-fftw/
 
 Library
   Build-Depends:
     fft >=0.1.7 && <0.2,
     carray >=0.1.5 && <0.2,
     storable-complex >=0.2.1 && <0.3,
-    accelerate-io >=1.0 && <1.1,
-    accelerate >=1.0 && <1.2,
+    accelerate-io >=1.2 && <1.3,
+    accelerate >=1.2 && <1.3,
     base >=4.5 && <5
 
   GHC-Options:      -Wall -fwarn-missing-import-lists
diff --git a/src/Data/Array/Accelerate/CArray/Conversion.hs b/src/Data/Array/Accelerate/CArray/Conversion.hs
--- a/src/Data/Array/Accelerate/CArray/Conversion.hs
+++ b/src/Data/Array/Accelerate/CArray/Conversion.hs
@@ -2,68 +2,62 @@
 {-# LANGUAGE TypeOperators #-}
 module Data.Array.Accelerate.CArray.Conversion where
 
-import qualified Data.Array.Accelerate.IO as AIO
+import qualified Data.Array.Accelerate.IO.Foreign.ForeignPtr as AIO
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate.Array.Sugar (EltRepr)
 import Data.Array.Accelerate (Array, DIM1, DIM2, Z(Z), (:.)((:.)))
 
 import qualified Data.Array.CArray as CArray
-import Data.Array.CArray (CArray, createCArray, withCArray, rangeSize)
+import Data.Array.CArray (CArray, unsafeForeignPtrToCArray, rangeSize)
 import Data.Ix (Ix)
 import Foreign.Storable.Complex ()
 
 import Data.Array.Accelerate.Data.Complex (Complex)
-import qualified Data.Complex as Complex
 
 import System.IO.Unsafe (unsafePerformIO)
-import Foreign.ForeignPtr (withForeignPtr)
-import Foreign.Ptr (Ptr)
+import Foreign.ForeignPtr (ForeignPtr,)
 import Foreign.Storable (Storable)
 
-import Control.Monad ((<=<))
-import Data.IORef (newIORef, writeIORef, readIORef)
 
-
 accFromCArrayReal1D ::
-   (A.Elt a, Storable a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+   (A.Elt a, Storable a, AIO.ForeignPtrs (EltRepr a) ~ ForeignPtr a) =>
    CArray Int a -> Array DIM1 a
 accFromCArrayReal1D arr =
    let (len, fptr) = CArray.toForeignPtr arr
-   in  unsafePerformIO $
-       withForeignPtr fptr $ \ptr -> AIO.fromPtr (Z :. len) ptr
+   in  AIO.fromForeignPtrs (Z :. len) fptr
 
 accFromCArrayReal2D ::
-   (A.Elt a, Storable a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+   (A.Elt a, Storable a, AIO.ForeignPtrs (EltRepr a) ~ ForeignPtr a) =>
    CArray (Int, Int) a -> Array DIM2 a
 accFromCArrayReal2D arr =
-   unsafePerformIO $
-   withCArray arr $ \ptr ->
-      AIO.fromPtr (accDimsFromArrayBounds2D $ CArray.bounds arr) ptr
+   AIO.fromForeignPtrs
+      (accDimsFromArrayBounds2D $ CArray.bounds arr)
+      (snd $ CArray.toForeignPtr arr)
 
 
 accFromCArrayComplex1D ::
-   (A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+   (Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
    CArray Int (Complex a) -> Array DIM1 (Complex a)
 accFromCArrayComplex1D arr =
    accFromCArrayComplex (accDimsFromArrayBounds1D $ CArray.bounds arr) arr
 
 accFromCArrayComplex2D ::
-   (A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+   (Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
    CArray (Int, Int) (Complex a) -> Array DIM2 (Complex a)
 accFromCArrayComplex2D arr =
    accFromCArrayComplex (accDimsFromArrayBounds2D $ CArray.bounds arr) arr
 
 accFromCArrayComplex ::
-   (Ix i, A.Shape sh,
-    A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
-   sh -> CArray i (Complex a) -> Array sh (Complex a)
+   (Ix i, A.Shape sh, Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
+   sh -> CArray i ac -> Array sh ac
 accFromCArrayComplex sh arr =
-   unsafePerformIO $
-   withCArray (CArray.amap Complex.realPart arr) $ \ptrReal ->
-   withCArray (CArray.amap Complex.imagPart arr) $ \ptrImag ->
-      AIO.fromPtr sh (((), ptrReal), ptrImag)
+   AIO.fromForeignPtrs sh (snd $ CArray.toForeignPtr arr)
 
 
+
 accDimsFromArrayBounds1D :: (CArray.Ix i) => (i, i) -> DIM1
 accDimsFromArrayBounds1D bnds = Z :. rangeSize bnds
 
@@ -74,49 +68,51 @@
 
 
 cArrayFromAccReal1D ::
-   (A.Elt a, Storable a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+   (A.Elt a, Storable a, AIO.ForeignPtrs (EltRepr a) ~ ForeignPtr a) =>
    Array DIM1 a -> CArray Int a
 cArrayFromAccReal1D arr =
    let (Z:.len) = A.arrayShape arr
    in  unsafePerformIO $
-       createCArray (0,len-1) $ \ptr -> AIO.toPtr arr ptr
+       unsafeForeignPtrToCArray (AIO.toForeignPtrs arr) (0,len-1)
 
 cArrayFromAccReal2D ::
-   (A.Elt a, Storable a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+   (A.Elt a, Storable a, AIO.ForeignPtrs (EltRepr a) ~ ForeignPtr a) =>
    Array DIM2 a -> CArray (Int, Int) a
 cArrayFromAccReal2D arr =
    unsafePerformIO $
-   createCArray (arrayBounds2DFromAccDims $ A.arrayShape arr) $ \ptr ->
-      AIO.toPtr arr ptr
+   unsafeForeignPtrToCArray (AIO.toForeignPtrs arr)
+      (arrayBounds2DFromAccDims $ A.arrayShape arr)
 
 cArrayFromAccComplex1D ::
-   (A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
-   Array DIM1 (Complex a) -> CArray Int (Complex a)
+   (Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
+   Array DIM1 ac -> CArray Int ac
 cArrayFromAccComplex1D arr =
    cArrayFromAccComplex
       (arrayBounds1DFromAccDims $ A.arrayShape arr) arr
 
 cArrayFromAccComplex2D ::
-   (A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
-   Array DIM2 (Complex a) -> CArray (Int,Int) (Complex a)
+   (Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
+   Array DIM2 ac -> CArray (Int,Int) ac
 cArrayFromAccComplex2D arr =
    cArrayFromAccComplex
       (arrayBounds2DFromAccDims $ A.arrayShape arr) arr
 
 cArrayFromAccComplex ::
    (Ix i, A.Shape sh,
-    A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
-   (i,i) -> Array sh (Complex a) -> CArray i (Complex a)
-cArrayFromAccComplex bnds arr = unsafePerformIO $ do
-   fmap (uncurry (CArray.liftArray2 (Complex.:+))) $
-      createCArrayAdd bnds $ \ptrReal ->
-      createCArray bnds $ \ptrImag ->
-         AIO.toPtr arr (((), ptrReal), ptrImag)
+    Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
+   (i,i) -> Array sh ac -> CArray i ac
+cArrayFromAccComplex bnds arr =
+   unsafePerformIO $
+   unsafeForeignPtrToCArray (AIO.toForeignPtrs arr) bnds
 
 
 withCArrayComplex ::
    (Ix i, A.Shape sh,
-    A.Elt a, Storable a, RealFloat a, AIO.BlockPtrs (EltRepr a) ~ Ptr a) =>
+    Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,
+    AIO.ForeignPtrs (EltRepr ac) ~ ForeignPtr ac) =>
    (sh -> (i,i)) ->
    (CArray i (Complex a) -> CArray i (Complex a)) ->
    Array sh (Complex a) -> Array sh (Complex a)
@@ -124,15 +120,6 @@
    let sh = A.arrayShape arr
    in  accFromCArrayComplex sh $ f $
        cArrayFromAccComplex (bndsFromSh sh) arr
-
-
-createCArrayAdd ::
-   (Ix i, Storable e) =>
-   (i,i) -> (Ptr e -> IO a) -> IO (CArray i e, a)
-createCArrayAdd bnds create = do
-   ref <- newIORef (error "uninitialized inner value")
-   arr <- createCArray bnds $ writeIORef ref <=< create
-   fmap ((,) arr) $ readIORef ref
 
 
 arrayBounds1DFromAccDims :: DIM1 -> (Int, Int)
diff --git a/src/Data/Array/Accelerate/FFTW/Manifest.hs b/src/Data/Array/Accelerate/FFTW/Manifest.hs
--- a/src/Data/Array/Accelerate/FFTW/Manifest.hs
+++ b/src/Data/Array/Accelerate/FFTW/Manifest.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE ConstraintKinds #-}
 module Data.Array.Accelerate.FFTW.Manifest (
    Transform,
@@ -15,7 +16,7 @@
 
 import qualified Data.Array.Accelerate.CArray.Conversion as Conv
 
-import qualified Data.Array.Accelerate.IO as AIO
+import qualified Data.Array.Accelerate.IO.Foreign.ForeignPtr as AIO
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate.Array.Sugar (EltRepr)
 import Data.Array.Accelerate (Array, (:.)((:.)))
@@ -24,14 +25,16 @@
 
 import Data.Array.Accelerate.Data.Complex (Complex)
 
-import Foreign.Ptr (Ptr)
+import Foreign.ForeignPtr (ForeignPtr)
 
 
 type Bounds i = (i,i)
 
 type Transform sh a = Array sh a -> Array sh a
 
-type Element a = (FFTWReal a, A.Elt a, AIO.BlockPtrs (EltRepr a) ~ Ptr a)
+type Element a =
+      (FFTWReal a, A.Elt (Complex a),
+       AIO.ForeignPtrs (EltRepr (Complex a)) ~ ForeignPtr (Complex a))
 
 dft ::
    (A.Shape sh, Element a) =>