diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,8 @@
 # Changelog for extensible-effects-concurrent
 
+## 0.25.0 
+- Improve effect type aliases and module structure, [read the details here](./ChangeLog-Details-0.25.0.md).
+        
 ## 0.24.3
 - Add `EmbedProtocol` related function `toEmbeddedOrigin`
     
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -37,6 +37,12 @@
 - A *multi-threaded* scheduler, based on the `async`
 - A *pure* single-threaded scheduler, based on coroutines
 
+For convenience, it is enough to import one of three modules:
+
+- `Control.Eff.Concurrent` for a multi threaded scheduler and `LoggingAndIo`
+- `Control.Eff.Concurrent.Pure`, for a single threaded scheduler and pure log capturing and otherwise no IO
+- `Control.Eff.Concurrent.SingleThreaded`, for a single threaded scheduler and totally impure logging via IO
+
 ### Process Life-Cycles and Interprocess Links
 
 All processes except the first process are **`spawned`** by existing 
diff --git a/examples/example-1/Main.hs b/examples/example-1/Main.hs
--- a/examples/example-1/Main.hs
+++ b/examples/example-1/Main.hs
@@ -6,7 +6,7 @@
 import           Control.Monad
 import           Data.Dynamic
 import           Control.Eff.Concurrent
-import           Control.Eff.Concurrent.Protocol.EffectfulServer
+import           Control.Eff.Concurrent.Protocol.EffectfulServer as Server
 import qualified Control.Exception             as Exc
 import qualified Data.Text as T
 import           Control.DeepSeq
@@ -41,10 +41,10 @@
 main :: IO ()
 main = defaultMain example
 
-mainProcessSpawnsAChildAndReturns :: HasCallStack => Eff InterruptableProcEff ()
+mainProcessSpawnsAChildAndReturns :: HasCallStack => Eff Effects ()
 mainProcessSpawnsAChildAndReturns = void (spawn "some child" (void receiveAnyMessage))
 
-example:: HasCallStack => Eff InterruptableProcEff ()
+example:: HasCallStack => Eff Effects ()
 example = do
   me <- self
   logInfo (T.pack ("I am " ++ show me))
@@ -73,10 +73,10 @@
             go
   go
 
-testServerLoop :: Eff InterruptableProcEff (Endpoint TestProtocol)
+testServerLoop :: Eff Effects (Endpoint TestProtocol)
 testServerLoop = start (genServer (const id) handleReq "test-server-1")
  where
-  handleReq :: GenServerId TestProtocol -> Event TestProtocol -> Eff InterruptableProcEff ()
+  handleReq :: GenServerId TestProtocol -> Event TestProtocol -> Eff Effects ()
   handleReq _myId (OnCall ser orig cm) =
     case cm of
       Terminate -> do
diff --git a/examples/example-2/Main.hs b/examples/example-2/Main.hs
--- a/examples/example-2/Main.hs
+++ b/examples/example-2/Main.hs
@@ -4,7 +4,7 @@
 
 import           Data.Dynamic
 import           Control.Eff
-import           Control.Eff.Concurrent
+import           Control.Eff.Concurrent.SingleThreaded
 import           Control.Eff.Concurrent.Protocol.StatefulServer
 import           Control.Monad
 import           Data.Foldable
@@ -33,8 +33,7 @@
   rnf Cnt = ()
 
 counterExample
-  :: (Typeable q, LogsTo IO q, Lifted IO q)
-  => Eff (InterruptableProcess q) ()
+  :: Eff Effects ()
 counterExample = do
   c <- spawnCounter
   let cp = _fromEndpoint c
@@ -124,15 +123,15 @@
 
     other -> logWarning (T.pack (show other))
 
-spawnCounter :: (LogsTo IO q, Lifted IO q) => Eff (InterruptableProcess q) ( Endpoint SupiCounter )
+spawnCounter :: (LogIo q) => Eff (Processes q) ( Endpoint SupiCounter )
 spawnCounter = start MkEmptySupiCounter
 
 
 deriving instance Show (Pdu Counter x)
 
 logCounterObservations
-  :: (LogsTo IO q, Lifted IO q, Typeable q)
-  => Eff (InterruptableProcess q) (Observer CounterChanged)
+  :: (LogIo q, Typeable q)
+  => Eff (Processes q) (Observer CounterChanged)
 logCounterObservations = do
   svr <- start OCCStart
   pure (toObserver svr)
diff --git a/examples/example-4/Main.hs b/examples/example-4/Main.hs
--- a/examples/example-4/Main.hs
+++ b/examples/example-4/Main.hs
@@ -14,7 +14,7 @@
 
 newtype WhoAreYou = WhoAreYou ProcessId deriving (Typeable, NFData, Show)
 
