diff --git a/src/Wordify/Rules/Dictionary.hs b/src/Wordify/Rules/Dictionary.hs
--- a/src/Wordify/Rules/Dictionary.hs
+++ b/src/Wordify/Rules/Dictionary.hs
@@ -1,66 +1,66 @@
-module Wordify.Rules.Dictionary (Dictionary,
-                                 makeDictionary,
-                                 dictionaryFromWords,
-                                 isValidWord,
-                                 invalidWords
-                                 ) where
-
-  import qualified Data.HashSet as HashSet
-  import Wordify.Rules.ScrabbleError
-  import qualified Control.Exception as Exc
-  import Text.ParserCombinators.Parsec
-  import Text.Parsec.Prim
-  import Data.Char
-  import Control.Monad
-  import Control.Arrow
-
-  data Dictionary = Dictionary (HashSet.HashSet String) deriving Show
-
-  {- | 
-     Returns the list of words which are not present in the given dictionary from a 
-     list of input words.  
-  -}
-  invalidWords :: Dictionary -> [String] -> [String]
-  invalidWords dictionary = filter $ not . isValidWord dictionary
+module Wordify.Rules.Dictionary
+  ( Dictionary,
+    makeDictionary,
+    dictionaryFromWords,
+    isValidWord,
+    invalidWords,
+  )
+where
 
-  {-
-     Returns true if the given word is in the given dictionary.
-  -}
-  isValidWord :: Dictionary -> String -> Bool
-  isValidWord (Dictionary dictionaryWords) = flip HashSet.member dictionaryWords
+import Conduit (MonadIO (liftIO), MonadResource, MonadUnliftIO, runResourceT)
+import qualified Control.Applicative as M
+import Control.Arrow
+import qualified Control.Exception as Exc
+import Control.Monad
+import qualified Control.Monad.Trans.Accum as Co
+import qualified Data.ByteString as BS
+import Data.Char
+import Data.Conduit
+import qualified Data.Conduit.Combinators as Co
+import qualified Data.Conduit.List as Cl
+import qualified Data.Foldable as C
+import qualified Data.HashSet as HashSet
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
+import Text.Parsec.Prim
+import Text.ParserCombinators.Parsec
+import Wordify.Rules.ScrabbleError
 
-  dictionaryFromWords :: [String] -> Dictionary
-  dictionaryFromWords = Dictionary . HashSet.fromList . upperCaseWords 
+data Dictionary = Dictionary (HashSet.HashSet T.Text) deriving (Show)
 
-  {- |
-    Creates a dictionary from a file containing a list of valid words, each word being seperated by a newline.
-  -}
-  makeDictionary :: FilePath -> IO (Either ScrabbleError Dictionary)
-  makeDictionary filePath = join . fmap parseDictionary <$> readDictionaryFile filePath
+-- |
+--     Returns the list of words which are not present in the given dictionary from a
+--     list of input words.
+invalidWords :: Dictionary -> [String] -> [String]
+invalidWords dictionary = filter $ not . isValidWord dictionary
 
-  readDictionaryFile :: FilePath -> IO (Either ScrabbleError String)
-  readDictionaryFile filePath = convertFileError <$> (Exc.try (readFile filePath) :: (IO (Either Exc.IOException String)))
-    where
-        convertFileError = left (\_ -> DictionaryFileNotFound filePath)
+{-
+   Returns true if the given word is in the given dictionary.
+-}
+isValidWord :: Dictionary -> String -> Bool
+isValidWord (Dictionary dictionaryWords) word = HashSet.member (T.pack word) dictionaryWords
 
-  parseDictionary :: String -> Either ScrabbleError Dictionary
-  parseDictionary =  either (Left . MalformedDictionaryFile . show) (Right . dictionaryFromWords) . parseFile
-    where
-        parseFile = parse dictionaryFile "" 
+dictionaryFromWords :: [String] -> Dictionary
+dictionaryFromWords words = Dictionary . HashSet.fromList $ map T.pack (upperCaseWords words)
 
-        dictionaryFile = 
-            do
-            dictWords <- many word
-            _ <- eof
-            return dictWords
+sinkFileLinesToHashset :: (MonadResource m, MonadUnliftIO m) => FilePath -> ConduitT () Void m (HashSet.HashSet T.Text)
+sinkFileLinesToHashset filePath =
+  Co.sourceFile filePath .| Co.linesUnboundedAscii .| Cl.map (T.toUpper . TE.decodeUtf8) .| Co.foldl insertIntoHashet HashSet.empty
+  where
+    insertIntoHashet = flip HashSet.insert
 
-        word = 
-            do
-            entry <- many letter :: Parser String
-            _ <- newline
-            return entry
- 
-  upperCaseWords :: [String] -> [String]
-  upperCaseWords = (map . map) toUpper
+loadDictionaryFromFile :: FilePath -> IO Dictionary
+loadDictionaryFromFile filePath = do
+  hashset <- runResourceT $ runConduit $ sinkFileLinesToHashset filePath
+  pure $ Dictionary hashset
 
+-- |
+--    Creates a dictionary from a file containing a list of valid words, each word being seperated by a newline.
+makeDictionary :: FilePath -> IO (Either ScrabbleError Dictionary)
+makeDictionary filePath = do
+  convertFileError <$> (Exc.try (loadDictionaryFromFile filePath) :: (IO (Either Exc.IOException Dictionary)))
+  where
+    convertFileError = left (\_ -> DictionaryFileNotFound filePath)
 
+upperCaseWords :: [String] -> [String]
+upperCaseWords = (map . map) toUpper
diff --git a/wordify.cabal b/wordify.cabal
--- a/wordify.cabal
+++ b/wordify.cabal
@@ -7,7 +7,7 @@
 -- hash: f28111054d235bc18dc5e0d167dd433a32a9e0c4e9627cc10c02822b5b2ac44e
 
 name:           wordify
-version:        0.1.0.0
+version:        0.1.0.1
 description:    Please see the README on GitHub at <https://github.com/githubuser/wordify#readme>
 category:       Game
 homepage:       https://github.com/happy0/wordify#readme
@@ -62,6 +62,9 @@
     , split
     , transformers
     , unordered-containers
+    , conduit
+    , text
+    , bytestring
   default-language: Haskell2010
 
 executable wordify-exe