diff --git a/library/Ptr/IO.hs b/library/Ptr/IO.hs
--- a/library/Ptr/IO.hs
+++ b/library/Ptr/IO.hs
@@ -131,12 +131,18 @@
   {-# SCC "pokeWord8" #-} 
   poke ptr value
 
+{-# INLINE pokeWord8Off #-}
+pokeWord8Off :: Ptr Word8 -> Int -> Word8 -> IO ()
+pokeWord8Off ptr off value =
+  {-# SCC "pokeWord8Off" #-} 
+  pokeByteOff ptr off value
+
 {-# INLINE pokeBEWord16 #-}
 pokeBEWord16 :: Ptr Word8 -> Word16 -> IO ()
 #ifdef WORDS_BIGENDIAN
 pokeBEWord16 =
   {-# SCC "pokeBEWord16" #-} 
-  poke
+  pokeStorable
 #else
 pokeBEWord16 ptr value =
   {-# SCC "pokeBEWord16" #-} 
@@ -191,6 +197,76 @@
     pokeByteOff ptr 6 (fromIntegral (D.shiftr_w64 value  8) :: Word8)
     pokeByteOff ptr 7 (fromIntegral value :: Word8)
 #endif
+#endif
+
+{-# INLINE pokeLEWord16 #-}
+pokeLEWord16 :: Ptr Word8 -> Word16 -> IO ()
+#ifdef WORDS_BIGENDIAN
+pokeLEWord16 p w =
+  {-# SCC "pokeLEWord16" #-} 
+  do
+    pokeWord8 p (fromIntegral w)
+    pokeWord8Off p 1 (fromIntegral (D.shiftr_w16 w 8))
+#else
+pokeLEWord16 =
+  {-# SCC "pokeLEWord16" #-} 
+  pokeStorable
+#endif
+
+{-# INLINE pokeLEWord32 #-}
+pokeLEWord32 :: Ptr Word8 -> Word32 -> IO ()
+#ifdef WORDS_BIGENDIAN
+pokeLEWord32 p w =
+  {-# SCC "pokeLEWord32" #-}
+  do
+    pokeWord8 p (fromIntegral w)
+    pokeWord8Off p 1 (fromIntegral (D.shiftr_w32 w 8))
+    pokeWord8Off p 2 (fromIntegral (D.shiftr_w32 w 16))
+    pokeWord8Off p 3 (fromIntegral (D.shiftr_w32 w 24))
+#else
+pokeLEWord32 =
+  {-# SCC "pokeLEWord32" #-} 
+  pokeStorable
+#endif
+
+{-# INLINE pokeLEWord64 #-}
+pokeLEWord64 :: Ptr Word8 -> Word64 -> IO ()
+#ifdef WORDS_BIGENDIAN
+#if WORD_SIZE_IN_BITS < 64
+--
+-- To avoid expensive 64 bit shifts on 32 bit machines, we cast to
+-- Word32, and write that
+--
+pokeLEWord64 p w =
+  {-# SCC "pokeLEWord64" #-} 
+  do
+    let b = fromIntegral (D.shiftr_w64 w 32) :: Word32
+        a = fromIntegral w                   :: Word32
+    pokeWord8 p (fromIntegral a)
+    pokeWord8Off p 1 (fromIntegral (D.shiftr_w32 a 8))
+    pokeWord8Off p 2 (fromIntegral (D.shiftr_w32 a 16))
+    pokeWord8Off p 3 (fromIntegral (D.shiftr_w32 a 24))
+    pokeWord8Off p 4 (fromIntegral b)
+    pokeWord8Off p 5 (fromIntegral (D.shiftr_w32 b 8))
+    pokeWord8Off p 6 (fromIntegral (D.shiftr_w32 b 16))
+    pokeWord8Off p 7 (fromIntegral (D.shiftr_w32 b 24))
+#else
+pokeLEWord64 p w =
+  {-# SCC "pokeLEWord64" #-} 
+  do
+    pokeWord8 p (fromIntegral w)
+    pokeWord8Off p 1 (fromIntegral (D.shiftr_w64 w 8))
+    pokeWord8Off p 2 (fromIntegral (D.shiftr_w64 w 16))
+    pokeWord8Off p 3 (fromIntegral (D.shiftr_w64 w 24))
+    pokeWord8Off p 4 (fromIntegral (D.shiftr_w64 w 32))
+    pokeWord8Off p 5 (fromIntegral (D.shiftr_w64 w 40))
+    pokeWord8Off p 6 (fromIntegral (D.shiftr_w64 w 48))
+    pokeWord8Off p 7 (fromIntegral (D.shiftr_w64 w 56))
+#endif
+#else
+pokeLEWord64 =
+  {-# SCC "pokeLEWord64" #-} 
+  pokeStorable
 #endif
 
 {-# INLINE pokeBytesTrimming #-}
diff --git a/library/Ptr/Poking.hs b/library/Ptr/Poking.hs
--- a/library/Ptr/Poking.hs
+++ b/library/Ptr/Poking.hs
@@ -59,6 +59,16 @@
 word8 x =
   Poking 1 (flip A.pokeWord8 x)
 
+{-# INLINE leWord32 #-}
+leWord32 :: Word32 -> Poking
+leWord32 x =
+  Poking 4 (flip A.pokeLEWord32 x)
+
+{-# INLINE leWord64 #-}
+leWord64 :: Word64 -> Poking
+leWord64 x =
+  Poking 8 (flip A.pokeLEWord64 x)
+
 {-# INLINE beWord32 #-}
 beWord32 :: Word32 -> Poking
 beWord32 x =
diff --git a/ptr.cabal b/ptr.cabal
--- a/ptr.cabal
+++ b/ptr.cabal
@@ -1,7 +1,7 @@
 name:
   ptr
 version:
-  0.16.2
+  0.16.3
 category:
   Ptr, Data
 synopsis:
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -48,8 +48,9 @@
 parsing =
   testGroup "Parsing" $
   [
-    testCase "" $
-    assertEqual "" "123" (A.parse "123456" (G.bytesWhile (< 52)) undefined undefined)
+    testCase "bytesWhile" $ assertEqual "" "123" (A.parse "123456" (G.bytesWhile (< 52)) undefined undefined)
+    ,
+    testCase "bytesWhile 2" $ assertEqual "" "123456" (A.parse "123456" (G.bytesWhile (< 59)) undefined undefined)
   ]
 
 pokeThenPeek :: B.Poke a -> C.Peek a -> Maybe (a -> a)