diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,9 @@
 # Changelog for chassis
 
+## v0.0.6.0
+
+* Export `Predicate`, `Equivalence`, `Comparison` and `Op`.
+
 ## v0.0.5.0
 
 * Export `NonEmpty`
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,8 +1,9 @@
 # chassis
 
-Chassis is an experimental prelude that exports most of the standard Haskell apparatus by default,
-common types and type classes, as well as lesser used abstractions from category theory by default.
-
-Chassis also re-exports some thins from vinyl and composite, and keeps polykinds on by default.
+Chassis is a prelude aimed at fixing some of the defects of base while providing
+convenient access to standard haskell tools. 
 
-Extremely early prototype idea.
+* No `Num`.
+* PolyKinded `Compose`.
+* MTL types are not exported by default, so as to not conflict with free monad libraries
+  with similar names for effect types.
diff --git a/chassis.cabal b/chassis.cabal
--- a/chassis.cabal
+++ b/chassis.cabal
@@ -5,8 +5,8 @@
 -- see: https://github.com/sol/hpack
 
 name:           chassis
-version:        0.0.5.0
-synopsis:       Prelude with algebraic constructs and polykinds on.
+version:        0.0.6.0
+synopsis:       Polykinded Prelude Kernel.
 category:       Prelude
 author:         Daniel Firth
 maintainer:     dan.firth@homotopic.tech
@@ -20,7 +20,7 @@
 
 source-repository head
   type: git
-  location: https://gitlab.com/homotopic-tech/chassis
+  location: https://gitlab.homotopic.tech/haskell/chassis
 
 library
   exposed-modules:
@@ -29,21 +29,18 @@
       Paths_chassis
   hs-source-dirs:
       src
+  ghc-options: -Weverything -Wno-all-missed-specialisations -Wno-implicit-prelude -Wno-missing-safe-haskell-mode -Wno-prepositive-qualified-module -Wno-safe -Wno-unsafe
   build-depends:
       base >=4.7 && <5
     , bytestring
     , comonad
-    , composite-base
+    , composite-base >=0.7.4.0
     , containers
-    , contravariant
     , distributive
-    , either
-    , exceptions
     , extra
     , first-class-families
     , path
     , profunctors
-    , rio
     , text
     , time
     , vinyl
