diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 0.2.3
+
+- GHC-8.0.1 compatibility
+- Dropped support for GHC-7.8
+
 # 0.2.0
 
 - Fix fanout behavior (Ben SInclair)
diff --git a/concurrent-machines.cabal b/concurrent-machines.cabal
--- a/concurrent-machines.cabal
+++ b/concurrent-machines.cabal
@@ -1,5 +1,5 @@
 name:                concurrent-machines
-version:             0.2.1
+version:             0.2.3
 synopsis:            Concurrent networked stream transducers
 
 description: A simple use-case for this library is to run the stages
@@ -31,6 +31,7 @@
 build-type:          Simple
 extra-source-files:  README.md, CHANGELOG.md
 cabal-version:       >=1.10
+tested-with:         GHC == 7.10.3, GHC == 8.0.1
 
 source-repository head
   type:     git
@@ -48,13 +49,13 @@
   -- other-modules:       
   other-extensions:    GADTs, FlexibleContexts, RankNTypes, TupleSections, 
                        ScopedTypeVariables
-  build-depends:       base >= 4.6 && < 5,
+  build-depends:       base >= 4.6 && < 4.10,
                        monad-control >= 1.0 && < 1.1,
-                       transformers >= 0.4 && < 0.5,
-                       time >= 1.4 && < 1.6,
+                       transformers >= 0.4 && < 0.6,
+                       time >= 1.4 && < 1.7,
                        containers >= 0.5 && < 0.6,
-                       transformers-base >= 0.4 && < 0.5,
-                       machines >= 0.5 && < 0.6,
+                       transformers-base >= 0.4 && < 0.6,
+                       machines >= 0.5 && < 0.7,
                        async >= 2.0.1 && < 2.2,
                        lifted-async >= 0.1 && < 0.9,
                        semigroups >= 0.8 && < 0.19
diff --git a/src/Data/Machine/Concurrent.hs b/src/Data/Machine/Concurrent.hs
--- a/src/Data/Machine/Concurrent.hs
+++ b/src/Data/Machine/Concurrent.hs
@@ -77,8 +77,7 @@
        => MachineT m k a -> ProcessT m a b -> MachineT m k b
 racers src snk = MachineT . join $
                  go <$> (Just <$> asyncRun src) <*> asyncRun snk
-  where go :: MonadBaseControl IO m
-           => Maybe (AsyncStep m k a)
+  where go :: Maybe (AsyncStep m k a)
            -> AsyncStep m (Is a) b
            -> m (MachineStep m k b)
         go srcA snkA =
@@ -106,8 +105,7 @@
                        go <$> (Just <$> asyncRun k) <*> asyncRun (f o)
         -- If we have an upstream source value ready, we must flush
         -- all available values yielded by downstream until it awaits.
-        flushDown :: Monad m
-                  => ProcessT m a b
+        flushDown :: ProcessT m a b
                   -> ((a -> ProcessT m a b) -> m (MachineStep m k b))
                   -> m (MachineStep m k b)
         flushDown m k = runMachineT m >>= \s -> case s of
@@ -117,8 +115,7 @@
         -- If downstream is awaiting an input, we must pull in all
         -- necessary upstream awaits until we have a yielded value to
         -- push downstream.
-        feedUp :: MonadBaseControl IO m
-               => MachineT m k a
+        feedUp :: MachineT m k a
                -> (a -> MachineT m k a -> m (MachineStep m k b))
                -> m (MachineStep m k b)
         feedUp m k = runMachineT m >>= \s -> case s of
