diff --git a/markup.cabal b/markup.cabal
--- a/markup.cabal
+++ b/markup.cabal
@@ -1,5 +1,5 @@
 Name:                   markup
-Version:                2.0.0
+Version:                2.1.0
 Author:                 Athan Clark <athan.clark@gmail.com>
 Maintainer:             Athan Clark <athan.clark@gmail.com>
 License:                MIT
@@ -35,10 +35,16 @@
                       , blaze-html
                       , blaze-markup
                       , comonad
+                      , exceptions
                       , lucid >= 2.5
+                      , mmorph
+                      , monad-control
+                      , monad-logger
                       , mtl
                       , path-extra >= 0.0.1
+                      , resourcet
                       , text
+                      , transformers-base
                       , urlpath >= 3.1.0
 
 Source-Repository head
diff --git a/src/Data/Markup/Types.hs b/src/Data/Markup/Types.hs
--- a/src/Data/Markup/Types.hs
+++ b/src/Data/Markup/Types.hs
@@ -1,16 +1,31 @@
 {-# LANGUAGE
-    DeriveFunctor
+    TypeFamilies
+  , DeriveFunctor
   , FlexibleContexts
   , FlexibleInstances
-  , GeneralizedNewtypeDeriving
-  , MultiParamTypeClasses
   , StandaloneDeriving
+  , UndecidableInstances
+  , MultiParamTypeClasses
+  , GeneralizedNewtypeDeriving
   #-}
 
 module Data.Markup.Types where
 
+import Data.Url
 import Data.Functor.Identity
-import Control.Monad.Trans
+import Control.Applicative
+import Control.Monad.Trans.Control
+import Control.Monad.Trans.Resource
+import Control.Monad
+import Control.Monad.Reader
+import Control.Monad.Writer
+import Control.Monad.State
+import Control.Monad.RWS
+import Control.Monad.Except
+import Control.Monad.Cont
+import Control.Monad.Base
+import Control.Monad.Catch
+import Control.Monad.Morph
 import Control.Comonad
 
 
@@ -18,14 +33,30 @@
 
 newtype InlineMarkupT m a = InlineMarkupT
   { runInlineMarkupT :: m a
-  } deriving (Functor)
+  } deriving (Monoid, Functor, Applicative, Alternative, Monad, MonadIO, MonadFix
+             , MonadPlus, MonadReader r, MonadState s, MonadWriter w, MonadRWS r w s
+             , MonadError e, MonadThrow, MonadCatch, MonadMask, MonadCont, MonadBase b
+             , MonadUrl b)
 
 type InlineMarkup = InlineMarkupT Identity
 
-deriving instance Monoid (m a)  => Monoid      (InlineMarkupT m a)
-deriving instance Applicative f => Applicative (InlineMarkupT f)
-deriving instance Monad m       => Monad       (InlineMarkupT m)
+instance MFunctor InlineMarkupT where
+  hoist f (InlineMarkupT x) = InlineMarkupT (f x)
 
+instance MMonad InlineMarkupT where
+  embed f (InlineMarkupT x) = f x
+
+instance MonadTransControl InlineMarkupT where
+  type StT InlineMarkupT a = a
+  liftWith f = InlineMarkupT (f runInlineMarkupT)
+  restoreT = InlineMarkupT
+
+instance ( MonadBaseControl b m
+         ) => MonadBaseControl b (InlineMarkupT m) where
+  type StM (InlineMarkupT m) a = ComposeSt InlineMarkupT m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
+
 instance ( Comonad m
          , Monad m
          ) => Comonad (InlineMarkupT m) where
@@ -40,14 +71,30 @@
 
 newtype HostedMarkupT m a = HostedMarkupT
   { runHostedMarkupT :: m a
-  } deriving (Functor)
+  } deriving (Monoid, Functor, Applicative, Alternative, Monad, MonadIO, MonadFix
+             , MonadPlus, MonadReader r, MonadState s, MonadWriter w, MonadRWS r w s
+             , MonadError e, MonadThrow, MonadCatch, MonadMask, MonadCont, MonadBase b
+             , MonadUrl b)
 
 type HostedMarkup = HostedMarkupT Identity
 
-deriving instance Monoid (m a)  => Monoid      (HostedMarkupT m a)
-deriving instance Applicative f => Applicative (HostedMarkupT f)
-deriving instance Monad m       => Monad       (HostedMarkupT m)
+instance MFunctor HostedMarkupT where
+  hoist f (HostedMarkupT x) = HostedMarkupT (f x)
 
+instance MMonad HostedMarkupT where
+  embed f (HostedMarkupT x) = f x
+
+instance MonadTransControl HostedMarkupT where
+  type StT HostedMarkupT a = a
+  liftWith f = HostedMarkupT (f runHostedMarkupT)
+  restoreT = HostedMarkupT
+
+instance ( MonadBaseControl b m
+         ) => MonadBaseControl b (HostedMarkupT m) where
+  type StM (HostedMarkupT m) a = ComposeSt HostedMarkupT m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
+
 instance ( Comonad m
          , Monad m
          ) => Comonad (HostedMarkupT m) where
@@ -62,13 +109,31 @@
 
 newtype LocalMarkupT m a = LocalMarkupT
   { runLocalMarkupT :: m a
-  } deriving (Functor)
+  } deriving (Monoid, Functor, Applicative, Alternative, Monad, MonadIO, MonadFix
+             , MonadPlus, MonadReader r, MonadState s, MonadWriter w, MonadRWS r w s
+             , MonadError e, MonadThrow, MonadCatch, MonadMask, MonadCont, MonadBase b
+             , MonadUrl b)
 
 type LocalMarkup = LocalMarkupT Identity
 
-deriving instance Monoid (m a)  => Monoid      (LocalMarkupT m a)
-deriving instance Applicative f => Applicative (LocalMarkupT f)
-deriving instance Monad m       => Monad       (LocalMarkupT m)
+
+instance MFunctor LocalMarkupT where
+  hoist f (LocalMarkupT x) = LocalMarkupT (f x)
+
+instance MMonad LocalMarkupT where
+  embed f (LocalMarkupT x) = f x
+
+instance MonadTransControl LocalMarkupT where
+  type StT LocalMarkupT a = a
+  liftWith f = LocalMarkupT (f runLocalMarkupT)
+  restoreT = LocalMarkupT
+
+instance ( MonadBaseControl b m
+         ) => MonadBaseControl b (LocalMarkupT m) where
+  type StM (LocalMarkupT m) a = ComposeSt LocalMarkupT m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
+
 
 instance ( Comonad m
          , Monad m