diff --git a/composite-opaleye.cabal b/composite-opaleye.cabal
--- a/composite-opaleye.cabal
+++ b/composite-opaleye.cabal
@@ -3,7 +3,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           composite-opaleye
-version:        0.2.0.0
+version:        0.3.0.0
 synopsis:       Opaleye SQL for Frames records
 description:    Integration between Frames records and Opaleye SQL, allowing records to be stored, retrieved, and queried from PostgreSQL.
 category:       Records
@@ -18,12 +18,10 @@
 library
   hs-source-dirs:
       src
-  default-extensions: DataKinds FlexibleContexts FlexibleInstances LambdaCase MultiParamTypeClasses NoImplicitPrelude OverloadedStrings PolyKinds ScopedTypeVariables StrictData TemplateHaskell TypeFamilies TypeOperators ViewPatterns
+  default-extensions: DataKinds FlexibleContexts FlexibleInstances LambdaCase MultiParamTypeClasses OverloadedStrings PolyKinds ScopedTypeVariables StrictData TemplateHaskell TypeFamilies TypeOperators ViewPatterns
   ghc-options: -Wall -O2
   build-depends:
       base >= 4.7 && < 5
-    , Frames
-    , basic-prelude
     , bytestring
     , composite-base
     , lens
diff --git a/src/Composite/Opaleye/ProductProfunctors.hs b/src/Composite/Opaleye/ProductProfunctors.hs
--- a/src/Composite/Opaleye/ProductProfunctors.hs
+++ b/src/Composite/Opaleye/ProductProfunctors.hs
@@ -1,15 +1,12 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Composite.Opaleye.ProductProfunctors where
 
-import BasicPrelude
+import Composite.Record ((:->)(Val), Rec((:&), RNil))
+import Data.Functor.Identity (Identity(Identity))
 import Data.Profunctor (dimap)
 import Data.Profunctor.Product (ProductProfunctor, (***!))
 import qualified Data.Profunctor.Product as PP
 import Data.Profunctor.Product.Default (Default(def))
-import Data.Vinyl.Core (Rec((:&), RNil))
-import Data.Vinyl.Functor (Identity(Identity))
--- FIXME would nice to be generic to all vinyl records but then the types get really really hairy trying to assert Unwrapped r ~ p a b, project out a, and so on
-import Frames ((:->)(Col))
 
 -- |Type class implementing traversal of a record, yanking individual product profunctors @Record [p a b]@
 -- (though with distinct @a@ and @b@ at each position) up to @p (Record as) (Record bs)@.
@@ -36,9 +33,9 @@
   type PRecContra p (s :-> p a b ': rs) = (s :-> a ': PRecContra p rs)
   type PRecCo     p (s :-> p a b ': rs) = (s :-> b ': PRecCo     p rs)
 
-  pRec (Identity (Col p) :& rs) =
-    dimap (\ (Identity (Col a) :& aRs) -> (a, aRs))
-          (\ (b, bRs) -> (Identity (Col b) :& bRs))
+  pRec (Identity (Val p) :& rs) =
+    dimap (\ (Identity (Val a) :& aRs) -> (a, aRs))
+          (\ (b, bRs) -> (Identity (Val b) :& bRs))
           (p ***! pRec rs)
 
 instance ProductProfunctor p => Default p (Rec Identity '[]) (Rec Identity '[]) where
@@ -47,8 +44,8 @@
 instance forall p s a b rsContra rsCo. (ProductProfunctor p, Default p a b, Default p (Rec Identity rsContra) (Rec Identity rsCo))
       => Default p (Rec Identity (s :-> a ': rsContra)) (Rec Identity (s :-> b ': rsCo)) where
   def =
-    dimap (\ (Identity (Col a) :& aRs) -> (a, aRs))
-          (\ (b, bRs) -> (Identity (Col b) :& bRs))
+    dimap (\ (Identity (Val a) :& aRs) -> (a, aRs))
+          (\ (b, bRs) -> (Identity (Val b) :& bRs))
           (step ***! recur)
     where
       step :: p a b
diff --git a/src/Composite/Opaleye/RecordTable.hs b/src/Composite/Opaleye/RecordTable.hs
--- a/src/Composite/Opaleye/RecordTable.hs
+++ b/src/Composite/Opaleye/RecordTable.hs
@@ -1,15 +1,12 @@
 module Composite.Opaleye.RecordTable where
 
-import BasicPrelude
-import Composite.Base (NamedField(fieldName))
-import Control.Lens (Wrapped(type Unwrapped, _Wrapped'), from, view)
+import Composite.Record ((:->)(Val), Rec((:&), RNil))
+import Data.Functor.Identity (Identity(Identity))
 import Data.Profunctor (dimap)
 import Data.Profunctor.Product ((***!))
 import qualified Data.Profunctor.Product as PP
 import Data.Proxy (Proxy(Proxy))
-import Data.Text (unpack)
-import Data.Vinyl.Core (Rec((:&), RNil))
-import Data.Vinyl.Functor (Identity(Identity))
+import GHC.TypeLits (KnownSymbol, symbolVal)
 import Opaleye (Column, TableProperties, required, optional)
 
 -- |Helper typeclass which picks which of 'required' or 'optional' to use for a pair of write column type and read column type.
@@ -50,18 +47,18 @@
   defaultRecTable = dimap (const ()) (const RNil) PP.empty
 
 instance
-    forall r reads w writes.
-    ( NamedField w, NamedField r
-    , DefaultRecTableField (Unwrapped w) (Unwrapped r)
+    forall s r reads w writes.
+    ( KnownSymbol s
+    , DefaultRecTableField w r
     , DefaultRecTable writes reads
-    ) => DefaultRecTable (w ': writes) (r ': reads) where
+    ) => DefaultRecTable (s :-> w ': writes) (s :-> r ': reads) where
   defaultRecTable =
-    dimap (\ (Identity (view _Wrapped' -> w) :& writeRs) -> (w, writeRs))
-          (\ (r, readRs) -> (Identity (view (from _Wrapped') r) :& readRs))
+    dimap (\ (Identity (Val w) :& writeRs) -> (w, writeRs))
+          (\ (r, readRs) -> (Identity (Val r) :& readRs))
           (step  ***! recur)
     where
-      step :: TableProperties (Unwrapped w) (Unwrapped r)
-      step = defaultRecTableField . unpack $ fieldName (Proxy :: Proxy r)
+      step :: TableProperties w r
+      step = defaultRecTableField $ symbolVal (Proxy :: Proxy s)
       recur :: TableProperties (Rec Identity writes) (Rec Identity reads)
       recur = defaultRecTable
 
diff --git a/src/Composite/Opaleye/TH.hs b/src/Composite/Opaleye/TH.hs
--- a/src/Composite/Opaleye/TH.hs
+++ b/src/Composite/Opaleye/TH.hs
@@ -1,9 +1,10 @@
 module Composite.Opaleye.TH where
 
-import BasicPrelude hiding (lift)
 import Composite.Opaleye.Util (constantColumnUsing)
 import Control.Lens ((<&>))
 import qualified Data.ByteString.Char8 as BSC8
+import Data.Maybe (fromMaybe)
+import Data.Monoid ((<>))
 import Data.Profunctor.Product.Default (Default, def)
 import Data.Traversable (for)
 import Database.PostgreSQL.Simple (ResultError(ConversionFailed, Incompatible, UnexpectedNull))