diff --git a/LIO/Concurrent/LChan/Trans.hs b/LIO/Concurrent/LChan/Trans.hs
new file mode 100644
--- /dev/null
+++ b/LIO/Concurrent/LChan/Trans.hs
@@ -0,0 +1,50 @@
+{-# LANGUAGE Safe #-}
+
+{- | 'MonadLIO' generalizations for "LIO.Concurrent.LChan". -}
+module LIO.Concurrent.LChan.Trans (
+    newLChan
+  , newLChanP
+  , writeLChan
+  , writeLChanP
+  , readLChan
+  , readLChanP
+  , dupLChan
+  , dupLChanP
+  ) where
+
+import safe LIO.Core
+import safe LIO.Label
+
+import safe qualified LIO.Concurrent.LChan as C
+
+-- | See 'LIO.Concurrent.LChan.newLChan'.
+newLChan :: (MonadLIO l m, Label l) => l -> m (C.LChan l a)
+newLChan = liftLIO . C.newLChan
+
+-- | See 'LIO.Concurrent.LChan.newLChanP'.
+newLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m (C.LChan l a)
+newLChanP p = liftLIO . C.newLChanP p
+
+-- | See 'LIO.Concurrent.LChan.writeLChan'.
+writeLChan :: (MonadLIO l m, Label l) => C.LChan l a -> a -> m ()
+writeLChan c = liftLIO . C.writeLChan c
+
+-- | See 'LIO.Concurrent.LChan.writeLChanP'.
+writeLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> C.LChan l a -> a -> m ()
+writeLChanP p c = liftLIO . C.writeLChanP p c
+
+-- | See 'LIO.Concurrent.LChan.readLChan'.
+readLChan :: (MonadLIO l m, Label l) => C.LChan l a -> m a
+readLChan = liftLIO . C.readLChan
+
+-- | See 'LIO.Concurrent.LChan.readLChanP'.
+readLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> C.LChan l a -> m a
+readLChanP p = liftLIO . C.readLChanP p
+
+-- | See 'LIO.Concurrent.LChan.dupLChan'.
+dupLChan :: (MonadLIO l m, Label l) => C.LChan l a -> m (C.LChan l a)
+dupLChan = liftLIO . C.dupLChan
+
+-- | See 'LIO.Concurrent.LChan.dupLChanP'.
+dupLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> C.LChan l a -> m (C.LChan l a)
+dupLChanP p = liftLIO . C.dupLChanP p
diff --git a/LIO/Concurrent/LMVar/Trans.hs b/LIO/Concurrent/LMVar/Trans.hs
new file mode 100644
--- /dev/null
+++ b/LIO/Concurrent/LMVar/Trans.hs
@@ -0,0 +1,100 @@
+{-# LANGUAGE Safe #-}
+
+{- | 'MonadLIO' generalizations for "LIO.Concurrent.LMVar". -}
+module LIO.Concurrent.LMVar.Trans
+  ( newEmptyLMVar
+  , newEmptyLMVarP
+  , newLMVar
+  , newLMVarP
+  , takeLMVar
+  , takeLMVarP
+  , tryTakeLMVar
+  , tryTakeLMVarP
+  , putLMVar
+  , putLMVarP
+  , tryPutLMVar
+  , tryPutLMVarP
+  , readLMVar
+  , readLMVarP
+  , swapLMVar
+  , swapLMVarP
+  , isEmptyLMVar
+  , isEmptyLMVarP
+  ) where
+
+import safe LIO.Core
+import safe LIO.Label
+
+import safe qualified LIO.Concurrent.LMVar as M
+
+-- | See 'LIO.Concurrent.LMVar.newEmptyLMVar'.
+newEmptyLMVar :: (MonadLIO l m, Label l) => l -> m (M.LMVar l a)
+newEmptyLMVar = liftLIO . M.newEmptyLMVar
+
+-- | See 'LIO.Concurrent.LMVar.newEmptyLMVarP'.
+newEmptyLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m (M.LMVar l a)
+newEmptyLMVarP p = liftLIO . M.newEmptyLMVarP p
+
+-- | See 'LIO.Concurrent.LMVar.newLMVar'.
+newLMVar :: (MonadLIO l m, Label l) => l -> a -> m (M.LMVar l a)
+newLMVar l = liftLIO . M.newLMVar l
+
+-- | See 'LIO.Concurrent.LMVar.newLMVarP'.
+newLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> a -> m (M.LMVar l a)
+newLMVarP p l = liftLIO . M.newLMVarP p l
+
+-- | See 'LIO.Concurrent.LMVar.takeLMVar'.
+takeLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m a
+takeLMVar = liftLIO . M.takeLMVar
+
+-- | See 'LIO.Concurrent.LMVar.takeLMVarP'.
+takeLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m a
+takeLMVarP p = liftLIO . M.takeLMVarP p
+
+-- | See 'LIO.Concurrent.LMVar.tryTakeLMVar'.
+tryTakeLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m (Maybe a)
+tryTakeLMVar = liftLIO . M.tryTakeLMVar
+
+-- | See 'LIO.Concurrent.LMVar.tryTakeLMVarP'.
+tryTakeLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m (Maybe a)
+tryTakeLMVarP p = liftLIO . M.tryTakeLMVarP p
+
+-- | See 'LIO.Concurrent.LMVar.putLMVar'.
+putLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> a -> m ()
+putLMVar mvar = liftLIO . M.putLMVar mvar
+
+-- | See 'LIO.Concurrent.LMVar.putLMVarP'.
+putLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> a -> m ()
+putLMVarP p mvar = liftLIO . M.putLMVarP p mvar
+
+-- | See 'LIO.Concurrent.LMVar.tryPutLMVar'.
+tryPutLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> a -> m Bool
+tryPutLMVar mvar = liftLIO . M.tryPutLMVar mvar
+
+-- | See 'LIO.Concurrent.LMVar.tryPutLMVarP'.
+tryPutLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> a -> m Bool
+tryPutLMVarP p mvar = liftLIO . M.tryPutLMVarP p mvar
+
+-- | See 'LIO.Concurrent.LMVar.readLMVar'.
+readLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m a
+readLMVar = liftLIO . M.readLMVar
+
+-- | See 'LIO.Concurrent.LMVar.readLMVarP'.
+readLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m a
+readLMVarP p = liftLIO . M.readLMVarP p
+
+-- | See 'LIO.Concurrent.LMVar.swapLMVar'.
+swapLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> a -> m a
+swapLMVar mvar = liftLIO . M.swapLMVar mvar
+
+-- | See 'LIO.Concurrent.LMVar.swapLMVarP'.
+swapLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> a -> m a
+swapLMVarP p mvar = liftLIO . M.swapLMVarP p mvar
+
+-- | See 'LIO.Concurrent.LMVar.isEmptyLMVar'.
+isEmptyLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m Bool
+isEmptyLMVar = liftLIO . M.isEmptyLMVar
+
+-- | See 'LIO.Concurrent.LMVar.isEmptyLMVarP'.
+isEmptyLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m Bool
+isEmptyLMVarP p = liftLIO . M.isEmptyLMVarP p
diff --git a/LIO/Core.hs b/LIO/Core.hs
--- a/LIO/Core.hs
+++ b/LIO/Core.hs
@@ -41,7 +41,7 @@
 label to ensure that @l_r ``canFlowTo`` l_cur@.  This is acomplished
 using a function such as 'taint'.
 
-The second purpose of the current label is to prevent inforation leaks
+The second purpose of the current label is to prevent information leaks
 into public channels. Specifically, it is only permissible to modify
 or write to data labeled @l_w@ when @l_cur``canFlowTo`` l_w@. Thus,
 the following attempt to leak the @val@ after reading it from a secret
@@ -91,6 +91,7 @@
 import safe LIO.Error
 import safe LIO.Exception
 import safe LIO.Label
+import safe LIO.Monad(MonadLIO(..))
 import safe LIO.Run
 import LIO.TCB
 
@@ -316,8 +317,13 @@
 --
 -- > guardWrite l = guardAlloc l >> taint l
 --
--- This guarantees that @l@ ``canFlowTo`` the current label (and
--- clearance), and that the current label ``canFlowTo`` @l@.
+-- The 'guardAlloc' ensures that we can write(-only) to the object
+-- labeled @l@, i.e., the current label ``canFlowTo`` @l@ (and @l@
+-- ``canFlowTo`` the current clearance). If this check succeeds then
+-- we raise the current label with 'taint' to reflect the fact that
+-- this is a also a read effect. Note that if the write-only guard
+-- succeeds, the 'taint' will always suceed (we're simply raising the
+-- current label to a label that is below the clearance).
 --
 guardWrite :: Label l => l -> LIO l ()
 guardWrite newl = withContext "guardWrite" $ do
@@ -330,16 +336,3 @@
 guardWriteP p newl = withContext "guardWriteP" $ do
   guardAllocP p newl
   taintP p newl
-
---
--- Monad base
---
-
--- | Synonym for monad in which 'LIO' is the base monad.
-class (Label l, Monad m) => MonadLIO l m | m -> l where
-  -- | Lift an 'LIO' computation.
-  liftLIO :: LIO l a -> m a
-
-instance Label l => MonadLIO l (LIO l) where
-  liftLIO = id
-
diff --git a/LIO/Core/Trans.hs b/LIO/Core/Trans.hs
new file mode 100644
--- /dev/null
+++ b/LIO/Core/Trans.hs
@@ -0,0 +1,73 @@
+{-# LANGUAGE Safe #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+{- | 'MonadLIO' generalizations for "LIO.Core". -}
+module LIO.Core.Trans (
+    getLabel
+  , setLabel
+  , setLabelP
+  , getClearance
+  , setClearance
+  , setClearanceP
+  , guardAlloc
+  , guardAllocP
+  , taint
+  , taintP
+  , guardWrite
+  , guardWriteP
+  ) where
+
+import safe LIO.Label
+import safe LIO.Monad
+
+import safe qualified LIO.Core as C
+
+-- | See 'LIO.Core.getLabel'.
+getLabel :: (MonadLIO l m, Label l) => m l
+getLabel = liftLIO C.getLabel
+
+-- | See 'LIO.Core.setLabel'.
+setLabel :: (MonadLIO l m, Label l) => l -> m ()
+setLabel = liftLIO . C.setLabel
+
+-- | See 'LIO.Core.setLabelP'.
+setLabelP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()
+setLabelP p = liftLIO . C.setLabelP p
+
+-- | See 'LIO.Core.getClearance'.
+getClearance :: (MonadLIO l m, Label l) => m l
+getClearance = liftLIO C.getClearance
+
+-- | See 'LIO.Core.setClearance'.
+setClearance :: (MonadLIO l m, Label l) => l -> m ()
+setClearance = liftLIO . C.setClearance
+
+-- | See 'LIO.Core.setClearanceP'.
+setClearanceP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()
+setClearanceP p = liftLIO . C.setClearanceP p
+
+-- | See 'LIO.Core.guardAlloc'.
+guardAlloc :: (MonadLIO l m, Label l) => l -> m ()
+guardAlloc = liftLIO . C.guardAlloc
+
+-- | See 'LIO.Core.guardAllocP'.
+guardAllocP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()
+guardAllocP p = liftLIO . C.guardAllocP p
+
+-- | See 'LIO.Core.taint'.
+taint :: (MonadLIO l m, Label l) => l -> m ()
+taint = liftLIO . C.taint
+
+-- | See 'LIO.Core.taintP'.
+taintP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()
+taintP p = liftLIO . C.taintP p
+
+-- | See 'LIO.Core.guardWrite'.
+guardWrite :: (MonadLIO l m, Label l) => l -> m ()
+guardWrite = liftLIO . C.guardWrite
+
+-- | See 'LIO.Core.guardWriteP'.
+guardWriteP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()
+guardWriteP p = liftLIO . C.guardWriteP p
diff --git a/LIO/DCLabel.hs b/LIO/DCLabel.hs
--- a/LIO/DCLabel.hs
+++ b/LIO/DCLabel.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
@@ -110,13 +110,12 @@
   , cTrue, cFalse, cToSet, cFromList
   ) where
 
-import safe Control.Applicative
 import safe Control.Monad
 import safe Data.Bits
 import safe qualified Data.ByteString as S
 import Data.Hashable
 import safe Data.List
-import safe Data.Monoid
+import safe Data.Monoid ()
 import safe Data.Set (Set)
 import safe qualified Data.Set as Set
 import safe Data.String
diff --git a/LIO/Error/Trans.hs b/LIO/Error/Trans.hs
new file mode 100644
--- /dev/null
+++ b/LIO/Error/Trans.hs
@@ -0,0 +1,29 @@
+{-# LANGUAGE Safe #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE ExistentialQuantification #-}
+
+{- | 'MonadLIO' generalizations for "LIO.Error". -}
+module LIO.Error.Trans (
+    labelError
+  , labelErrorP
+  ) where
+
+import safe LIO.Label
+import safe LIO.Monad
+
+import safe qualified LIO.Error as E
+
+-- | See 'LIO.Error.labelError'.
+labelError :: (MonadLIO l m, Label l)
+    => String -- ^ Function that failed.
+    -> [l]    -- ^ Labels involved in error.
+    -> m a
+labelError fl = liftLIO . E.labelError fl
+
+-- | See 'LIO.Error.labelErrorP'.
+labelErrorP :: (MonadLIO l m, Label l, PrivDesc l p)
+    => String  -- ^ Function that failed.
+    -> Priv p  -- ^ Privileges involved.
+    -> [l]     -- ^ Labels involved.
+    -> m a
+labelErrorP fl p = liftLIO . E.labelErrorP fl p
diff --git a/LIO/LIORef/Trans.hs b/LIO/LIORef/Trans.hs
new file mode 100644
--- /dev/null
+++ b/LIO/LIORef/Trans.hs
@@ -0,0 +1,71 @@
+{-# LANGUAGE Safe #-}
+{-# LANGUAGE ConstraintKinds,
+             FlexibleContexts #-}
+
+{- | 'MonadLIO' generalizations for "LIO.LIORef". -}
+module LIO.LIORef.Trans (
+    newLIORef
+  , newLIORefP
+  , readLIORef
+  , readLIORefP
+  , writeLIORef
+  , writeLIORefP
+  , modifyLIORef
+  , modifyLIORefP
+  , atomicModifyLIORef
+  , atomicModifyLIORefP
+  ) where
+
+import safe LIO.Core
+import safe LIO.Label
+
+import safe LIO.LIORef (LIORef)
+import safe qualified LIO.LIORef as R
+
+-- | See 'LIO.LIORef.newLIORef'.
+newLIORef :: (MonadLIO l m, Label l)
+          => l                  -- ^ Label of reference
+          -> a                  -- ^ Initial value
+          -> m (LIORef l a) -- ^ Mutable reference
+newLIORef l = liftLIO . R.newLIORef l
+
+-- | See 'LIO.LIORef.newLIORefP'.
+newLIORefP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> a -> m (LIORef l a)
+newLIORefP p l = liftLIO . R.newLIORefP p l
+
+-- | See 'LIO.LIORef.readLIORef'.
+readLIORef :: (MonadLIO l m, Label l) => LIORef l a -> m a
+readLIORef = liftLIO . R.readLIORef
+
+-- | See 'LIO.LIORef.readLIORefP'.
+readLIORefP :: (MonadLIO l m, PrivDesc l p) => Priv p -> LIORef l a -> m a
+readLIORefP priv = liftLIO . R.readLIORefP priv
+
+-- | See 'LIO.LIORef.writeLIORef'.
+writeLIORef :: (MonadLIO l m, Label l) => LIORef l a -> a -> m ()
+writeLIORef ref = liftLIO . R.writeLIORef ref
+
+-- | See 'LIO.LIORef.writeLIORefP'.
+writeLIORefP :: (MonadLIO l m, PrivDesc l p) => Priv p -> LIORef l a -> a -> m ()
+writeLIORefP priv ref = liftLIO . R.writeLIORefP priv ref
+
+-- | See 'LIO.LIORef.modifyLIORef'.
+modifyLIORef :: (MonadLIO l m, Label l)
+             => LIORef l a             -- ^ Labeled reference
+             -> (a -> a)               -- ^ Modifier
+             -> m ()
+modifyLIORef ref = liftLIO . R.modifyLIORef ref
+
+-- | See 'LIO.LIORef.modifyLIORefP'.
+modifyLIORefP :: (MonadLIO l m, PrivDesc l p)
+              =>  Priv p -> LIORef l a -> (a -> a) -> m ()
+modifyLIORefP priv ref = liftLIO . R.modifyLIORefP priv ref
+
+-- | See 'LIO.LIORef.atomicModifyLIORef'.
+atomicModifyLIORef :: (MonadLIO l m, Label l) => LIORef l a -> (a -> (a, b)) -> m b
+atomicModifyLIORef ref = liftLIO . R.atomicModifyLIORef ref
+
+-- | See 'LIO.LIORef.atomicModifyLIORefP'.
+atomicModifyLIORefP :: (MonadLIO l m, PrivDesc l p)
+                    => Priv p -> LIORef l a -> (a -> (a, b)) -> m b
+atomicModifyLIORefP priv ref = liftLIO . R.atomicModifyLIORefP priv ref
diff --git a/LIO/Label.hs b/LIO/Label.hs
--- a/LIO/Label.hs
+++ b/LIO/Label.hs
@@ -18,7 +18,7 @@
   , NoPrivs(..), noPrivs
   ) where
 
-import safe Data.Monoid
+import safe Data.Monoid ()
 import safe Data.Typeable
 
 import LIO.TCB
@@ -46,7 +46,7 @@
 with current label @lcur@ observes data labeled @l1@, it must hold
 that @l1 ``canFlowTo`` lcur@.  If the thread is later permitted to
 modify an object labeled @l2@, it must hold that @lcur ``canFlowTo``
-l2@.  By transitifity of the ``canFlowTo`` relation, it holds that @l1
+l2@.  By transitivity of the ``canFlowTo`` relation, it holds that @l1
 ``canFlowTo`` l2@.
 
 -}
@@ -221,10 +221,6 @@
     -- Less formally, @downgradeP p l@ returns a label representing
     -- the furthest you can downgrade data labeled @l@ given
     -- privileges described by @p@.
-    --
-    -- Yet another way to view this function is that @downgradeP p l@
-    -- returns the greatest lower bound (under 'canFlowTo') of the set
-    -- of all labels @l'@ such that @'canFlowToP' p l' l@.
     downgradeP :: p     -- ^ Privilege description
                   -> l  -- ^ Label to downgrade
                   -> l  -- ^ Lowest label equivelent to input
diff --git a/LIO/Labeled/Trans.hs b/LIO/Labeled/Trans.hs
new file mode 100644
--- /dev/null
+++ b/LIO/Labeled/Trans.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE Trustworthy #-}
+
+{- | 'MonadLIO' generalizations for "LIO.Labeled". -}
+module LIO.Labeled.Trans (
+    label
+  , labelP
+  , unlabel
+  , unlabelP
+  , relabelLabeledP
+  , taintLabeled
+  , taintLabeledP
+  , lFmap
+  , lAp
+  ) where
+
+import safe LIO.Label
+import safe LIO.Core
+import LIO.TCB
+
+import safe qualified LIO.Labeled as L
+
+-- | See 'LIO.Labeled.label'.
+label :: (MonadLIO l m, Label l) => l -> a -> m (Labeled l a)
+label l = liftLIO . L.label l
+
+-- | See 'LIO.Labeled.labelP'.
+labelP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> a -> m (Labeled l a)
+labelP p l = liftLIO . L.labelP p l
+
+-- | See 'LIO.Labeled.unlabel'.
+unlabel :: (MonadLIO l m, Label l) => Labeled l a -> m a
+unlabel = liftLIO . L.unlabel
+
+-- | See 'LIO.Labeled.unlabelP'.
+unlabelP :: (MonadLIO l m, PrivDesc l p) => Priv p -> Labeled l a -> m a
+unlabelP p = liftLIO . L.unlabelP p
+
+-- | See 'LIO.Labeled.relabelLabeledP'.
+relabelLabeledP :: (MonadLIO l m, PrivDesc l p)
+                => Priv p -> l -> Labeled l a -> m (Labeled l a)
+relabelLabeledP p newl = liftLIO . L.relabelLabeledP p newl
+
+-- | See 'LIO.Labeled.taintLabeled'.
+taintLabeled :: (MonadLIO l m, Label l) => l -> Labeled l a -> m (Labeled l a)
+taintLabeled l = liftLIO . L.taintLabeled l
+
+-- | See 'LIO.Labeled.taintLabeledP'.
+taintLabeledP :: (MonadLIO l m, PrivDesc l p)
+              => Priv p -> l -> Labeled l a -> m (Labeled l a)
+taintLabeledP p l = liftLIO . L.taintLabeledP p l
+
+-- | See 'LIO.Labeled.lFmap'.
+lFmap :: (MonadLIO l m, Label l) => Labeled l a -> (a -> b) -> m (Labeled l b)
+lFmap l = liftLIO . L.lFmap l
+
+-- | See 'LIO.Labeled.lAp'.
+lAp :: (MonadLIO l m, Label l) => Labeled l (a -> b) -> Labeled l a -> m (Labeled l b)
+lAp lf = liftLIO . L.lAp lf
diff --git a/LIO/Monad.hs b/LIO/Monad.hs
new file mode 100644
--- /dev/null
+++ b/LIO/Monad.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module LIO.Monad (
+    MonadLIO(..)
+  ) where
+
+import safe LIO.Label
+import LIO.TCB
+
+-- | Synonym for monad in which 'LIO' is the base monad.
+class (Label l, Monad m) => MonadLIO l m | m -> l where
+  -- | Lift an 'LIO' computation.
+  liftLIO :: LIO l a -> m a
+
+instance Label l => MonadLIO l (LIO l) where
+  liftLIO = id
diff --git a/LIO/TCB.hs b/LIO/TCB.hs
--- a/LIO/TCB.hs
+++ b/LIO/TCB.hs
@@ -34,11 +34,11 @@
   , LabeledResult(..), LResStatus(..)
   ) where
 
-import safe Control.Applicative
+import safe Control.Applicative ()
 import safe Control.Exception (Exception(..), SomeException(..))
 import safe qualified Control.Concurrent as IO
 import safe Control.Monad
-import safe Data.Monoid
+import safe Data.Monoid ()
 import safe Data.IORef
 import safe Data.Typeable
 
diff --git a/examples/channel.hs b/examples/channel.hs
--- a/examples/channel.hs
+++ b/examples/channel.hs
@@ -9,15 +9,18 @@
 
 import LIO.TCB (ioTCB)
 
+main :: IO ()
 main = evalDC $ do
-  log <- newLChan ("Logger" %% True)
+  logger <- newLChan ("Logger" %% True)
   forkLIO $ forever $ do
-    msg  <- readLChan log
+    msg  <- readLChan logger
     lcur <- getLabel
     ioTCB $ putStrLn $ show lcur ++ " > " ++ msg
   forkLIO $ do
-    writeLChan log "in them alternate threads"
+    writeLChan logger "in them alternate threads"
   forkLIO $ do
     taint ("Alice" %% True)
-    writeLChan log "i has failed"
-  forM_ [1..10] $ \i -> writeLChan log $ "yo "++ show  i
+    writeLChan logger "i has failed"
+  forM_ oneToTen $ \i -> writeLChan logger $ "yo "++ show  i
+    where oneToTen :: [Int]
+          oneToTen = [1..10]
diff --git a/examples/dclabel.hs b/examples/dclabel.hs
--- a/examples/dclabel.hs
+++ b/examples/dclabel.hs
@@ -24,6 +24,7 @@
 p :: DCPriv
 p = PrivTCB  $ "Alice" /\ "Carla"
 
+main :: IO ()
 main = do
   putStrLn $ "Label 1: " ++ show l1
   putStrLn $ "Label 2: " ++ show l2
diff --git a/examples/gate.hs b/examples/gate.hs
--- a/examples/gate.hs
+++ b/examples/gate.hs
@@ -1,5 +1,4 @@
 import LIO
-import LIO.Delegate
 import LIO.DCLabel
 
 import LIO.TCB
@@ -18,6 +17,7 @@
 bob   = PrivTCB . toCNF $ "Bob"
 clark = PrivTCB . toCNF $ "Clark"
 
+main :: IO ()
 main = putStrLn . show $ 
   [ callGate addGate alice 1 2 -- Just 3
   , callGate addGate bob   3 4 -- Just 7
diff --git a/examples/waitAndCatch.hs b/examples/waitAndCatch.hs
--- a/examples/waitAndCatch.hs
+++ b/examples/waitAndCatch.hs
@@ -2,19 +2,18 @@
 
 module Main (main) where
 
-import Prelude hiding (catch)
+import Prelude
 import LIO
 import LIO.TCB (ioTCB)
 import LIO.DCLabel
 import LIO.Concurrent
-import Control.Exception (SomeException)
 
 
-l,m,h :: DCLabel
+l,m :: DCLabel
 l = "A" \/ "B" %% True
 m = "M" %% True
-h = "A" /\ "B" %% True
 
+main :: IO ()
 main =  do
   lr <- evalDC $ do
     lb <- label m (6 :: Int)
diff --git a/lio.cabal b/lio.cabal
--- a/lio.cabal
+++ b/lio.cabal
@@ -1,13 +1,15 @@
 Name:           lio
-Version:        0.11.5.0
+Version:        0.11.6.0
 Cabal-Version:  >= 1.8
 Build-type:     Simple
 License:        GPL
 License-File:   LICENSE
 Author:         Hails team
-Maintainer:	Hails team <hails at scs dot stanford dot edu>
+Maintainer:     Deian Stefan <deian at cs dot ucsd dot edu>
 Synopsis:       Labeled IO Information Flow Control Library
 Category:       Security
+Homepage:       https://github.com/plsyssec/lio
+Bug-Reports:    https://github.com/plsyssec/lio/issues
 Description:
 
   The /Labeled IO/ (LIO) library is an information flow control (IFC)
@@ -60,11 +62,11 @@
 
 Source-repository head
   Type:     git
-  Location: git://github.com/scslab/lio.git
+  Location: https://github.com/PLSysSec/lio.git
 
 Library
   Build-Depends:
-    base          >= 4.5     && < 5.0
+    base          >= 4.5     && < 6.0
    ,containers
    ,bytestring    >= 0.10
    ,hashable      >= 1.2
@@ -80,18 +82,25 @@
     LIO.Label
     -- * Core library
     LIO.Core
+    LIO.Core.Trans
+    LIO.Monad
     LIO.Error
+    LIO.Error.Trans
     LIO.Exception
     -- * Labeled values
     LIO.Labeled
+    LIO.Labeled.Trans
     -- * Labeled IORefs
     LIO.LIORef
+    LIO.LIORef.Trans
     -- * LIO privileges
     LIO.Delegate
     -- * Concurrency
     LIO.Concurrent
     LIO.Concurrent.LMVar
+    LIO.Concurrent.LMVar.Trans
     LIO.Concurrent.LChan
+    LIO.Concurrent.LChan.Trans
     -- * DCLabels
     LIO.DCLabel
     -- * Privileged internals