diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Revision history for large-generics
 
+## 0.2.0.0 -- 2022-04-06
+
+* Use `SmallArray` instead of `Vector`
+
 ## 0.1.0.0 -- 2022-03-23
 
 * First public release
diff --git a/large-generics.cabal b/large-generics.cabal
--- a/large-generics.cabal
+++ b/large-generics.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               large-generics
-version:            0.1.0.0
+version:            0.2.0.0
 synopsis:           Generic programming API for large-records and large-anon
 description:        The large-generics package offers a style of generic
                     programming inspired by generics-sop, but optimized for
@@ -45,7 +45,10 @@
     , aeson        >= 1.4.4 && < 2.1
     , generics-sop >= 0.5   && < 0.6
     , sop-core     >= 0.5   && < 0.6
-    , vector       >= 0.12  && < 0.13
+    , primitive    >= 0.7   && < 0.8
+
+  if impl(ghc >= 8.10)
+    ghc-options: -Wunused-packages
 
 test-suite test-large-generics
   type:
diff --git a/src/Data/Record/Generic/Rep.hs b/src/Data/Record/Generic/Rep.hs
--- a/src/Data/Record/Generic/Rep.hs
+++ b/src/Data/Record/Generic/Rep.hs
@@ -55,14 +55,14 @@
   , zipWith
   )
 
-import Data.Proxy
+import Control.Monad (forM_)
 import Data.Functor.Identity
 import Data.Functor.Product
+import Data.Primitive.SmallArray
+import Data.Proxy
 import Data.SOP.Classes (fn_2)
 import Unsafe.Coerce (unsafeCoerce)
 
-import qualified Data.Vector as V
-
 import Data.Record.Generic
 import Data.Record.Generic.Rep.Internal
 
@@ -82,11 +82,13 @@
 
 getAtIndex :: Index a x -> Rep f a -> f x
 getAtIndex (UnsafeIndex ix) (Rep v) =
-    unsafeCoerce $ V.unsafeIndex v ix
+    unsafeCoerce $ indexSmallArray v ix
 
 putAtIndex :: Index a x -> f x -> Rep f a -> Rep f a
-putAtIndex (UnsafeIndex ix) x (Rep v) = Rep $
-    V.unsafeUpd v [(ix, unsafeCoerce x)]
+putAtIndex (UnsafeIndex ix) x (Rep v) = Rep $ runSmallArray $ do
+    v' <- thawSmallArray v 0 (sizeofSmallArray v)
+    writeSmallArray v' ix (noInlineUnsafeCo x)
+    return v'
 
 updateAtIndex ::
      Functor m
@@ -96,7 +98,14 @@
 updateAtIndex ix f a = (\x -> putAtIndex ix x a) <$> f (getAtIndex ix a)
 
 allIndices :: forall a. Generic a => Rep (Index a) a
-allIndices = Rep $ V.generate (recordSize (metadata (Proxy @a))) UnsafeIndex
+allIndices = Rep $ runSmallArray $ do
+    v <- newSmallArray size undefined
+    forM_ [0 .. size - 1] $ \i ->
+      writeSmallArray v i (UnsafeIndex i)
+    return v
+  where
+    size :: Int
+    size = recordSize (metadata (Proxy @a))
 
 -- | Map with index
 --
@@ -117,7 +126,10 @@
 -------------------------------------------------------------------------------}
 
 pure :: forall f a. Generic a => (forall x. f x) -> Rep f a
-pure f = Rep (V.replicate (recordSize (metadata (Proxy @a))) f)
+pure f = Rep $ runSmallArray $ newSmallArray size f
+  where
+    size :: Int
+    size = recordSize (metadata (Proxy @a))
 
 cpure ::
      (Generic a, Constraints a c)
diff --git a/src/Data/Record/Generic/Rep/Internal.hs b/src/Data/Record/Generic/Rep/Internal.hs
--- a/src/Data/Record/Generic/Rep/Internal.hs
+++ b/src/Data/Record/Generic/Rep/Internal.hs
@@ -24,13 +24,12 @@
 import qualified Prelude
 
 import Data.Coerce (coerce)
