diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2012, Dan Burton
+Copyright (c) 2012-2026, Dan Burton
 
 All rights reserved.
 
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -31,4 +31,4 @@
 
 ----
 
-(c) 2012 Dan Burton
+(c) 2012-2026 Dan Burton
diff --git a/src/Control/Monad/Tardis.hs b/src/Control/Monad/Tardis.hs
--- a/src/Control/Monad/Tardis.hs
+++ b/src/Control/Monad/Tardis.hs
@@ -61,14 +61,14 @@
     while setting the backwards-traveling state will affect the /past/.
     Take a look at how Monadic bind is implemented for 'TardisT':
 
-> m >>= f  = TardisT $ \ ~(bw, fw) -> do
->   rec (x,  ~(bw'', fw' )) <- runTardisT m (bw', fw)
->       (x', ~(bw' , fw'')) <- runTardisT (f x) (bw, fw')
+> m >>= f  = TardisT $ \ ~(bw, fw) -> mdo
+>   (x,  ~(bw'', fw' )) <- runTardisT m (bw', fw)
+>   (x', ~(bw' , fw'')) <- runTardisT (f x) (bw, fw')
 >   return (x', (bw'', fw''))
 
     Like the Reverse State monad transformer, TardisT's Monad instance
     requires that the monad it transforms is an instance of MonadFix,
-    as is evidenced by the use of @rec@.
+    as is evidenced by the use of @mdo@.
     Notice how the forwards-traveling state travels /normally/:
     first it is fed to @m@, producing @fw'@, and then it is fed to @f x@,
     producing @fw''@. The backwards-traveling state travels in the opposite
diff --git a/src/Control/Monad/Tardis/Class.hs b/src/Control/Monad/Tardis/Class.hs
--- a/src/Control/Monad/Tardis/Class.hs
+++ b/src/Control/Monad/Tardis/Class.hs
@@ -66,13 +66,12 @@
 
   -- | A Tardis is merely a pure state transformation.
   tardis :: ((bw, fw) -> (a, (bw, fw))) -> m a
-  tardis f = do
-    rec
-      let (a, (future', past')) = f (future, past)
-      sendPast future'
-      past <- getPast
-      future <- getFuture
-      sendFuture past'
+  tardis f = mdo
+    let (a, (future', past')) = f (future, past)
+    sendPast future'
+    past <- getPast
+    future <- getFuture
+    sendFuture past'
     return a
 
 -- | Modify the forwards-traveling state
@@ -83,10 +82,9 @@
 -- | Modify the backwards-traveling state
 -- as it passes through from future to past.
 modifyBackwards :: MonadTardis bw fw m => (bw -> bw) -> m ()
-modifyBackwards f = do
-  rec
-    sendPast (f x)
-    x <- getFuture
+modifyBackwards f = mdo
+  sendPast (f x)
+  x <- getFuture
   return ()
 
 -- | Retrieve a specific view of the forwards-traveling state.
diff --git a/src/Control/Monad/Trans/Tardis.hs b/src/Control/Monad/Trans/Tardis.hs
--- a/src/Control/Monad/Trans/Tardis.hs
+++ b/src/Control/Monad/Trans/Tardis.hs
@@ -125,22 +125,21 @@
 -------------------------------------------------
 
 instance MonadFix m => Monad (TardisT bw fw m) where
-  return x = tardis $ \s -> (x, s)
-  m >>= f  = TardisT $ \ ~(bw, fw) -> do
-    rec (x,  ~(bw'', fw' )) <- runTardisT m (bw', fw)
-        (x', ~(bw' , fw'')) <- runTardisT (f x) (bw, fw')
+  m >>= f  = TardisT $ \ ~(bw, fw) -> mdo
+    (x,  ~(bw'', fw' )) <- runTardisT m (bw', fw)
+    (x', ~(bw' , fw'')) <- runTardisT (f x) (bw, fw')
     return (x', (bw'', fw''))
 
 instance MonadFix m => Functor (TardisT bw fw m) where
   fmap = liftM
 
 instance MonadFix m => Applicative (TardisT bw fw m) where
-  pure = return
+  pure x = tardis $ \s -> (x, s)
   (<*>) = ap
 
 instance MonadFix m => MonadFix (TardisT bw fw m) where
-  mfix f = TardisT $ \s -> do
-    rec (x, s') <- runTardisT (f x) s
+  mfix f = TardisT $ \s -> mdo
+    (x, s') <- runTardisT (f x) s
     return (x, s')
 
 instance MFunctor (TardisT bw fw) where
@@ -194,10 +193,9 @@
 -- | Modify the backwards-traveling state
 -- as it passes through from future to past.
 modifyBackwards :: MonadFix m => (bw -> bw) -> TardisT bw fw m ()
-modifyBackwards f = do
-  rec
-    sendPast (f x)
-    x <- getFuture
+modifyBackwards f = mdo
+  sendPast (f x)
+  x <- getFuture
   return ()
 
 
diff --git a/tardis.cabal b/tardis.cabal
--- a/tardis.cabal
+++ b/tardis.cabal
@@ -1,5 +1,5 @@
 name:                tardis
-version:             0.5.0
+version:             0.5.0.1
 synopsis:            Bidirectional state monad transformer
 homepage:            https://github.com/DanBurton/tardis
 bug-reports:         https://github.com/DanBurton/tardis/issues
@@ -10,7 +10,7 @@
 category:            Control
 build-type:          Simple
 cabal-version:       >=1.10
-tested-with:         GHC == 9.8.1, GHC == 9.6.3, GHC == 9.4.8
+tested-with:         GHC == 9.14.1, GHC == 9.12.2, GHC == 9.10.3, GHC == 9.8.4, GHC == 9.6.7, GHC == 9.4.8
 extra-source-files:  README.md, ChangeLog.md
 
 description:
@@ -32,6 +32,7 @@
   build-depends:       base >= 4.8 && < 5
                      , mtl==2.*
                      , mmorph==1.*
+  ghc-options: -Wcompat -Wall -Wno-unused-imports
 
 test-suite tardis-tests
   default-language:  Haskell2010
@@ -41,12 +42,8 @@
   build-depends:     base >= 4.8 && < 5
                    , tardis
   other-modules:   Example
+  ghc-options: -Wcompat -Wall -Wno-unrecognised-warning-flags -Wno-x-partial
 
 source-repository head
   type:     git
-  location: git://github.com/DanBurton/tardis.git
-
-source-repository this
-  type:     git
-  location: git://github.com/DanBurton/tardis.git
-  tag:      tardis-0.4.1.0
+  location: https://github.com/DanBurton/tardis.git
diff --git a/test/Example.hs b/test/Example.hs
--- a/test/Example.hs
+++ b/test/Example.hs
@@ -38,17 +38,16 @@
     PreviousScores scores <- getPast
     let score = head scores
     return $ (finalFrameScore + score) : scores
-  go (f : fs) = do
-    rec
-      sendPast $ NextThrows throws'
-      PreviousScores scores <- getPast
-      let score = head scores
-      sendFuture $ PreviousScores (score' : scores)
-      NextThrows ~(nextThrow1, nextThrow2) <- getFuture
-      let (score', throws') = case f of
-            Strike    -> (score + 10 + nextThrow1 + nextThrow2, (10, nextThrow1))
-            Spare n   -> (score + 10 + nextThrow1,              (n, 10 - n))
-            Frame n m -> (score + n + m,                        (n, m))
+  go (f : fs) = mdo
+    sendPast $ NextThrows throws'
+    PreviousScores scores <- getPast
+    let score = head scores
+    sendFuture $ PreviousScores (score' : scores)
+    NextThrows ~(nextThrow1, nextThrow2) <- getFuture
+    let (score', throws') = case f of
+          Strike    -> (score + 10 + nextThrow1 + nextThrow2, (10, nextThrow1))
+          Spare n   -> (score + 10 + nextThrow1,              (n, 10 - n))
+          Frame n m -> (score + n + m,                        (n, m))
     go fs
 
   finalFrameScore = case lastFrame game of
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -7,4 +7,6 @@
     putStrLn $ "Expected: " <> show expectedScores
     putStrLn $ "Actual: " <> show actualScores
     exitFailure
-  True -> exitSuccess
+  True -> do
+    putStrLn "Test passed."
+    exitSuccess