diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,30 @@
+Copyright Kamil Dworakowski (c) 2020
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Author name here nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,4 @@
+# mock-time
+
+Allows to mock out Data.Time.getCurrentTime and Control.Concrurent.threadDelay
+
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/mock-time.cabal b/mock-time.cabal
new file mode 100644
--- /dev/null
+++ b/mock-time.cabal
@@ -0,0 +1,72 @@
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.33.0.
+--
+-- see: https://github.com/sol/hpack
+--
+-- hash: f70ad4f0d259256d4dd856fc4bce3eb41bb5f2766f36c5baf158d814f0f83acb
+
+name:           mock-time
+version:        0.1.0
+synopsis:       Mock time in tests
+description:    Allows to mock out Data.Time.getCurrentTime and Control.Concrurent.threadDelay
+category:       Test
+homepage:       https://github.com/luntain/error-or-bundle/blob/master/mock-time#readme
+author:         Kamil Dworakowski
+maintainer:     kamil@dworakowski.name
+copyright:      2020 Kamil Dworakowski
+license:        BSD3
+license-file:   LICENSE
+tested-with:    GHC==8.0.1, GHC==8.2.2, GHC==8.8.1, GHC==8.8.3, GHC==8.10.2
+build-type:     Simple
+extra-source-files:
+    README.md
+
+library
+  exposed-modules:
+      Control.Monad.Time
+      Control.Monad.Time.DefaultInstance
+      Control.Monad.Trans.SimulatedTime
+      Test.SimulatedTime
+  other-modules:
+      Paths_mock_time
+  hs-source-dirs:
+      src
+  build-depends:
+      base >=4.7 && <5
+    , error-or
+    , exceptions
+    , mtl
+    , primitive
+    , resourcet
+    , stm
+    , time
+    , unliftio-core
+  default-language: Haskell2010
+
+test-suite my-test-suite
+  type: exitcode-stdio-1.0
+  main-is: Tests.hs
+  other-modules:
+      Paths_mock_time
+  hs-source-dirs:
+      tests
+  ghc-options: -threaded -rtsopts -with-rtsopts=-N -Wall
+  build-depends:
+      QuickCheck
+    , base >=4.7 && <5
+    , error-or
+    , error-or-utils
+    , exceptions
+    , inbox
+    , mock-time
+    , mtl
+    , primitive
+    , resourcet
+    , stm
+    , tasty
+    , tasty-hunit
+    , tasty-quickcheck
+    , time
+    , unliftio-core
+  default-language: Haskell2010
diff --git a/src/Control/Monad/Time.hs b/src/Control/Monad/Time.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Time.hs
@@ -0,0 +1,29 @@
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+module Control.Monad.Time
+  ( MonadTime (..),
+  )
+where
+
+import Control.Monad.Trans
+import Data.Time hiding (getCurrentTime)
+
+-- | A class interface with overridable time implementation.
+-- Import `Control.Monad.Time.DefaultInstance` for the default
+-- implementation using the real underlying time functions.
+-- See `Control.Monad.Trans.SimulatedTime` for an instance
+-- that allows to control time.
+class Monad m => MonadTime m where
+  getCurrentTime :: m UTCTime
+  threadDelay :: Int -> m ()
+
+instance {-# OVERLAPPABLE #-}
+  ( MonadTime m,
+    MonadTrans t,
+    Monad (t m)
+  ) =>
+  MonadTime (t m)
+  where
+  getCurrentTime = lift getCurrentTime
+  threadDelay a = lift (threadDelay a)
diff --git a/src/Control/Monad/Time/DefaultInstance.hs b/src/Control/Monad/Time/DefaultInstance.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Time/DefaultInstance.hs
@@ -0,0 +1,22 @@
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+-- | The instance of 'MonadTime' for IO, using the underlying system time and does
+-- This is to be used in production code, or in thoses tests where controling time
+-- is not needed.
+--
+-- This is only and instance for IO, for instances for monad transformers see
+-- 'Control.Monad.Trans.SimulatedTime'.
+module Control.Monad.Time.DefaultInstance (
+module Control.Monad.Time.DefaultInstance,
+module Control.Monad.Time) where
+
+import Control.Monad.Time
+import Control.Monad.Trans (liftIO)
+
+import Data.Time (getCurrentTime)
+import Control.Concurrent (threadDelay)
+
+instance {-# OVERLAPPING #-}
+  MonadTime IO where
+  getCurrentTime = liftIO Data.Time.getCurrentTime
+  threadDelay delay = liftIO $ Control.Concurrent.threadDelay delay
diff --git a/src/Control/Monad/Trans/SimulatedTime.hs b/src/Control/Monad/Trans/SimulatedTime.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Trans/SimulatedTime.hs
@@ -0,0 +1,144 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE PolyKinds #-}
+
+-- | An implementation of `Control.Monad.Time.MonadTime` with a monad transformer.
+module Control.Monad.Trans.SimulatedTime
+  ( SimulatedTimeT (..),
+    runSimulatedTimeT,
+    RealTimeT(..),
+    getTimeEnv,
+    module Test.SimulatedTime
+  )
+where
+
+import Control.Applicative (Alternative)
+import qualified Control.Concurrent
+import Control.Monad.Catch (MonadCatch, MonadMask(..), MonadThrow)
+import Control.Monad.Cont (MonadCont)
+import Control.Monad.Except (MonadError)
+import Control.Monad.Primitive (PrimMonad)
+import Control.Monad.RWS (MonadState, MonadWriter)
+import Control.Monad.Reader
+import Control.Monad.Time
+import Control.Monad.Trans.Resource (MonadResource)
+import Control.Monad.Zip (MonadZip)
+import qualified Data.Time
+import Control.Monad.IO.Unlift
+import Test.SimulatedTime
+
+#if __GLASGOW_HASKELL__ < 880
+import Control.Monad.Fail (MonadFail(..))
+#endif
+
+-- | A newtype wrapper over `ReaderT` `TimeEnv`
+newtype SimulatedTimeT m a = SimulatedTimeT {unSimulatedTimeT :: ReaderT TimeEnv m a}
+  deriving
+    ( Functor,
+      Applicative,
+      Alternative,
+      Monad,
+      MonadIO,
+      MonadState s,
+      MonadWriter w,
+      MonadTrans,
+      MonadFail,
+      MonadThrow,
+      MonadCatch,
+      MonadError e,
+      MonadCont,
+      MonadPlus,
+      MonadFix,
+      -- MonadUnliftIO, -- gives an incomprehensible typing error
+      MonadResource,
+      MonadZip
+#if MIN_VERSION_GLASGOW_HASKELL(8,2,0,0)
+      , PrimMonad
+#endif
+    )
+
+-- | Run the reader
+runSimulatedTimeT :: SimulatedTimeT m a -> TimeEnv -> m a
+runSimulatedTimeT = runReaderT . unSimulatedTimeT
+
+instance MonadReader r m => MonadReader r (SimulatedTimeT m) where
+  ask = lift ask
+  local f = SimulatedTimeT . mapReaderT (local f) . unSimulatedTimeT
+  reader = lift . reader
+
+instance MonadIO m => MonadTime (SimulatedTimeT m) where
+  getCurrentTime = SimulatedTimeT $ do
+    env <- ask
+    liftIO $ getSimulatedTime env
+
+  threadDelay delay = SimulatedTimeT $ do
+    env <- ask
+    liftIO $ threadDelay' env delay
+
+-- | Use 'TimeEnv' to control the simulated time, for instance call
+-- 'Time.SimlatedTime.advance' on it to advance in simulated time.
+getTimeEnv :: Monad m => SimulatedTimeT m TimeEnv
+getTimeEnv = SimulatedTimeT ask
+
+instance MonadUnliftIO m => MonadUnliftIO (SimulatedTimeT m) where
+   withRunInIO (inner :: (forall a. SimulatedTimeT m a -> IO a) -> IO b) =
+     SimulatedTimeT (withRunInIO (\x -> inner (x . unSimulatedTimeT))) -- \x is needed to avoid some typing problems
+
+instance MonadMask m => MonadMask (SimulatedTimeT m) where
+    mask inner = SimulatedTimeT $ mask (\unmask -> unSimulatedTimeT $ inner (SimulatedTimeT . unmask . unSimulatedTimeT))
+    uninterruptibleMask inner = SimulatedTimeT (uninterruptibleMask (\unmask -> unSimulatedTimeT $ inner (SimulatedTimeT . unmask . unSimulatedTimeT)))
+    generalBracket acquire release inner =
+      SimulatedTimeT $ generalBracket (unSimulatedTimeT acquire) (fmap (fmap unSimulatedTimeT) release) (fmap (unSimulatedTimeT) inner)
+
+-- | An implementation for `MonadTime` that uses real time directly,
+-- not allowing for control. Use it from code where you need to choose
+-- implementation for MockTime, but don't need to control the time.
+--
+-- Example: use this one in the executable, while `SimulatedTimeT` is
+-- used in tests that need to control time.
+newtype RealTimeT m a = RealTimeT {runRealTimeT :: m a}
+  deriving
+    ( Functor,
+      Applicative,
+      Alternative,
+      Monad,
+      MonadIO,
+      MonadReader s,
+      MonadState s,
+      MonadWriter w,
+      --MonadTrans, "cannot eta-reduce the representation type enough", says ghc
+      MonadFail,
+      MonadThrow,
+      MonadCatch,
+      MonadError e,
+      MonadCont,
+      MonadPlus,
+      MonadFix,
+      MonadResource,
+      MonadZip
+#if MIN_VERSION_GLASGOW_HASKELL(8,2,0,0)
+      , PrimMonad
+#endif
+    )
+
+instance MonadIO m => MonadTime (RealTimeT m) where
+  getCurrentTime = RealTimeT $ liftIO $ Data.Time.getCurrentTime
+  threadDelay delay = RealTimeT $ do liftIO $ Control.Concurrent.threadDelay delay
+
+instance MonadUnliftIO m => MonadUnliftIO (RealTimeT m) where
+   withRunInIO (inner :: (forall a. RealTimeT m a -> IO a) -> IO b) =
+     RealTimeT (withRunInIO (\x -> inner (x . runRealTimeT))) -- \x is needed to avoid some typing problems
+
+instance MonadMask m => MonadMask (RealTimeT m) where
+    mask inner = RealTimeT $ mask (\unmask -> runRealTimeT $ inner (RealTimeT . unmask . runRealTimeT))
+    uninterruptibleMask inner = RealTimeT (uninterruptibleMask (\unmask -> runRealTimeT $ inner (RealTimeT . unmask . runRealTimeT)))
+    generalBracket acquire release inner =
+      RealTimeT $ generalBracket (runRealTimeT acquire) (fmap (fmap runRealTimeT) release) (fmap (runRealTimeT) inner)
diff --git a/src/Test/SimulatedTime.hs b/src/Test/SimulatedTime.hs
new file mode 100644
--- /dev/null
+++ b/src/Test/SimulatedTime.hs
@@ -0,0 +1,104 @@
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE UnboxedTuples #-}
+
+-- | Contains a simulated-time implementaion. It can be used directly,
+-- to implement the simulated versions of getCurrentTime and
+-- threadDelay, or can be used via monad transformers defined in
+-- `Control.Monad.Trans.SimulatedTime`
+module Test.SimulatedTime
+  ( TimeEnv,
+    create,
+    advance,
+    triggerEvents,
+    getSimulatedTime,
+    threadDelay',
+  )
+where
+
+import Control.Concurrent hiding (threadDelay)
+import qualified Control.Concurrent
+import Control.Concurrent.STM
+import Control.Monad (unless, when)
+import Data.Foldable (forM_)
+import Data.Function (on)
+import Data.Functor (void)
+import Data.List (insertBy, partition)
+import Data.Maybe (listToMaybe)
+import Data.Time hiding (getCurrentTime)
+import qualified Data.Time
+import Data.Bifunctor (Bifunctor(first))
+
+-- | It remembers the offset from system time and keeps a list of
+-- sleeping threads (threads in 'threadDelay'' call)
+data TimeEnv
+  = TimeEnv
+      { offset :: TVar NominalDiffTime,
+        events :: TVar [(UTCTime, MVar ())]
+      }
+
+-- | Create the simulated time env from the given time start point. For example
+--
+-- @
+-- timeEnv <- create (fromGregorian 2000 1 1) 0
+-- getSimulatedTime timeEnv
+-- @
+create :: UTCTime -> IO TimeEnv
+create epoch = do
+  now <- Data.Time.getCurrentTime
+  TimeEnv <$> newTVarIO (diffUTCTime epoch now) <*> newTVarIO []
+
+-- | The current simulated time
+getSimulatedTime :: TimeEnv -> IO UTCTime
+getSimulatedTime t = do
+  now <- Data.Time.getCurrentTime
+  offset <- readTVarIO (offset t)
+  return $ addUTCTime offset now
+
+-- | Wake up due sleeping threads, based on TimeEnv. This happens on
+-- its own, but this call can quicken things up. Under the hood it is
+-- just @advance tenv 0@
+triggerEvents :: TimeEnv -> IO ()
+triggerEvents t = advance t 0
+
+-- | Move the simulated time by a delta
+advance :: TimeEnv -> NominalDiffTime -> IO ()
+advance t diff = do
+  now <- Data.Time.getCurrentTime
+  due <- atomically $ do
+    unless (diff == 0) $ modifyTVar (offset t) (+ diff)
+    modifyTVar (events t) (map (first (addUTCTime (- diff))))
+    extractDueEvents t now
+  forM_ due (flip putMVar ())
+  scheduleNextWakeUp t now
+
+-- the 'now' is the system time now, as opposed to simulated now
+extractDueEvents :: TimeEnv -> UTCTime -> STM [MVar ()]
+extractDueEvents t now = do
+  (due, inTheFuture) <- partition ((<= now) . fst) <$> readTVar (events t)
+  writeTVar (events t) inTheFuture
+  return (map snd due)
+
+scheduleNextWakeUp :: TimeEnv -> UTCTime -> IO ()
+scheduleNextWakeUp t now = do
+  nextEvent <- listToMaybe . map fst <$> readTVarIO (events t)
+  case nextEvent of
+    Nothing -> return ()
+    Just tm -> do
+      let us = ceiling (diffUTCTime tm now * 1000000)
+      void (forkIO (Control.Concurrent.threadDelay us >> triggerEvents t))
+
+-- | Simulated alternative to `Control.Concurrent.threadDelay`, sleep
+-- for the given number of microseconds. Threads wakes up according to
+-- the simulated time.
+threadDelay' :: TimeEnv -> Int -> IO ()
+threadDelay' t us = do
+  mvar <- newEmptyMVar
+  now <- Data.Time.getCurrentTime
+  shouldScheduleWakeUp <- atomically $ do
+    nextWakeUp <- listToMaybe . map fst <$> readTVar (events t)
+    let eventTime = addUTCTime (fromIntegral us / (1000 * 1000)) now
+    modifyTVar (events t) (insertBy (compare `on` fst) (eventTime, mvar))
+    return (maybe True (eventTime <) nextWakeUp)
+  when shouldScheduleWakeUp (scheduleNextWakeUp t now)
+  readMVar mvar
diff --git a/tests/Tests.hs b/tests/Tests.hs
new file mode 100644
--- /dev/null
+++ b/tests/Tests.hs
@@ -0,0 +1,62 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# language OverloadedStrings #-}
+import Control.Concurrent (forkIO)
+import Control.Monad
+import Data.ErrorOr
+import Data.Time
+import Data.ErrorOr.Validation
+import Test.Inbox
+import Test.QuickCheck
+import Test.QuickCheck.Monadic
+import qualified Test.SimulatedTime as SimTime
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.QuickCheck
+#if __GLASGOW_HASKELL__ < 880
+import Data.Semigroup
+#endif
+
+main :: IO ()
+main =
+  defaultMain $
+    testGroup
+      "tests"
+      [ testCase "put" $ do
+          tenv <- SimTime.create (UTCTime (fromGregorian 2015 7 18) 0)
+          box <- newInbox
+          _ <- forkIO (SimTime.threadDelay' tenv 50000 >> putInbox box "50ms")
+          _ <- forkIO (SimTime.threadDelay' tenv 500000 >> putInbox box ".5s")
+          _ <- forkIO (SimTime.threadDelay' tenv 1000000 >> putInbox box "1s")
+          t0 <- Data.Time.getCurrentTime
+          takeInbox box (equalTo "50ms")
+          t1 <- Data.Time.getCurrentTime
+          let elapsed = diffUTCTime t1 t0
+          toE $ (elapsed <! 0.070) <> (elapsed >! 0.049),
+
+        -- takes around 5.5s
+        testProperty "advance" $ do
+          let sorted :: [Int] =
+                [ 50000,
+                  10^6,
+                  10^7
+                ]
+          shuffled <- shuffle sorted
+          return . monadicIO . run $ do
+            fluxCapacitor <- SimTime.create (UTCTime (fromGregorian 2015 7 18) 0)
+            inbox <- newInbox
+            t0 <- Data.Time.getCurrentTime
+            forM_ shuffled $ \delay -> void $ forkIO $ do
+                SimTime.threadDelay' fluxCapacitor delay
+                putInbox inbox delay
+            takeInbox inbox (equalTo 50000)
+            elapsed <- flip diffUTCTime t0 <$> Data.Time.getCurrentTime
+            toE (elapsed >! 0.049)
+            toE =<< expectEmpty inbox
+            SimTime.advance fluxCapacitor 1
+            takeInbox inbox (equalTo $ 10^6)
+            toE . tag "1s" =<< expectEmpty inbox
+            SimTime.advance fluxCapacitor 10
+            takeInbox inbox (equalTo $ 10^7)
+            toE . tag "10s" =<< expectEmpty inbox
+      ]
