diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,26 @@
+## 0.14.6
+
+* Fix allocRet using unit of bytes but using as unit of ty directly without adaptation
+
+## 0.14.5
+
+* Fix bug in memXorWith not working as advertised if source different from destination
+
+## 0.14.4
+
+* Add support for foundation uarray creation
+* optimise memXorWith
+
+## 0.14.3
+
+* Add support for foundation uarray peeking
+
+## 0.14.2
+
+* Fix use of ghc 8.2 touch
+* Prevent span from reading past buffer
+* cleanup .prof spam
+
 ## 0.14.1
 
 * Fix `Show` instance of Bytes (Oliver Chéron)
diff --git a/Data/ByteArray/Types.hs b/Data/ByteArray/Types.hs
--- a/Data/ByteArray/Types.hs
+++ b/Data/ByteArray/Types.hs
@@ -25,6 +25,7 @@
 import qualified Foundation.Collection as F
 import qualified Foundation.String as F (toBytes, Encoding(UTF8))
 import qualified Foundation.Array.Internal as F
+import qualified Foundation.Primitive as F
 #endif
 
 -- | Class to Access size properties and data of a ByteArray
@@ -36,7 +37,12 @@
 
 -- | Class to allocate new ByteArray of specific size
 class (Eq ba, Ord ba, Monoid ba, ByteArrayAccess ba) => ByteArray ba where
-    allocRet  :: Int -> (Ptr p -> IO a) -> IO (a, ba)
+    -- | allocate `n` bytes and perform the given operation
+    allocRet  :: Int
+                -- ^ number of bytes to allocate. i.e. might not match the
+                -- size of the given type `ba`.
+              -> (Ptr p -> IO a)
+              -> IO (a, ba)
 
 #ifdef WITH_BYTESTRING_SUPPORT
 instance ByteArrayAccess B.ByteString where
@@ -55,17 +61,46 @@
 uarrayRecastW8 = F.recast
 
 instance F.PrimType ty => ByteArrayAccess (F.UArray ty) where
+#if MIN_VERSION_foundation(0,0,10)
+    length a = let F.CountOf i = F.length (uarrayRecastW8 a) in i
+#else
     length = F.length . uarrayRecastW8
+#endif
     withByteArray a f = F.withPtr (uarrayRecastW8 a) (f . castPtr)
 
 instance ByteArrayAccess F.String where
-    length = F.length
+#if MIN_VERSION_foundation(0,0,10)
+    length str = let F.CountOf i = F.length bytes in i
+#else
+    length str = F.length bytes
+#endif
+      where
+        -- the Foundation's length return a number of elements not a number of
+        -- bytes. For @ByteArrayAccess@, because we are using an @Int@, we
+        -- didn't see that we were returning the wrong @CountOf@.
+        bytes = F.toBytes F.UTF8 str
     withByteArray s f = withByteArray (F.toBytes F.UTF8 s) f
 
 instance (Ord ty, F.PrimType ty) => ByteArray (F.UArray ty) where
     allocRet sz f = do
-        mba <- F.new (F.Size sz)
+        mba <- F.new $ sizeRecastBytes sz F.Proxy
         a   <- F.withMutablePtr mba (f . castPtr)
         ba  <- F.unsafeFreeze mba
         return (a, ba)
+      where
+#if MIN_VERSION_foundation(0,0,10)
+        sizeRecastBytes :: F.PrimType ty => Int -> F.Proxy ty -> F.CountOf ty
+        sizeRecastBytes w p = F.CountOf $
+            let (q,r) = w `Prelude.quotRem` szTy
+             in q + (if r == 0 then 0 else 1)
+          where !(F.CountOf szTy) = F.primSizeInBytes p
+        {-# INLINE [1] sizeRecastBytes #-}
+#else
+        sizeRecastBytes :: F.PrimType ty => Int -> F.Proxy ty -> F.Size ty
+        sizeRecastBytes w p = F.Size $
+            let (q,r) = w `Prelude.quotRem` szTy
+             in q + (if r == 0 then 0 else 1)
+          where !(F.Size szTy) = F.primSizeInBytes p
+        {-# INLINE [1] sizeRecastBytes #-}
+#endif
 #endif
diff --git a/memory.cabal b/memory.cabal
--- a/memory.cabal
+++ b/memory.cabal
@@ -1,5 +1,5 @@
 Name:                memory
-Version:             0.14.5
+version:             0.14.6
 Synopsis:            memory and related abstraction stuff
 Description:
     Chunk of memory, polymorphic byte array management and manipulation
@@ -19,7 +19,7 @@
 License-file:        LICENSE
 Copyright:           Vincent Hanquez <vincent@snarc.org>
 Author:              Vincent Hanquez <vincent@snarc.org>
-Maintainer:          vincent@snarc.org
+Maintainer:          vincent@snarc.org, Nicolas Di Prima <nicolas@primetype.co.uk>
 Category:            memory
 Stability:           experimental
 Build-Type:          Simple
@@ -115,3 +115,6 @@
                    , memory
   ghc-options:       -Wall -fno-warn-orphans -fno-warn-missing-signatures -threaded
   default-language:  Haskell2010
+  if flag(support_foundation)
+    CPP-options:     -DWITH_FOUNDATION_SUPPORT
+    Build-depends:   foundation >= 0.0.8
diff --git a/tests/Tests.hs b/tests/Tests.hs
--- a/tests/Tests.hs
+++ b/tests/Tests.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE Rank2Types #-}
 module Main where
@@ -13,6 +14,10 @@
 
 import qualified SipHash
 
+#ifdef WITH_FOUNDATION_SUPPORT
+import qualified Foundation as F
+#endif
+
 data Backend = BackendByte | BackendScrubbedBytes
     deriving (Show,Eq,Bounded,Enum)
 
@@ -161,6 +166,9 @@
         ]
     , testShowProperty "showing" $ \witnessID expectedShow (Words8 l) ->
           (show . witnessID . B.pack $ l) == expectedShow l
+#ifdef WITH_FOUNDATION_SUPPORT
+    , testFoundationTypes
+#endif
     ]
   where
     basicProperties witnessID =
@@ -213,3 +221,20 @@
             let b = witnessID (B.pack l)
              in B.span (const False) b == (B.empty, b)
         ]
+
+#ifdef WITH_FOUNDATION_SUPPORT
+testFoundationTypes = testGroup "Foundation"
+  [ testCase "allocRet 4 _ :: F.UArray Int8 === 4" $ do
+      x <- (B.length :: F.UArray F.Int8 -> Int) . snd <$> B.allocRet 4 (const $ return ())
+      assertEqual "" 4 x
+  , testCase "allocRet 4 _ :: F.UArray Int16 === 4" $ do
+      x <- (B.length :: F.UArray F.Int16 -> Int) . snd <$> B.allocRet 4 (const $ return ())
+      assertEqual "" 4 x
+  , testCase "allocRet 4 _ :: F.UArray Int32 === 4" $ do
+      x <- (B.length :: F.UArray F.Int32 -> Int) . snd <$> B.allocRet 4 (const $ return ())
+      assertEqual "" 4 x
+  , testCase "allocRet 4 _ :: F.UArray Int64 === 8" $ do
+      x <- (B.length :: F.UArray F.Int64 -> Int) . snd <$> B.allocRet 4 (const $ return ())
+      assertEqual "" 8 x
+  ]
+#endif