+import Data.Foldable (toList)
+import Data.Primitive.SmallArray
 import Data.SOP.BasicFunctors
-import Data.Vector (Vector)
 import GHC.Exts (Any)
 import Unsafe.Coerce (unsafeCoerce)
 
-import qualified Data.Vector as V
-
 {-------------------------------------------------------------------------------
   Representation
 -------------------------------------------------------------------------------}
@@ -39,7 +38,7 @@
 --
 -- The @f@ parameter describes which functor has been applied to all fields of
 -- the record; in other words @Rep I@ is isomorphic to the record itself.
-newtype Rep f a = Rep (Vector (f Any))
+newtype Rep f a = Rep (SmallArray (f Any))
 
 type role Rep representational nominal
 
@@ -62,24 +61,24 @@
 -------------------------------------------------------------------------------}
 
 collapse :: Rep (K a) b -> [a]
-collapse (Rep v) = coerce (V.toList v)
+collapse (Rep v) = coerce (toList v)
 
 -- | Convert 'Rep' to list
 toListAny :: Rep f a -> [f Any]
-toListAny (Rep v) = V.toList v
+toListAny (Rep v) = toList v
 
 -- | Convert list to 'Rep'
 --
 -- Does not check that the list has the right number of elements.
 unsafeFromList :: [b] -> Rep (K b) a
-unsafeFromList = Rep . V.fromList . Prelude.map K
+unsafeFromList = Rep . smallArrayFromList . Prelude.map K
 
 -- | Convert list to 'Rep'
 --
 -- Does not check that the list has the right number of elements, nor the
 -- types of those elements.
 unsafeFromListAny :: [f Any] -> Rep f a
-unsafeFromListAny = Rep . V.fromList
+unsafeFromListAny = Rep . smallArrayFromList
 
 {-------------------------------------------------------------------------------
   Some specialised instances for 'Rep
@@ -87,12 +86,12 @@
 
 instance Show x => Show (Rep (K x) a) where
   show (Rep v) =
-      show $ Prelude.map unK (V.toList v)
+      show $ Prelude.map unK (toList v)
 
 instance Eq x => Eq (Rep (K x) a) where
   Rep v == Rep v' =
-         Prelude.map unK (V.toList v)
-      == Prelude.map unK (V.toList v')
+         Prelude.map unK (toList v)
+      == Prelude.map unK (toList v')
 
 {-------------------------------------------------------------------------------
   Auxiliary
diff --git a/src/Data/Record/Generic/SOP.hs b/src/Data/Record/Generic/SOP.hs
--- a/src/Data/Record/Generic/SOP.hs
+++ b/src/Data/Record/Generic/SOP.hs
@@ -25,14 +25,15 @@
   , glowerBound
   ) where
 
+import Data.Foldable (toList)
 import Data.Kind
+import Data.Primitive.SmallArray
 import Data.Proxy
 import Data.SOP.Dict (all_NP)
 import Generics.SOP (SOP(..), NS(..), NP(..), SListI, All, Code, Compose)
 import GHC.Exts (Any)
 import GHC.TypeLits (Symbol)
 
-import qualified Data.Vector  as V
 import qualified Generics.SOP as SOP
 
 import Data.Record.Generic
@@ -59,14 +60,14 @@
 
 fromSOP :: SListI (MetadataOf a) => NP (Field f) (MetadataOf a) -> Rep f a
 fromSOP =
-    Rep . V.fromList . SOP.hcollapse . SOP.hmap conv
+    Rep . smallArrayFromList . SOP.hcollapse . SOP.hmap conv
   where
     conv :: Field f field -> K (f Any) field
     conv (Field fx) = K $ noInlineUnsafeCo fx
 
 toSOP :: SListI (MetadataOf a) => Rep f a -> Maybe (NP (Field f) (MetadataOf a))
 toSOP (Rep v) =
-    SOP.hmap conv <$> SOP.fromList (V.toList v)
+    SOP.hmap conv <$> SOP.fromList (toList v)
   where
     conv :: K (f Any) field -> Field f field
     conv (K fx) = Field (noInlineUnsafeCo fx)