diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,9 @@
 
+Version 5.7
+-----
+
+* Implemented MonadMask and MonadCatch for basic simulation computations.
+
 Version 5.6
 -----
 
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009-2017 David Sorokin <david.sorokin@gmail.com>
+Copyright (c) 2009-2018 David Sorokin <david.sorokin@gmail.com>
 
 All rights reserved.
 
diff --git a/Simulation/Aivika/Generator.hs b/Simulation/Aivika/Generator.hs
--- a/Simulation/Aivika/Generator.hs
+++ b/Simulation/Aivika/Generator.hs
@@ -24,6 +24,7 @@
 import Data.IORef
 import Data.Word
 import Data.Vector
+import Data.Functor
 
 -- | A discrete probability density function.
 type DiscretePDF a = [(a, Double)]
diff --git a/Simulation/Aivika/Internal/Cont.hs b/Simulation/Aivika/Internal/Cont.hs
--- a/Simulation/Aivika/Internal/Cont.hs
+++ b/Simulation/Aivika/Internal/Cont.hs
@@ -62,6 +62,7 @@
 import Control.Exception
 import Control.Monad
 import Control.Monad.Trans
+import qualified Control.Monad.Catch as MC
 import Control.Applicative
 
 import Debug.Trace
@@ -284,6 +285,12 @@
 instance MonadIO Cont where
   liftIO = liftIOC 
 