-firstExample :: (HasCallStack, Member Logs q) => Eff (InterruptableProcess q) ()
+firstExample :: (HasCallStack, Member Logs q) => Eff (Processes q) ()
 firstExample = do
   person <- spawn "first-example"
     (do
diff --git a/extensible-effects-concurrent.cabal b/extensible-effects-concurrent.cabal
--- a/extensible-effects-concurrent.cabal
+++ b/extensible-effects-concurrent.cabal
@@ -1,6 +1,6 @@
 cabal-version:  2.0
 name:           extensible-effects-concurrent
-version:        0.24.3
+version:        0.25.0
 description:    Please see the README on GitHub at <https://github.com/sheyll/extensible-effects-concurrent#readme>
 synopsis:       Message passing concurrency as extensible-effect
 homepage:       https://github.com/sheyll/extensible-effects-concurrent#readme
@@ -81,6 +81,8 @@
                   Control.Eff.LogWriter.UDP,
                   Control.Eff.LogWriter.UnixSocket,
                   Control.Eff.Concurrent,
+                  Control.Eff.Concurrent.Pure,
+                  Control.Eff.Concurrent.SingleThreaded,
                   Control.Eff.Concurrent.Protocol,
                   Control.Eff.Concurrent.Protocol.Client,
                   Control.Eff.Concurrent.Protocol.EffectfulServer,
diff --git a/src/Control/Eff/Concurrent.hs b/src/Control/Eff/Concurrent.hs
--- a/src/Control/Eff/Concurrent.hs
+++ b/src/Control/Eff/Concurrent.hs
@@ -1,5 +1,18 @@
 -- | Erlang style processes with message passing concurrency based on
 -- (more) @extensible-effects@.
+--
+-- This module re-exports most of the library.
+--
+-- There are several /scheduler/ implementations to choose from.
+--
+-- This module re-exports "Control.Eff.Concurrent.Process.ForkIOScheduler".
+--
+-- To use another scheduler implementation, don't import this module, but instead
+-- import one of:
+--
+-- * "Control.Eff.Concurrent.Pure"
+-- * "Control.Eff.Concurrent.SingleThreaded"
+--
 module Control.Eff.Concurrent
   (
     -- * Concurrent Processes with Message Passing Concurrency
@@ -9,9 +22,6 @@
     -- ** Concurrent Scheduler
     module Control.Eff.Concurrent.Process.ForkIOScheduler
   ,
-    -- ** Single Threaded Scheduler
-    module Control.Eff.Concurrent.Process.SingleThreadedScheduler
-  ,
     -- * Timers and Timeouts
     module Control.Eff.Concurrent.Process.Timer
   ,
@@ -69,7 +79,7 @@
                                                 , Serializer(..)
                                                 , ProcessId(..)
                                                 , fromProcessId
-                                                , ConsProcess
+                                                , SafeProcesses
                                                 , ResumeProcess(..)
                                                 , ProcessState(..)
                                                 , yieldProcess
@@ -135,7 +145,7 @@
                                                 , ExitRecovery(..)
                                                 , RecoverableInterrupt
                                                 , Interrupts
-                                                , InterruptableProcess
+                                                , Processes
                                                 , ExitSeverity(..)
                                                 , SomeExitReason(SomeExitReason)
                                                 , toExitRecovery
@@ -216,15 +226,10 @@
                                                 ( schedule
                                                 , defaultMain
                                                 , defaultMainWithLogWriter
-                                                , ProcEff
-                                                , InterruptableProcEff
-                                                , SchedulerIO
-                                                , HasSchedulerIO
-                                                )
-
-import           Control.Eff.Concurrent.Process.SingleThreadedScheduler
-                                                ( schedulePure
-                                                , defaultMainSingleThreaded
+                                                , SafeEffects
+                                                , Effects
+                                                , BaseEffects
+                                                , HasBaseEffects
                                                 )
 import           Control.Eff.Log
 import           Control.Eff.LogWriter.Async
diff --git a/src/Control/Eff/Concurrent/Process.hs b/src/Control/Eff/Concurrent/Process.hs
--- a/src/Control/Eff/Concurrent/Process.hs
+++ b/src/Control/Eff/Concurrent/Process.hs
@@ -31,7 +31,7 @@
     -- ** ProcessId Type
   , ProcessId(..)
   , fromProcessId
-  , ConsProcess
+  , SafeProcesses
   , ResumeProcess(..)
   -- ** Process State
   , ProcessState(..)
@@ -105,7 +105,7 @@
   , ExitRecovery(..)
   , RecoverableInterrupt
   , Interrupts
-  , InterruptableProcess
+  , Processes
   , ExitSeverity(..)
   , SomeExitReason(SomeExitReason)
   , toExitRecovery
@@ -643,20 +643,21 @@
 -- | 'Interrupt's which are 'Recoverable'.
 type RecoverableInterrupt = Interrupt 'Recoverable
 
--- | /Cons/ 'Process' onto a list of effects.
-type ConsProcess r = Process r ': r
+-- | This adds a layer of the 'Interrupts' effect on top of 'Processes'
+type Processes e = Interrupts ': SafeProcesses e
 
+-- | /Cons/ 'Process' onto a list of effects. This is called @SafeProcesses@ because
+-- the the actions cannot be interrupted in.
+type SafeProcesses r = Process r ': r
+
 -- | 'Exc'eptions containing 'Interrupt's.
 -- See 'handleInterrupts', 'exitOnInterrupt' or 'provideInterrupts'
 type Interrupts = Exc (Interrupt 'Recoverable)
 
--- | This adds a layer of the 'Interrupts' effect on top of 'Process'
-type InterruptableProcess e = Interrupts ': Process e ': e
-
--- | Handle all 'Interrupt's of an 'InterruptableProcess' by
+-- | Handle all 'Interrupt's of an 'Processes' by
 -- wrapping them up in 'interruptToExit' and then do a process 'Shutdown'.
 provideInterruptsShutdown
-  :: forall e a . Eff (InterruptableProcess e) a -> Eff (ConsProcess e) a
+  :: forall e a . Eff (Processes e) a -> Eff (SafeProcesses e) a
 provideInterruptsShutdown e = do
   res <- provideInterrupts e
   case res of
@@ -902,7 +903,7 @@
   :: forall r q
    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)
   => ProcessTitle
-  -> Eff (InterruptableProcess q) ()
+  -> Eff (Processes q) ()
   -> Eff r ProcessId
 spawn t child =
   executeAndResumeOrThrow (Spawn @q t (provideInterruptsShutdown child))
@@ -912,7 +913,7 @@
   :: forall r q
    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)
   => ProcessTitle
-  -> Eff (InterruptableProcess q) ()
+  -> Eff (Processes q) ()
   -> Eff r ()
 spawn_ t child = void (spawn t child)
 
@@ -923,20 +924,20 @@
   :: forall r q
    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)
   => ProcessTitle
-  -> Eff (InterruptableProcess q) ()
+  -> Eff (Processes q) ()
   -> Eff r ProcessId
 spawnLink t child =
   executeAndResumeOrThrow (SpawnLink @q t (provideInterruptsShutdown child))
 
 -- | Start a new process, the new process will execute an effect, the function
 -- will return immediately with a 'ProcessId'. The spawned process has only the
--- /raw/ 'ConsProcess' effects. For non-library code 'spawn' might be better
+-- /raw/ 'SafeProcesses' effects. For non-library code 'spawn' might be better
 -- suited.
 spawnRaw
   :: forall r q
    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)
   => ProcessTitle
-  -> Eff (ConsProcess q) ()
+  -> Eff (SafeProcesses q) ()
   -> Eff r ProcessId
 spawnRaw t child = executeAndResumeOrThrow (Spawn @q t child)
 
@@ -945,7 +946,7 @@
   :: forall r q
    . (HasCallStack, SetMember Process (Process q) r, Member Interrupts r)
   => ProcessTitle
-  -> Eff (ConsProcess q) ()
+  -> Eff (SafeProcesses q) ()
   -> Eff r ()
 spawnRaw_ t = void . spawnRaw t
 
diff --git a/src/Control/Eff/Concurrent/Process/ForkIOScheduler.hs b/src/Control/Eff/Concurrent/Process/ForkIOScheduler.hs
--- a/src/Control/Eff/Concurrent/Process/ForkIOScheduler.hs
+++ b/src/Control/Eff/Concurrent/Process/ForkIOScheduler.hs
@@ -14,10 +14,10 @@
   ( schedule
   , defaultMain
   , defaultMainWithLogWriter
-  , ProcEff
-  , InterruptableProcEff
-  , SchedulerIO
-  , HasSchedulerIO
+  , SafeEffects
+  , Effects
+  , BaseEffects
+  , HasBaseEffects
   )
 where
 
@@ -192,7 +192,7 @@
 -- | Create a new 'SchedulerState' run an IO action, catching all exceptions,
 -- and when the actions returns, clean up and kill all processes.
 withNewSchedulerState
-  :: (HasCallStack) => Eff SchedulerIO () -> Eff LoggingAndIo ()
+  :: (HasCallStack) => Eff BaseEffects () -> Eff LoggingAndIo ()
 withNewSchedulerState mainProcessAction = Safe.bracketWithError
   (lift (atomically newSchedulerState))
   (\exceptions schedulerState -> do
@@ -213,7 +213,7 @@
     return x
   )
  where
-  tearDownScheduler :: Eff SchedulerIO ()
+  tearDownScheduler :: Eff BaseEffects ()
   tearDownScheduler = do
     schedulerState <- getSchedulerState
     let cancelTableVar = schedulerState ^. processCancellationTable
@@ -243,28 +243,36 @@
       )
 
 -- | The concrete list of 'Eff'ects of processes compatible with this scheduler.
--- This builds upon 'SchedulerIO'.
-type ProcEff = ConsProcess SchedulerIO
+-- This builds upon 'BaseEffects'.
+--
+-- @since 0.25.0
+type SafeEffects = SafeProcesses BaseEffects
 
--- | The concrete list of the effects, that the 'Process' uses
-type InterruptableProcEff = InterruptableProcess SchedulerIO
+-- | The 'Eff'ects for interruptable, concurrent processes, scheduled via 'forkIO'.
+--
+-- @since 0.25.0
+type Effects = Processes BaseEffects
 
 -- | Type class constraint to indicate that an effect union contains the
 -- effects required by every process and the scheduler implementation itself.
-type HasSchedulerIO r = (HasCallStack, Lifted IO r, SchedulerIO <:: r)
+--
+-- @since 0.25.0
+type HasBaseEffects r = (HasCallStack, Lifted IO r, BaseEffects <:: r)
 
 -- | The concrete list of 'Eff'ects for this scheduler implementation.
-type SchedulerIO = (Reader SchedulerState : LoggingAndIo)
+--
+-- @since 0.25.0
+type BaseEffects = Reader SchedulerState : LoggingAndIo
 
 -- | Start the message passing concurrency system then execute a 'Process' on
