diff --git a/Spec/Spec.hs b/Spec/Spec.hs
deleted file mode 100644
--- a/Spec/Spec.hs
+++ /dev/null
@@ -1,1 +0,0 @@
-{-# OPTIONS_GHC -F -pgmF hspec-discover #-}
diff --git a/Src/GameEngine.hs b/Src/GameEngine.hs
deleted file mode 100644
--- a/Src/GameEngine.hs
+++ /dev/null
@@ -1,90 +0,0 @@
-{- |
-
-Haskell library for creating simple deterministic games,
-such as tic-tac-toe. The engine requires a minimal set of
-actions related to the game, and then will run the game
-until a terminal state is reached.
-
-Simple generic example below. See the specs for a more detailed example.
-
-> import GameEngine
->
-> game :: GameEngine Int Int
-> game = GameEngine gameActions initialState
->
-> gameActions :: GameActions Int Int
-> gameActions = GameActions {
->    getPlayer  = -- find the next player from a game state,
->    getMove    = -- find a move from the game state,
->    getResult  = -- transitions from a state to another state,
->    isTerminal = -- determines if the game is terminal,
->    getScore   = -- get score from a terminal state
->  }
->
-> initialState :: GameState Int
-> initialState = GameState 0
->
-> -- run the game engine until a terminal state is reached
-> playSimple game
-
--}
-
-{-# LANGUAGE RankNTypes #-}
-
-
-module GameEngine (
-    Symbol,
-    GameState(..),
-    Player(..),
-    Move(..),
-    GameActions(..),
-    GameEngine(..),
-    play,
-    playSimple,
-    playIO
-  ) where
-
-
-import Control.Monad.Identity
-import GameEngine.GameState
-import GameEngine.GameActions
-import GameEngine.Move
-import GameEngine.Player
-
-
-data GameEngine a b = GameEngine {
-    actions :: GameActions a b,
-    -- ^ Defines how the game will be played
-
-    state   :: GameState a
-    -- ^ The current state of the game
-  }
--- ^ Holds information about how the game is played, and the current state of the game.
-
-
--- TODO: provided function should be forced to be an identity only function
--- forall a. a -> m a
-play :: Monad m => (GameState a -> m (GameState a)) -> GameEngine a b -> m Int
--- ^ Run the provided game engine under a monadic context until a terminal state is reached.
--- Note: provided function should act as an identity only, and should not modify the game state.
-play f engine
-  | performWithState isTerminal engine = return . performWithState getScore engine $ performWithState getPlayer engine
-  | otherwise = f (getNextState engine) >>= play f . GameEngine (actions engine)
-
-
-playSimple :: GameEngine a b -> Int
--- ^ Run the provided game engine without a context until a terminal state is reached.
-playSimple = runIdentity . play Identity
-
-
-playIO :: (GameState a -> IO ()) -> GameEngine a b -> IO Int
--- ^ Run the provided game engine within an IO context until a terminal state is reached.
-playIO f = play (\x -> f x >> return x)
-
-
-getNextState :: GameEngine a b -> GameState a
-getNextState engine = performWithState getResult engine $ performWithState getMove engine
-
-
-performWithState :: (GameActions a b -> GameState a -> c) -> GameEngine a b -> c
-performWithState f engine = f (actions engine) $ state engine
diff --git a/Src/GameEngine/GameActions.hs b/Src/GameEngine/GameActions.hs
deleted file mode 100644
--- a/Src/GameEngine/GameActions.hs
+++ /dev/null
@@ -1,27 +0,0 @@
-module GameEngine.GameActions (
-    GameActions(..)
-  ) where
-
-
-import GameEngine.Player
-import GameEngine.Move
-import GameEngine.GameState
-
-
-data GameActions a b = GameActions {
-    getPlayer  :: GameState a -> Player,
-    -- ^ Specifies which player has the move in the state
-
-    getMove    :: GameState a -> Move b,
-    -- ^ Returns a legal move in the state
-
-    getResult  :: GameState a -> Move b -> GameState a,
-    -- ^ The transition model, which determines the result of a move
-
-    isTerminal :: GameState a -> Bool,
-    -- ^ True if game is over, False otherwise
-
-    getScore   :: GameState a -> Player -> Int
-    -- ^ A utility function to determine the numeric value for a game that ends in a terminal state
-  }
--- ^ Set of actions that defines how the game will be played
diff --git a/Src/GameEngine/GameState.hs b/Src/GameEngine/GameState.hs
deleted file mode 100644
--- a/Src/GameEngine/GameState.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module GameEngine.GameState (
-    GameState(..)
-  ) where
-
-
-data GameState a = GameState a deriving (Eq, Show)
diff --git a/Src/GameEngine/Move.hs b/Src/GameEngine/Move.hs
deleted file mode 100644
--- a/Src/GameEngine/Move.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module GameEngine.Move (
-    Move(..)
-  ) where
-
-
-data Move a = Move a deriving (Eq, Show)
diff --git a/Src/GameEngine/Player.hs b/Src/GameEngine/Player.hs
deleted file mode 100644
--- a/Src/GameEngine/Player.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module GameEngine.Player (
-    Symbol,
-    Player(..)
-  ) where
-
-
-type Symbol = Char
-
-
-data Player = Player Symbol deriving (Eq, Show)
diff --git a/deterministic-game-engine.cabal b/deterministic-game-engine.cabal
--- a/deterministic-game-engine.cabal
+++ b/deterministic-game-engine.cabal
@@ -1,5 +1,5 @@
 name:                deterministic-game-engine
-version:             0.2.1
+version:             0.3.0
 synopsis:            Simple deterministic game engine
 description:         Haskell library for creating simple deterministic games,
                      such as tic-tac-toe. The engine requires a minimal set of
@@ -22,12 +22,12 @@
 
 
 library
-  hs-source-dirs:      Src
-  exposed-modules:     GameEngine
-  other-modules:       GameEngine.GameActions,
-                       GameEngine.GameState,
-                       GameEngine.Move,
-                       GameEngine.Player
+  hs-source-dirs:      src
+  exposed-modules:     Game.Deterministic.GameEngine
+  other-modules:       Game.Deterministic.GameEngine.GameActions,
+                       Game.Deterministic.GameEngine.GameState,
+                       Game.Deterministic.GameEngine.Move,
+                       Game.Deterministic.GameEngine.Player
 
   build-depends:       base <5.0,
                        mtl
@@ -36,12 +36,12 @@
 
 
 test-suite test
-  hs-source-dirs:      Spec
+  hs-source-dirs:      spec
   main-is:             Spec.hs
   ghc-options:         -Wall
   type:                exitcode-stdio-1.0
   build-depends:       base <5.0,
                        hspec >=2.1 && <2.2,
-                       deterministic-game-engine ==0.2.1
+                       deterministic-game-engine ==0.3.0
 
   default-language:    Haskell2010
diff --git a/spec/Spec.hs b/spec/Spec.hs
new file mode 100644
--- /dev/null
+++ b/spec/Spec.hs
@@ -0,0 +1,1 @@
+{-# OPTIONS_GHC -F -pgmF hspec-discover #-}
diff --git a/src/Game/Deterministic/GameEngine.hs b/src/Game/Deterministic/GameEngine.hs
new file mode 100644
--- /dev/null
+++ b/src/Game/Deterministic/GameEngine.hs
@@ -0,0 +1,103 @@
+{- |
+
+Haskell library for creating simple deterministic games,
+such as tic-tac-toe. The engine requires a minimal set of
+actions related to the game, and then will run the game
+until a terminal state is reached.
+
+Simple generic example below. See the specs for a more detailed example.
+
+> import GameEngine
+>
+> game :: GameEngine Int Int
+> game = GameEngine gameActions initialState
+>
+> gameActions :: GameActions Int Int
+> gameActions = GameActions {
+>    getPlayer  = -- find the next player from a game state,
+>    getMove    = -- find a move from the game state,
+>    getResult  = -- transitions from a state to another state,
+>    isTerminal = -- determines if the game is terminal,
+>    getScore   = -- get score from a terminal state
+>  }
+>
+> initialState :: GameState Int
+> initialState = GameState 0
+>
+> -- run the game engine until a terminal state is reached
+> playSimple game
+
+-}
+
+{-# LANGUAGE RankNTypes #-}
+
+
+module Game.Deterministic.GameEngine (
+    Symbol,
+    GameState(..),
+    Player(..),
+    Move(..),
+    GameActions(..),
+    GameEngine(..),
+    GameEngineSimple,
+    GameEngineIO,
+    play,
+    playSimple,
+    playIO
+  ) where
+
+
+import           Control.Monad.Identity
+import           Game.Deterministic.GameEngine.GameActions
+import           Game.Deterministic.GameEngine.GameState
+import           Game.Deterministic.GameEngine.Move
+import           Game.Deterministic.GameEngine.Player
+
+
+data GameEngine m a b = GameEngine {
+    actions :: GameActions m a b,
+    -- ^ Defines how the game will be played
+
+    state   :: GameState a
+    -- ^ The current state of the game
+  }
+-- ^ Holds information about how the game is played, and the current state of the game.
+
+
+type GameEngineSimple a b = GameEngine Identity a b
+type GameEngineIO a b = GameEngine IO a b
+
+
+play :: Monad m => GameEngine m a b -> m Int
+-- ^ Run the provided game engine under a monadic context until a terminal state is reached.
+play engine = do
+  isTerm <- isTerminal gameActions gameState
+
+  if isTerm then do
+    player <- getPlayer gameActions gameState
+    getScore gameActions gameState player
+    else do
+      nextState <- getNextState engine
+      play $ GameEngine (actions engine) nextState
+  where
+    gameActions = actions engine
+    gameState = state engine
+
+
+playSimple :: GameEngineSimple a b -> Int
+-- ^ Run the provided game engine without a context until a terminal state is reached.
+playSimple = runIdentity . play
+
+
+playIO :: GameEngineIO a b -> IO Int
+-- ^ Run the provided game engine within an IO context until a terminal state is reached.
+playIO = play
+
+
+getNextState :: Monad m => GameEngine m a b -> m (GameState a)
+getNextState engine = do
+  nextMove <- getMove gameActions gameState
+  getResult gameActions gameState nextMove
+  where
+    gameActions = actions engine
+    gameState = state engine
diff --git a/src/Game/Deterministic/GameEngine/GameActions.hs b/src/Game/Deterministic/GameEngine/GameActions.hs
new file mode 100644
--- /dev/null
+++ b/src/Game/Deterministic/GameEngine/GameActions.hs
@@ -0,0 +1,27 @@
+module Game.Deterministic.GameEngine.GameActions (
+    GameActions(..)
+  ) where
+
+
+import           Game.Deterministic.GameEngine.GameState
+import           Game.Deterministic.GameEngine.Move
+import           Game.Deterministic.GameEngine.Player
+
+
+data GameActions m a b = GameActions {
+    getPlayer  :: GameState a -> m Player,
+    -- ^ Specifies which player has the move in the state
+
+    getMove    :: GameState a -> m (Move b),
+    -- ^ Returns a legal move in the state
+
+    getResult  :: GameState a -> Move b -> m (GameState a),
+    -- ^ The transition model, which determines the result of a move
+
+    isTerminal :: GameState a -> m Bool,
+    -- ^ True if game is over, False otherwise
+
+    getScore   :: GameState a -> Player -> m Int
+    -- ^ A utility function to determine the numeric value for a game that ends in a terminal state
+  }
+-- ^ Set of actions that defines how the game will be played
diff --git a/src/Game/Deterministic/GameEngine/GameState.hs b/src/Game/Deterministic/GameEngine/GameState.hs
new file mode 100644
--- /dev/null
+++ b/src/Game/Deterministic/GameEngine/GameState.hs
@@ -0,0 +1,6 @@
+module Game.Deterministic.GameEngine.GameState (
+    GameState(..)
+  ) where
+
+
+data GameState a = GameState a deriving (Eq, Show)
diff --git a/src/Game/Deterministic/GameEngine/Move.hs b/src/Game/Deterministic/GameEngine/Move.hs
new file mode 100644
--- /dev/null
+++ b/src/Game/Deterministic/GameEngine/Move.hs
@@ -0,0 +1,6 @@
+module Game.Deterministic.GameEngine.Move (
+    Move(..)
+  ) where
+
+
+data Move a = Move a deriving (Eq, Show)
diff --git a/src/Game/Deterministic/GameEngine/Player.hs b/src/Game/Deterministic/GameEngine/Player.hs
new file mode 100644
--- /dev/null
+++ b/src/Game/Deterministic/GameEngine/Player.hs
@@ -0,0 +1,10 @@
+module Game.Deterministic.GameEngine.Player (
+    Symbol,
+    Player(..)
+  ) where
+
+
+type Symbol = Char
+
+
+data Player = Player Symbol deriving (Eq, Show)