diff --git a/changelog.md b/changelog.md
new file mode 100644
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,11 @@
+0.1.0.0
+-------
+
+* Updated for Vinyl 0.5.*
+* Removed slicing lens and overwriting (already in Vinyl proper).
+
+0.0.0.0
+------
+
+* Initial commit.
+
diff --git a/src/Data/Vinyl/Upcast.hs b/src/Data/Vinyl/Upcast.hs
deleted file mode 100644
--- a/src/Data/Vinyl/Upcast.hs
+++ /dev/null
@@ -1,71 +0,0 @@
-{-# LANGUAGE
-      DataKinds
-    , MultiParamTypeClasses
-    , FlexibleContexts
-    , FlexibleInstances
-    , PolyKinds
-    , ScopedTypeVariables
-    , TypeFamilies
-    , TypeOperators
-    , UndecidableInstances
-    #-}
-
-{-# OPTIONS_HADDOCK show-extensions #-}
-
-{-|
-Module      : Data.Vinyl.Upcast
-Description : Upward cast and slicing.
-Copyright   : (c) Marcin Mrotek, 2014
-License     : BSD3
-Maintainer  : marcin.jan.mrotek@gmail.com
--}
-
-module Data.Vinyl.Upcast (
-      Overwrite(..)
-    , slice
-    , (:>)(..)
-    , AltRec(..)
-) where
-
-import Control.Applicative
-import Data.Monoid
-import Data.Vinyl
-import Data.Vinyl.TyFun
-
--- |Overwrite a wider record with a narrower record.
-class Overwrite (xs :: [k]) (ys :: [k]) where
-    overwrite :: Rec el f xs -> Rec el f ys -> Rec el f xs
-
-instance Overwrite xs '[] where
-    overwrite xs _ = xs
-
-instance (IElem y xs, Overwrite xs ys) => Overwrite xs (y ': ys) where
-    overwrite xs (y :& ys) = overwrite (ith (implicitly :: Elem y xs) y xs) ys
-        where 
-            ith :: Elem x rs ->  f (el $ x) -> Rec el f rs -> Rec el f rs
-            ith Here      y (_ :& xs) = y :& xs 
-            ith (There p) y (x :& xs) = x :& ith p y xs
-
-slice :: (Functor f, Overwrite xs ys, xs <: ys) 
-      => (Rec el g ys -> f (Rec el g ys))
-      ->  Rec el g xs -> f (Rec el g xs)
--- ^A lens from a record to a portion of it.
-slice k x = overwrite x <$> k (cast x)
-
--- |Wrapper for Rec with a different Monoid instance. Instead of lifting mappend, it acts on (f (el $ r)) directly, to support temporarily turning records into monoids by changing functors.
-newtype AltRec el f rs = AltRec {getRec :: Rec el f rs}
-
-instance Monoid (AltRec el f '[]) where
-    mempty = AltRec RNil
-    _ `mappend` _ = AltRec RNil
-
-instance (Monoid (f (el $ r)), Monoid (AltRec el f rs)) => Monoid (AltRec el f (r ': rs)) where
-    mempty = AltRec $ mempty :& getRec mempty
-    (AltRec (x :& xs)) `mappend` (AltRec (y :& ys)) = AltRec $ (x <> y) :& getRec (AltRec xs `mappend` AltRec ys)
-
--- |Upward record casting.
-class (Overwrite ys xs, ys <: xs) => (xs :: [k]) :> (ys :: [k]) where
-    upcast :: (Monoid (AltRec el f ys)) => Rec el f xs -> Rec el f ys
-
-instance (Overwrite ys xs, ys <: xs) => xs :> ys where
-    upcast xs = overwrite (getRec mempty) xs
diff --git a/src/Data/Vinyl/Utils/Compose.hs b/src/Data/Vinyl/Utils/Compose.hs
--- a/src/Data/Vinyl/Utils/Compose.hs
+++ b/src/Data/Vinyl/Utils/Compose.hs
@@ -17,9 +17,9 @@
     rtraverse1
 ) where
 import Control.Applicative
-import Data.Functor.Compose
+import Data.Vinyl.Functor
 import Data.Vinyl
 
-rtraverse1 :: Applicative f => Rec el (Compose f g) rs -> f (Rec el g rs)
+rtraverse1 :: Applicative f => Rec (Compose f g) rs -> f (Rec g rs)
 -- ^Traverse a record parametrized with a composition of functors, leaving the inner functor.
 rtraverse1 = rtraverse getCompose
diff --git a/src/Data/Vinyl/Utils/Const.hs b/src/Data/Vinyl/Utils/Const.hs
--- a/src/Data/Vinyl/Utils/Const.hs
+++ b/src/Data/Vinyl/Utils/Const.hs
@@ -19,24 +19,23 @@
       ConstApplicative(..)
     , rconst
     , constCommute
-    , rconstdist
+    , rtraverseconst
 ) where
 
 import Data.Vinyl.Utils.Compose
 
-import Control.Applicative
-import Data.Functor.Compose
+import Control.Applicative hiding (Const)
+import Data.Vinyl.Functor
 import Data.Vinyl
-import Data.Vinyl.TyFun
 
-cfmap :: (a -> b) -> Rec el (Const a) rs -> Rec el (Const b) rs
+cfmap :: (a -> b) -> Rec (Const a) rs -> Rec (Const b) rs
 -- ^Map a function over a constant type record.
 cfmap _ RNil = RNil
 cfmap f (Const r :& rs) = Const (f r) :& cfmap f rs
 
 -- |Extension of 'pure' to constant type records.
 class ConstApplicative (rs :: [k]) where
-    cpure :: a -> Rec el (Const a) rs
+    cpure :: a -> Rec (Const a) rs
  
 instance ConstApplicative '[] where
     cpure = const RNil
@@ -44,12 +43,12 @@
 instance ConstApplicative rs => ConstApplicative (r ': rs) where
     cpure x = Const x :& cpure x
 
-capp  :: (Rec el (Const (a -> b)) rs) -> Rec el (Const a) rs -> Rec el (Const b) rs
+capp  :: (Rec (Const (a -> b)) rs) -> Rec (Const a) rs -> Rec (Const b) rs
 -- ^Extension of (<*>) to constant type records.
 capp RNil RNil = RNil
 capp (Const f :& fs) (Const x :& xs) = Const (f x) :& capp fs xs
 
-rconst :: (Applicative f, RecApplicative rs) => f a -> f (Rec el (Const a) rs)
+rconst :: (Applicative f, RecApplicative rs) => f a -> f (Rec (Const a) rs)
 rconst = rtraverse1 . rcpure
     where rcpure a = rpure (Compose $ Const <$> a)
 
@@ -57,6 +56,6 @@
 -- ^Commute a constant functor with another functor.
 constCommute (Const a) = Compose $ Const <$> a
 
-rconstdist :: Applicative f => Rec el (Const (f a)) rs -> f (Rec el (Const a) rs)
+rtraverseconst :: Applicative f => Rec (Const (f a)) rs -> f (Rec (Const a) rs)
 -- ^Distribute a functor over a constant type record.
-rconstdist rec = rtraverse1 $ constCommute <<$>> rec
+rtraverseconst rec = rtraverse1 $ constCommute <<$>> rec
diff --git a/src/Data/Vinyl/Utils/Operator.hs b/src/Data/Vinyl/Utils/Operator.hs
--- a/src/Data/Vinyl/Utils/Operator.hs
+++ b/src/Data/Vinyl/Utils/Operator.hs
@@ -27,55 +27,53 @@
     , p
 ) where
 
-import Control.Applicative
-import Data.Functor.Compose
+import Control.Applicative hiding (Const)
 import Data.Functor.Contravariant
 import Data.Monoid
 import Data.Vinyl
-import Data.Vinyl.Constraint
-import Data.Vinyl.TyFun
+import Data.Vinyl.Functor
 
-operator :: (forall t. f t -> g t -> h t) -> Rec el f rs -> Rec el g rs -> Rec el h rs
--- ^Create an operator between records sharing their universes and fields but differing in functors.
+operator :: (forall t. f t -> g t -> h t) -> Rec f rs -> Rec g rs -> Rec h rs
+-- ^Create an operator between records sharing their fields but differing in functors.
 operator _ RNil RNil = RNil
 operator f (a :& as) (b :& bs) = (f a b) :& operator f as bs
 
-(/$/) :: Functor f => Rec el ((->) a) rs -> Rec el (Const (f a)) rs -> Rec el f rs
+(/$/) :: Functor f => Rec ((->) a) rs -> Rec (Const (f a)) rs -> Rec f rs
 -- ^Apply a record of (a -> x) functions to a constant type record to obtain a plain f-record.
 (/$/) = operator (\f (Const x) -> f <$> x)
 
-(/$$/) :: Rec el (Compose ((->) a) f) rs -> Rec el (Const a) rs -> Rec el f rs
--- ^Apply a record of (f a -> f x) functions to a constant type record to obtain a plain f-record.
+(/$$/) :: Rec (Compose ((->) a) f) rs -> Rec (Const a) rs -> Rec f rs
+-- ^Apply a record of (a -> f x) functions to a constant type record to obtain a plain f-record.
 (/$$/) = operator (\(Compose f) (Const x) -> f x)
 
-(\$\) :: Functor f => Rec el (Op a) rs -> Rec el f rs -> Rec el (Const (f a)) rs
+(\$\) :: Functor f => Rec (Op a) rs -> Rec f rs -> Rec (Const (f a)) rs
 -- ^Apply a record of (x -> a) functions to a plain f-record to obtain a constant type record.
 (\$\) = operator (\(Op f) x -> Const $ f <$> x)
 
-(\$$\) :: Rec el (Compose (Op a) f) rs -> Rec el f rs -> Rec el (Const a) rs
--- ^Apply a record of (f x -> f a) functions to a plain f-record to obtain a constant type record.
+(\$$\) :: Rec (Compose (Op a) f) rs -> Rec f rs -> Rec (Const a) rs
+-- ^Apply a record of (f x -> a) functions to a plain f-record to obtain a constant type record.
 (\$$\) = operator (\(Compose (Op f)) x -> Const $ f x)
 
 predicate (Predicate p) x = Const $ p <$> x
 
-(\&&\) :: forall el f rs. Applicative f => Rec el Predicate rs -> Rec el f rs -> f Bool
+(\&&\) :: forall f rs. Applicative f => Rec Predicate rs -> Rec f rs -> f Bool
 -- ^Apply a predicate record to a plain f-record to obtain a boolean product inside the f functor.
 (\&&\) p r = go result $ pure True
     where
-        go :: Rec el (Const (f Bool)) xs -> f Bool -> f Bool
+        go :: Rec (Const (f Bool)) xs -> f Bool -> f Bool
         go RNil b = b
         go (Const a :& as) b = go as $ (&&) <$> a <*> b
-        result :: Rec el (Const (f Bool)) rs
+        result :: Rec (Const (f Bool)) rs
         result = operator predicate p r
     
-(\||\) :: forall el f rs. Applicative f => Rec el Predicate rs -> Rec el f rs -> f Bool
+(\||\) :: forall f rs. Applicative f => Rec Predicate rs -> Rec f rs -> f Bool
 -- ^Apply a predicate record to a plain f-record to obtain a boolean sum inside the f functor.
 (\||\) p r = go result $ pure False
     where 
-        go :: Rec el (Const (f Bool)) xs -> f Bool -> f Bool
+        go :: Rec (Const (f Bool)) xs -> f Bool -> f Bool
         go RNil b = b
         go (Const a :& as) b = go as $ (||) <$> a <*> b
-        result :: Rec el (Const (f Bool)) rs
+        result :: Rec (Const (f Bool)) rs
         result = operator predicate p r
 
 p :: (a -> Bool) -> Predicate a
diff --git a/vinyl-utils.cabal b/vinyl-utils.cabal
--- a/vinyl-utils.cabal
+++ b/vinyl-utils.cabal
@@ -2,9 +2,9 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                vinyl-utils
-version:             0.0.0.0
+version:             0.1.0.0
 synopsis:            Utilities for vinyl
-description:         Upcast operator, slicing lens, and operations on records parametrized with various kinds of functors.
+description:         Operations on records parametrized with various kinds of functors.
 license:             BSD3
 license-file:        LICENSE
 author:              Marcin Mrotek
@@ -15,6 +15,7 @@
 -- extra-source-files:  
 cabal-version:       >=1.10
 homepage:            http://hub.darcs.net/mjm/vinyl-utils
+extra-source-files:  changelog.md
 source-repository    head
     type:    darcs
     location: mjm@hub.darcs.net:mjm/vinyl-utils
@@ -23,12 +24,11 @@
   exposed-modules:     Data.Vinyl.Utils.Const
                       ,Data.Vinyl.Utils.Compose
                       ,Data.Vinyl.Utils.Operator
-                      ,Data.Vinyl.Upcast
   -- other-modules:       
   -- other-extensions:    
   build-depends:       base >=4.7 && <4.8
                       ,contravariant
                       ,transformers
-                      ,vinyl
+                      ,vinyl >= 0.5
   hs-source-dirs:      src
   default-language:    Haskell2010