--- top of 'SchedulerIO' effect. All logging is sent to standard output.
-defaultMain :: HasCallStack => Eff InterruptableProcEff () -> IO ()
+-- top of 'BaseEffects' effect. All logging is sent to standard output.
+defaultMain :: HasCallStack => Eff Effects () -> IO ()
 defaultMain = defaultMainWithLogWriter consoleLogWriter
 
 -- | Start the message passing concurrency system then execute a 'Process' on
--- top of 'SchedulerIO' effect. All logging is sent to standard output.
+-- top of 'BaseEffects' effect. All logging is sent to standard output.
 defaultMainWithLogWriter
-  :: HasCallStack => LogWriter IO -> Eff InterruptableProcEff () -> IO ()
+  :: HasCallStack => LogWriter IO -> Eff Effects () -> IO ()
 defaultMainWithLogWriter lw =
   runLift . withLogging lw . withAsyncLogWriter (1024 :: Int) . schedule
 
@@ -273,18 +281,18 @@
 handleProcess
   :: (HasCallStack)
   => ProcessInfo
-  -> Eff ProcEff (Interrupt 'NoRecovery)
-  -> Eff SchedulerIO (Interrupt 'NoRecovery)
+  -> Eff SafeEffects (Interrupt 'NoRecovery)
+  -> Eff BaseEffects (Interrupt 'NoRecovery)
 handleProcess myProcessInfo actionToRun = fix
   (handle_relay' singleStep (\er _nextRef -> return er))
   actionToRun
   0
  where
   singleStep
-    :: (Eff ProcEff xx -> (Int -> Eff SchedulerIO (Interrupt 'NoRecovery)))
-    -> Arrs ProcEff x xx
-    -> Process SchedulerIO x
-    -> (Int -> Eff SchedulerIO (Interrupt 'NoRecovery))
+    :: (Eff SafeEffects xx -> (Int -> Eff BaseEffects (Interrupt 'NoRecovery)))
+    -> Arrs SafeEffects x xx
+    -> Process BaseEffects x
+    -> (Int -> Eff BaseEffects (Interrupt 'NoRecovery))
   singleStep k q p !nextRef = stepProcessInterpreter
     nextRef
     p
@@ -303,8 +311,8 @@
   kontinueWith
     :: forall s v a
      . HasCallStack
-    => (s -> Arr SchedulerIO v a)
-    -> (s -> Arr SchedulerIO v a)
+    => (s -> Arr BaseEffects v a)
+    -> (s -> Arr BaseEffects v a)
   kontinueWith kontinue !nextRef !result = do
     setMyProcessState ProcessIdle
     lift yield
@@ -312,8 +320,8 @@
   diskontinueWith
     :: forall a
      . HasCallStack
-    => Arr SchedulerIO (Interrupt 'NoRecovery) a
-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a
+    => Arr BaseEffects (Interrupt 'NoRecovery) a
+    -> Arr BaseEffects (Interrupt 'NoRecovery) a
   diskontinueWith diskontinue !reason = do
     setMyProcessState ProcessShuttingDown
     diskontinue reason
@@ -321,10 +329,10 @@
     :: forall v a
      . HasCallStack
     => Int
-    -> Process SchedulerIO v
-    -> (Int -> Arr SchedulerIO v a)
-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a
-    -> Eff SchedulerIO a
+    -> Process BaseEffects v
+    -> (Int -> Arr BaseEffects v a)
+    -> Arr BaseEffects (Interrupt 'NoRecovery) a
+    -> Eff BaseEffects a
   stepProcessInterpreter !nextRef !request kontinue diskontinue =
     tryTakeNextShutdownRequest >>= maybe
       noShutdownRequested
@@ -361,10 +369,10 @@
   interpretRequestAfterShutdownRequest
     :: forall v a
      . HasCallStack
-    => Arr SchedulerIO (Interrupt 'NoRecovery) a
+    => Arr BaseEffects (Interrupt 'NoRecovery) a
     -> Interrupt 'NoRecovery
-    -> Process SchedulerIO v
-    -> Eff SchedulerIO a
+    -> Process BaseEffects v
+    -> Eff BaseEffects a
   interpretRequestAfterShutdownRequest diskontinue shutdownRequest = \case
     SendMessage   _ _ -> diskontinue shutdownRequest
     SendInterrupt _ _ -> diskontinue shutdownRequest
@@ -387,11 +395,11 @@
   interpretRequestAfterInterruptRequest
     :: forall v a
      . HasCallStack
-    => Arr SchedulerIO v a
-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a
+    => Arr BaseEffects v a
+    -> Arr BaseEffects (Interrupt 'NoRecovery) a
     -> Interrupt 'Recoverable
-    -> Process SchedulerIO v
-    -> Eff SchedulerIO a
+    -> Process BaseEffects v
+    -> Eff BaseEffects a
   interpretRequestAfterInterruptRequest kontinue diskontinue interruptRequest =
     \case
       SendMessage   _     _ -> kontinue (Interrupted interruptRequest)
@@ -416,11 +424,11 @@
   interpretRequest
     :: forall v a
      . HasCallStack
-    => (Int -> Arr SchedulerIO v a)
-    -> Arr SchedulerIO (Interrupt 'NoRecovery) a
+    => (Int -> Arr BaseEffects v a)
+    -> Arr BaseEffects (Interrupt 'NoRecovery) a
     -> Int
-    -> Process SchedulerIO v
-    -> Eff SchedulerIO a
+    -> Process BaseEffects v
+    -> Eff BaseEffects a
   interpretRequest kontinue diskontinue nextRef = \case
     SendMessage toPid msg ->
       interpretSend toPid msg >>= kontinue nextRef . ResumeWith
@@ -525,7 +533,7 @@
         >>= lift
         .   atomically
         .   enqueueShutdownRequest toPid msg
-    interpretFlush :: Eff SchedulerIO (ResumeProcess [StrictDynamic])
+    interpretFlush :: Eff BaseEffects (ResumeProcess [StrictDynamic])
     interpretFlush = do
       setMyProcessState ProcessBusyReceiving
       lift $ atomically $ do
@@ -534,7 +542,7 @@
         return (ResumeWith (toList (myMessageQ ^. incomingMessages)))
     interpretReceive
       :: MessageSelector b
-      -> Eff SchedulerIO (Either (Interrupt 'NoRecovery) (ResumeProcess b))
+      -> Eff BaseEffects (Either (Interrupt 'NoRecovery) (ResumeProcess b))
     interpretReceive f = do
       setMyProcessState ProcessBusyReceiving
       lift $ atomically $ do
@@ -561,9 +569,9 @@
         (runMessageSelector f m)
 
 -- | This is the main entry point to running a message passing concurrency
--- application. This function takes a 'Process' on top of the 'SchedulerIO'
+-- application. This function takes a 'Process' on top of the 'BaseEffects'
 -- effect for concurrent logging.
-schedule :: (HasCallStack) => Eff InterruptableProcEff () -> Eff LoggingAndIo ()
+schedule :: (HasCallStack) => Eff Effects () -> Eff LoggingAndIo ()
 schedule procEff =
   liftBaseWith
       (\runS -> Async.withAsync
@@ -585,8 +593,8 @@
   :: (HasCallStack)
   => Maybe ProcessInfo
   -> ProcessTitle
-  -> Eff ProcEff ()
-  -> Eff SchedulerIO (ProcessId, Async (Interrupt 'NoRecovery))
+  -> Eff SafeEffects ()
+  -> Eff BaseEffects (ProcessId, Async (Interrupt 'NoRecovery))
 spawnNewProcess mLinkedParent title mfa = do
   schedulerState <- getSchedulerState
   procInfo       <- allocateProcInfo schedulerState
@@ -619,7 +627,7 @@
           (maybe (Just (T.pack (printf "% 9s" (show pid)))) Just)
     in  censorLogs @IO addProcessId
   triggerProcessLinksAndMonitors
-    :: ProcessId -> Interrupt e -> TVar (Set ProcessId) -> Eff SchedulerIO ()
+    :: ProcessId -> Interrupt e -> TVar (Set ProcessId) -> Eff BaseEffects ()
   triggerProcessLinksAndMonitors !pid !reason !linkSetVar = do
     schedulerState <- getSchedulerState
     lift $ atomically $ triggerAndRemoveMonitor pid
@@ -670,7 +678,7 @@
   doForkProc
     :: ProcessInfo
     -> SchedulerState
-    -> Eff SchedulerIO (Async (Interrupt 'NoRecovery))
+    -> Eff BaseEffects (Async (Interrupt 'NoRecovery))
   doForkProc procInfo schedulerState = control
     (\inScheduler -> do
       let cancellationsVar = schedulerState ^. processCancellationTable
@@ -723,7 +731,7 @@
       return reason
 
 -- * Scheduler Accessor
-getSchedulerState :: HasSchedulerIO r => Eff r SchedulerState
+getSchedulerState :: HasBaseEffects r => Eff r SchedulerState
 getSchedulerState = ask
 
 enqueueMessageOtherProcess
diff --git a/src/Control/Eff/Concurrent/Process/Interactive.hs b/src/Control/Eff/Concurrent/Process/Interactive.hs
--- a/src/Control/Eff/Concurrent/Process/Interactive.hs
+++ b/src/Control/Eff/Concurrent/Process/Interactive.hs
@@ -50,14 +50,14 @@
 newtype SchedulerSession r = SchedulerSession (TMVar (SchedulerQueue r))
 
 newtype SchedulerQueue r =
-  SchedulerQueue (TChan (Eff (InterruptableProcess r) (Maybe String)))
+  SchedulerQueue (TChan (Eff (Processes r) (Maybe String)))
 
 -- | Fork a scheduler with a process that communicates with it via 'MVar',
 -- which is also the reason for the @Lift IO@ constraint.
 forkInteractiveScheduler
   :: forall r
    . (SetMember Lift (Lift IO) r)
-  => (Eff (InterruptableProcess r) () -> IO ())
+  => (Eff (Processes r) () -> IO ())
   -> IO (SchedulerSession r)
 forkInteractiveScheduler ioScheduler = do
   inQueue  <- newTChanIO
@@ -74,7 +74,7 @@
   return (SchedulerSession queueVar)
  where
   readEvalPrintLoop
-    :: TMVar (SchedulerQueue r) -> Eff (InterruptableProcess r) ()
+    :: TMVar (SchedulerQueue r) -> Eff (Processes r) ()
   readEvalPrintLoop queueVar = do
     nextActionOrExit <- readAction
     case nextActionOrExit of
@@ -107,7 +107,7 @@
   :: forall r a
    . (SetMember Lift (Lift IO) r)
   => SchedulerSession r
-  -> Eff (InterruptableProcess r) a
+  -> Eff (Processes r) a
   -> IO a
 submit (SchedulerSession qVar) theAction = do
   mResVar <- timeout 5000000 $ atomically
diff --git a/src/Control/Eff/Concurrent/Process/SingleThreadedScheduler.hs b/src/Control/Eff/Concurrent/Process/SingleThreadedScheduler.hs
--- a/src/Control/Eff/Concurrent/Process/SingleThreadedScheduler.hs
+++ b/src/Control/Eff/Concurrent/Process/SingleThreadedScheduler.hs
@@ -1,11 +1,20 @@
 -- | A coroutine based, single threaded scheduler for 'Process'es.
 module Control.Eff.Concurrent.Process.SingleThreadedScheduler
   ( scheduleM
-  , schedulePure
-  , scheduleIO
   , scheduleMonadIOEff
   , scheduleIOWithLogging
-  , defaultMainSingleThreaded
+  , schedulePure
+  , PureEffects
+  , PureSafeEffects
+  , PureBaseEffects
+  , HasPureBaseEffects
+  , defaultMain
+  , defaultMainWithLogWriter
+  , scheduleIO
+  , EffectsIo
+  , SafeEffectsIo
+  , BaseEffectsIo
+  , HasBaseEffectsIo
   )
 where
 
@@ -209,7 +218,7 @@
 --
 -- @since 0.3.0.2
 schedulePure
-  :: Eff (InterruptableProcess '[Logs, LogWriterReader PureLogWriter]) a
+  :: Eff (Processes '[Logs, LogWriterReader PureLogWriter]) a
   -> Either (Interrupt 'NoRecovery) a
 schedulePure e = run (scheduleM (withSomeLogging @PureLogWriter) (return ()) e)
 
@@ -220,7 +229,7 @@
 scheduleIO
   :: MonadIO m
   => (forall b . Eff r b -> Eff '[Lift m] b)
-  -> Eff (InterruptableProcess r) a
+  -> Eff (Processes r) a
   -> m (Either (Interrupt 'NoRecovery) a)
 scheduleIO r = scheduleM (runLift . r) (liftIO yield)
 
@@ -230,7 +239,7 @@
 -- @since 0.3.0.2
 scheduleMonadIOEff
   :: MonadIO (Eff r)
-  => Eff (InterruptableProcess r) a
+  => Eff (Processes r) a
   -> Eff r (Either (Interrupt 'NoRecovery) a)
 scheduleMonadIOEff = -- schedule (lift yield)
   scheduleM id (liftIO yield)
@@ -246,7 +255,7 @@
 scheduleIOWithLogging
   :: HasCallStack
   => LogWriter IO
-  -> Eff (InterruptableProcess LoggingAndIo) a
+  -> Eff EffectsIo a
   -> IO (Either (Interrupt 'NoRecovery) a)
 scheduleIOWithLogging h = scheduleIO (withLogging h)
 
@@ -273,7 +282,7 @@
   -> m () -- ^ An that performs a __yield__ w.r.t. the underlying effect
   --  @r@. E.g. if @Lift IO@ is present, this might be:
   --  @lift 'Control.Concurrent.yield'.
-  -> Eff (InterruptableProcess r) a
+  -> Eff (Processes r) a
   -> m (Either (Interrupt 'NoRecovery) a)
 scheduleM r y e = do
   c <- runAsCoroutinePure r (provideInterruptsShutdown e)
@@ -359,12 +368,12 @@
   :: forall v r m
    . Monad m
   => (forall a . Eff r a -> m a)
-  -> Eff (ConsProcess r) v
+  -> Eff (SafeProcesses r) v
   -> m (OnYield r v)
 runAsCoroutinePure r = r . fix (handle_relay' cont (return . OnDone))
  where
-  cont :: (Eff (ConsProcess r) v -> Eff r (OnYield r v))
-       -> Arrs (ConsProcess r) x v
+  cont :: (Eff (SafeProcesses r) v -> Eff r (OnYield r v))
+       -> Arrs (SafeProcesses r) x v
        -> Process r x
        -> Eff r (OnYield r v)
   cont k q FlushMessages                = return (OnFlushMessages (k . qApp q))
@@ -566,11 +575,80 @@
       nextTargets <- _runEff sts $ traverse deliverTheGoodNews targets
       return (nextTargets Seq.>< allButTarget)
 
--- | Execute a 'Process' using 'scheduleM' on top of 'Lift' @IO@ and 'withLogging'
--- @String@ effects.
-defaultMainSingleThreaded :: HasCallStack => Eff (InterruptableProcess LoggingAndIo) () -> IO ()
-defaultMainSingleThreaded =
+-- | Execute a 'Process' using 'scheduleM' on top of 'Lift' @IO@.
+-- All logging is written to the console using 'consoleLogWriter'.
+--
+-- To use another 'LogWriter' use 'defaultMainWithLogWriter' instead.
+defaultMain :: HasCallStack => Eff EffectsIo () -> IO ()
+defaultMain =
   void
     . runLift
     . withLogging consoleLogWriter
     . scheduleMonadIOEff
+
+-- | Execute a 'Process' using 'scheduleM' on top of 'Lift' @IO@.
+-- All logging is written using the given 'LogWriter'.
+--
+-- @since 0.25.0
+defaultMainWithLogWriter :: HasCallStack => LogWriter IO -> Eff EffectsIo () -> IO ()
+defaultMainWithLogWriter lw =
+  void
+    . runLift
+    . withLogging lw
+    . scheduleMonadIOEff
+
+
+-- | The effect list for 'Process' effects in the single threaded pure scheduler.
+--
+-- See 'PureBaseEffects' and 'Processes'
+--
+-- @since 0.25.0
+type PureEffects = Processes PureBaseEffects
+
+-- | The effect list for 'Process' effects in the single threaded pure scheduler.
+--  This is like 'SafeProcesses', no 'Interrupts' are present.
+--
+-- See 'PureBaseEffects' and 'SafeProcesses'
+--
+-- @since 0.25.0
+type PureSafeEffects = SafeProcesses PureBaseEffects
+
+-- | The effect list for a pure, single threaded scheduler contains only
+-- 'Logs' and the 'LogWriterReader' for 'PureLogWriter'.
+--
+-- @since 0.25.0
+type PureBaseEffects = '[Logs, LogWriterReader PureLogWriter]
+
+-- | Constraint for the existence of the underlying scheduler effects.
+--
+-- See 'PureBaseEffects'
+--
+-- @since 0.25.0
+type HasPureBaseEffects e = (HasCallStack, PureBaseEffects <:: e)
+
+-- | The effect list for 'Process' effects in the single threaded scheduler.
+--
+-- See 'BaseEffectsIo'
+--
+-- @since 0.25.0
+type EffectsIo = Processes BaseEffectsIo
+
+-- | The effect list for 'Process' effects in the single threaded scheduler.
+--  This is like 'SafeProcesses', no 'Interrupts' are present.
+--
+-- See 'BaseEffectsIo'.
+--
+-- @since 0.25.0
+type SafeEffectsIo = SafeProcesses BaseEffectsIo
+
+-- | The effect list for the underlying scheduler.
+--
+-- See 'LoggingAndIo'
+--
+-- @since 0.25.0
+type BaseEffectsIo = LoggingAndIo
+
+-- | Constraint for the existence of the underlying scheduler effects.
+--
+-- @since 0.25.0
+type HasBaseEffectsIo e = (HasCallStack, Lifted IO e, LoggingAndIo <:: e)
diff --git a/src/Control/Eff/Concurrent/Protocol/EffectfulServer.hs b/src/Control/Eff/Concurrent/Protocol/EffectfulServer.hs
--- a/src/Control/Eff/Concurrent/Protocol/EffectfulServer.hs
+++ b/src/Control/Eff/Concurrent/Protocol/EffectfulServer.hs
@@ -65,8 +65,8 @@
   -- | Effects of the implementation
   --
   -- @since 0.24.1
-  type Effects a e :: [Type -> Type]
-  type Effects a e = e
+  type ServerEffects a e :: [Type -> Type]
+  type ServerEffects a e = e
 
   -- | Return the 'ProcessTitle'.
   --
@@ -77,15 +77,15 @@
   serverTitle _ = fromString $ prettyTypeableShows (typeRep (Proxy @(ServerPdu a))) "-server"
 
   -- | Process the effects of the implementation
-  runEffects :: Init a e -> Eff (Effects a e) x -> Eff e x
+  runEffects :: Init a e -> Eff (ServerEffects a e) x -> Eff e x
 
-  default runEffects :: Effects a e ~ e => Init a e -> Eff (Effects a e) x -> Eff e x
+  default runEffects :: ServerEffects a e ~ e => Init a e -> Eff (ServerEffects a e) x -> Eff e x
   runEffects = const id
 
   -- | Update the 'Model' based on the 'Event'.
-  onEvent :: Init a e -> Event (ServerPdu a) -> Eff (Effects a e) ()
+  onEvent :: Init a e -> Event (ServerPdu a) -> Eff (ServerEffects a e) ()
 
-  default onEvent :: (Show (Init a e),  Member Logs (Effects a e)) => Init a e -> Event (ServerPdu a) -> Eff (Effects a e) ()
+  default onEvent :: (Show (Init a e),  Member Logs (ServerEffects a e)) => Init a e -> Event (ServerPdu a) -> Eff (ServerEffects a e) ()
   onEvent i e = logInfo ("unhandled: " <> T.pack (show i) <> " " <> T.pack (show e))
 
 
@@ -94,15 +94,15 @@
 -- @since 0.24.0
 start
   :: forall a q h
-  . ( Server a (InterruptableProcess q)
+  . ( Server a (Processes q)
     , Typeable a
     , Typeable (ServerPdu a)
-    , LogsTo h (InterruptableProcess q)
-    , SetMember Process (Process q) (Effects a (InterruptableProcess q))
-    , Member Interrupts             (Effects a (InterruptableProcess q))
+    , LogsTo h (Processes q)
+    , SetMember Process (Process q) (ServerEffects a (Processes q))
+    , Member Interrupts             (ServerEffects a (Processes q))
     , HasCallStack)
-  => Init a (InterruptableProcess q)
-  -> Eff (InterruptableProcess q) (Endpoint (ServerPdu a))
+  => Init a (Processes q)
+  -> Eff (Processes q) (Endpoint (ServerPdu a))
 start a = asEndpoint <$> spawn (serverTitle a) (protocolServerLoop a)
 
 -- | Execute the server loop.
@@ -112,13 +112,13 @@
   :: forall a q h
   . ( Typeable a
     , Typeable (ServerPdu a)
-    , Server a (InterruptableProcess q)
-    , LogsTo h (InterruptableProcess q)
-    , SetMember Process (Process q) (Effects a (InterruptableProcess q))
-    , Member Interrupts (Effects a (InterruptableProcess q))
+    , Server a (Processes q)
+    , LogsTo h (Processes q)
+    , SetMember Process (Process q) (ServerEffects a (Processes q))
+    , Member Interrupts (ServerEffects a (Processes q))
     , HasCallStack)
-  => Init a (InterruptableProcess q)
-  -> Eff (InterruptableProcess q) (Endpoint (ServerPdu a))
+  => Init a (Processes q)
+  -> Eff (Processes q) (Endpoint (ServerPdu a))
 startLink a = asEndpoint <$> spawnLink (serverTitle a) (protocolServerLoop a)
 
 -- | Execute the server loop.
@@ -126,14 +126,14 @@
 -- @since 0.24.0
 protocolServerLoop
      :: forall q h a
-     . ( Server a (InterruptableProcess q)
-       , LogsTo h (InterruptableProcess q)
-       , SetMember Process (Process q) (Effects a (InterruptableProcess q))
-       , Member Interrupts (Effects a (InterruptableProcess q))
+     . ( Server a (Processes q)
+       , LogsTo h (Processes q)
+       , SetMember Process (Process q) (ServerEffects a (Processes q))
+       , Member Interrupts (ServerEffects a (Processes q))
        , Typeable a
        , Typeable (ServerPdu a)
        )
-  => Init a (InterruptableProcess q) -> Eff (InterruptableProcess q) ()
+  => Init a (Processes q) -> Eff (Processes q) ()
 protocolServerLoop a = do
   myEp <- T.pack . show . asEndpoint @(ServerPdu a) <$> self
   censorLogs (lmAddEp myEp) $ do
@@ -154,7 +154,7 @@
     handleInt i = onEvent a (OnInterrupt i) *> pure Nothing
     mainLoop :: (Typeable a)
       => Either (Interrupt 'Recoverable) (Event (ServerPdu a))
-      -> Eff (Effects a (InterruptableProcess q)) (Maybe ())
+      -> Eff (ServerEffects a (Processes q)) (Maybe ())
     mainLoop (Left i) = handleInt i
     mainLoop (Right i) = onEvent a i *> pure Nothing
 
@@ -213,7 +213,7 @@
 -- This is such a helper. The @GenServer@ is a record with to callbacks,
 -- and a 'Server' instance that simply invokes the given callbacks.
 --
--- 'Server's that are directly based on 'LogIo' and 'InterruptableProcess' effects.
+-- 'Server's that are directly based on 'LogIo' and 'Processes' effects.
 --
 -- The name prefix @Gen@ indicates the inspiration from Erlang's @gen_server@ module.
 --
@@ -221,7 +221,7 @@
 data GenServer tag eLoop e where
   MkGenServer
     :: (TangibleGenServer tag eLoop e, HasCallStack) =>
-    { genServerRunEffects :: forall x . (Eff eLoop x -> Eff (InterruptableProcess e) x)
+    { genServerRunEffects :: forall x . (Eff eLoop x -> Eff (Processes e) x)
     , genServerOnEvent :: Event tag -> Eff eLoop ()
     } -> GenServer tag eLoop e
   deriving Typeable
@@ -254,10 +254,10 @@
       . prettyTypeableShows (typeOf px)
       )
 
-instance (TangibleGenServer tag eLoop e) => Server (GenServer (tag :: Type) eLoop e) (InterruptableProcess e) where
+instance (TangibleGenServer tag eLoop e) => Server (GenServer (tag :: Type) eLoop e) (Processes e) where
   type ServerPdu (GenServer tag eLoop e) = tag
-  type Effects (GenServer tag eLoop e) (InterruptableProcess e) = eLoop
-  data instance Init (GenServer tag eLoop e) (InterruptableProcess e) =
+  type ServerEffects (GenServer tag eLoop e) (Processes e) = eLoop
+  data instance Init (GenServer tag eLoop e) (Processes e) =
         GenServerInit
          { genServerCallbacks :: GenServer tag eLoop e
          , genServerId :: GenServerId tag
@@ -268,10 +268,10 @@
       (genServerRunEffects cb m)
   onEvent (GenServerInit cb _cId) req = genServerOnEvent cb req
 
-instance NFData (Init (GenServer tag eLoop e) (InterruptableProcess e)) where
+instance NFData (Init (GenServer tag eLoop e) (Processes e)) where
   rnf (GenServerInit _ x) = rnf x
 
-instance Typeable tag => Show (Init (GenServer tag eLoop e) (InterruptableProcess e)) where
+instance Typeable tag => Show (Init (GenServer tag eLoop e) (Processes e)) where
   showsPrec d (GenServerInit _ x) =
     showParen (d>=10)
       ( showsPrec 11 x
@@ -294,12 +294,12 @@
   :: forall tag eLoop e .
      ( HasCallStack
      , TangibleGenServer tag eLoop e
-     , Server (GenServer tag eLoop e) (InterruptableProcess e)
+     , Server (GenServer tag eLoop e) (Processes e)
      )
-  => (forall x . GenServerId tag -> Eff eLoop x -> Eff (InterruptableProcess e) x)
+  => (forall x . GenServerId tag -> Eff eLoop x -> Eff (Processes e) x)
   -> (GenServerId tag -> Event tag -> Eff eLoop ())
   -> GenServerId tag
-  -> Init (GenServer tag eLoop e) (InterruptableProcess e)
+  -> Init (GenServer tag eLoop e) (Processes e)
 genServer initCb stepCb i =
   GenServerInit
     { genServerId = i
diff --git a/src/Control/Eff/Concurrent/Protocol/Observer/Queue.hs b/src/Control/Eff/Concurrent/Protocol/Observer/Queue.hs
--- a/src/Control/Eff/Concurrent/Protocol/Observer/Queue.hs
+++ b/src/Control/Eff/Concurrent/Protocol/Observer/Queue.hs
@@ -140,10 +140,10 @@
      , TangiblePdu (Observer o) 'Asynchronous
      , Member Logs q
      , Lifted IO q
-     , LogsTo h (InterruptableProcess q)
+     , LogsTo h (Processes q)
      , HasCallStack)
   => ObservationQueue o
-  -> Eff (InterruptableProcess q) (Observer o)
+  -> Eff (Processes q) (Observer o)
 spawnLinkObservationQueueWriter q = do
   cbo <- startLink (MkObservationQueue q)
   pure (toObserver cbo)
diff --git a/src/Control/Eff/Concurrent/Protocol/StatefulServer.hs b/src/Control/Eff/Concurrent/Protocol/StatefulServer.hs
--- a/src/Control/Eff/Concurrent/Protocol/StatefulServer.hs
+++ b/src/Control/Eff/Concurrent/Protocol/StatefulServer.hs
@@ -81,19 +81,19 @@
   -- | Return an initial 'Model' and 'Settings'
   setup ::
        StartArgument a q
-    -> Eff (InterruptableProcess q) (Model a, Settings a)
+    -> Eff (Processes q) (Model a, Settings a)
 
   default setup ::
        (Default (Model a), Default (Settings a))
     => StartArgument a q
-    -> Eff (InterruptableProcess q) (Model a, Settings a)
+    -> Eff (Processes q) (Model a, Settings a)
   setup _ = pure (def, def)
 
   -- | Update the 'Model' based on the 'Event'.
   update ::
        StartArgument a q
     -> Effectful.Event (Protocol a)
-    -> Eff (ModelState a ': SettingsReader a ': InterruptableProcess q) ()
+    -> Eff (ModelState a ': SettingsReader a ': Processes q) ()
 
 -- | This type is used to build stateful 'EffectfulServer' instances.
 --
@@ -102,10 +102,10 @@
 -- @since 0.24.0
 data Stateful a deriving Typeable
 
-instance Server a q => Effectful.Server (Stateful a) (InterruptableProcess q) where
-  data Init (Stateful a) (InterruptableProcess q) = Init (StartArgument a q)
+instance Server a q => Effectful.Server (Stateful a) (Processes q) where
+  data Init (Stateful a) (Processes q) = Init (StartArgument a q)
   type ServerPdu (Stateful a) = Protocol a
-  type Effects (Stateful a) (InterruptableProcess q) = ModelState a ': SettingsReader a ': InterruptableProcess q
+  type ServerEffects (Stateful a) (Processes q) = ModelState a ': SettingsReader a ': Processes q
 
   runEffects (Init sa) m = do
     (st, env) <- setup sa
@@ -121,11 +121,11 @@
   :: forall a q h
   . ( HasCallStack
     , Typeable a
-    , LogsTo h (InterruptableProcess q)
-    , Effectful.Server (Stateful a) (InterruptableProcess q)
+    , LogsTo h (Processes q)
+    , Effectful.Server (Stateful a) (Processes q)
     , Server a q
     )
-  => StartArgument a q -> Eff (InterruptableProcess q) (Endpoint (Protocol a))
+  => StartArgument a q -> Eff (Processes q) (Endpoint (Protocol a))
 start = Effectful.start . Init
 
 -- | Execute the server loop.
@@ -135,11 +135,11 @@
   :: forall a q h
   . ( HasCallStack
     , Typeable a
-    , LogsTo h (InterruptableProcess q)
-    , Effectful.Server (Stateful a) (InterruptableProcess q)
+    , LogsTo h (Processes q)
+    , Effectful.Server (Stateful a) (Processes q)
     , Server a q
     )
-  => StartArgument a q -> Eff (InterruptableProcess q) (Endpoint (Protocol a))
+  => StartArgument a q -> Eff (Processes q) (Endpoint (Protocol a))
 startLink = Effectful.startLink . Init
 
 
diff --git a/src/Control/Eff/Concurrent/Protocol/Supervisor.hs b/src/Control/Eff/Concurrent/Protocol/Supervisor.hs
--- a/src/Control/Eff/Concurrent/Protocol/Supervisor.hs
+++ b/src/Control/Eff/Concurrent/Protocol/Supervisor.hs
@@ -252,13 +252,13 @@
 startSupervisor
   :: forall p e
   . ( HasCallStack
-    , LogsTo IO (InterruptableProcess e)
+    , LogsTo IO (Processes e)
     , Lifted IO e
     , TangibleSup p
     , Server (Sup p) e
     )
   => StartArgument (Sup p) e
-  -> Eff (InterruptableProcess e) (Endpoint (Sup p))
+  -> Eff (Processes e) (Endpoint (Sup p))
 startSupervisor = Server.start
 
 -- | Stop the supervisor and shutdown all processes.
diff --git a/src/Control/Eff/Concurrent/Pure.hs b/src/Control/Eff/Concurrent/Pure.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Eff/Concurrent/Pure.hs
@@ -0,0 +1,72 @@
+-- | Concurrent, communicating processes, executed using a pure, single-threaded scheduler.
+--
+-- This module re-exports most of the library.
+--
+-- There are several /scheduler/ implementations to choose from.
+--
+-- This module re-exports the pure parts of "Control.Eff.Concurrent.Process.SingleThreadedScheduler".
+--
+-- To use another scheduler implementation, don't import this module, but instead
+-- import one of:
+--
+-- * "Control.Eff.Concurrent"
+-- * "Control.Eff.Concurrent.SingleThreaded"
+--
+-- @since 0.25.0
+module Control.Eff.Concurrent.Pure
+  ( -- * Generic functions and type for Processes and Messages
+    module Control.Eff.Concurrent
+    -- * Scheduler
+  , schedule
+  , Effects
+  , SafeEffects
+  , BaseEffects
+  , HasBaseEffects
+  -- * External Libraries
+  ) where
+
+import Control.Eff
+import Control.Eff.Concurrent                  hiding
+                                                ( schedule
+                                                , defaultMain
+                                                , defaultMainWithLogWriter
+                                                , Effects
+                                                , SafeEffects
+                                                , BaseEffects
+                                                , HasBaseEffects
+                                                )
+
+import Control.Eff.Concurrent.Process.SingleThreadedScheduler
+
+-- | Run the 'Effects' using a single threaded, coroutine based, pure scheduler
+-- from "Control.Eff.Concurrent.Process.SingleThreadedScheduler".
+--
+-- @since 0.25.0
+schedule :: Eff Effects a -> Either (Interrupt 'NoRecovery) a
+schedule = schedulePure
+
+-- | The effect list for 'Process' effects in the single threaded pure scheduler.
+--
+-- See 'PureEffects'
+--
+-- @since 0.25.0
+type Effects = PureEffects
+
+-- | The effect list for 'Process' effects in the single threaded pure scheduler.
+--  This is like 'SafeProcesses', no 'Interrupts' are present.
+--
+-- See 'PureSafeEffects'
+--
+-- @since 0.25.0
+type SafeEffects = PureSafeEffects
+
+-- | The effect list for the underlying scheduler.
+--
+-- @since 0.25.0
+type BaseEffects = PureBaseEffects
+
+-- | Constraint for the existence of the underlying scheduler effects.
+--
+-- @since 0.25.0
+type HasBaseEffects e = HasPureBaseEffects e
+
diff --git a/src/Control/Eff/Concurrent/SingleThreaded.hs b/src/Control/Eff/Concurrent/SingleThreaded.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Eff/Concurrent/SingleThreaded.hs
@@ -0,0 +1,84 @@
+-- | Concurrent, communicating processes, executed using a single-threaded
+-- scheduler, with support for 'IO' and 'Logs'.
+--
+-- This module re-exports most of the library.
+--
+-- There are several /scheduler/ implementations to choose from.
+--
+-- This module re-exports the impure parts of "Control.Eff.Concurrent.Process.SingleThreadedScheduler".
+--
+-- To use another scheduler implementation, don't import this module, but instead
+-- import one of:
+--
+-- * "Control.Eff.Concurrent"
+-- * "Control.Eff.Concurrent.Pure"
+--
+-- @since 0.25.0
+module Control.Eff.Concurrent.SingleThreaded
+  ( -- * Generic functions and type for Processes and Messages
+    module Control.Eff.Concurrent
+    -- * Scheduler
+  , schedule
+  , defaultMain
+  , defaultMainWithLogWriter
+  , Effects
+  , SafeEffects
+  , BaseEffects
+  , HasBaseEffects
+  -- * External Libraries
+  ) where
+
+import Control.Eff
+import Control.Eff.Concurrent                  hiding
+                                                ( schedule
+                                                , defaultMain
+                                                , defaultMainWithLogWriter
+                                                , Effects
+                                                , SafeEffects
+                                                , BaseEffects
+                                                , HasBaseEffects
+                                                )
+
+import Control.Eff.Concurrent.Process.SingleThreadedScheduler
+import GHC.Stack (HasCallStack)
+
+-- | Run the 'Effects' using a single threaded, coroutine based, scheduler
+-- from "Control.Eff.Concurrent.Process.SingleThreadedScheduler".
+--
+-- @since 0.25.0
+schedule
+  :: HasCallStack
+  => LogWriter IO
+  -> Eff Effects a
+  -> IO (Either (Interrupt 'NoRecovery) a)
+schedule = scheduleIOWithLogging
+
+-- | The effect list for 'Process' effects in the single threaded scheduler.
+--
+-- See 'EffectsIo'
+--
+-- @since 0.25.0
+type Effects = EffectsIo
+
+-- | The effect list for 'Process' effects in the single threaded scheduler.
+--  This is like 'SafeProcesses', no 'Interrupts' are present.
+--
+-- See 'SafeEffectsIo'
+--
+-- @since 0.25.0
+type SafeEffects = SafeEffectsIo
+
+-- | The effect list for the underlying scheduler.
+--
+-- See 'BaseEffectsIo'
+--
+-- @since 0.25.0
+type BaseEffects = BaseEffectsIo
+
+-- | Constraint for the existence of the underlying scheduler effects.
+--
+-- See 'HasBaseEffectsIo'
+--
+-- @since 0.25.0
+type HasBaseEffects e = HasBaseEffectsIo e
+
diff --git a/test/Common.hs b/test/Common.hs
--- a/test/Common.hs
+++ b/test/Common.hs
@@ -18,7 +18,7 @@
 timeoutSeconds :: Integer -> Timeout
 timeoutSeconds seconds = Timeout (seconds * 1000000) (show seconds ++ "s")
 
-runTestCase :: TestName -> Eff InterruptableProcEff () -> TestTree
+runTestCase :: TestName -> Eff Effects () -> TestTree
 runTestCase msg =
   testCase msg .
   runLift . withTraceLogging "unit-tests" local0 allLogMessages . Scheduler.schedule . handleInterrupts onInt
@@ -36,9 +36,9 @@
     _ -> untilInterrupted pa
 
 scheduleAndAssert ::
-     forall r. (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
-  -> ((String -> Bool -> Eff (InterruptableProcess r) ()) -> Eff (InterruptableProcess r) ())
+     forall r. (LogIo r)
+  => IO (Eff (Processes r) () -> IO ())
+  -> ((String -> Bool -> Eff (Processes r) ()) -> Eff (Processes r) ())
   -> IO ()
 scheduleAndAssert schedulerFactory testCaseAction =
   withFrozenCallStack $ do
@@ -52,8 +52,8 @@
 
 applySchedulerFactory ::
      forall r. (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
-  -> Eff (InterruptableProcess r) ()
+  => IO (Eff (Processes r) () -> IO ())
+  -> Eff (Processes r) ()
   -> IO ()
 applySchedulerFactory factory procAction = do
   scheduler <- factory
diff --git a/test/ForkIOScheduler.hs b/test/ForkIOScheduler.hs
--- a/test/ForkIOScheduler.hs
+++ b/test/ForkIOScheduler.hs
@@ -53,21 +53,21 @@
           assertBool "the other process was still running" wasStillRunningP1
   | (busyWith , busyEffect) <-
     [ ( "receiving"
-      , void (send (ReceiveSelectedMessage @SchedulerIO selectAnyMessage))
+      , void (send (ReceiveSelectedMessage @BaseEffects selectAnyMessage))
       )
     , ( "sending"
-      , void (send (SendMessage @SchedulerIO 44444 (toStrictDynamic ("test message" :: String))))
+      , void (send (SendMessage @BaseEffects 44444 (toStrictDynamic ("test message" :: String))))
       )
     , ( "sending shutdown"
-      , void (send (SendShutdown @SchedulerIO 44444 ExitNormally))
+      , void (send (SendShutdown @BaseEffects 44444 ExitNormally))
       )
-    , ("selfpid-ing", void (send (SelfPid @SchedulerIO)))
+    , ("selfpid-ing", void (send (SelfPid @BaseEffects)))
     , ( "spawn-ing"
       , void
         (send
-          (Spawn @SchedulerIO  "test"
+          (Spawn @BaseEffects  "test"
             (void
-              (send (ReceiveSelectedMessage @SchedulerIO selectAnyMessage))
+              (send (ReceiveSelectedMessage @BaseEffects selectAnyMessage))
             )
           )
         )
diff --git a/test/Interactive.hs b/test/Interactive.hs
--- a/test/Interactive.hs
+++ b/test/Interactive.hs
@@ -15,19 +15,19 @@
 test_interactive :: TestTree
 test_interactive = setTravisTestOptions $ testGroup
   "Interactive"
-  [ testGroup "SingleThreadedScheduler" $ allTests SingleThreaded.defaultMainSingleThreaded
+  [ testGroup "SingleThreadedScheduler" $ allTests SingleThreaded.defaultMain
   , testGroup "ForkIOScheduler" $ allTests ForkIOScheduler.defaultMain
   ]
 
 allTests
   :: SetMember Lift (Lift IO) r
-  => (Eff (InterruptableProcess r) () -> IO ())
+  => (Eff (Processes r) () -> IO ())
   -> [TestTree]
 allTests scheduler = [happyCaseTest scheduler]
 
 happyCaseTest
   :: SetMember Lift (Lift IO) r
-  => (Eff (InterruptableProcess r) () -> IO ())
+  => (Eff (Processes r) () -> IO ())
   -> TestTree
 happyCaseTest scheduler =
   testCase "start, wait and stop interactive scheduler" $ do
diff --git a/test/ProcessBehaviourTestCases.hs b/test/ProcessBehaviourTestCases.hs
--- a/test/ProcessBehaviourTestCases.hs
+++ b/test/ProcessBehaviourTestCases.hs
@@ -65,7 +65,7 @@
 allTests
   :: forall r
    . (Lifted IO r, LogsTo IO r, Typeable r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 allTests schedulerFactory = localOption
   (timeoutSeconds 300)
@@ -124,7 +124,7 @@
 returnToSenderServer
   :: forall q
    . (HasCallStack, Lifted IO q, LogsTo IO q, Member Logs q, Typeable q)
-  => Eff (InterruptableProcess q) (Endpoint ReturnToSender)
+  => Eff (Processes q) (Endpoint ReturnToSender)
 returnToSenderServer = start
   (genServer @ReturnToSender
     (const id)
@@ -148,7 +148,7 @@
 selectiveReceiveTests
   :: forall r
    . (Lifted IO r, LogsTo IO r, Typeable r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 selectiveReceiveTests schedulerFactory = setTravisTestOptions
   (testGroup
@@ -160,7 +160,7 @@
           nMax = 10
           receiverLoop donePid = go nMax
            where
-            go :: Int -> Eff (InterruptableProcess r) ()
+            go :: Int -> Eff (Processes r) ()
             go 0 = sendMessage donePid True
             go n = do
               void $ receiveSelectedMessage (filterMessage (== n))
@@ -201,7 +201,7 @@
 yieldLoopTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 yieldLoopTests schedulerFactory =
   let maxN = 100000
@@ -243,7 +243,7 @@
 pingPongTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 pingPongTests schedulerFactory = testGroup
   "Yield Tests"
@@ -318,7 +318,7 @@
 errorTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 errorTests schedulerFactory = testGroup
   "causing and handling errors"
@@ -363,7 +363,7 @@
 concurrencyTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 concurrencyTests schedulerFactory =
   let n = 100
@@ -474,7 +474,7 @@
 exitTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 exitTests schedulerFactory =
   testGroup "process exit tests"
@@ -624,7 +624,7 @@
 sendShutdownTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 sendShutdownTests schedulerFactory = testGroup
   "sendShutdown"
@@ -717,7 +717,7 @@
 linkingTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 linkingTests schedulerFactory = setTravisTestOptions
   (testGroup
@@ -931,7 +931,7 @@
 monitoringTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 monitoringTests schedulerFactory = setTravisTestOptions
   (testGroup
@@ -1001,7 +1001,7 @@
 timerTests
   :: forall r
    . (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 timerTests schedulerFactory = setTravisTestOptions
   (testGroup
@@ -1057,7 +1057,7 @@
 
 processDetailsTests ::
      forall r. (Lifted IO r, LogsTo IO r)
-  => IO (Eff (InterruptableProcess r) () -> IO ())
+  => IO (Eff (Processes r) () -> IO ())
   -> TestTree
 processDetailsTests schedulerFactory =
   setTravisTestOptions
diff --git a/test/SingleThreadedScheduler.hs b/test/SingleThreadedScheduler.hs
--- a/test/SingleThreadedScheduler.hs
+++ b/test/SingleThreadedScheduler.hs
@@ -38,7 +38,7 @@
 test_mainProcessSpawnsAChildAndExitsNormally = setTravisTestOptions
     (testCase
         "spawn a child and exit normally"
-        (Scheduler.defaultMainSingleThreaded
+        (Scheduler.defaultMain
             (do
                 void (spawn "test" (void receiveAnyMessage))
                 void exitNormally
@@ -52,7 +52,7 @@
 test_mainProcessSpawnsAChildBothExitNormally = setTravisTestOptions
     (testCase
         "spawn a child and let it exit and exit"
-        (Scheduler.defaultMainSingleThreaded
+        (Scheduler.defaultMain
             (do
                 child <- spawn "test"
                     (do
diff --git a/test/SupervisorTests.hs b/test/SupervisorTests.hs
--- a/test/SupervisorTests.hs
+++ b/test/SupervisorTests.hs
@@ -37,7 +37,7 @@
                  () <- receiveMessage
                  Sup.stopSupervisor sup
              unlinkProcess testWorker
-             sup <- receiveMessage :: Eff InterruptableProcEff  (Endpoint (Sup.Sup TestProtocol))
+             sup <- receiveMessage :: Eff Effects  (Endpoint (Sup.Sup TestProtocol))
              supAliveAfter1 <- isSupervisorAlive sup
              logInfo ("still alive 1: " <> pack (show supAliveAfter1))
              lift (supAliveAfter1 @=? True)
@@ -264,7 +264,7 @@
   | ExitWhenRequested
   deriving Eq
 
-instance Server TestProtocol SchedulerIO where
+instance Server TestProtocol BaseEffects where
   update (TestServerArgs testMode tId) evt =
     case evt of
       OnCast (TestInterruptWith i) -> do
@@ -283,6 +283,6 @@
             exitBecause (interruptToExit x)
       _ ->
         logDebug (pack (show tId) <> ": got some info: " <> pack (show evt))
-  data instance StartArgument TestProtocol SchedulerIO = TestServerArgs TestProtocolServerMode Int
+  data instance StartArgument TestProtocol BaseEffects = TestServerArgs TestProtocolServerMode Int
 
 type instance ChildId TestProtocol = Int