diff --git a/hw-bits.cabal b/hw-bits.cabal
--- a/hw-bits.cabal
+++ b/hw-bits.cabal
@@ -1,7 +1,7 @@
 cabal-version:  2.2
 
 name:                   hw-bits
-version:                0.7.0.9
+version:                0.7.1.0
 synopsis:               Bit manipulation
 description:            Please see README.md
 category:               Data, Bit
@@ -28,6 +28,7 @@
 
 common base                 { build-depends: base                 >= 4          && < 5      }
 
+common bitvec               { build-depends: bitvec               >= 1.0        && < 1.1    }
 common bytestring           { build-depends: bytestring           >= 0.9        && < 0.11   }
 common criterion            { build-depends: criterion            >= 1.2        && < 1.6    }
 common deepseq              { build-depends: deepseq              >= 1.4        && < 1.5    }
@@ -48,6 +49,7 @@
 library
   import:               base
                       , common
+                      , bitvec
                       , bytestring
                       , deepseq
                       , hw-int
@@ -84,6 +86,7 @@
 test-suite hw-bits-test
   import:               base
                       , common
+                      , bitvec
                       , bytestring
                       , hedgehog
                       , hspec
diff --git a/src/HaskellWorks/Data/Bits/AllExcess/AllExcess0.hs b/src/HaskellWorks/Data/Bits/AllExcess/AllExcess0.hs
--- a/src/HaskellWorks/Data/Bits/AllExcess/AllExcess0.hs
+++ b/src/HaskellWorks/Data/Bits/AllExcess/AllExcess0.hs
@@ -6,7 +6,10 @@
 import HaskellWorks.Data.Bits.PopCount.PopCount0
 import HaskellWorks.Data.Bits.PopCount.PopCount1
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 class AllExcess0 a where
   -- | Number of 0-bits minues the number of 1-bits.
