diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,9 @@
+0.0.3
+
+* Add `bytestring`, `lazyByteString`, `shortByteString` prisms and
+  `ReviewOne`/`AsOne` instances for `ByteString` (strict, lazy, and short)
+  in `Control.One.One`
+
 0.0.2
 
 * Introduce the `One f a t` data type representing a value with a
diff --git a/one.cabal b/one.cabal
--- a/one.cabal
+++ b/one.cabal
@@ -1,6 +1,6 @@
 cabal-version:        2.4
 name:                 one
-version:              0.0.2
+version:              0.0.3
 synopsis:             One
 description:          Data types that have a singleton view
 license:              BSD-3-Clause
diff --git a/src/Control/One/One.hs b/src/Control/One/One.hs
--- a/src/Control/One/One.hs
+++ b/src/Control/One/One.hs
@@ -45,6 +45,11 @@
     lazyText,
     shortText,
 
+    -- ** ByteString
+    bytestring,
+    lazyByteString,
+    shortByteString,
+
     -- ** Newtypes
     first',
     last',
@@ -86,9 +91,13 @@
 import Data.Semigroup.Bitraversable (Bitraversable1 (..))
 import Data.Semigroup.Foldable (Foldable1 (..))
 import Data.Semigroup.Traversable (Traversable1 (..))
+import qualified Data.ByteString as ByteString
+import qualified Data.ByteString.Lazy as LazyByteString
+import qualified Data.ByteString.Short as ShortByteString
 import qualified Data.Text as Text
 import qualified Data.Text.Lazy as LazyText
 import qualified Data.Text.Short as ShortText
+import Data.Word (Word8)
 import Data.Tuple (Solo (..))
 import GHC.Generics (Generic, Par1 (..))
 
@@ -108,6 +117,9 @@
 -- >>> import Data.Functor.Classes (liftEq, liftCompare, liftShowsPrec, liftEq2, liftCompare2, liftShowsPrec2)
 -- >>> import Data.Functor.Identity (Identity(..))
 -- >>> import Data.List.NonEmpty (NonEmpty(..))
+-- >>> import qualified Data.ByteString as ByteString
+-- >>> import qualified Data.ByteString.Lazy as LazyByteString
+-- >>> import qualified Data.ByteString.Short as ShortByteString
 -- >>> import qualified Data.Text as Text
 -- >>> import qualified Data.Text.Lazy as LazyText
 -- >>> import qualified Data.Text.Short as ShortText
@@ -527,6 +539,102 @@
 -- Nothing
 instance AsOne ShortText.ShortText (Const ShortText.ShortText) Char () where
   matchOne x = case ShortText.uncons x of
+    Nothing -> Nothing
+    Just (h, t) -> Just (One h (Const t))
+
+-- | >>> preview bytestring (ByteString.pack [104, 101, 108, 108, 111])
+-- Just (One 104 (Const "ello"))
+--
+-- >>> preview bytestring ByteString.empty
+-- Nothing
+--
+-- >>> review bytestring (One 104 (Const (ByteString.pack [101, 108, 108, 111])))
+-- "hello"
+bytestring :: Prism' ByteString.ByteString (One (Const ByteString.ByteString) Word8 ())
+bytestring =
+  prism'
+    (\(One h (Const t)) -> ByteString.cons h t)
+    ( \x -> case ByteString.uncons x of
+        Nothing -> Nothing
+        Just (h, t) -> Just (One h (Const t))
+    )
+
+-- | >>> review reviewOne (One 104 (Const (ByteString.pack [105]))) :: ByteString.ByteString
+-- "hi"
+instance ReviewOne ByteString.ByteString (Const ByteString.ByteString) Word8 () where
+  reviewOne = bytestring
+
+-- | >>> preview _One (ByteString.pack [104, 105]) :: Maybe (One (Const ByteString.ByteString) Word8 ())
+-- Just (One 104 (Const "i"))
+--
+-- >>> preview _One ByteString.empty :: Maybe (One (Const ByteString.ByteString) Word8 ())
+-- Nothing
+instance AsOne ByteString.ByteString (Const ByteString.ByteString) Word8 () where
+  matchOne x = case ByteString.uncons x of
+    Nothing -> Nothing
+    Just (h, t) -> Just (One h (Const t))
+
+-- | >>> preview lazyByteString (LazyByteString.pack [104, 101, 108, 108, 111])
+-- Just (One 104 (Const "ello"))
+--
+-- >>> preview lazyByteString LazyByteString.empty
+-- Nothing
+--
+-- >>> review lazyByteString (One 104 (Const (LazyByteString.pack [101, 108, 108, 111])))
+-- "hello"
+lazyByteString :: Prism' LazyByteString.ByteString (One (Const LazyByteString.ByteString) Word8 ())
+lazyByteString =
+  prism'
+    (\(One h (Const t)) -> LazyByteString.cons h t)
+    ( \x -> case LazyByteString.uncons x of
+        Nothing -> Nothing
+        Just (h, t) -> Just (One h (Const t))
+    )
+
+-- | >>> review reviewOne (One 104 (Const (LazyByteString.pack [105]))) :: LazyByteString.ByteString
+-- "hi"
+instance ReviewOne LazyByteString.ByteString (Const LazyByteString.ByteString) Word8 () where
+  reviewOne = lazyByteString
+
+-- | >>> preview _One (LazyByteString.pack [104, 105]) :: Maybe (One (Const LazyByteString.ByteString) Word8 ())
+-- Just (One 104 (Const "i"))
+--
+-- >>> preview _One LazyByteString.empty :: Maybe (One (Const LazyByteString.ByteString) Word8 ())
+-- Nothing
+instance AsOne LazyByteString.ByteString (Const LazyByteString.ByteString) Word8 () where
+  matchOne x = case LazyByteString.uncons x of
+    Nothing -> Nothing
+    Just (h, t) -> Just (One h (Const t))
+
+-- | >>> preview shortByteString (ShortByteString.pack [104, 101, 108, 108, 111])
+-- Just (One 104 (Const "ello"))
+--
+-- >>> preview shortByteString (ShortByteString.pack [])
+-- Nothing
+--
+-- >>> review shortByteString (One 104 (Const (ShortByteString.pack [101, 108, 108, 111])))
+-- "hello"
+shortByteString :: Prism' ShortByteString.ShortByteString (One (Const ShortByteString.ShortByteString) Word8 ())
+shortByteString =
+  prism'
+    (\(One h (Const t)) -> ShortByteString.cons h t)
+    ( \x -> case ShortByteString.uncons x of
+        Nothing -> Nothing
+        Just (h, t) -> Just (One h (Const t))
+    )
+
+-- | >>> review reviewOne (One 104 (Const (ShortByteString.pack [105]))) :: ShortByteString.ShortByteString
+-- "hi"
+instance ReviewOne ShortByteString.ShortByteString (Const ShortByteString.ShortByteString) Word8 () where
+  reviewOne = shortByteString
+
+-- | >>> preview _One (ShortByteString.pack [104, 105]) :: Maybe (One (Const ShortByteString.ShortByteString) Word8 ())
+-- Just (One 104 (Const "i"))
+--
+-- >>> preview _One (ShortByteString.pack []) :: Maybe (One (Const ShortByteString.ShortByteString) Word8 ())
+-- Nothing
+instance AsOne ShortByteString.ShortByteString (Const ShortByteString.ShortByteString) Word8 () where
+  matchOne x = case ShortByteString.uncons x of
     Nothing -> Nothing
     Just (h, t) -> Just (One h (Const t))