diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,12 @@
+
+Version 4.6
+-----
+
+* Removed the MonadTemplate type class as it often caused overlapping family data
+  instances.
+
+* Updated module DoubleLinkedList.
+
+* Breaking change: arrows Net and Processor are trying to perform computations
+  in parallel as possible, when using the proc notation. Earlier they executed
+  sequentially.
diff --git a/Simulation/Aivika/IO/Comp.hs b/Simulation/Aivika/IO/Comp.hs
--- a/Simulation/Aivika/IO/Comp.hs
+++ b/Simulation/Aivika/IO/Comp.hs
@@ -1,6 +1,4 @@
 
-{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
-
 -- |
 -- Module     : Simulation.Aivika.IO.Comp
 -- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>
@@ -9,7 +7,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- It allows making the 'MonadIO'-based monad an instance of type class 'MonadComp'
+-- It makes the 'IO' monad an instance of type class 'MonadComp'
 -- on top of which the simulation monads can be built.
 --
 module Simulation.Aivika.IO.Comp () where
@@ -22,9 +20,9 @@
 
 import Simulation.Aivika.Trans.Comp
 import Simulation.Aivika.Trans.Exception
-import Simulation.Aivika.Trans.Template
 
--- | A template-based instantiation of the 'MonadComp' type class. 
-instance (Functor m, Monad m, MonadIO m, MonadException m, MonadTemplate m) => MonadComp m where
+-- | An instantiation of the 'MonadComp' type class. 
+instance MonadComp IO where
+-- instance (Functor m, Monad m, MonadIO m, MonadException m, MonadTemplate m) => MonadComp m where
 
   {-# SPECIALISE instance MonadComp IO #-}
diff --git a/Simulation/Aivika/IO/DES.hs b/Simulation/Aivika/IO/DES.hs
--- a/Simulation/Aivika/IO/DES.hs
+++ b/Simulation/Aivika/IO/DES.hs
@@ -1,6 +1,4 @@
 
-{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
-
 -- |
 -- Module     : Simulation.Aivika.IO.DES
 -- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>
@@ -9,7 +7,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- It allows making the 'MonadIO'-based monad an instance of type class 'MonadDES'
+-- It makes the 'IO' monad an instance of type class 'MonadDES'
 -- used for Discrete Event Simulation (DES).
 --
 module Simulation.Aivika.IO.DES () where
@@ -22,11 +20,11 @@
 
 import Simulation.Aivika.Trans.Comp
 import Simulation.Aivika.Trans.DES
-import Simulation.Aivika.Trans.Template
 
 import Simulation.Aivika.IO.QueueStrategy
 
--- | A template-based instantiation of the 'MonadDES' type class.
-instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m, MonadEventQueueTemplate m) => MonadDES m where
+-- | An instantiation of the 'MonadDES' type class.
+instance MonadDES IO where
+-- instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m, MonadEventQueueTemplate m) => MonadDES m where
 
   {-# SPECIALISE instance MonadDES IO #-}
diff --git a/Simulation/Aivika/IO/Dynamics/Memo.hs b/Simulation/Aivika/IO/Dynamics/Memo.hs
--- a/Simulation/Aivika/IO/Dynamics/Memo.hs
+++ b/Simulation/Aivika/IO/Dynamics/Memo.hs
@@ -9,7 +9,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- The 'MonadIO'-based monad can be an instance of the 'MonadMemo' type class.
+-- The 'IO' monad is an instance of the 'MonadMemo' type class.
 --
 
 module Simulation.Aivika.IO.Dynamics.Memo () where
@@ -27,11 +27,11 @@
 import Simulation.Aivika.Trans.Internal.Dynamics
 import Simulation.Aivika.Trans.Dynamics.Memo
 import Simulation.Aivika.Trans.Dynamics.Extra
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Array
 
--- | The 'MonadIO' based monad is an instance of the 'MonadMemo' type class.
-instance (Monad m, MonadIO m, MonadTemplate m) => MonadMemo m where
+-- | The 'IO' monad is an instance of the 'MonadMemo' type class.
+instance MonadMemo IO where
+-- instance (Monad m, MonadIO m, MonadTemplate m) => MonadMemo m where
 
   {-# SPECIALISE instance MonadMemo IO #-}
 
diff --git a/Simulation/Aivika/IO/Dynamics/Memo/Unboxed.hs b/Simulation/Aivika/IO/Dynamics/Memo/Unboxed.hs
--- a/Simulation/Aivika/IO/Dynamics/Memo/Unboxed.hs
+++ b/Simulation/Aivika/IO/Dynamics/Memo/Unboxed.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.Dynamics.Memo.Unboxed
@@ -9,7 +9,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- The 'MonadIO'-based monad can be an instance of the 'MonadMemo' type class.
+-- The 'IO' monad can be an instance of the 'MonadMemo' type class.
 --
 
 module Simulation.Aivika.IO.Dynamics.Memo.Unboxed () where
@@ -27,11 +27,11 @@
 import Simulation.Aivika.Trans.Internal.Dynamics
 import Simulation.Aivika.Trans.Dynamics.Memo.Unboxed
 import Simulation.Aivika.Trans.Dynamics.Extra
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Array
 
--- | The 'MonadIO' based monad is an instance of the 'MonadMemo' type class.
-instance (Monad m, MonadIO m, MonadTemplate m, MArray IOUArray e IO) => MonadMemo m e where
+-- | The 'IO' based monad can be an instance of the 'MonadMemo' type class.
+instance MArray IOUArray e IO => MonadMemo IO e where
+-- instance (Monad m, MonadIO m, MonadTemplate m, MArray IOUArray e IO) => MonadMemo m e where
 
   {-# SPECIALISE instance MonadMemo IO Double #-}
   {-# SPECIALISE instance MonadMemo IO Float #-}
diff --git a/Simulation/Aivika/IO/Event.hs b/Simulation/Aivika/IO/Event.hs
--- a/Simulation/Aivika/IO/Event.hs
+++ b/Simulation/Aivika/IO/Event.hs
@@ -9,8 +9,8 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- The module defines a template-based event queue, where
--- the 'MonadIO'-based monad can be an instance of 'EventQueueing' and 'EventIOQueueing'.
+-- The module defines an event queue, where the 'IO' monad is an instance of
+-- 'EventQueueing' and 'EventIOQueueing'.
 --
 module Simulation.Aivika.IO.Event () where
 
@@ -24,17 +24,17 @@
 import Simulation.Aivika.Trans.Ref.Base
 import Simulation.Aivika.Trans.DES
 import Simulation.Aivika.Trans.Comp
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Internal.Types
 import Simulation.Aivika.Trans.Event
 
--- | A template-based implementation of the 'EventQueueing' type class.
-instance (Monad m, MonadIO m, MonadEventQueueTemplate m) => EventQueueing m where
+-- | An implementation of the 'EventQueueing' type class.
+instance EventQueueing IO where
+-- instance (Monad m, MonadIO m, MonadEventQueueTemplate m) => EventQueueing m where
 
   {-# SPECIALISE instance EventQueueing IO #-}
 
-  data EventQueue m =
-    EventQueue { queuePQ :: PQ.PriorityQueue (Point m -> m ()),
+  data EventQueue IO =
+    EventQueue { queuePQ :: PQ.PriorityQueue (Point IO -> IO ()),
                  -- ^ the underlying priority queue
                  queueBusy :: IORef Bool,
                  -- ^ whether the queue is currently processing events
@@ -70,7 +70,8 @@
     liftIO . PQ.queueCount . queuePQ . runEventQueue . pointRun
 
 -- | Process the pending events.
-processPendingEventsCore :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m ()
+processPendingEventsCore :: Bool -> Dynamics IO ()
+-- processPendingEventsCore :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m ()
 {-# INLINE processPendingEventsCore #-}
 processPendingEventsCore includingCurrentEvents = Dynamics r where
   r p =
@@ -105,7 +106,8 @@
                  call q p
 
 -- | Process the pending events synchronously, i.e. without past.
-processPendingEvents :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m ()
+processPendingEvents :: Bool -> Dynamics IO ()
+-- processPendingEvents :: (MonadIO m, MonadEventQueueTemplate m) => Bool -> Dynamics m ()
 {-# INLINE processPendingEvents #-}
 processPendingEvents includingCurrentEvents = Dynamics r where
   r p =
@@ -120,34 +122,42 @@
   m = processPendingEventsCore includingCurrentEvents
 
 -- | A memoized value.
-processEventsIncludingCurrent :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
+processEventsIncludingCurrent :: Dynamics IO ()
+-- processEventsIncludingCurrent :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
 {-# INLINE processEventsIncludingCurrent #-}
 processEventsIncludingCurrent = processPendingEvents True
 
 -- | A memoized value.
-processEventsIncludingEarlier :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
+processEventsIncludingEarlier :: Dynamics IO ()
+-- processEventsIncludingEarlier :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
 {-# INLINE processEventsIncludingEarlier #-}
 processEventsIncludingEarlier = processPendingEvents False
 
 -- | A memoized value.
-processEventsIncludingCurrentCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
+processEventsIncludingCurrentCore :: Dynamics IO ()
+-- processEventsIncludingCurrentCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
 {-# INLINE processEventsIncludingCurrentCore #-}
 processEventsIncludingCurrentCore = processPendingEventsCore True
 
 -- | A memoized value.
-processEventsIncludingEarlierCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
+processEventsIncludingEarlierCore :: Dynamics IO ()
+-- processEventsIncludingEarlierCore :: (MonadIO m, MonadEventQueueTemplate m) => Dynamics m ()
 {-# INLINE processEventsIncludingEarlierCore #-}
 processEventsIncludingEarlierCore = processPendingEventsCore True
 
 -- | Process the events.
-processEvents :: (MonadIO m, MonadEventQueueTemplate m) => EventProcessing -> Dynamics m ()
+processEvents :: EventProcessing -> Dynamics IO ()
+-- processEvents :: (MonadIO m, MonadEventQueueTemplate m) => EventProcessing -> Dynamics m ()
 {-# INLINABLE processEvents #-}
 processEvents CurrentEvents = processEventsIncludingCurrent
 processEvents EarlierEvents = processEventsIncludingEarlier
 processEvents CurrentEventsOrFromPast = processEventsIncludingCurrentCore
 processEvents EarlierEventsOrFromPast = processEventsIncludingEarlierCore
 
--- | A template-based implementation of the 'EventIOQueueing' type class.
-instance (Monad m, MonadIO m, MonadEventQueueTemplate m, MonadDES m) => EventIOQueueing m where
+-- | An implementation of the 'EventIOQueueing' type class.
+instance EventIOQueueing IO where
+-- instance (Monad m, MonadIO m, MonadEventQueueTemplate m, MonadDES m) => EventIOQueueing m where
+
+  {-# SPECIALISE instance EventIOQueueing IO #-}
 
   enqueueEventIO = enqueueEvent
diff --git a/Simulation/Aivika/IO/Generator.hs b/Simulation/Aivika/IO/Generator.hs
--- a/Simulation/Aivika/IO/Generator.hs
+++ b/Simulation/Aivika/IO/Generator.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.Generator
@@ -10,7 +10,7 @@
 -- Tested with: GHC 8.0.1
 --
 -- Here is defined a random number generator, where
--- the 'MonadIO'-based monad can be an instance of 'MonadGenerator'.
+-- the 'IO' monad is an instance of 'MonadGenerator'.
 --
 module Simulation.Aivika.IO.Generator () where
 
@@ -23,16 +23,16 @@
 
 import Simulation.Aivika.Trans.Generator
 import Simulation.Aivika.Trans.Generator.Primitive
-import Simulation.Aivika.Trans.Template
 
-instance (Functor m, Monad m, MonadIO m, MonadTemplate m) => MonadGenerator m where
+instance MonadGenerator IO where
+-- instance (Functor m, Monad m, MonadIO m, MonadTemplate m) => MonadGenerator m where
 
   {-# SPECIALISE instance MonadGenerator IO #-}
 
-  data Generator m =
-    Generator { generator01 :: m Double,
+  data Generator IO =
+    Generator { generator01 :: IO Double,
                 -- ^ the generator of uniform numbers from 0 to 1
-                generatorNormal01 :: m Double
+                generatorNormal01 :: IO Double
                 -- ^ the generator of normal numbers with mean 0 and variance 1
               }
 
diff --git a/Simulation/Aivika/IO/QueueStrategy.hs b/Simulation/Aivika/IO/QueueStrategy.hs
--- a/Simulation/Aivika/IO/QueueStrategy.hs
+++ b/Simulation/Aivika/IO/QueueStrategy.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, FunctionalDependencies, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies, MultiParamTypeClasses #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.QueueStrategy
@@ -10,7 +10,7 @@
 -- Tested with: GHC 8.0.1
 --
 -- This module defines some queue strategy instances
--- for the 'MonadIO'-based computations.
+-- for the 'IO' computation.
 --
 module Simulation.Aivika.IO.QueueStrategy () where
 
@@ -22,7 +22,6 @@
 import Simulation.Aivika.Trans.Simulation
 import Simulation.Aivika.Trans.Event
 import Simulation.Aivika.Trans.QueueStrategy
-import Simulation.Aivika.Trans.Template
 
 import Simulation.Aivika.IO.Comp
 
@@ -31,13 +30,14 @@
 import qualified Simulation.Aivika.Vector as V
 
 -- | An implementation of the 'FCFS' queue strategy.
-instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m)
-         => QueueStrategy m FCFS where
+instance QueueStrategy IO FCFS where
+-- instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m)
+--          => QueueStrategy m FCFS where
 
   {-# SPECIALISE instance QueueStrategy IO FCFS #-}
 
   -- | A queue used by the 'FCFS' strategy.
-  newtype StrategyQueue m FCFS a = FCFSQueue (LL.DoubleLinkedList a)
+  newtype StrategyQueue IO FCFS a = FCFSQueue (LL.DoubleLinkedList a)
 
   {-# INLINABLE newStrategyQueue #-}
   newStrategyQueue s =
@@ -49,8 +49,9 @@
     liftIO $ LL.listNull q
 
 -- | An implementation of the 'FCFS' queue strategy.
-instance (QueueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)
-         => DequeueStrategy m FCFS where
+instance DequeueStrategy IO FCFS where
+-- instance (QueueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DequeueStrategy m FCFS where
 
   {-# SPECIALISE instance DequeueStrategy IO FCFS #-}
 
@@ -62,8 +63,9 @@
        return i
 
 -- | An implementation of the 'FCFS' queue strategy.
-instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)
-         => EnqueueStrategy m FCFS where
+instance EnqueueStrategy IO FCFS where
+-- instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)
+--          => EnqueueStrategy m FCFS where
 
   {-# SPECIALISE instance EnqueueStrategy IO FCFS #-}
 
@@ -72,8 +74,9 @@
     liftIO $ LL.listAddLast q i
 
 -- | An implementation of the 'FCFS' queue strategy.
-instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)
-         => DeletingQueueStrategy m FCFS where
+instance DeletingQueueStrategy IO FCFS where
+-- instance (DequeueStrategy m FCFS, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DeletingQueueStrategy m FCFS where
 
   {-# SPECIALISE instance DeletingQueueStrategy IO FCFS #-}
 
@@ -86,13 +89,14 @@
     liftIO $ LL.listContainsBy q p
 
 -- | An implementation of the 'LCFS' queue strategy.
-instance (MonadComp m, MonadIO m, MonadTemplate m)
-         => QueueStrategy m LCFS where
+instance QueueStrategy IO LCFS where
+-- instance (MonadComp m, MonadIO m, MonadTemplate m)
+--          => QueueStrategy m LCFS where
 
   {-# SPECIALISE instance QueueStrategy IO LCFS #-}
 
   -- | A queue used by the 'LCFS' strategy.
-  newtype StrategyQueue m LCFS a = LCFSQueue (LL.DoubleLinkedList a)
+  newtype StrategyQueue IO LCFS a = LCFSQueue (LL.DoubleLinkedList a)
 
   {-# INLINABLE newStrategyQueue #-}
   newStrategyQueue s =
@@ -104,8 +108,9 @@
     liftIO $ LL.listNull q
 
 -- | An implementation of the 'LCFS' queue strategy.
-instance (QueueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)
-         => DequeueStrategy m LCFS where
+instance DequeueStrategy IO LCFS where
+-- instance (QueueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DequeueStrategy m LCFS where
 
   {-# SPECIALISE instance DequeueStrategy IO LCFS #-}
 
@@ -117,8 +122,9 @@
        return i
 
 -- | An implementation of the 'LCFS' queue strategy.
-instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)
-         => EnqueueStrategy m LCFS where
+instance EnqueueStrategy IO LCFS where
+-- instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)
+--          => EnqueueStrategy m LCFS where
 
   {-# SPECIALISE instance EnqueueStrategy IO LCFS #-}
 
@@ -127,8 +133,9 @@
     liftIO $ LL.listInsertFirst q i
 
 -- | An implementation of the 'LCFS' queue strategy.
-instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)
-         => DeletingQueueStrategy m LCFS where
+instance DeletingQueueStrategy IO LCFS where
+-- instance (DequeueStrategy m LCFS, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DeletingQueueStrategy m LCFS where
 
   {-# SPECIALISE instance DeletingQueueStrategy IO LCFS #-}
 
@@ -140,14 +147,15 @@
   strategyQueueContainsBy (LCFSQueue q) p =
     liftIO $ LL.listContainsBy q p
 
--- | A template-based implementation of the 'StaticPriorities' queue strategy.
-instance (MonadComp m, MonadIO m, MonadTemplate m)
-         => QueueStrategy m StaticPriorities where
+-- | An implementation of the 'StaticPriorities' queue strategy.
+instance QueueStrategy IO StaticPriorities where
+-- instance (MonadComp m, MonadIO m, MonadTemplate m)
+--          => QueueStrategy m StaticPriorities where
 
   {-# SPECIALISE instance QueueStrategy IO StaticPriorities #-}
 
   -- | A queue used by the 'StaticPriorities' strategy.
-  newtype StrategyQueue m StaticPriorities a = StaticPriorityQueue (PQ.PriorityQueue a)
+  newtype StrategyQueue IO StaticPriorities a = StaticPriorityQueue (PQ.PriorityQueue a)
 
   {-# INLINABLE newStrategyQueue #-}
   newStrategyQueue s =
@@ -158,9 +166,10 @@
   strategyQueueNull (StaticPriorityQueue q) =
     liftIO $ PQ.queueNull q
 
--- | A template-based implementation of the 'StaticPriorities' queue strategy.
-instance (QueueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)
-         => DequeueStrategy m StaticPriorities where
+-- | An implementation of the 'StaticPriorities' queue strategy.
+instance DequeueStrategy IO StaticPriorities where
+-- instance (QueueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DequeueStrategy m StaticPriorities where
 
   {-# SPECIALISE instance DequeueStrategy IO StaticPriorities #-}
 
@@ -171,9 +180,10 @@
        PQ.dequeue q
        return i
 
--- | A template-based implementation of the 'StaticPriorities' queue strategy.
-instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)
-         => PriorityQueueStrategy m StaticPriorities Double where
+-- | An implementation of the 'StaticPriorities' queue strategy.
+instance PriorityQueueStrategy IO StaticPriorities Double where
+-- instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)
+--          => PriorityQueueStrategy m StaticPriorities Double where
 
   {-# SPECIALISE instance PriorityQueueStrategy IO StaticPriorities Double #-}
 
@@ -182,8 +192,9 @@
     liftIO $ PQ.enqueue q p i
 
 -- | An implementation of the 'StaticPriorities' queue strategy.
-instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)
-         => DeletingQueueStrategy m StaticPriorities where
+instance DeletingQueueStrategy IO StaticPriorities where
+-- instance (DequeueStrategy m StaticPriorities, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DeletingQueueStrategy m StaticPriorities where
 
   {-# SPECIALISE instance DeletingQueueStrategy IO StaticPriorities #-}
 
@@ -195,14 +206,15 @@
   strategyQueueContainsBy (StaticPriorityQueue q) p =
     liftIO $ PQ.queueContainsBy q p
 
--- | A template-based implementation of the 'SIRO' queue strategy.
-instance (MonadComp m, MonadIO m, MonadTemplate m)
-         => QueueStrategy m SIRO where
+-- | An implementation of the 'SIRO' queue strategy.
+instance QueueStrategy IO SIRO where
+-- instance (MonadComp m, MonadIO m, MonadTemplate m)
+--          => QueueStrategy m SIRO where
 
   {-# SPECIALISE instance QueueStrategy IO SIRO #-}
 
   -- | A queue used by the 'SIRO' strategy.
-  newtype StrategyQueue m SIRO a = SIROQueue (V.Vector a)
+  newtype StrategyQueue IO SIRO a = SIROQueue (V.Vector a)
   
   {-# INLINABLE newStrategyQueue #-}
   newStrategyQueue s =
@@ -215,9 +227,10 @@
     do n <- V.vectorCount q
        return (n == 0)
 
--- | A template-based implementation of the 'SIRO' queue strategy.
-instance (QueueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)
-         => DequeueStrategy m SIRO where
+-- | An implementation of the 'SIRO' queue strategy.
+instance DequeueStrategy IO SIRO where
+-- instance (QueueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DequeueStrategy m SIRO where
 
   {-# SPECIALISE instance DequeueStrategy IO SIRO #-}
 
@@ -229,9 +242,10 @@
        liftIO $ V.vectorDeleteAt q i
        return x
 
--- | A template-based implementation of the 'SIRO' queue strategy.
-instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)
-         => EnqueueStrategy m SIRO where
+-- | An implementation of the 'SIRO' queue strategy.
+instance EnqueueStrategy IO SIRO where
+-- instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)
+--          => EnqueueStrategy m SIRO where
 
   {-# SPECIALISE instance EnqueueStrategy IO SIRO #-}
 
@@ -240,8 +254,9 @@
     liftIO $ V.appendVector q i
 
 -- | An implementation of the 'SIRO' queue strategy.
-instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)
-         => DeletingQueueStrategy m SIRO where
+instance DeletingQueueStrategy IO SIRO where
+-- instance (DequeueStrategy m SIRO, MonadComp m, MonadIO m, MonadTemplate m)
+--          => DeletingQueueStrategy m SIRO where
 
   {-# SPECIALISE instance DeletingQueueStrategy IO SIRO #-}
 
diff --git a/Simulation/Aivika/IO/Ref/Base.hs b/Simulation/Aivika/IO/Ref/Base.hs
--- a/Simulation/Aivika/IO/Ref/Base.hs
+++ b/Simulation/Aivika/IO/Ref/Base.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.Ref.Base
@@ -9,7 +9,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- The 'MonadIO'-based monad can be an instance of 'MonadRef'.
+-- The 'IO' monad in an instance of 'MonadRef'.
 --
 module Simulation.Aivika.IO.Ref.Base () where
 
@@ -20,15 +20,15 @@
 
 import Simulation.Aivika.Trans.Internal.Types
 import Simulation.Aivika.Trans.Ref.Base
-import Simulation.Aivika.Trans.Template
 
--- | The 'MonadIO' based monad is an instance of 'MonadRef'.
-instance (Monad m, MonadIO m, MonadTemplate m) => MonadRef m where
+-- | 'IO' is an instance of 'MonadRef'.
+instance MonadRef IO where
+-- instance (Monad m, MonadIO m, MonadTemplate m) => MonadRef m where
 
   {-# SPECIALISE instance MonadRef IO #-}
 
   -- | A type safe wrapper for the 'IORef' reference.
-  newtype Ref m a = Ref { refValue :: IORef a }
+  newtype Ref IO a = Ref { refValue :: IORef a }
 
   {-# INLINE newRef #-}
   newRef a =
@@ -53,11 +53,12 @@
   {-# INLINE equalRef #-}
   equalRef (Ref r1) (Ref r2) = (r1 == r2)
 
--- | The 'MonadIO' based monad is an instance of 'MonadRef0'.
-instance (MonadIO m, MonadTemplate m) => MonadRef0 m where
+-- | 'IO' is an instance of 'MonadRef0'.
+instance MonadRef0 IO where
+-- instance (MonadIO m, MonadTemplate m) => MonadRef0 m where
 
   {-# SPECIALISE instance MonadRef0 IO #-}
-
+  
   {-# INLINE newRef0 #-}
   newRef0 a =
     do x <- liftIO $ newIORef a
diff --git a/Simulation/Aivika/IO/Resource/Preemption.hs b/Simulation/Aivika/IO/Resource/Preemption.hs
--- a/Simulation/Aivika/IO/Resource/Preemption.hs
+++ b/Simulation/Aivika/IO/Resource/Preemption.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies, FlexibleInstances #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.Resource.Preemption
@@ -10,7 +10,7 @@
 -- Tested with: GHC 8.0.1
 --
 -- This module defines the preemptible resource, where
--- the 'MonadIO'-based monad can be an instance of 'MonadResource'.
+-- the 'IO' monad is an instance of 'MonadResource'.
 --
 module Simulation.Aivika.IO.Resource.Preemption () where
 
@@ -24,7 +24,6 @@
 import Simulation.Aivika.Trans.Exception
 import Simulation.Aivika.Trans.Ref.Base
 import Simulation.Aivika.Trans.DES
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Internal.Specs
 import Simulation.Aivika.Trans.Internal.Simulation
 import Simulation.Aivika.Trans.Internal.Event
@@ -38,30 +37,31 @@
 
 import qualified Simulation.Aivika.PriorityQueue as PQ
 
--- | The 'MonadIO' based monad is an instance of 'MonadResource'.
-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where
+-- | The 'IO' monad is an instance of 'MonadResource'.
+instance MonadResource IO where
+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where
 
   {-# SPECIALISE instance MonadResource IO #-}
 
   -- | A template-based implementation of the preemptible resource.
-  data Resource m = 
+  data Resource IO = 
     Resource { resourceMaxCount0 :: Maybe Int,
                -- ^ Return the maximum count of the resource, where 'Nothing'
                -- means that the resource has no upper bound.
                resourceCountRef :: IORef Int,
                resourceCountStatsRef :: IORef (TimingStats Int),
-               resourceCountSource :: SignalSource m Int,
+               resourceCountSource :: SignalSource IO Int,
                resourceUtilisationCountRef :: IORef Int,
                resourceUtilisationCountStatsRef :: IORef (TimingStats Int),
-               resourceUtilisationCountSource :: SignalSource m Int,
+               resourceUtilisationCountSource :: SignalSource IO Int,
                resourceQueueCountRef :: IORef Int,
                resourceQueueCountStatsRef :: IORef (TimingStats Int),
-               resourceQueueCountSource :: SignalSource m Int,
+               resourceQueueCountSource :: SignalSource IO Int,
                resourceTotalWaitTimeRef :: IORef Double,
                resourceWaitTimeRef :: IORef (SamplingStats Double),
-               resourceWaitTimeSource :: SignalSource m (),
-               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem m),
-               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem m) }
+               resourceWaitTimeSource :: SignalSource IO (),
+               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem IO),
+               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem IO) }
 
   {-# INLINABLE newResource #-}
   newResource count =
@@ -290,22 +290,27 @@
                           preemptedItemTime :: Double,
                           preemptedItemId :: ProcessId m }
 
-instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where
+instance Eq (Resource IO) where
+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where
 
   {-# INLINABLE (==) #-}
   x == y = resourceCountRef x == resourceCountRef y  -- unique references
 
-instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where
+instance Eq (ResourceActingItem IO) where
+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where
 
   {-# INLINABLE (==) #-}
   x == y = actingItemId x == actingItemId y
 
 -- | Release the resource increasing its count and resuming one of the
 -- previously suspended or preempted processes as possible.
-releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m)
-                    => Resource m
+releaseResource' :: Resource IO
                     -- ^ the resource to release
-                    -> Event m ()
+                    -> Event IO ()
+-- releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m)
+--                     => Resource m
+--                     -- ^ the resource to release
+--                     -> Event m ()
 {-# INLINABLE releaseResource' #-}
 releaseResource' r =
   Event $ \p ->
@@ -349,7 +354,8 @@
 
 -- | Preempt a process with the lowest priority that acquires yet the resource
 -- and decrease the count of available resource by 1. 
-decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()
+decResourceCount' :: Resource IO -> Event IO ()
+-- decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()
 {-# INLINABLE decResourceCount' #-}
 decResourceCount' r =
   Event $ \p ->
@@ -372,7 +378,8 @@
      invokeEvent p $ updateResourceCount r (-1)
 
 -- | Update the resource count and its statistics.
-updateResourceCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()
+updateResourceCount :: Resource IO -> Int -> Event IO ()
+-- updateResourceCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()
 {-# INLINABLE updateResourceCount #-}
 updateResourceCount r delta =
   Event $ \p ->
@@ -386,7 +393,8 @@
        triggerSignal (resourceCountSource r) a'
 
 -- | Update the resource queue length and its statistics.
-updateResourceQueueCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()
+updateResourceQueueCount :: Resource IO -> Int -> Event IO ()
+-- updateResourceQueueCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()
 {-# INLINABLE updateResourceQueueCount #-}
 updateResourceQueueCount r delta =
   Event $ \p ->
@@ -400,7 +408,8 @@
        triggerSignal (resourceQueueCountSource r) a'
 
 -- | Update the resource utilisation count and its statistics.
-updateResourceUtilisationCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()
+updateResourceUtilisationCount :: Resource IO -> Int -> Event IO ()
+-- updateResourceUtilisationCount :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Int -> Event m ()
 {-# INLINABLE updateResourceUtilisationCount #-}
 updateResourceUtilisationCount r delta =
   Event $ \p ->
@@ -414,7 +423,8 @@
        triggerSignal (resourceUtilisationCountSource r) a'
 
 -- | Update the resource wait time and its statistics.
-updateResourceWaitTime :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Double -> Event m ()
+updateResourceWaitTime :: Resource IO -> Double -> Event IO ()
+-- updateResourceWaitTime :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Double -> Event m ()
 {-# INLINABLE updateResourceWaitTime #-}
 updateResourceWaitTime r delta =
   Event $ \p ->
diff --git a/Simulation/Aivika/IO/Resource/Preemption/Base.hs b/Simulation/Aivika/IO/Resource/Preemption/Base.hs
--- a/Simulation/Aivika/IO/Resource/Preemption/Base.hs
+++ b/Simulation/Aivika/IO/Resource/Preemption/Base.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies, FlexibleInstances #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.Resource.Preemption.Base
@@ -9,8 +9,8 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- This module defines the optimised preemptible resource, where
--- the 'MonadIO'-based monad can be an instance of 'MonadResource'.
+-- This module defines an optimised preemptible resource, where
+-- the 'IO' monad is an instance of 'MonadResource'.
 --
 module Simulation.Aivika.IO.Resource.Preemption.Base () where
 
@@ -23,7 +23,6 @@
 import Simulation.Aivika.Trans.Exception
 import Simulation.Aivika.Trans.Ref.Base
 import Simulation.Aivika.Trans.DES
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Internal.Specs
 import Simulation.Aivika.Trans.Internal.Simulation
 import Simulation.Aivika.Trans.Internal.Event
@@ -35,17 +34,18 @@
 
 import qualified Simulation.Aivika.PriorityQueue as PQ
 
--- | The 'MonadIO' based monad is an instance of 'MonadResource'.
-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where
+-- | The 'IO' monad is an instance of 'MonadResource'.
+instance MonadResource IO where
+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadResource m where
 
   {-# SPECIALISE instance MonadResource IO #-}
 
   -- | A template-based implementation of the preemptible resource.
-  data Resource m = 
+  data Resource IO = 
     Resource { resourceMaxCount0 :: Maybe Int,
                resourceCountRef :: IORef Int,
-               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem m),
-               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem m) }
+               resourceActingQueue :: PQ.PriorityQueue (ResourceActingItem IO),
+               resourceWaitQueue :: PQ.PriorityQueue (ResourceAwaitingItem IO) }
 
   {-# INLINABLE newResource #-}
   newResource count =
@@ -189,17 +189,20 @@
 type ResourceAwaitingItem m =
   Either (ResourceRequestingItem m) (ResourcePreemptedItem m)
 
-instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where
+instance Eq (Resource IO) where
+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (Resource m) where
 
   {-# INLINABLE (==) #-}
   x == y = resourceCountRef x == resourceCountRef y  -- unique references
 
-instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where
+instance Eq (ResourceActingItem IO) where
+-- instance (MonadDES m, MonadIO m, MonadTemplate m) => Eq (ResourceActingItem m) where
 
   {-# INLINABLE (==) #-}
   x == y = actingItemId x == actingItemId y
 
-releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()
+releaseResource' :: Resource IO -> Event IO ()
+-- releaseResource' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()
 {-# INLINABLE releaseResource' #-}
 releaseResource' r =
   Event $ \p ->
@@ -236,7 +239,8 @@
                           do liftIO $ PQ.enqueue (resourceActingQueue r) (- priority) $ ResourceActingItem priority pid
                              invokeEvent p $ processPreemptionEnd pid
 
-decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()
+decResourceCount' :: Resource IO -> Event IO ()
+-- decResourceCount' :: (MonadDES m, MonadIO m, MonadTemplate m) => Resource m -> Event m ()
 {-# INLINABLE decResourceCount' #-}
 decResourceCount' r =
   Event $ \p ->
diff --git a/Simulation/Aivika/IO/SD.hs b/Simulation/Aivika/IO/SD.hs
--- a/Simulation/Aivika/IO/SD.hs
+++ b/Simulation/Aivika/IO/SD.hs
@@ -1,6 +1,4 @@
 
-{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
-
 -- |
 -- Module     : Simulation.Aivika.IO.SD
 -- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>
@@ -9,7 +7,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- It allows making the 'MonadIO'-based monad an instance of type class 'MonadSD'
+-- It makes the 'IO' monad an instance of type class 'MonadSD'
 -- used for System Dynamics (SD).
 --
 module Simulation.Aivika.IO.SD () where
@@ -22,9 +20,9 @@
 
 import Simulation.Aivika.Trans.Comp
 import Simulation.Aivika.Trans.SD
-import Simulation.Aivika.Trans.Template
 
--- | A template-based instantiation of the 'MonadSD' type class.
-instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m) => MonadSD m where
+-- | An instantiation of the 'MonadSD' type class.
+instance MonadSD IO where
+-- instance (Monad m, MonadComp m, MonadIO m, MonadTemplate m) => MonadSD m where
   
   {-# SPECIALISE instance MonadSD IO #-}
diff --git a/Simulation/Aivika/IO/Signal.hs b/Simulation/Aivika/IO/Signal.hs
--- a/Simulation/Aivika/IO/Signal.hs
+++ b/Simulation/Aivika/IO/Signal.hs
@@ -29,7 +29,6 @@
 import Simulation.Aivika.Trans.DES
 import Simulation.Aivika.Trans.Internal.Specs
 import Simulation.Aivika.Trans.Internal.Event
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Signal
 
 import Simulation.Aivika.IO.DES
@@ -45,16 +44,18 @@
                   signalHistoryValues :: V.Vector a }
 
 -- | Create a history of the signal values.
-newSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)
-                    => Signal m a -> Event m (SignalHistory m a)
+newSignalHistory :: Signal IO a -> Event IO (SignalHistory IO a)
+-- newSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)
+--                     => Signal m a -> Event m (SignalHistory m a)
 {-# INLINABLE newSignalHistory #-}
 newSignalHistory =
   newSignalHistoryStartingWith Nothing
 
 -- | Create a history of the signal values starting with
 -- the optional initial value.
-newSignalHistoryStartingWith :: (MonadDES m, MonadIO m, MonadTemplate m)
-                                => Maybe a -> Signal m a -> Event m (SignalHistory m a)
+newSignalHistoryStartingWith :: Maybe a -> Signal IO a -> Event IO (SignalHistory IO a)
+-- newSignalHistoryStartingWith :: (MonadDES m, MonadIO m, MonadTemplate m)
+--                                 => Maybe a -> Signal m a -> Event m (SignalHistory m a)
 {-# INLINABLE newSignalHistoryStartingWith #-}
 newSignalHistoryStartingWith init signal =
   Event $ \p ->
@@ -77,8 +78,9 @@
                             signalHistoryValues = xs }
        
 -- | Read the history of signal values.
-readSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)
-                     => SignalHistory m a -> Event m (Array Int Double, Array Int a)
+readSignalHistory :: SignalHistory IO a -> Event IO (Array Int Double, Array Int a)
+-- readSignalHistory :: (MonadDES m, MonadIO m, MonadTemplate m)
+--                      => SignalHistory m a -> Event m (Array Int Double, Array Int a)
 {-# INLINABLE readSignalHistory #-}
 readSignalHistory history =
   Event $ \p ->
diff --git a/Simulation/Aivika/IO/Var.hs b/Simulation/Aivika/IO/Var.hs
--- a/Simulation/Aivika/IO/Var.hs
+++ b/Simulation/Aivika/IO/Var.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE TypeFamilies, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies #-}
 
 -- |
 -- Module     : Simulation.Aivika.IO.Var
@@ -9,7 +9,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- The 'MonadIO'-based monad can be an instance 'MonadVar'.
+-- The 'IO' monad is an instance of 'MonadVar'.
 --
 module Simulation.Aivika.IO.Var () where
 
@@ -24,7 +24,6 @@
 import Simulation.Aivika.Trans.Internal.Event
 import Simulation.Aivika.Trans.Ref
 import Simulation.Aivika.Trans.Signal
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Var
 
 import Simulation.Aivika.IO.DES
@@ -32,17 +31,18 @@
 import qualified Simulation.Aivika.Vector as V
 import qualified Simulation.Aivika.Vector.Unboxed as UV
 
--- | The 'MonadIO' based monad is an instance of 'MonadVar'.
-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadVar m where
+-- | The 'IO' monad is an instance of 'MonadVar'.
+instance MonadVar IO where
+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m) => MonadVar m where
 
   {-# SPECIALISE instance MonadVar IO #-}
 
   -- | A template-based implementation of the variable.
-  data Var m a = 
+  data Var IO a = 
     Var { varXS    :: UV.Vector Double,
           varMS    :: V.Vector a,
           varYS    :: V.Vector a,
-          varChangedSource :: SignalSource m a }
+          varChangedSource :: SignalSource IO a }
 
   {-# INLINABLE newVar #-}
   newVar a =
diff --git a/Simulation/Aivika/IO/Var/Unboxed.hs b/Simulation/Aivika/IO/Var/Unboxed.hs
--- a/Simulation/Aivika/IO/Var/Unboxed.hs
+++ b/Simulation/Aivika/IO/Var/Unboxed.hs
@@ -9,7 +9,7 @@
 -- Stability  : experimental
 -- Tested with: GHC 8.0.1
 --
--- The 'MonadIO'-based monad can be an instance 'MonadVar'.
+-- The 'IO' monad can be an instance of 'MonadVar'.
 --
 module Simulation.Aivika.IO.Var.Unboxed () where
 
@@ -24,7 +24,6 @@
 import Simulation.Aivika.Trans.Internal.Event
 import Simulation.Aivika.Trans.Ref
 import Simulation.Aivika.Trans.Signal
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Var.Unboxed
 
 import Simulation.Aivika.IO.DES
@@ -32,19 +31,20 @@
 import Simulation.Aivika.Unboxed
 import qualified Simulation.Aivika.Vector.Unboxed as UV
 
--- | The 'MonadIO' based monad is an instance of 'MonadVar'.
-instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m, Unboxed a) => MonadVar m a where
+-- | The 'IO' monad can be an instance of 'MonadVar'.
+instance Unboxed a => MonadVar IO a where
+-- instance (Monad m, MonadDES m, MonadIO m, MonadTemplate m, Unboxed a) => MonadVar m a where
 
   {-# SPECIALISE instance MonadVar IO Double #-}
   {-# SPECIALISE instance MonadVar IO Float #-}
   {-# SPECIALISE instance MonadVar IO Int #-}
 
   -- | A template-based implementation of the variable.
-  data Var m a = 
+  data Var IO a = 
     Var { varXS    :: UV.Vector Double,
           varMS    :: UV.Vector a,
           varYS    :: UV.Vector a,
-          varChangedSource :: SignalSource m a }
+          varChangedSource :: SignalSource IO a }
      
   {-# INLINABLE newVar #-}
   newVar a =
diff --git a/Simulation/Aivika/Trans.hs b/Simulation/Aivika/Trans.hs
--- a/Simulation/Aivika/Trans.hs
+++ b/Simulation/Aivika/Trans.hs
@@ -57,7 +57,6 @@
         module Simulation.Aivika.Trans.Stream,
         module Simulation.Aivika.Trans.Stream.Random,
         module Simulation.Aivika.Trans.Task,
-        module Simulation.Aivika.Trans.Template,
         module Simulation.Aivika.Trans.Transform,
         module Simulation.Aivika.Trans.Transform.Extra,
         module Simulation.Aivika.Trans.Transform.Memo.Unboxed,
@@ -108,7 +107,6 @@
 import Simulation.Aivika.Trans.Stream
 import Simulation.Aivika.Trans.Stream.Random
 import Simulation.Aivika.Trans.Task
-import Simulation.Aivika.Trans.Template
 import Simulation.Aivika.Trans.Transform
 import Simulation.Aivika.Trans.Transform.Extra
 import Simulation.Aivika.Trans.Transform.Memo.Unboxed
diff --git a/Simulation/Aivika/Trans/DoubleLinkedList.hs b/Simulation/Aivika/Trans/DoubleLinkedList.hs
--- a/Simulation/Aivika/Trans/DoubleLinkedList.hs
+++ b/Simulation/Aivika/Trans/DoubleLinkedList.hs
@@ -18,9 +18,17 @@
         listAddLast,
         listRemoveFirst,
         listRemoveLast,
+        listRemove,
+        listRemoveBy,
+        listContains,
+        listContainsBy,
         listFirst,
-        listLast) where 
+        listLast,
+        clearList,
+        freezeList) where 
 
+import Data.Maybe
+
 import Control.Monad
 
 import Simulation.Aivika.Trans.Ref.Base
@@ -175,3 +183,74 @@
          error "Empty list: listLast"
        Just t ->
          return $ itemVal t
+
+-- | Remove the specified element from the list and return a flag
+-- indicating whether the element was found and removed.
+listRemove :: (Eq a, MonadRef m) => DoubleLinkedList m a -> a -> Event m Bool
+{-# INLINABLE listRemove #-}
+listRemove x v = fmap isJust $ listRemoveBy x (== v)
+
+-- | Remove an element satisfying the specified predicate and return
+-- the element if found.
+listRemoveBy :: MonadRef m => DoubleLinkedList m a -> (a -> Bool) -> Event m (Maybe a)
+{-# INLINABLE listRemoveBy #-}
+listRemoveBy x p = readRef (listHead x) >>= loop
+  where loop item =
+          case item of
+            Nothing   -> return Nothing
+            Just item ->
+              do let f = p (itemVal item)
+                 if not f
+                   then readRef (itemNext item) >>= loop
+                   else do size <- readRef (listSize x)
+                           prev <- readRef (itemPrev item)
+                           next <- readRef (itemNext item)
+                           writeRef (listSize x) (size - 1)
+                           case (prev, next) of
+                             (Nothing, Nothing) ->
+                               do writeRef (listHead x) Nothing
+                                  writeRef (listTail x) Nothing
+                             (Nothing, head' @ (Just item')) ->
+                               do writeRef (itemPrev item') Nothing
+                                  writeRef (listHead x) head'
+                             (tail' @ (Just item'), Nothing) ->
+                               do writeRef (itemNext item') Nothing
+                                  writeRef (listTail x) tail'
+                             (Just prev', Just next') ->
+                               do writeRef (itemNext prev') (Just next')
+                                  writeRef (itemPrev next') (Just prev')
+                           return (Just $ itemVal item)
+
+-- | Detect whether the specified element is contained in the list.
+listContains :: (Eq a, MonadRef m) => DoubleLinkedList m a -> a -> Event m Bool
+{-# INLINABLE listContains #-}
+listContains x v = fmap isJust $ listContainsBy x (== v)
+
+-- | Detect whether an element satisfying the specified predicate is contained in the list.
+listContainsBy :: MonadRef m => DoubleLinkedList m a -> (a -> Bool) -> Event m (Maybe a)
+{-# INLINABLE listContainsBy #-}
+listContainsBy x p = readRef (listHead x) >>= loop
+  where loop item =
+          case item of
+            Nothing   -> return Nothing
+            Just item ->
+              do let f = p (itemVal item)
+                 if not f
+                   then readRef (itemNext item) >>= loop
+                   else return $ Just (itemVal item)
+
+-- | Clear the contents of the list.
+clearList :: MonadRef m => DoubleLinkedList m a -> Event m ()
+{-# INLINABLE clearList #-}
+clearList q =
+  do writeRef (listHead q) Nothing
+     writeRef (listTail q) Nothing
+     writeRef (listSize q) 0
+
+-- | Freeze the list and return its contents.
+freezeList :: MonadRef m => DoubleLinkedList m a -> Event m [a]
+{-# INLINABLE freezeList #-}
+freezeList x = readRef (listTail x) >>= loop []
+  where loop acc Nothing     = return acc
+        loop acc (Just item) = readRef (itemPrev item) >>= loop (itemVal item : acc)
+  
diff --git a/Simulation/Aivika/Trans/Net.hs b/Simulation/Aivika/Trans/Net.hs
--- a/Simulation/Aivika/Trans/Net.hs
+++ b/Simulation/Aivika/Trans/Net.hs
@@ -106,15 +106,13 @@
   {-# INLINABLE (***) #-}
   (Net f) *** (Net g) =
     Net $ \(b, b') ->
-    do (c, p1) <- f b
-       (c', p2) <- g b'
+    do ((c, p1), (c', p2)) <- zipProcessParallel (f b) (g b')
        return ((c, c'), p1 *** p2)
        
   {-# INLINABLE (&&&) #-}
   (Net f) &&& (Net g) =
     Net $ \b ->
-    do (c, p1) <- f b
-       (c', p2) <- g b
+    do ((c, p1), (c', p2)) <- zipProcessParallel (f b) (g b)
        return ((c, c'), p1 &&& p2)
 
 instance MonadDES m => ArrowChoice (Net m) where
diff --git a/Simulation/Aivika/Trans/Processor.hs b/Simulation/Aivika/Trans/Processor.hs
--- a/Simulation/Aivika/Trans/Processor.hs
+++ b/Simulation/Aivika/Trans/Processor.hs
@@ -97,25 +97,25 @@
     Processor $ \xys ->
     Cons $
     do (xs, ys) <- liftSimulation $ unzipStream xys
-       runStream $ zipStreamSeq (f xs) ys
+       runStream $ zipStreamParallel (f xs) ys
 
   {-# INLINABLE second #-}
   second (Processor f) =
     Processor $ \xys ->
     Cons $
     do (xs, ys) <- liftSimulation $ unzipStream xys
-       runStream $ zipStreamSeq xs (f ys)
+       runStream $ zipStreamParallel xs (f ys)
 
   {-# INLINABLE (***) #-}
   Processor f *** Processor g =
     Processor $ \xys ->
     Cons $
     do (xs, ys) <- liftSimulation $ unzipStream xys
-       runStream $ zipStreamSeq (f xs) (g ys)
+       runStream $ zipStreamParallel (f xs) (g ys)
 
   {-# INLINABLE (&&&) #-}
   Processor f &&& Processor g =
-    Processor $ \xs -> zipStreamSeq (f xs) (g xs)
+    Processor $ \xs -> zipStreamParallel (f xs) (g xs)
 
 instance MonadDES m => ArrowChoice (Processor m) where
 
diff --git a/Simulation/Aivika/Trans/Template.hs b/Simulation/Aivika/Trans/Template.hs
deleted file mode 100644
--- a/Simulation/Aivika/Trans/Template.hs
+++ /dev/null
@@ -1,29 +0,0 @@
-
--- |
--- Module     : Simulation.Aivika.Trans.Template
--- Copyright  : Copyright (c) 2009-2016, David Sorokin <david.sorokin@gmail.com>
--- License    : BSD3
--- Maintainer : David Sorokin <david.sorokin@gmail.com>
--- Stability  : experimental
--- Tested with: GHC 8.0.1
---
--- It defines explicit type sub-classes of 'IO'-based monads on top of which
--- the simulation monads can be automatically generated.
---
-module Simulation.Aivika.Trans.Template
-       (MonadTemplate,
-        MonadEventQueueTemplate) where
-
-import Control.Monad.Trans
-
--- | It defines a type class based on which the simulation computations can be automatically generated.
-class Monad m => MonadTemplate m
-
--- | It defines a type class based on which the event queue can be automatically generated.
-class Monad m => MonadEventQueueTemplate m
-
--- | An instance of the type class.
-instance MonadTemplate IO
-
--- | An instance of the type class.
-instance MonadEventQueueTemplate IO
diff --git a/aivika-transformers.cabal b/aivika-transformers.cabal
--- a/aivika-transformers.cabal
+++ b/aivika-transformers.cabal
@@ -1,5 +1,5 @@
 name:            aivika-transformers
-version:         4.5.1
+version:         4.6
 synopsis:        Transformers for the Aivika simulation library
 description:
     This package is a generalization of the aivika [1] simulation library
@@ -43,6 +43,7 @@
                      examples/TimeOutWait.hs
                      examples/TruckHaulingSituation.hs
                      examples/WorkStationsInSeries.hs
+                     CHANGELOG.md
 
 library
 
@@ -107,7 +108,6 @@
                      Simulation.Aivika.Trans.SystemDynamics
                      Simulation.Aivika.Trans.Table
                      Simulation.Aivika.Trans.Task
-                     Simulation.Aivika.Trans.Template
                      Simulation.Aivika.Trans.Transform
                      Simulation.Aivika.Trans.Transform.Extra
                      Simulation.Aivika.Trans.Transform.Memo