@@ -48,5 +51,13 @@
   {-# INLINE allExcess0 #-}
 
 instance AllExcess0 (DVS.Vector Word64) where
+  allExcess0 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)
+  {-# INLINE allExcess0 #-}
+
+instance AllExcess0 (DVU.Vector Bit.Bit) where
+  allExcess0 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)
+  {-# INLINE allExcess0 #-}
+
+instance AllExcess0 (DVU.Vector BitTS.Bit) where
   allExcess0 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)
   {-# INLINE allExcess0 #-}
diff --git a/src/HaskellWorks/Data/Bits/AllExcess/AllExcess1.hs b/src/HaskellWorks/Data/Bits/AllExcess/AllExcess1.hs
--- a/src/HaskellWorks/Data/Bits/AllExcess/AllExcess1.hs
+++ b/src/HaskellWorks/Data/Bits/AllExcess/AllExcess1.hs
@@ -6,8 +6,11 @@
 import HaskellWorks.Data.Bits.PopCount.PopCount0
 import HaskellWorks.Data.Bits.PopCount.PopCount1
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 class AllExcess1 a where
   -- | Number of 1-bits minues the number of 0-bits.
@@ -66,4 +69,12 @@
 
 instance AllExcess1 (DVS.Vector Word64) where
   allExcess1 w = fromIntegral (popCount1 w) - fromIntegral (popCount0 w)
+  {-# INLINE allExcess1 #-}
+
+instance AllExcess1 (DVU.Vector Bit.Bit) where
+  allExcess1 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)
+  {-# INLINE allExcess1 #-}
+
+instance AllExcess1 (DVU.Vector BitTS.Bit) where
+  allExcess1 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)
   {-# INLINE allExcess1 #-}
diff --git a/src/HaskellWorks/Data/Bits/BitLength.hs b/src/HaskellWorks/Data/Bits/BitLength.hs
--- a/src/HaskellWorks/Data/Bits/BitLength.hs
+++ b/src/HaskellWorks/Data/Bits/BitLength.hs
@@ -15,8 +15,11 @@
 import HaskellWorks.Data.Positioning
 import Prelude                       hiding (length)
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 class BitLength v where
   -- | Number of bits in a value including ones and zeros.
@@ -127,4 +130,12 @@
 
 instance BitLength (DVS.Vector Word64) where
   bitLength v = length v * bitLength (v !!! 0)
+  {-# INLINE bitLength #-}
+
+instance BitLength (DVU.Vector Bit.Bit) where
+  bitLength = fromIntegral . DVU.length
+  {-# INLINE bitLength #-}
+
+instance BitLength (DVU.Vector BitTS.Bit) where
+  bitLength = fromIntegral . DVU.length
   {-# INLINE bitLength #-}
diff --git a/src/HaskellWorks/Data/Bits/BitParse.hs b/src/HaskellWorks/Data/Bits/BitParse.hs
--- a/src/HaskellWorks/Data/Bits/BitParse.hs
+++ b/src/HaskellWorks/Data/Bits/BitParse.hs
@@ -12,9 +12,12 @@
 import HaskellWorks.Data.Bits.BitWise
 import HaskellWorks.Data.String.Parse
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.ByteString      as BS
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 -- | Parsers for bit strings
 class BitParse a where
@@ -126,3 +129,11 @@
 instance BitParse (DVS.Vector Word64) where
   bitParse0 = bitParse1 <|> return DVS.empty
   bitParse1 = fromList `fmap` bitParse0
+
+instance BitParse (DVU.Vector Bit.Bit) where
+  bitParse0 = bitParse1 <|> return DVU.empty
+  bitParse1 = fromList . map Bit.Bit <$> many bitParse1
+
+instance BitParse (DVU.Vector BitTS.Bit) where
+  bitParse0 = bitParse1 <|> return DVU.empty
+  bitParse1 = fromList . map BitTS.Bit <$> many bitParse1
diff --git a/src/HaskellWorks/Data/Bits/BitRead.hs b/src/HaskellWorks/Data/Bits/BitRead.hs
--- a/src/HaskellWorks/Data/Bits/BitRead.hs
+++ b/src/HaskellWorks/Data/Bits/BitRead.hs
@@ -11,9 +11,12 @@
 import HaskellWorks.Data.Bits.BitParse
 import HaskellWorks.Data.String.Parse
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.ByteString      as BS
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 -- | Bit string reader that produces a value of a type
 class BitRead a where
@@ -77,6 +80,12 @@
   bitRead = bitRead'
 
 instance BitRead (DVS.Vector Word64) where
+  bitRead = bitRead'
+
+instance BitRead (DVU.Vector Bit.Bit) where
+  bitRead = bitRead'
+
+instance BitRead (DVU.Vector BitTS.Bit) where
   bitRead = bitRead'
 
 instance BitRead [Bool] where
diff --git a/src/HaskellWorks/Data/Bits/BitShow.hs b/src/HaskellWorks/Data/Bits/BitShow.hs
--- a/src/HaskellWorks/Data/Bits/BitShow.hs
+++ b/src/HaskellWorks/Data/Bits/BitShow.hs
@@ -11,10 +11,13 @@
 import HaskellWorks.Data.Bits.BitWise
 import HaskellWorks.Data.Bits.Word
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.ByteString      as BS
 import qualified Data.ByteString.Lazy as BSL
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 -- | Shower of a value as a bit string
 class BitShow a where
@@ -104,6 +107,12 @@
 
 instance BitShow (DVS.Vector Word64) where
   bitShows = bitShows . toList
+
+instance BitShow (DVU.Vector Bit.Bit) where
+  bitShows = bitShows . fmap Bit.unBit . toList
+
+instance BitShow (DVU.Vector BitTS.Bit) where
+  bitShows = bitShows . fmap BitTS.unBit . toList
 
 bitShow :: BitShow a => a -> String
 bitShow a = bitShows a ""
diff --git a/src/HaskellWorks/Data/Bits/BitWise.hs b/src/HaskellWorks/Data/Bits/BitWise.hs
--- a/src/HaskellWorks/Data/Bits/BitWise.hs
+++ b/src/HaskellWorks/Data/Bits/BitWise.hs
@@ -17,9 +17,12 @@
 import HaskellWorks.Data.Positioning
 import Prelude                          as P
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Bits            as B
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 -- We pervasively use precedence to avoid excessive parentheses, and we use
 -- the same precedence conventions of the C programming language: arithmetic
@@ -139,6 +142,14 @@
 
 instance TestBit (DVS.Vector Word64) where
   (.?.) v n = let (q, r) = n `quotRem` elemBitEnd v in (v !!! q) .?. r
+  {-# INLINE (.?.) #-}
+
+instance TestBit (DVU.Vector Bit.Bit) where
+  (.?.) v n = Bit.unBit (v DVU.! fromIntegral n)
+  {-# INLINE (.?.) #-}
+
+instance TestBit (DVU.Vector BitTS.Bit) where
+  (.?.) v n = BitTS.unBit (v DVU.! fromIntegral n)
   {-# INLINE (.?.) #-}
 
 instance BitWise Int where
diff --git a/src/HaskellWorks/Data/Bits/ElemFixedBitSize.hs b/src/HaskellWorks/Data/Bits/ElemFixedBitSize.hs
--- a/src/HaskellWorks/Data/Bits/ElemFixedBitSize.hs
+++ b/src/HaskellWorks/Data/Bits/ElemFixedBitSize.hs
@@ -8,8 +8,11 @@
 import Data.Word
 import HaskellWorks.Data.Positioning
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 -- | Class of values that have elements of a fixed bit size
 --
@@ -83,3 +86,11 @@
 instance ElemFixedBitSize (DVS.Vector Word64) where
   type Elem (DVS.Vector Word64) = Word64
   elemFixedBitSize _ = 64
+
+instance ElemFixedBitSize (DVU.Vector Bit.Bit) where
+  type Elem (DVU.Vector Bit.Bit) = Bit.Bit
+  elemFixedBitSize _ = 1
+
+instance ElemFixedBitSize (DVU.Vector BitTS.Bit) where
+  type Elem (DVU.Vector BitTS.Bit) = BitTS.Bit
+  elemFixedBitSize _ = 1
diff --git a/src/HaskellWorks/Data/Bits/FromBitTextByteString.hs b/src/HaskellWorks/Data/Bits/FromBitTextByteString.hs
--- a/src/HaskellWorks/Data/Bits/FromBitTextByteString.hs
+++ b/src/HaskellWorks/Data/Bits/FromBitTextByteString.hs
@@ -8,8 +8,11 @@
 import Data.Word
 import HaskellWorks.Data.Bits
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.ByteString      as BS
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 class FromBitTextByteString a where
   -- | Convert a binary byte string to a value of type @a
@@ -86,6 +89,26 @@
                 Just (d, ds) | d == w1  -> gen' (n + 1) (w .|. (1 .<. fromIntegral n)) ds
                 Just (_, ds) -> gen' n w ds
                 Nothing      -> Just (w, cs)
+
+instance FromBitTextByteString (DVU.Vector Bit.Bit) where
+  fromBitTextByteString :: BS.ByteString -> DVU.Vector Bit.Bit
+  fromBitTextByteString bs = DVU.unfoldrN (BS.length bs) gen bs
+    where gen :: BS.ByteString -> Maybe (Bit.Bit, BS.ByteString)
+          gen cs = case BS.uncons cs of
+            Just (d, ds) | d == w0  -> Just (Bit.Bit False, ds)
+            Just (d, ds) | d == w1  -> Just (Bit.Bit True,  ds)
+            Just (_, ds) -> gen ds
+            Nothing      -> Nothing
+
+instance FromBitTextByteString (DVU.Vector BitTS.Bit) where
+  fromBitTextByteString :: BS.ByteString -> DVU.Vector BitTS.Bit
+  fromBitTextByteString bs = DVU.unfoldrN (BS.length bs) gen bs
+    where gen :: BS.ByteString -> Maybe (BitTS.Bit, BS.ByteString)
+          gen cs = case BS.uncons cs of
+            Just (d, ds) | d == w0  -> Just (BitTS.Bit False, ds)
+            Just (d, ds) | d == w1  -> Just (BitTS.Bit True,  ds)
+            Just (_, ds) -> gen ds
+            Nothing      -> Nothing
 
 w0 :: Word8
 w0 = 48
diff --git a/src/HaskellWorks/Data/Bits/PopCount/PopCount0.hs b/src/HaskellWorks/Data/Bits/PopCount/PopCount0.hs
--- a/src/HaskellWorks/Data/Bits/PopCount/PopCount0.hs
+++ b/src/HaskellWorks/Data/Bits/PopCount/PopCount0.hs
@@ -14,8 +14,11 @@
 import HaskellWorks.Data.Positioning
 import Prelude                                   as P
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 class PopCount0 v where
   -- | The number of 0-bits in the value.
@@ -176,4 +179,12 @@
 
 instance PopCount0 (DVS.Vector (Broadword Word64)) where
   popCount0 = DVS.foldl' (\c -> (c +) . popCount0) 0
+  {-# INLINE popCount0 #-}
+
+instance PopCount0 (DVU.Vector Bit.Bit) where
+  popCount0 v = fromIntegral $ DVU.length v - Bit.countBits v
+  {-# INLINE popCount0 #-}
+
+instance PopCount0 (DVU.Vector BitTS.Bit) where
+  popCount0 v = fromIntegral $ DVU.length v - BitTS.countBits v
   {-# INLINE popCount0 #-}
diff --git a/src/HaskellWorks/Data/Bits/PopCount/PopCount1.hs b/src/HaskellWorks/Data/Bits/PopCount/PopCount1.hs
--- a/src/HaskellWorks/Data/Bits/PopCount/PopCount1.hs
+++ b/src/HaskellWorks/Data/Bits/PopCount/PopCount1.hs
@@ -12,9 +12,12 @@
 import HaskellWorks.Data.Positioning
 import Prelude                                as P
 
+import qualified Data.Bit             as Bit
+import qualified Data.Bit.ThreadSafe  as BitTS
 import qualified Data.Bits            as DB
 import qualified Data.Vector          as DV
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 type FastWord a = Builtin a
 
@@ -197,4 +200,12 @@
 
 instance PopCount1 (DVS.Vector (Broadword Word64)) where
   popCount1 = DVS.foldl' (\c -> (c +) . popCount1) 0
+  {-# INLINE popCount1 #-}
+
+instance PopCount1 (DVU.Vector Bit.Bit) where
+  popCount1 = fromIntegral . Bit.countBits
+  {-# INLINE popCount1 #-}
+
+instance PopCount1 (DVU.Vector BitTS.Bit) where
+  popCount1 = fromIntegral . BitTS.countBits
   {-# INLINE popCount1 #-}
diff --git a/test/HaskellWorks/Data/Bits/BitReadSpec.hs b/test/HaskellWorks/Data/Bits/BitReadSpec.hs
--- a/test/HaskellWorks/Data/Bits/BitReadSpec.hs
+++ b/test/HaskellWorks/Data/Bits/BitReadSpec.hs
@@ -11,7 +11,9 @@
 import Hedgehog
 import Test.Hspec
 
-import qualified Data.Vector as DV
+import qualified Data.Bit            as Bit
+import qualified Data.Vector         as DV
+import qualified Data.Vector.Unboxed as DVU
 
 {-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
 
@@ -29,6 +31,7 @@
   it "bitRead \"\" :: Maybe [Word8]" . requireTest $ do
     let ws = bitRead "" :: Maybe [Word8]
     ws === Just []
+
   it "bitRead \"10000000 101\" :: Maybe (DV.Vector Word8)" . requireTest $ do
     let v = bitRead "10000000 101" :: Maybe (DV.Vector Word8)
     v === Just [1, 5]
@@ -41,6 +44,20 @@
   it "bitRead \"\" :: Maybe (DV.Vector Word8)" . requireTest $ do
     let v = bitRead "" :: Maybe (DV.Vector Word8)
     v === Just []
+
+  it "bitRead \"10000000 101\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do
+    let v = bitRead "10000000 101" :: Maybe (DVU.Vector Bit.Bit)
+    v === Just [1,0,0,0,0,0,0,0, 1,0,1]
+  it "bitRead \"11100100 10101111 1\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do
+    let v = bitRead "11100100 10101111 1" :: Maybe (DVU.Vector Bit.Bit)
+    v === Just [1,1,1,0,0,1,0,0, 1,0,1,0,1,1,1,1, 1]
+  it "bitRead \"11100100 10101111 1\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do
+    let v = bitRead "11100100 10101111 1" :: Maybe (DVU.Vector Bit.Bit)
+    v === Just [1,1,1,0,0,1,0,0, 1,0,1,0,1,1,1,1, 1]
+  it "bitRead \"\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do
+    let v = bitRead "" :: Maybe (DVU.Vector Bit.Bit)
+    v === Just []
+
   it "bitShow (8 :: Word8)" . requireTest $ do
     let bs = bitShow (8 :: Word8)
     bs === "00010000"
diff --git a/test/HaskellWorks/Data/Bits/BitWiseSpec.hs b/test/HaskellWorks/Data/Bits/BitWiseSpec.hs
--- a/test/HaskellWorks/Data/Bits/BitWiseSpec.hs
+++ b/test/HaskellWorks/Data/Bits/BitWiseSpec.hs
@@ -10,8 +10,10 @@
 import Hedgehog
 import Test.Hspec
 
+import qualified Data.Bit             as Bit
 import qualified Data.Bits            as B
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 import qualified Hedgehog.Gen         as G
 import qualified Hedgehog.Range       as R
 
@@ -56,6 +58,9 @@
     it "for [Word64] matches Data.Bits implementation" $ requireProperty $ do
       w <- forAll $ G.list (R.constant 0 10) (G.word64 R.constantBounded)
       popCount0 w === popCount0 (DVS.fromList w)
+    it "for [Bool] matches DVU Bit.Bit" $ requireProperty $ do
+      w <- forAll $ G.list (R.constant 0 1000) G.bool
+      popCount0 w === popCount0 (DVU.fromList (fmap Bit.Bit w))
   describe "for popCount1" $ do
     it "for Word8 matches Data.Bits implementation" $ requireProperty $ do
       w <- forAll $ G.word8 R.constantBounded
@@ -93,3 +98,6 @@
     it "for [Word64] matches Data.Bits implementation" $ requireProperty $ do
       w <- forAll $ G.list (R.constant 0 10) (G.word64 R.constantBounded)
       popCount1 w === popCount1 (DVS.fromList w)
+    it "for [Bool] matches DVU Bit.Bit" $ requireProperty $ do
+      w <- forAll $ G.list (R.constant 0 1000) G.bool
+      popCount1 w === popCount1 (DVU.fromList (fmap Bit.Bit w))
diff --git a/test/HaskellWorks/Data/Bits/FromBitTextByteStringSpec.hs b/test/HaskellWorks/Data/Bits/FromBitTextByteStringSpec.hs
--- a/test/HaskellWorks/Data/Bits/FromBitTextByteStringSpec.hs
+++ b/test/HaskellWorks/Data/Bits/FromBitTextByteStringSpec.hs
@@ -12,8 +12,10 @@
 import Hedgehog
 import Test.Hspec
 
+import qualified Data.Bit             as Bit
 import qualified Data.ByteString      as BS
 import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed  as DVU
 
 {-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
 
@@ -95,3 +97,22 @@
     it "fromBitTextByteString (BS.unpack \"11110000111100001111000011110000111100001111000011110000111100001\") :: DVS.Vector Word64" . requireTest $ do
       let w = fromBitTextByteString "11110000111100001111000011110000111100001111000011110000111100001" :: DVS.Vector Word64
       w === DVS.fromList [0x0f0f0f0f0f0f0f0f, 0x1]
+  describe "For (DVU.Vector Bit.Bit)" $ do
+    it "fromBitTextByteString (BS.unpack []) :: DVU.Vector Bit.Bit" . requireTest $ do
+      let w = fromBitTextByteString (BS.pack []) :: DVU.Vector Bit.Bit
+      w === DVU.fromList []
+    it "fromBitTextByteString (BS.unpack \"0\") :: DVU.Vector Bit.Bit" . requireTest $ do
+      let w = fromBitTextByteString "0" :: DVU.Vector Bit.Bit
+      w === DVU.fromList [0]
+    it "fromBitTextByteString (BS.unpack \"1\") :: DVU.Vector Bit.Bit" . requireTest $ do
+      let w = fromBitTextByteString "1" :: DVU.Vector Bit.Bit
+      w === DVU.fromList [1]
+    it "fromBitTextByteString (BS.unpack \"1111000011110000111100001111000011110000111100001111000011110000\") :: DVU.Vector Bit.Bit" . requireTest $ do
+      let w = fromBitTextByteString "1111000011110000111100001111000011110000111100001111000011110000" :: DVU.Vector Bit.Bit
+      w === DVU.fromList [1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0]
+    it "fromBitTextByteString (BS.unpack \"11110000111100001111000011110000111100001111000011110000111100000\") :: DVU.Vector Bit.Bit" . requireTest $ do
+      let w = fromBitTextByteString "11110000111100001111000011110000111100001111000011110000111100000" :: DVU.Vector Bit.Bit
+      w === DVU.fromList [1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0]
+    it "fromBitTextByteString (BS.unpack \"11110000111100001111000011110000111100001111000011110000111100001\") :: DVU.Vector Bit.Bit" . requireTest $ do
+      let w = fromBitTextByteString "11110000111100001111000011110000111100001111000011110000111100001" :: DVU.Vector Bit.Bit
+      w === DVU.fromList [1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1]