+instance MC.MonadThrow Cont where
+  throwM = throwCont
+
+instance MC.MonadCatch Cont where
+  catch = catchCont
+
 -- | Invoke the computation.
 invokeCont :: ContParams a -> Cont a -> Event ()
 {-# INLINE invokeCont #-}
@@ -381,7 +388,7 @@
 -- if it will be wrapped in the 'IO' monad. Therefore, you should use specialised
 -- functions like the stated one that use the 'throw' function but within the 'IO' computation,
 -- which allows already handling the exception.
-throwCont :: IOException -> Cont a
+throwCont :: Exception e => e -> Cont a
 throwCont = liftIO . throw
 
 -- | Run the 'Cont' computation with the specified cancelation source 
diff --git a/Simulation/Aivika/Internal/Dynamics.hs b/Simulation/Aivika/Internal/Dynamics.hs
--- a/Simulation/Aivika/Internal/Dynamics.hs
+++ b/Simulation/Aivika/Internal/Dynamics.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE RecursiveDo, RankNTypes #-}
 
 -- |
 -- Module     : Simulation.Aivika.Internal.Dynamics
@@ -39,6 +39,7 @@
 import Control.Monad
 import Control.Monad.Trans
 import Control.Monad.Fix
+import qualified Control.Monad.Catch as MC
 import Control.Applicative
 
 import Debug.Trace
@@ -192,6 +193,22 @@
 throwDynamics :: Exception e => e -> Dynamics a
 throwDynamics = throw
 
+-- | Runs an action with asynchronous exceptions disabled.
+maskDynamics :: ((forall a. Dynamics a -> Dynamics a) -> Dynamics b) -> Dynamics b
+maskDynamics a =
+  Dynamics $ \p ->
+  MC.mask $ \u ->
+  invokeDynamics p (a $ q u)
+  where q u (Dynamics b) = Dynamics (u . b)
+
+-- | Like 'maskDynamics', but the masked computation is not interruptible.
+uninterruptibleMaskDynamics :: ((forall a. Dynamics a -> Dynamics a) -> Dynamics b) -> Dynamics b
+uninterruptibleMaskDynamics a =
+  Dynamics $ \p ->
+  MC.uninterruptibleMask $ \u ->
+  invokeDynamics p (a $ q u)
+  where q u (Dynamics b) = Dynamics (u . b)
+
 -- | Invoke the 'Dynamics' computation.
 invokeDynamics :: Point -> Dynamics a -> IO a
 {-# INLINE invokeDynamics #-}
@@ -201,6 +218,16 @@
   mfix f = 
     Dynamics $ \p ->
     do { rec { a <- invokeDynamics p (f a) }; return a }
+
+instance MC.MonadThrow Dynamics where
+  throwM = throwDynamics
+
+instance MC.MonadCatch Dynamics where
+  catch = catchDynamics
+
+instance MC.MonadMask Dynamics where
+  mask = maskDynamics
+  uninterruptibleMask = uninterruptibleMaskDynamics
 
 -- | Computation that returns the current simulation time.
 time :: Dynamics Double
diff --git a/Simulation/Aivika/Internal/Event.hs b/Simulation/Aivika/Internal/Event.hs
--- a/Simulation/Aivika/Internal/Event.hs
+++ b/Simulation/Aivika/Internal/Event.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE RecursiveDo, RankNTypes #-}
 
 -- |
 -- Module     : Simulation.Aivika.Internal.Event
@@ -67,6 +67,7 @@
 import Control.Monad
 import Control.Monad.Trans
 import Control.Monad.Fix
+import qualified Control.Monad.Catch as MC
 import Control.Applicative
 
 import Debug.Trace (trace)
@@ -163,6 +164,22 @@
 throwEvent :: Exception e => e -> Event a
 throwEvent = throw
 
+-- | Runs an action with asynchronous exceptions disabled.
+maskEvent :: ((forall a. Event a -> Event a) -> Event b) -> Event b
+maskEvent a =
+  Event $ \p ->
+  MC.mask $ \u ->
+  invokeEvent p (a $ q u)
+  where q u (Event b) = Event (u . b)
+
+-- | Like 'maskEvent', but the masked computation is not interruptible.
+uninterruptibleMaskEvent :: ((forall a. Event a -> Event a) -> Event b) -> Event b
+uninterruptibleMaskEvent a =
+  Event $ \p ->
+  MC.uninterruptibleMask $ \u ->
+  invokeEvent p (a $ q u)
+  where q u (Event b) = Event (u . b)
+
 -- | Invoke the 'Event' computation.
 invokeEvent :: Point -> Event a -> IO a
 {-# INLINE invokeEvent #-}
@@ -172,6 +189,16 @@
   mfix f = 
     Event $ \p ->
     do { rec { a <- invokeEvent p (f a) }; return a }
+
+instance MC.MonadThrow Event where
+  throwM = throwEvent
+
+instance MC.MonadCatch Event where
+  catch = catchEvent
+
+instance MC.MonadMask Event where
+  mask = maskEvent
+  uninterruptibleMask = uninterruptibleMaskEvent
 
 -- | Defines how the events are processed.
 data EventProcessing = CurrentEvents
diff --git a/Simulation/Aivika/Internal/Parameter.hs b/Simulation/Aivika/Internal/Parameter.hs
--- a/Simulation/Aivika/Internal/Parameter.hs
+++ b/Simulation/Aivika/Internal/Parameter.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE RecursiveDo, RankNTypes #-}
 
 -- |
 -- Module     : Simulation.Aivika.Internal.Parameter
@@ -47,6 +47,7 @@
 import Control.Monad
 import Control.Monad.Trans
 import Control.Monad.Fix
+import qualified Control.Monad.Catch as MC
 import Control.Applicative
 
 import Data.IORef
@@ -203,6 +204,22 @@
 throwParameter :: Exception e => e -> Parameter a
 throwParameter = throw
 
+-- | Runs an action with asynchronous exceptions disabled.
+maskParameter :: ((forall a. Parameter a -> Parameter a) -> Parameter b) -> Parameter b
+maskParameter a =
+  Parameter $ \r ->
+  MC.mask $ \u ->
+  invokeParameter r (a $ q u)
+  where q u (Parameter b) = Parameter (u . b)
+
+-- | Like 'maskParameter', but the masked computation is not interruptible.
+uninterruptibleMaskParameter :: ((forall a. Parameter a -> Parameter a) -> Parameter b) -> Parameter b
+uninterruptibleMaskParameter a =
+  Parameter $ \r ->
+  MC.uninterruptibleMask $ \u ->
+  invokeParameter r (a $ q u)
+  where q u (Parameter b) = Parameter (u . b)
+
 -- | Invoke the 'Parameter' computation.
 invokeParameter :: Run -> Parameter a -> IO a
 {-# INLINE invokeParameter #-}
@@ -213,6 +230,16 @@
     Parameter $ \r ->
     do { rec { a <- invokeParameter r (f a) }; return a }  
 
+instance MC.MonadThrow Parameter where
+  throwM = throwParameter
+
+instance MC.MonadCatch Parameter where
+  catch = catchParameter
+
+instance MC.MonadMask Parameter where
+  mask = maskParameter
+  uninterruptibleMask = uninterruptibleMaskParameter
+  
 -- | Memoize the 'Parameter' computation, always returning the same value
 -- within a simulation run. However, the value will be recalculated for other
 -- simulation runs. Also it is thread-safe when different simulation runs
diff --git a/Simulation/Aivika/Internal/Process.hs b/Simulation/Aivika/Internal/Process.hs
--- a/Simulation/Aivika/Internal/Process.hs
+++ b/Simulation/Aivika/Internal/Process.hs
@@ -104,6 +104,7 @@
 import Control.Exception
 import Control.Monad
 import Control.Monad.Trans
+import qualified Control.Monad.Catch as MC
 import Control.Applicative
 
 import Simulation.Aivika.Internal.Specs
@@ -470,6 +471,12 @@
 instance MonadIO Process where
   liftIO = liftIOP
   
+instance MC.MonadThrow Process where
+  throwM = throwProcess
+
+instance MC.MonadCatch Process where
+  catch = catchProcess
+
 returnP :: a -> Process a
 {-# INLINE returnP #-}
 returnP a = Process $ \pid -> return a
diff --git a/Simulation/Aivika/Internal/Simulation.hs b/Simulation/Aivika/Internal/Simulation.hs
--- a/Simulation/Aivika/Internal/Simulation.hs
+++ b/Simulation/Aivika/Internal/Simulation.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE RecursiveDo, ExistentialQuantification, DeriveDataTypeable #-}
+{-# LANGUAGE RecursiveDo, ExistentialQuantification, DeriveDataTypeable, RankNTypes #-}
 
 -- |
 -- Module     : Simulation.Aivika.Internal.Simulation
@@ -39,6 +39,7 @@
 import Control.Monad
 import Control.Monad.Trans
 import Control.Monad.Fix
+import qualified Control.Monad.Catch as MC
 import Control.Applicative
 
 import Data.IORef
@@ -163,6 +164,22 @@
 throwSimulation :: Exception e => e -> Simulation a
 throwSimulation = throw
 
+-- | Runs an action with asynchronous exceptions disabled.
+maskSimulation :: ((forall a. Simulation a -> Simulation a) -> Simulation b) -> Simulation b
+maskSimulation a =
+  Simulation $ \r ->
+  MC.mask $ \u ->
+  invokeSimulation r (a $ q u)
+  where q u (Simulation b) = Simulation (u . b)
+
+-- | Like 'maskSimulation', but the masked computation is not interruptible.
+uninterruptibleMaskSimulation :: ((forall a. Simulation a -> Simulation a) -> Simulation b) -> Simulation b
+uninterruptibleMaskSimulation a =
+  Simulation $ \r ->
+  MC.uninterruptibleMask $ \u ->
+  invokeSimulation r (a $ q u)
+  where q u (Simulation b) = Simulation (u . b)
+
 -- | Invoke the 'Simulation' computation.
 invokeSimulation :: Run -> Simulation a -> IO a
 {-# INLINE invokeSimulation #-}
@@ -172,6 +189,16 @@
   mfix f = 
     Simulation $ \r ->
     do { rec { a <- invokeSimulation r (f a) }; return a }  
+
+instance MC.MonadThrow Simulation where
+  throwM = throwSimulation
+
+instance MC.MonadCatch Simulation where
+  catch = catchSimulation
+
+instance MC.MonadMask Simulation where
+  mask = maskSimulation
+  uninterruptibleMask = uninterruptibleMaskSimulation
 
 -- | Memoize the 'Simulation' computation, always returning the same value
 -- within a simulation run.
diff --git a/aivika.cabal b/aivika.cabal
--- a/aivika.cabal
+++ b/aivika.cabal
@@ -1,5 +1,5 @@
 name:            aivika
-version:         5.6
+version:         5.7
 synopsis:        A multi-method simulation library
 description:
     Aivika is a discrete event simulation (DES) framework with support of activity-oriented,
@@ -113,7 +113,7 @@
 category:        Simulation
 license:         BSD3
 license-file:    LICENSE
-copyright:       (c) 2009-2017. David Sorokin <david.sorokin@gmail.com>
+copyright:       (c) 2009-2018. David Sorokin <david.sorokin@gmail.com>
 author:          David Sorokin
 maintainer:      David Sorokin <david.sorokin@gmail.com>
 homepage:        http://www.aivikasoft.com
@@ -239,7 +239,8 @@
                      vector >= 0.10.0.1,
                      deepseq >= 1.1.0.0,
                      binary >= 0.6.4.0,
-                     semigroups >= 0.10
+                     semigroups >= 0.10,
+                     exceptions >= 0.6
 
     other-extensions:   FlexibleContexts,
                         FlexibleInstances,