diff --git a/Changelog.txt b/Changelog.txt
--- a/Changelog.txt
+++ b/Changelog.txt
@@ -1,3 +1,15 @@
+Sun Jul  5 23:49:09 PDT 2015  paul@thev.net
+  * Bump version to 0.5.2.3
+
+Sun Jul  5 23:45:09 PDT 2015  paul@thev.net
+  * Backward compatability fix to work with GHC 7.8.4
+
+Tue Jun 23 11:52:53 PDT 2015  plcplc@gmail.com
+  * Update for ghc 7.10.1
+  
+  Specifically adressing the change that we now have "class (Applicative m) => Monad m" in base.
+  
+
 Tue Aug  5 15:45:35 PDT 2014  paul@thev.net
   * Bump version to 0.5.2.2
 
diff --git a/GLFW.cabal b/GLFW.cabal
--- a/GLFW.cabal
+++ b/GLFW.cabal
@@ -1,5 +1,5 @@
 name:          GLFW
-version:       0.5.2.2
+version:       0.5.2.3
 homepage:      http://haskell.org/haskellwiki/GLFW
 maintainer:    Paul H. Liu <paul@thev.net>
 cabal-version: >= 1.12
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -19,6 +19,7 @@
 import Data.Maybe (fromJust)
 import Foreign (sizeOf)
 import Control.Monad (when)
+import Control.Applicative
 --import Control.Monad.State 
 --import Control.Monad.Trans.Class (lift)
 
@@ -232,23 +233,38 @@
 -- Since we cannot specify that only Setup.hs depends on mtl, we include StateT here.
 
 newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }
-execStateT m s = fmap snd $ runStateT m s 
+execStateT m s = fmap snd $ runStateT m s
+
 class (Monad m) => MonadState s m | m -> s where
     get :: m s
-    put :: s -> m () 
-class MonadTrans t where 
+    put :: s -> m ()
+
+class MonadTrans t where
     lift :: Monad m => m a -> t m a
 modify f = get >>= put . f
+
+instance (Functor m) => Functor (StateT s m) where
+  fmap f m = StateT $ fmap (\(x, s) -> (f x, s)) . runStateT m
+
+instance (Functor m, Monad m) => Applicative (StateT s m) where
+  pure a  = StateT $ \s -> return (a, s)
+  f <*> x = StateT $ \s -> do
+        ~(f', s')  <- runStateT f s
+        ~(x', s'') <- runStateT x s'
+        return (f' x', s'')
+
 instance (Monad m) => Monad (StateT s m) where
-    return a = StateT $ \s -> return (a, s)
+    return = return
     m >>= k  = StateT $ \s -> do
-        ~(a, s') <- runStateT m s 
+        ~(a, s') <- runStateT m s
         runStateT (k a) s'
-    fail str = StateT $ \_ -> fail str 
+    fail str = StateT $ \_ -> fail str
+
 instance MonadTrans (StateT s) where
     lift m = StateT $ \s -> do
         a <- m
         return (a, s)
+
 instance (Monad m) => MonadState s (StateT s m) where
-    get   = StateT $ \s -> return (s, s) 
+    get   = StateT $ \s -> return (s, s)
     put s = StateT $ \_ -> return ((), s)