diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+1.1.4
+
+* Fix `MonadFail`-related code to work for GHCJS
+
 1.1.3
 
 * Add an `MFunctor` instance for `ComposeT` for GHC >= 8.6
diff --git a/mmorph.cabal b/mmorph.cabal
--- a/mmorph.cabal
+++ b/mmorph.cabal
@@ -1,6 +1,6 @@
 Name: mmorph
-Version: 1.1.3
-Cabal-Version: >= 1.8.0.2
+Version: 1.1.4
+Cabal-Version: >= 1.10
 Build-Type: Simple
 License: BSD3
 License-File: LICENSE
@@ -24,5 +24,9 @@
         mtl                 >= 2.1     && < 2.3,
         transformers        >= 0.2.0.0 && < 0.6,
         transformers-compat >= 0.3     && < 0.7
+    if impl(ghc < 8.0)
+        Build-Depends:
+            fail == 4.9.*
     Exposed-Modules: Control.Monad.Morph, Control.Monad.Trans.Compose
     GHC-Options: -O2
+    Default-Language: Haskell2010
diff --git a/src/Control/Monad/Trans/Compose.hs b/src/Control/Monad/Trans/Compose.hs
--- a/src/Control/Monad/Trans/Compose.hs
+++ b/src/Control/Monad/Trans/Compose.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE UndecidableInstances #-}
@@ -35,9 +36,8 @@
 import Data.Traversable (Traversable(traverse, sequenceA, mapM, sequence))
 import Prelude hiding (foldr, foldl, foldr1, foldl1, mapM, sequence)
 
-#if __GLASGOW_HASKELL__ >= 800
+#if !MIN_VERSION_base(4,11,0)
 import Control.Monad.Fail (MonadFail(..))
-import qualified Control.Monad.Fail
 #endif
 
 infixr 9 `ComposeT`
@@ -45,7 +45,26 @@
 -- | Composition of monad transformers.
 newtype ComposeT (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) m a
     = ComposeT { getComposeT :: f (g m) a }
-  deriving (Eq, Ord, Read, Show)
+    deriving
+    ( Alternative
+    , Applicative
+    , Eq
+    , Foldable
+    , Functor
+    , Ord
+    , Read
+    , Show
+    , Monad
+    , MonadCont
+    , MonadError e
+    , MonadFail
+    , MonadIO
+    , MonadPlus
+    , MonadReader r
+    , MonadRWS r w s
+    , MonadState s
+    , MonadWriter w
+    )
 
 instance (MFunctor f, MonadTrans f, MonadTrans g) => MonadTrans (ComposeT f g)
   where
@@ -56,77 +75,6 @@
     => MFunctor (ComposeT f g) where
     hoist f (ComposeT m) = ComposeT (hoist (hoist f) m)
 #endif
-
-instance Functor (f (g m)) => Functor (ComposeT f g m) where
-    fmap f (ComposeT m) = ComposeT (fmap f m)
-
-instance Applicative (f (g m)) => Applicative (ComposeT f g m) where
-    pure a = ComposeT (pure a)
-    ComposeT f <*> ComposeT a = ComposeT (f <*> a)
-    ComposeT a *> ComposeT b = ComposeT (a *> b)
-    ComposeT a <* ComposeT b = ComposeT (a <* b)
-
-instance Alternative (f (g m)) => Alternative (ComposeT f g m) where
-    empty = ComposeT empty
-    ComposeT a <|> ComposeT b = ComposeT (a <|> b)
-
-instance Monad (f (g m)) => Monad (ComposeT f g m) where
-    return a = ComposeT (return a)
-    m >>= f  = ComposeT (getComposeT m >>= \x -> getComposeT (f x))
-#if __GLASGOW_HASKELL__ < 808
-    fail e   = ComposeT (Prelude.fail e)
-#endif
-
-#if __GLASGOW_HASKELL__ >= 800
-instance MonadFail (f (g m)) => MonadFail (ComposeT f g m) where
-    fail e = ComposeT (Control.Monad.Fail.fail e)
-#endif
-
-instance MonadPlus (f (g m)) => MonadPlus (ComposeT f g m) where
-    mzero = ComposeT mzero
-    ComposeT a `mplus` ComposeT b = ComposeT (a `mplus` b)
-
-instance MonadIO (f (g m)) => MonadIO (ComposeT f g m) where
-    liftIO m = ComposeT (liftIO m)
-
-instance Foldable (f (g m)) => Foldable (ComposeT f g m) where
-    fold        (ComposeT m) = fold m
-    foldMap f   (ComposeT m) = foldMap f   m
-    foldr   f a (ComposeT m) = foldr   f a m
-    foldl   f a (ComposeT m) = foldl   f a m
-    foldr1 f    (ComposeT m) = foldr1  f   m
-    foldl1 f    (ComposeT m) = foldl1  f   m
-
-instance Traversable (f (g m)) => Traversable (ComposeT f g m) where
-    traverse f (ComposeT m) = fmap  ComposeT (traverse f m)
-    sequenceA  (ComposeT m) = fmap  ComposeT (sequenceA  m)
-    mapM     f (ComposeT m) = liftM ComposeT (mapM     f m)
-    sequence   (ComposeT m) = liftM ComposeT (sequence   m)
-
-instance MonadCont (f (g m)) => MonadCont (ComposeT f g m) where
-    callCC f = ComposeT $ callCC $ \c -> getComposeT (f (ComposeT . c))
-
-instance MonadError e (f (g m)) => MonadError e (ComposeT f g m) where
-    throwError     = ComposeT . throwError
-    catchError m h = ComposeT $ catchError (getComposeT m) (getComposeT . h)
-
-instance MonadRWS r w s (f (g m)) => MonadRWS r w s (ComposeT f g m)
-
-instance MonadReader r (f (g m)) => MonadReader r (ComposeT f g m) where
-    ask    = ComposeT ask
-    local  = mapComposeT . local
-    reader = ComposeT . reader
-
-instance MonadState s (f (g m)) => MonadState s (ComposeT f g m) where
-    get   = ComposeT get
-    put   = ComposeT . put
-    state = ComposeT . state
-
-instance MonadWriter w (f (g m)) => MonadWriter w (ComposeT f g m) where
-    writer = ComposeT . writer
-    tell   = ComposeT . tell
-    listen = mapComposeT listen
-    pass   = mapComposeT pass
 
 -- | Transform the computation inside a 'ComposeT'.
 mapComposeT :: (f (g m) a -> p (q n) b) -> ComposeT f g m a -> ComposeT p q n b