diff --git a/Data/Array/Accelerate/IO/BlockCopy.hs b/Data/Array/Accelerate/IO/BlockCopy.hs
--- a/Data/Array/Accelerate/IO/BlockCopy.hs
+++ b/Data/Array/Accelerate/IO/BlockCopy.hs
@@ -23,7 +23,7 @@
 import Foreign
 import Foreign.C
 import GHC.Base
-import Data.Array.Base (bOOL_SCALE, wORD_SCALE, fLOAT_SCALE, dOUBLE_SCALE)
+import Data.Array.Base (wORD_SCALE, fLOAT_SCALE, dOUBLE_SCALE)
 import Data.ByteString
 
 -- friends
@@ -64,7 +64,7 @@
 type instance BlockCopyFuns Word64 = BlockCopyFun Word64
 type instance BlockCopyFuns Float  = BlockCopyFun Float
 type instance BlockCopyFuns Double = BlockCopyFun Double
-type instance BlockCopyFuns Bool   = BlockCopyFun Word8 -- Packed a bit vector
+type instance BlockCopyFuns Bool   = BlockCopyFun Word8
 type instance BlockCopyFuns Char   = BlockCopyFun Char
 type instance BlockCopyFuns (a,b)  = (BlockCopyFuns a, BlockCopyFuns b)
 
@@ -93,7 +93,7 @@
 type instance BlockPtrs Word64 = Ptr Word64
 type instance BlockPtrs Float  = Ptr Float
 type instance BlockPtrs Double = Ptr Double
-type instance BlockPtrs Bool   = Ptr Word8 -- Packed as a bit vector
+type instance BlockPtrs Bool   = Ptr Word8
 type instance BlockPtrs Char   = Ptr Char
 type instance BlockPtrs (a,b)  = (BlockPtrs a, BlockPtrs b)
 
@@ -164,8 +164,8 @@
    aux ArrayEltRword64 ad = base (ptrsOfArrayData ad) (sizeA * 8)
    aux ArrayEltRfloat  ad = base (ptrsOfArrayData ad) (box fLOAT_SCALE sizeA)
    aux ArrayEltRdouble ad = base (ptrsOfArrayData ad) (box dOUBLE_SCALE sizeA)
-   aux ArrayEltRbool   ad = base (ptrsOfArrayData ad) (box bOOL_SCALE sizeA)
-   aux ArrayEltRchar   _ = error "not defined yet" -- base (castPtr $ ptrsOfArrayData ad) (sizeA * 4)
+   aux ArrayEltRbool   ad = base (ptrsOfArrayData ad) sizeA
+   aux ArrayEltRchar   ad = base (ptrsOfArrayData ad) (sizeA * 4)
    aux (ArrayEltRpair a b) (AD_Pair ad1 ad2) = ((bpFromC, bsFromC), (bpToC, bsToC), toH)
      where
        ((bpFromC1, bsFromC1), (bpToC1, bsToC1), toH1) = aux a ad1
diff --git a/Data/Array/Accelerate/IO/Repa.hs b/Data/Array/Accelerate/IO/Repa.hs
--- a/Data/Array/Accelerate/IO/Repa.hs
+++ b/Data/Array/Accelerate/IO/Repa.hs
@@ -64,14 +64,16 @@
 -- further parallel computation on the GPU.
 --
 data A
-data instance R.Array A sh e
-  = AAccelerate !sh !(A.ArrayData (A.EltRepr e))
 
 -- Repr ------------------------------------------------------------------------
 
 -- | Reading elements of the Accelerate array
 --
-instance A.Elt e => R.Repr A e where
+instance A.Elt e => R.Source A e where
+  data Array A sh e
+    = AAccelerate !sh !(A.ArrayData (A.EltRepr e))
+
+
   {-# INLINE extent #-}
   extent (AAccelerate sh _)
     = sh
@@ -95,30 +97,30 @@
 
 -- | Filling Accelerate arrays
 --
-instance A.Elt e => R.Fillable A e where
-  data MArr A e
-    = forall s. MAArr (A.MutableArrayData s (A.EltRepr e))
+instance A.Elt e => R.Target A e where
+  data MVec A e
+    = forall s. MAVec (A.MutableArrayData s (A.EltRepr e))
 
-  {-# INLINE newMArr #-}
-  newMArr n
-    = MAArr `liftM` unsafeSTToIO (A.newArrayData n)
+  {-# INLINE newMVec #-}
+  newMVec n
+    = MAVec `liftM` unsafeSTToIO (A.newArrayData n)
 
-  {-# INLINE unsafeWriteMArr #-}
-  unsafeWriteMArr (MAArr mad) n e
+  {-# INLINE unsafeWriteMVec #-}
+  unsafeWriteMVec (MAVec mad) n e
     = unsafeSTToIO
     $ A.writeArrayData mad n (A.fromElt e)
 
-  {-# INLINE unsafeFreezeMArr #-}
-  unsafeFreezeMArr sh (MAArr mad)
+  {-# INLINE unsafeFreezeMVec #-}
+  unsafeFreezeMVec sh (MAVec mad)
     = do adata  <- unsafeSTToIO $ A.unsafeFreezeArrayData mad
          return $! AAccelerate sh adata
 
-  {-# INLINE deepSeqMArr #-}
-  deepSeqMArr (MAArr arr) x             -- maybe?
+  {-# INLINE deepSeqMVec #-}
+  deepSeqMVec (MAVec arr) x             -- maybe?
     = arr `seq` x
 
-  {-# INLINE touchMArr #-}
-  touchMArr _                           -- maybe?
+  {-# INLINE touchMVec #-}
+  touchMVec _                           -- maybe?
     = return ()
 
 
@@ -148,7 +150,7 @@
 -- | Sequential computation of array elements
 --
 computeAccS
-    :: R.Fill r A sh e
+    :: (R.Load r sh e, A.Elt e)
     => R.Array r sh e -> R.Array A sh e
 {-# INLINE computeAccS #-}
 computeAccS = R.computeS
@@ -156,7 +158,7 @@
 -- | Parallel computation of array elements
 --
 computeAccP
-    :: (R.Fill r A sh e, A.Elt e, Monad m)
+    :: (R.Load r sh e, A.Elt e, Monad m)
     => R.Array r sh e
     -> m (R.Array A sh e)
 {-# INLINE computeAccP #-}
diff --git a/accelerate-io.cabal b/accelerate-io.cabal
--- a/accelerate-io.cabal
+++ b/accelerate-io.cabal
@@ -1,5 +1,5 @@
 Name:                   accelerate-io
-Version:                0.12.0.0
+Version:                0.12.1.0
 Cabal-version:          >= 1.6
 Tested-with:            GHC >= 7.0.3
 Build-type:             Simple
@@ -37,11 +37,11 @@
 
 Library
   Include-Dirs:         include
-  Build-depends:        accelerate      >= 0.12,
+  Build-depends:        accelerate      >= 0.12.1 && < 0.13,
                         array           >= 0.3,
                         base            == 4.*,
                         bytestring      >= 0.9,
-                        repa            >= 3.1.2,
+                        repa            >= 3.2,
                         vector          >= 0.9
 
   Exposed-modules:      Data.Array.Accelerate.IO