diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Revision history for byte-order
 
-## 0.1.0.0 -- YYYY-mm-dd
+## 0.1.1.0 -- YYYY-mm-dd
 
-* First version. Released on an unsuspecting world.
+* Add `PrimUnaligned` instance for `Fixed`.
+* Add modules for more convenient interface to reading and writing
+  fixed-endianness elements to byte arrays:
+  `Data.Primitive.ByteArray.LittleEndian` and
+  `Data.Primitive.ByteArray.BigEndian`.
+
+## 0.1.0.0 -- 2019-05-29
+
+* Initial release.
diff --git a/byte-order.cabal b/byte-order.cabal
--- a/byte-order.cabal
+++ b/byte-order.cabal
@@ -1,6 +1,6 @@
 cabal-version: 2.2
 name: byte-order
-version: 0.1.0.0
+version: 0.1.1.0
 synopsis: Portable big-endian and little-endian conversions
 description:
   This library provides an interface to portably work with byte
@@ -19,11 +19,14 @@
 
 library
   exposed-modules:
+    Data.Primitive.ByteArray.BigEndian
+    Data.Primitive.ByteArray.LittleEndian
     System.ByteOrder
     System.ByteOrder.Class
   build-depends:
     , base >=4.11.1.0 && <5
     , primitive >=0.6.4 && <0.8
+    , primitive-unaligned >=0.1.1 && <0.2
   hs-source-dirs: src
   default-language: Haskell2010
   ghc-options: -O2 -Wall