diff --git a/src/Chassis.hs b/src/Chassis.hs
--- a/src/Chassis.hs
+++ b/src/Chassis.hs
@@ -1,201 +1,403 @@
 {-# LANGUAGE ExplicitNamespaces #-}
-{-# LANGUAGE PolyKinds          #-}
-module Chassis (
--- * Void
-  Void
-, absurd
-
--- * Bool
-, Bool(..)
-, not
+{-# LANGUAGE PolyKinds #-}
 
--- * Numbers
-, Int
-, Num(..)
+module Chassis
+  ( -- * Void
+    Void,
+    absurd,
 
--- * String/Text/ByteString
-, String
-, ByteString
-, Text
-, Show(..)
+    -- * Bool
+    Bool (..),
+    not,
 
--- * Classic Algebra
-, Semigroup(..)
-, Monoid(..)
-, Eq(..)
-, Ord(..)
+    -- * Numbers
+    Int,
 
--- * Function Composition
-, (.)
-, ($)
+    -- * String/Text/ByteString
+    String,
+    ByteString,
+    Text,
+    Show (..),
 
--- * IO
-, IO
+    -- * Classic Algebra
+    Semigroup (..),
+    Monoid (..),
+    Eq (..),
+    Ord (..),
 
--- * Maybe
-, Maybe(..)
-, maybe
+    -- * Function Application
+    ($),
+    (&),
 
--- * Either
-, Either(..)
-, either
+    -- * IO
+    IO,
 
--- * NonEmpty
-, NonEmpty(..)
+    -- * Maybe
+    Maybe (..),
+    maybe,
 
--- * Map
-, Map(..)
+    -- * Either
+    Either (..),
+    either,
 
--- * Tuples & Currying
-, fst
-, snd
-, const
-, curry
-, uncurry
+    -- * NonEmpty
+    NonEmpty (..),
 
--- * Foldable
-, Foldable(..)
+    -- * Map
+    Map,
 
--- * Functor
-, Functor(..)
-, (<$>)
-, void
+    -- * Tuples & Currying
+    fst,
+    snd,
+    const,
+    curry,
+    uncurry,
 
--- * Applicative
-, Applicative(..)
-, when
-, unless
-, whenM
-, whenJust
+    -- * Foldable
+    Foldable (..),
 
--- * Traversable
-, Traversable(..)
-, traverse_
-, for_
-, filterM
+    -- * Functor
+    Functor (..),
+    ($>),
+    (<$>),
+    void,
 
--- * Monad
-, Monad(..)
-, join
-, forM_
-, forM
-, mapM_
-, sequence_
-, (=<<)
-, (>=>)
+    -- * Applicative
+    Applicative (..),
+    when,
+    unless,
+    whenM,
+    whenJust,
 
--- * Contravariant
-, Contravariant(..)
-, (>$<)
+    -- * Traversable
+    Traversable (..),
+    traverse_,
+    for_,
+    filterM,
 
--- * Distributive
-, Distributive(..)
+    -- * Monad
+    Monad (..),
+    join,
+    forM_,
+    forM,
+    mapM_,
+    sequence_,
+    (=<<),
+    (>=>),
 
--- * Comonad
-, ComonadApply(..)
-, Comonad(..)
-, (=>=)
-, (<<=)
+    -- * Contravariant
+    Contravariant (..),
+    (>$<),
+    Predicate,
+    Equivalence,
+    Comparison,
+    Op,
 
--- * Profunctor
-, Profunctor(..)
-, Strong(..)
-, Choice(..)
+    -- * Distributive
+    Distributive (..),
 
--- * Category
-, Category(..)
-, Arrow(..)
-, (>>>)
-, ArrowChoice(..)
-, ArrowLoop(..)
+    -- * Comonad
+    Comonad (..),
+    (=>=),
+    (<<=),
 
--- * EnvT
-, Env(..)
-, EnvT(..)
-, env
-, runEnv
-, runEnvT
+    -- * Profunctor
+    Profunctor (..),
+    Strong (..),
+    Choice (..),
 
--- * Extensible Records
-, Rec(..)
-, RMap
-, rtraverse
-, rcast
-, CoRec(..)
-, type (∈)
+    -- * Category
+    Category (..),
+    Arrow (..),
+    Kleisli (..),
+    (>>>),
+    (<<<),
 
--- * Compose
-, (:.)
-, Compose(..)
-, onCompose
+    -- * EnvT
+    Env,
+    EnvT (..),
+    env,
+    runEnv,
+    runEnvT,
 
--- * Generic
-, Generic
+    -- * Extensible Records
+    Rec (..),
+    RMap,
+    rtraverse,
+    rcast,
+    CoRec (..),
+    type (∈),
 
--- * Time
-, UTCTime
+    -- * Compose
+    (:.),
+    Compose (..),
+    onCompose,
 
--- * Path
-, Path
-, Rel
-, Abs
-, File
-, Dir
-, mkRelDir
-, mkRelFile
-, mkAbsDir
-, mkAbsFile
-, (</>)
+    -- * Generic
+    Generic,
 
-, flip
-, rights
-, Type
+    -- * Time
+    UTCTime,
 
--- * First Class Families
-, Exp
-, Eval
-, FMap
+    -- * Path
+    Path,
+    Rel,
+    Abs,
+    File,
+    Dir,
+    mkRelDir,
+    mkRelFile,
+    mkAbsDir,
+    mkAbsFile,
+    (</>),
+    flip,
+    rights,
 
--- * Exceptions
-, Exception(..)
-, SomeException(..)
+    -- * Kinds
+    Type,
+    Constraint,
 
--- * Undefined
-, undefined
+    -- * First Class Families
+    Exp,
+    Eval,
+    FMap,
 
--- * Lists
-, fromMaybe
-, headMaybe
-, tailMaybe
-, initMaybe
-) where
+    -- * Exceptions
+    Exception (..),
+    SomeException,
+  )
+where
 
 import Composite.CoRecord
+  ( CoRec
+      ( CoVal
+      ),
+  )
 import Control.Applicative
+  ( Applicative
+      ( liftA2,
+        pure,
+        (<*>)
+      ),
+  )
 import Control.Arrow
-import Control.Category hiding ((.))
+  ( Arrow
+      ( arr,
+        first,
+        second,
+        (&&&),
+        (***)
+      ),
+    Kleisli (runKleisli),
+  )
+import Control.Category
+  ( Category
+      ( id,
+        (.)
+      ),
+    (<<<),
+    (>>>),
+  )
+import Control.Comonad
+  ( Comonad
+      ( duplicate,
+        extend,
+        extract
+      ),
+    (<<=),
+    (=>=),
+  )
 import Control.Comonad.Env
+  ( Env,
+    EnvT (EnvT),
+    env,
+    runEnv,
+    runEnvT,
+  )
 import Control.Exception
+  ( Exception
+      ( displayException
+      ),
+    SomeException,
+  )
 import Control.Monad
+  ( Monad
+      ( return,
+        (>>),
+        (>>=)
+      ),
+    filterM,
+    forM,
+    forM_,
+    join,
+    mapM,
+    mapM_,
+    sequence,
+    sequence_,
+    unless,
+    void,
+    when,
+    (=<<),
+    (>=>),
+  )
 import Control.Monad.Extra
+  ( whenJust,
+    whenM,
+  )
 import Data.ByteString
+  ( ByteString,
+  )
 import Data.Distributive
+  ( Distributive (distribute),
+  )
 import Data.Either
+  ( Either
+      ( Left,
+        Right
+      ),
+    either,
+    rights,
+  )
 import Data.Foldable
+  ( Foldable (foldl', foldr),
+    for_,
+    traverse_,
+  )
+import Data.Function
+  ( ( &
+    ),
+  )
+import Data.Functor
+  ( Functor (fmap),
+    ($>),
+    (<$),
+    (<$>),
+  )
 import Data.Functor.Contravariant
+  ( Comparison,
+    Contravariant
+      ( contramap
+      ),
+    Equivalence,
+    Op,
+    Predicate,
+    (>$<),
+  )
 import Data.Kind
+  ( Constraint,
+    Type,
+  )
 import Data.List.NonEmpty
-import Data.Map (Map)
+  ( NonEmpty ((:|)),
+  )
+import Data.Map
+  ( Map,
+  )
 import Data.Maybe
+  ( Maybe
+      ( Just,
+        Nothing
+      ),
+    maybe,
+  )
 import Data.Profunctor
+  ( Choice
+      ( left',
+        right'
+      ),
+    Profunctor
+      ( dimap,
+        lmap,
+        rmap
+      ),
+    Strong
+      ( first',
+        second'
+      ),
+  )
 import Data.Text
-import Data.Time (UTCTime)
+  ( Text,
+  )
+import Data.Time
+  ( UTCTime,
+  )
 import Data.Vinyl
+  ( RMap,
+    Rec (RNil, (:&)),
+    rcast,
+    rtraverse,
+    type (∈),
+  )
 import Data.Vinyl.Functor
+  ( Compose (getCompose),
+    onCompose,
+    type (:.),
+  )
 import Data.Void
-import Fcf (Eval, Exp)
-import Fcf.Class.Functor (FMap)
+  ( Void,
+    absurd,
+  )
+import Fcf
+  ( Eval,
+    Exp,
+  )
+import Fcf.Class.Functor
+  ( FMap,
+  )
 import GHC.Generics
-import RIO.List (headMaybe, tailMaybe, initMaybe)
+  ( Generic,
+  )
 import Path
+  ( Abs,
+    Dir,
+    File,
+    Path,
+    Rel,
+    mkAbsDir,
+    mkAbsFile,
+    mkRelDir,
+    mkRelFile,
+    (</>),
+  )
 import Prelude
+  ( Bool
+      ( False,
+        True
+      ),
+    Eq
+      ( (/=),
+        (==)
+      ),
+    IO,
+    Int,
+    Monoid
+      ( mempty
+      ),
+    Ord
+      ( compare,
+        max,
+        min,
+        (<),
+        (<=),
+        (>),
+        (>=)
+      ),
+    Semigroup
+      ( (<>)
+      ),
+    Show
+      ( show
+      ),
+    String,
+    Traversable
+      ( traverse
+      ),
+    const,
+    curry,
+    flip,
+    fst,
+    not,
+    snd,
+    uncurry,
+    ($),
+  )