diff --git a/markup.cabal b/markup.cabal
--- a/markup.cabal
+++ b/markup.cabal
@@ -1,9 +1,10 @@
 Name:                   markup
-Version:                0.0.8
+Version:                1.0.0
 Author:                 Athan Clark <athan.clark@gmail.com>
 Maintainer:             Athan Clark <athan.clark@gmail.com>
 License:                MIT
 License-File:           LICENSE
+Category:               Data, Web
 Synopsis:               Abstraction for markup languages
 Description:
   This library tries to make things more uniformly controlled when working with
@@ -56,6 +57,7 @@
                       , blaze-markup
                       , text
                       , urlpath >= 1.0
+                      , comonad
 
 Test-Suite spec
   Type:                 exitcode-stdio-1.0
diff --git a/src/Data/Markup/Class.hs b/src/Data/Markup/Class.hs
--- a/src/Data/Markup/Class.hs
+++ b/src/Data/Markup/Class.hs
@@ -1,32 +1,25 @@
-{-# LANGUAGE AllowAmbiguousTypes   #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE KindSignatures        #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE UndecidableInstances  #-}
+{-# LANGUAGE
+    FlexibleContexts
+  , FlexibleInstances
+  , KindSignatures
+  , MultiParamTypeClasses
+  , UndecidableInstances
+  #-}
 
 module Data.Markup.Class where
 
 import           Data.Markup.Types
-
+import           Control.Comonad
 
 -- | Overload assets and their markup library, over some deployment
 class Deploy symbol input markup (m :: * -> *) where
   deploy :: symbol -> input -> m markup
 
 -- | Overload extraction of (co)monad
-class Monad m => Markup (m :: * -> *) where
+class Markup (m :: * -> *) where
   renderMarkup :: m a -> a
   toMarkup :: a -> m a
 
-instance Markup InlineMarkupM where
-  renderMarkup = runInlineMarkupM
-  toMarkup = InlineMarkupM
-
-instance Markup HostedMarkupM where
-  renderMarkup = runHostedMarkupM
-  toMarkup = HostedMarkupM
-
-instance Markup LocalMarkupM where
-  renderMarkup = runLocalMarkupM
-  toMarkup = LocalMarkupM
+instance (Monad m, Comonad m) => Markup m where
+  renderMarkup = extract
+  toMarkup = return
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,14 +1,17 @@
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE StandaloneDeriving         #-}
+{-# LANGUAGE
+    DeriveFunctor
+  , FlexibleContexts
+  , FlexibleInstances
+  , GeneralizedNewtypeDeriving
+  , MultiParamTypeClasses
+  , StandaloneDeriving
+  #-}
 
 module Data.Markup.Types where
 
 import           Control.Applicative
 import           Control.Monad.Trans
+import           Control.Comonad
 import           Data.Monoid
 
 
@@ -20,6 +23,10 @@
 deriving instance Applicative f => Applicative (InlineMarkupT f)
 deriving instance Monad m => Monad (InlineMarkupT m)
 
+instance (Comonad m, Monad m) => Comonad (InlineMarkupT m) where
+  extract = extract . runInlineMarkupT
+  duplicate = InlineMarkupT . return
+
 instance MonadTrans InlineMarkupT where
   lift = InlineMarkupT
 
@@ -30,6 +37,10 @@
 deriving instance Applicative f => Applicative (HostedMarkupT f)
 deriving instance Monad m => Monad (HostedMarkupT m)
 
+instance (Comonad m, Monad m) => Comonad (HostedMarkupT m) where
+  extract = extract . runHostedMarkupT
+  duplicate = HostedMarkupT . return
+
 instance MonadTrans HostedMarkupT where
   lift = HostedMarkupT
 
@@ -40,6 +51,10 @@
 deriving instance Applicative f => Applicative (LocalMarkupT f)
 deriving instance Monad m => Monad (LocalMarkupT m)
 
+instance (Comonad m, Monad m) => Comonad (LocalMarkupT m) where
+  extract = extract . runLocalMarkupT
+  duplicate = LocalMarkupT . return
+
 instance MonadTrans LocalMarkupT where
   lift = LocalMarkupT
 
@@ -59,6 +74,10 @@
   return = InlineMarkupM
   x >>= f = f $ runInlineMarkupM x
 
+instance Comonad InlineMarkupM where
+  extract = runInlineMarkupM
+  duplicate = InlineMarkupM
+
 newtype HostedMarkupM a = HostedMarkupM {runHostedMarkupM :: a}
   deriving (Functor)
 
@@ -73,6 +92,10 @@
   return = HostedMarkupM
   x >>= f = f $ runHostedMarkupM x
 
+instance Comonad HostedMarkupM where
+  extract = runHostedMarkupM
+  duplicate = HostedMarkupM
+
 newtype LocalMarkupM a = LocalMarkupM {runLocalMarkupM :: a}
   deriving (Functor)
 
@@ -86,3 +109,7 @@
 instance Monad LocalMarkupM where
   return = LocalMarkupM
   x >>= f = f $ runLocalMarkupM x
+
+instance Comonad LocalMarkupM where
+  extract = runLocalMarkupM
+  duplicate = LocalMarkupM