diff --git a/src/Data/Machine/Concurrent/Buffer.hs b/src/Data/Machine/Concurrent/Buffer.hs
--- a/src/Data/Machine/Concurrent/Buffer.hs
+++ b/src/Data/Machine/Concurrent/Buffer.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, FlexibleContexts, GADTs, ScopedTypeVariables, TupleSections #-}
+ {-# LANGUAGE CPP, FlexibleContexts, GADTs, ScopedTypeVariables, TupleSections #-}
 -- | Place buffers between two machines. This is most useful with
 -- irregular production rates.
 module Data.Machine.Concurrent.Buffer (
@@ -25,7 +25,7 @@
 
 -- | Drain downstream until it awaits a value, then pass the awaiting
 -- step to the given function.
-drain :: (Functor m, Monad m)
+drain :: Monad m
       => MachineStep m k a
       -> (MachineStep m k a -> m (MachineStep m k' a))
       -> m (MachineStep m k' a)
diff --git a/src/Data/Machine/Concurrent/Fanout.hs b/src/Data/Machine/Concurrent/Fanout.hs
--- a/src/Data/Machine/Concurrent/Fanout.hs
+++ b/src/Data/Machine/Concurrent/Fanout.hs
@@ -31,7 +31,7 @@
 
 -- | Like 'Data.List.mapAccumL' but with a monadic accumulating
 -- function.
-mapAccumLM :: (Functor m, MonadBaseControl IO m)
+mapAccumLM :: MonadBaseControl IO m
            => (acc -> x -> m (acc, y)) -> acc -> [Async (StM m x)]
            -> m (acc, [y])
 mapAccumLM f z = fmap (second ($ [])) . foldM aux (z,id)
@@ -51,7 +51,7 @@
 -- | Share inputs with each of a list of processes in lockstep. Any
 -- values yielded by the processes for a given input are combined into
 -- a single yield from the composite process.
-fanout :: (Functor m, MonadBaseControl IO m, Semigroup r)
+fanout :: (MonadBaseControl IO m, Semigroup r)
        => [ProcessT m a r] -> ProcessT m a r
 fanout xs = encased $ Await (MachineT . aux) Refl (fanout xs)
   where aux y = do (rs,xs') <- mapM (feed y) xs >>= mapAccumLM yields []
@@ -70,7 +70,7 @@
 -- run a collection of 'ProcessT's that await but don't yield some
 -- number of times, you can use 'fanOutSteps . map (fmap (const ()))'
 -- followed by a 'taking' process.
-fanoutSteps :: (Functor m, MonadBaseControl IO m, Monoid r)
+fanoutSteps :: (MonadBaseControl IO m, Monoid r)
             => [ProcessT m a r] -> ProcessT m a r
 fanoutSteps xs = encased $ Await (MachineT . aux) Refl (fanoutSteps xs)
   where aux y = do (rs,xs') <- mapM (feed y) xs >>= mapAccumLM yields []
diff --git a/src/Data/Machine/Concurrent/Scatter.hs b/src/Data/Machine/Concurrent/Scatter.hs
--- a/src/Data/Machine/Concurrent/Scatter.hs
+++ b/src/Data/Machine/Concurrent/Scatter.hs
@@ -92,8 +92,7 @@
 mergeSum snkL snkR = MachineT $ do sl <- asyncRun snkL
                                    sr <- asyncRun snkR
                                    go sl sr
-  where go :: MonadBaseControl IO m
-           => AsyncStep m (Is a) r
+  where go :: AsyncStep m (Is a) r
            -> AsyncStep m (Is b) r
            -> m (MachineStep m (Is (Either a b)) r)
         go sl sr = waitEither sl sr >>= 
@@ -137,8 +136,7 @@
         lft = Left
         rgt :: d -> Either b d
         rgt = Right
-        go :: MonadBaseControl IO m
-           => AsyncStep m (Is a) (Either b d)
+        go :: AsyncStep m (Is a) (Either b d)
            -> AsyncStep m (Is c) (Either b d)
            -> m (MachineStep m (Is (Either a c)) (Either b d))
         go sl sr = waitEither sl sr >>=
diff --git a/src/Data/Machine/Concurrent/Tee.hs b/src/Data/Machine/Concurrent/Tee.hs
--- a/src/Data/Machine/Concurrent/Tee.hs
+++ b/src/Data/Machine/Concurrent/Tee.hs
@@ -14,8 +14,7 @@
 tee ma mb m = MachineT $ do srcL <- asyncRun ma
                             srcR <- asyncRun mb
                             go m (Just srcL) (Just srcR)
-  where go :: MonadBaseControl IO m
-           => TeeT m a' b' c
+  where go :: TeeT m a' b' c
            -> Maybe (AsyncStep m (Is a) a')
            -> Maybe (AsyncStep m (Is b) b')
            -> m (MachineStep m (T a b) c)