diff --git a/src/Data/Primitive/ByteArray/BigEndian.hs b/src/Data/Primitive/ByteArray/BigEndian.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Primitive/ByteArray/BigEndian.hs
@@ -0,0 +1,60 @@
+-- | This is drop-in replacement for the read, write, and index functions
+-- present in @Data.Primitive.ByteArray@ and @Data.Primitive.ByteArray.Unaligned@.
+-- While the functions from those modules use native byte order, the functions
+-- in this one use big-endian byte order (most significant byte first).
+module Data.Primitive.ByteArray.BigEndian
+  ( -- * Aligned
+    writeByteArray
+  , readByteArray
+  , indexByteArray
+    -- * Unaligned
+  , writeUnalignedByteArray
+  , readUnalignedByteArray
+  , indexUnalignedByteArray
+  ) where
+
+import Data.Primitive (Prim,MutableByteArray,ByteArray)
+import Control.Monad.Primitive (PrimState,PrimMonad)
+import System.ByteOrder (Bytes,toBigEndian,fromBigEndian)
+import Data.Primitive.ByteArray.Unaligned (PrimUnaligned)
+import qualified Data.Primitive as PM
+import qualified Data.Primitive.ByteArray.Unaligned as PMU
+
+-- | Write a primitive value to the byte array. The offset is given
+-- in elements of type @a@ rather than in bytes. The most significant
+-- byte in the value comes first.
+writeByteArray :: (PrimMonad m, Prim a, Bytes a) => MutableByteArray (PrimState m) -> Int -> a -> m ()
+writeByteArray arr ix v = PM.writeByteArray arr ix (toBigEndian v)
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the most significant one. The offset is given in elements of
+-- type @a@ rather than in bytes.
+readByteArray :: (PrimMonad m, Prim a, Bytes a) => MutableByteArray (PrimState m) -> Int -> m a
+readByteArray arr ix = fromBigEndian <$> PM.readByteArray arr ix
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the most significant one. The offset is given in elements of
+-- type @a@ rather than in bytes.
+indexByteArray :: (Prim a, Bytes a) => ByteArray -> Int -> a
+indexByteArray arr ix = fromBigEndian (PM.indexByteArray arr ix)
+
+-- | Write a primitive value to the byte array. The offset is given
+-- in bytes rather than in elements of type @a@. The most significant
+-- byte in the value comes first.
+writeUnalignedByteArray :: (PrimMonad m, PrimUnaligned a, Bytes a)
+  => MutableByteArray (PrimState m) -> Int -> a -> m ()
+writeUnalignedByteArray arr ix v = PMU.writeUnalignedByteArray arr ix (toBigEndian v)
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the most significant one. The offset is given in bytes rather
+-- than in elements of type @a@.
+readUnalignedByteArray :: (PrimMonad m, PrimUnaligned a, Bytes a)
+  => MutableByteArray (PrimState m) -> Int -> m a
+readUnalignedByteArray arr ix = fromBigEndian <$> PMU.readUnalignedByteArray arr ix
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the most significant one. The offset is given in bytes rather
+-- than in elements of type @a@.
+indexUnalignedByteArray :: (PrimUnaligned a, Bytes a)
+  => ByteArray -> Int -> a
+indexUnalignedByteArray arr ix = fromBigEndian (PMU.indexUnalignedByteArray arr ix)
diff --git a/src/Data/Primitive/ByteArray/LittleEndian.hs b/src/Data/Primitive/ByteArray/LittleEndian.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Primitive/ByteArray/LittleEndian.hs
@@ -0,0 +1,62 @@
+-- | This is drop-in replacement for the read, write, and index functions
+-- present in @Data.Primitive.ByteArray@ and @Data.Primitive.ByteArray.Unaligned@.
+-- While the functions from those modules use native byte order, the functions
+-- in this one use little-endian byte order (least significant byte first).
+module Data.Primitive.ByteArray.LittleEndian
+  ( -- * Aligned
+    writeByteArray
+  , readByteArray
+  , indexByteArray
+    -- * Unaligned
+  , writeUnalignedByteArray
+  , readUnalignedByteArray
+  , indexUnalignedByteArray
+  ) where
+
+import Data.Primitive (Prim,MutableByteArray,ByteArray)
+import Control.Monad.Primitive (PrimState,PrimMonad)
+import System.ByteOrder (Bytes,toLittleEndian,fromLittleEndian)
+import Data.Primitive.ByteArray.Unaligned (PrimUnaligned)
+import qualified Data.Primitive as PM
+import qualified Data.Primitive.ByteArray.Unaligned as PMU
+
+-- | Write a primitive value to the byte array. The offset is given
+-- in elements of type @a@ rather than in bytes. The least significant
+-- byte in the value comes first.
+writeByteArray :: (PrimMonad m, Prim a, Bytes a)
+  => MutableByteArray (PrimState m) -> Int -> a -> m ()
+writeByteArray arr ix v = PM.writeByteArray arr ix (toLittleEndian v)
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the least significant one. The offset is given in elements of
+-- type @a@ rather than in bytes.
+readByteArray :: (PrimMonad m, Prim a, Bytes a)
+  => MutableByteArray (PrimState m) -> Int -> m a
+readByteArray arr ix = fromLittleEndian <$> PM.readByteArray arr ix
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the least significant one. The offset is given in elements of
+-- type @a@ rather than in bytes.
+indexByteArray :: (Prim a, Bytes a) => ByteArray -> Int -> a
+indexByteArray arr ix = fromLittleEndian (PM.indexByteArray arr ix)
+
+-- | Write a primitive value to the byte array. The offset is given
+-- in bytes rather than in elements of type @a@. The least significant
+-- byte in the value comes first.
+writeUnalignedByteArray :: (PrimMonad m, PrimUnaligned a, Bytes a)
+  => MutableByteArray (PrimState m) -> Int -> a -> m ()
+writeUnalignedByteArray arr ix v = PMU.writeUnalignedByteArray arr ix (toLittleEndian v)
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the least significant one. The offset is given in bytes rather
+-- than in elements of type @a@.
+readUnalignedByteArray :: (PrimMonad m, PrimUnaligned a, Bytes a)
+  => MutableByteArray (PrimState m) -> Int -> m a
+readUnalignedByteArray arr ix = fromLittleEndian <$> PMU.readUnalignedByteArray arr ix
+
+-- | Read a primitive value from the byte array, interpreting the first
+-- byte as the least significant one. The offset is given in bytes rather
+-- than in elements of type @a@.
+indexUnalignedByteArray :: (PrimUnaligned a, Bytes a)
+  => ByteArray -> Int -> a
+indexUnalignedByteArray arr ix = fromLittleEndian (PMU.indexUnalignedByteArray arr ix)
diff --git a/src/System/ByteOrder.hs b/src/System/ByteOrder.hs
--- a/src/System/ByteOrder.hs
+++ b/src/System/ByteOrder.hs
@@ -1,9 +1,12 @@
 {-# language DataKinds #-}
+{-# language DerivingStrategies #-}
+{-# language GeneralizedNewtypeDeriving #-}
 {-# language GADTSyntax #-}
 {-# language KindSignatures #-}
 {-# language MagicHash #-}
 {-# language RoleAnnotations #-}
 {-# language ScopedTypeVariables #-}
+{-# language StandaloneDeriving #-}
 {-# language TypeApplications #-}
 {-# language UnboxedTuples #-}
 
@@ -48,6 +51,7 @@
   ) where
 
 import Data.Kind (Type)
+import Data.Primitive.ByteArray.Unaligned (PrimUnaligned)
 import Data.Primitive.Types (Prim)
 import Foreign.Ptr (Ptr,castPtr)
 import Foreign.Storable (Storable)
@@ -55,6 +59,7 @@
 import System.ByteOrder.Class (Bytes(..),FixedOrdering,toFixedEndian)
 
 import qualified Data.Primitive.Types as PM
+import qualified Data.Primitive.ByteArray.Unaligned as PMU
 import qualified Foreign.Storable as FS
 
 -- | Convert from a big-endian word to a native-endian word.
@@ -74,6 +79,13 @@
 
 type role Fixed phantom representational
 
+deriving newtype instance Num a => Num (Fixed b a)
+deriving newtype instance Real a => Real (Fixed b a)
+deriving newtype instance Integral a => Integral (Fixed b a)
+deriving newtype instance Ord a => Ord (Fixed b a)
+deriving newtype instance Enum a => Enum (Fixed b a)
+deriving newtype instance Eq a => Eq (Fixed b a)
+
 instance (FixedOrdering b, Prim a, Bytes a) => Prim (Fixed b a) where
   {-# inline sizeOf# #-}
   {-# inline alignment# #-}
@@ -97,6 +109,15 @@
     (# s1, x #) -> (# s1, Fixed (toFixedEndian @b x) #)
   writeOffAddr# a i (Fixed x) = PM.writeOffAddr# a i (toFixedEndian @b x)
   setOffAddr# a i n (Fixed x) = PM.setOffAddr# a i n (toFixedEndian @b x)
+
+instance (FixedOrdering b, PrimUnaligned a, Bytes a) => PrimUnaligned (Fixed b a) where
+  {-# inline indexUnalignedByteArray# #-}
+  {-# inline readUnalignedByteArray# #-}
+  {-# inline writeUnalignedByteArray# #-}
+  indexUnalignedByteArray# a i = Fixed (toFixedEndian @b (PMU.indexUnalignedByteArray# a i))
+  readUnalignedByteArray# a i s0 = case PMU.readUnalignedByteArray# a i s0 of
+    (# s1, x #) -> (# s1, Fixed (toFixedEndian @b x) #)
+  writeUnalignedByteArray# a i (Fixed x) = PMU.writeUnalignedByteArray# a i (toFixedEndian @b x)
 
 instance (FixedOrdering b, Storable a, Bytes a) => Storable (Fixed b a) where
   {-# inline sizeOf #-}