diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,11 +1,13 @@
 # webdriver-wrapper
 
-This package was created so end-users don't need to manually manage Selenium or their webdriver when dealing with the [webdriver](https://hackage.haskell.org/package/webdriver) package. For now, only `geckodriver` (aka Firefox) is supported - but `chromedriver` should be easy to implement. If you can't use Firefox for whichever reason, let me know and I'll look into implementing `chromedriver` support. 
+This package was created so end-users don't need to manually manage Selenium or their webdriver when dealing with the [webdriver](https://hackage.haskell.org/package/webdriver) package.
 
-This package is strongly inspired by [sandwich-webdriver](https://hackage.haskell.org/package/sandwich-webdriver). My original use-case didn't require the sandwich test suite, though, so I made this package which intends on being simpler and more minimalistic. 
+This package is strongly inspired by [sandwich-webdriver](https://hackage.haskell.org/package/sandwich-webdriver). My original use-case didn't require the sandwich test suite, though, so I made this package which focuses on being simpler and more minimalistic. 
 
 ## Extra dependencies
-You must have Java installed, since Selenium is distributed as a `.jar` file. I'm running OpenJDK 17 on my machine, and it works perfectly with the selected Selenium version. 
+You must have Java installed, since Selenium is distributed as a `.jar` file. I'm running OpenJDK 17 on my machine, and it just works.
 
 ## How to use
-There are two functions which are "batteries-included": `wrappedRunSession` and `wrappedRunWD`. Just use them as you would `runSession` and `runWD`. The wrapped functions will handle downloading Selenium and geckodriver (if they were not already downloaded), plus starting and stopping Selenium. If you already have some code with `runSession` or `runWD`, their wrapped counterparts are drop-in replacements. 
+The `wrappedRunSession` function is a drop-in replacement for `runSession`. It will download, if needed, Selenium and a webdriver to `~/.local/haskell-webdriver-wrapper/{your_architecture}` (on Linux) or `%APPDATA%/haskell-webdriver-wrapper/{your_architecture}` (on Windows). Then it starts Selenium and runs your `WD a` computation, closing Selenium whether WD succeeds or fails. 
+
+For `runWD`, there are two functions: `wrappedFirefoxRunWD` and `wrappedChromeRunWD`. They're also drop-in replacements for `runWD`, and will also handle everything related to Selenium - the only difference being, as you can imagine, `wrappedFirefoxRunWD` runs your session on Firefox and `wrappedChromeRunWD` runs your session on Chrome. 
diff --git a/src/Test/WebDriverWrapper.hs b/src/Test/WebDriverWrapper.hs
--- a/src/Test/WebDriverWrapper.hs
+++ b/src/Test/WebDriverWrapper.hs
@@ -1,41 +1,61 @@
 {- |
-Module : Core
+Module : Test.WebDriverWrapper
 Description : end-user functions.
 
 The wrapped functions (`wrappedRunSession` and `wrappedRunWD`) will download Selenium and Firefox's webdriver (geckodriver) if they're not already on the `Test.WebDriverWrapper.Constants.downloadPath`, then start Selenium before running the webdriver equivalent function (`runSession` and `runWD`). They kill the Selenium process at the end of their execution. 
 -}
-module Test.WebDriverWrapper (wrappedRunSession, wrappedRunWD, wrapWebDriverFunction, downloadIfMissing) where
+{-# OPTIONS_GHC -Wno-missing-fields #-}
+{-# LANGUAGE NamedFieldPuns #-}
+module Test.WebDriverWrapper (wrappedRunSession, wrapWebDriverFunction, wrappedFirefoxRunWD, wrappedChromeRunWD) where
 
 import System.Process (cleanupProcess)
 import Control.Concurrent.Async (concurrently_)
 import Test.WebDriverWrapper.Selenium (getSeleniumIfNeeded, startSelenium)
 import Test.WebDriverWrapper.GeckoDriver (getGeckoDriverIfNeeded)
-import Test.WebDriver (runSession)
+import Test.WebDriver
+    ( runSession,
+      Capabilities(..),
+      WDConfig(wdCapabilities),
+      Browser(..) )
 import Test.WebDriver.Types (WD, WDSession)
-import Test.WebDriver.Config (WebDriverConfig)
 import Test.WebDriver.Monad (runWD)
 import Control.Exception (bracket)
+import Test.WebDriverWrapper.ChromeDriver (getChromeDriverIfNeeded)
 
 -- | Same as `runSession`, but starts Selenium before execution and kills Selenium after execution. 
--- Will download Selenium or Firefox's webdriver (geckodriver) if any is missing. 
-wrappedRunSession :: WebDriverConfig conf => conf -> WD a -> IO a
-wrappedRunSession conf wd = wrapWebDriverFunction (conf,wd) (uncurry runSession) 
+-- Will download Selenium or the browser's webdriver (geckodriver or chromedriver) if any is missing. 
+wrappedRunSession :: WDConfig -> WD a -> IO a
+wrappedRunSession conf wd = wrapWebDriverFunction (browser $ wdCapabilities conf) (conf, wd) (uncurry runSession)
 
 -- | Same as `runWD`, but starts Selenium before execution and kills Selenium after execution. 
 -- Will download Selenium or Firefox's webdriver (geckodriver) if any is missing. 
-wrappedRunWD ::  WDSession -> WD a -> IO a 
-wrappedRunWD session wd = wrapWebDriverFunction (session, wd) (uncurry runWD)
+wrappedFirefoxRunWD ::  WDSession -> WD a -> IO a
+wrappedFirefoxRunWD session wd = wrapWebDriverFunction (Firefox{}) (session, wd) (uncurry runWD)
 
+-- | Same as `runWD`, but starts Selenium before execution and kills Selenium after execution. 
+-- Will download Selenium or Chrome's webdriver (chromedriver) if any is missing. 
+wrappedChromeRunWD ::  WDSession -> WD a -> IO a
+wrappedChromeRunWD session wd = wrapWebDriverFunction (Chrome{}) (session, wd) (uncurry runWD)
+
 -- | Runs a function in between starting and killing Selenium. Takes in the arguments and the function, in that order. 
--- Will download Selenium or Firefox's webdriver (geckodriver) if any is missing. 
-wrapWebDriverFunction :: a -> (a -> IO b) -> IO b
-wrapWebDriverFunction webdriverArgs webdriverFunction = do
-    downloadIfMissing
+-- Will download Selenium and the Browser's webdriver (geckodriver or chromedriver) if any is missing. 
+wrapWebDriverFunction :: Browser -> a -> (a -> IO b) -> IO b
+wrapWebDriverFunction browser' webdriverArgs webdriverFunction = do
+    case browser' of
+        Firefox {}             -> downloadIfMissingGecko
+        Chrome  {chromeBinary} -> downloadIfMissingChrome chromeBinary
+        _                      -> error "unsuported browser"
+
     bracket
-        startSelenium
+        (startSelenium browser')
         cleanupProcess
         (const $ webdriverFunction webdriverArgs)
 
 -- | Dowloads Selenium or Firefox's webdriver (geckodriver) if they're missing. 
-downloadIfMissing :: IO()
-downloadIfMissing =  concurrently_ getSeleniumIfNeeded getGeckoDriverIfNeeded
+downloadIfMissingGecko :: IO()
+downloadIfMissingGecko =  concurrently_ getSeleniumIfNeeded getGeckoDriverIfNeeded
+
+-- | Dowloads Selenium or Firefox's webdriver (geckodriver) if they're missing. 
+-- Takes a @chromeBinary@'s path, whose @chromedriver@ version will match. 
+downloadIfMissingChrome :: Maybe FilePath -> IO()
+downloadIfMissingChrome chromeBinary' =  concurrently_ getSeleniumIfNeeded $ getChromeDriverIfNeeded chromeBinary'
diff --git a/src/Test/WebDriverWrapper/ChromeDriver.hs b/src/Test/WebDriverWrapper/ChromeDriver.hs
new file mode 100644
--- /dev/null
+++ b/src/Test/WebDriverWrapper/ChromeDriver.hs
@@ -0,0 +1,99 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveAnyClass #-}
+
+module Test.WebDriverWrapper.ChromeDriver (getChromeDriverIfNeeded) where
+
+import Test.WebDriverWrapper.Constants (chromeDriverPath, downloadPath, chromeDriverVersionsUrl, chromeDriverArchIndex, chromeDriverArchivePath, chromeDriverArchiveDirectory)
+import System.Directory (doesFileExist, createDirectoryIfMissing, copyFile, removeDirectoryRecursive, removeFile)
+import Control.Monad (unless)
+import Test.WebDriverWrapper.Helpers (download, decompressZip, evalUntillSuccess)
+import Network.HTTP.Simple (parseRequest, setRequestMethod, httpLBS)
+import Network.HTTP.Client.Conduit (Response(responseBody))
+import Data.Aeson (eitherDecode)
+import qualified Data.Aeson.KeyMap as AKM
+import qualified Data.Aeson as A
+import qualified Data.Vector as V
+import qualified Data.Text as T
+import GHC.Generics (Generic)
+import System.FilePath ((</>))
+import System.Process (readProcess)
+import Data.Maybe (maybeToList)
+
+-- | Checks if @chromedriver@ is in the `downloadPath`. If not, download it. 
+getChromeDriverIfNeeded :: Maybe FilePath -> IO()
+getChromeDriverIfNeeded browserBinary = do
+    chromeDriverPath' <- chromeDriverPath
+    hasChromeDriver   <- doesFileExist chromeDriverPath'
+    unless hasChromeDriver $ getChromeDriver browserBinary
+
+getChromeDriver :: Maybe FilePath  -> IO()
+getChromeDriver browserBinary = do
+    dPath   <- downloadPath
+    chromeVersion <- getChromeVersion browserBinary
+
+    url <- getChromeDriverDownloadUrl $ T.pack chromeVersion
+    chromeDriverArchivePath' <- chromeDriverArchivePath
+    chromeDriverArchiveDirectory' <- chromeDriverArchiveDirectory
+    chromeDriverPath' <- chromeDriverPath
+
+    createDirectoryIfMissing True dPath
+
+    download url chromeDriverArchivePath'
+    decompressZip chromeDriverArchivePath' dPath
+    copyFile (chromeDriverArchiveDirectory' </> "chromedriver") chromeDriverPath'
+    
+    removeDirectoryRecursive chromeDriverArchiveDirectory'
+    removeFile chromeDriverArchivePath'
+
+
+getChromeDriverDownloadUrl :: T.Text -> IO String
+getChromeDriverDownloadUrl chromeVersion = do
+    requestUrl <- parseRequest chromeDriverVersionsUrl
+    let
+        request
+            = setRequestMethod "GET"
+            requestUrl
+    response <- responseBody <$> httpLBS request
+    let
+        decodedResponse = eitherDecode response :: Either String ChromeDriverMain
+
+        allVersions = case decodedResponse of
+            (Left err)        -> error err
+            (Right versions') ->  versions  versions'
+        
+        versionIndex = V.findIndexR ((==chromeVersion).version) allVersions
+        versionDownloads = downloads . (allVersions V.!) <$> versionIndex
+
+        maybeLastVersionUrl  =  do
+            versionDownloads' <- versionDownloads
+            chromedriver <- AKM.lookup "chromedriver" versionDownloads'
+            platform <- chromedriver V.!? chromeDriverArchIndex
+            AKM.lookup "url" platform
+
+        url = case maybeLastVersionUrl of
+            Nothing     -> error "Couldn't get chromedriver url!"
+            (Just url') -> T.unpack url'
+    return url
+
+getChromeVersion :: Maybe FilePath -> IO String
+getChromeVersion executableNames = do
+    let candidates = maybeToList executableNames ++ ["google-chrome"] -- defaults to google-chrome in PATH's version. 
+    terminalOutput <- evalUntillSuccess $ readVersion <$> candidates
+    return $ last $ words terminalOutput
+    where
+        readVersion exec = readProcess exec ["--version"] ""
+
+-- To help out Aeson in parsing the JSON.
+data ChromeDriverMain = ChromeDriverMain{
+    timestamp :: T.Text,
+    versions :: V.Vector ChromeDriverVersion
+}
+  deriving (Show, Generic, A.ToJSON, A.FromJSON)
+
+data ChromeDriverVersion = ChromeDriverVersion{
+    version :: T.Text,
+    revision :: T.Text,
+    downloads :: AKM.KeyMap (V.Vector (AKM.KeyMap T.Text))
+}
+  deriving (Show, Generic, A.ToJSON, A.FromJSON)
diff --git a/src/Test/WebDriverWrapper/Constants.hs b/src/Test/WebDriverWrapper/Constants.hs
--- a/src/Test/WebDriverWrapper/Constants.hs
+++ b/src/Test/WebDriverWrapper/Constants.hs
@@ -7,8 +7,7 @@
 Module : Test.WebDriverWrapper.Constants
 Description : Constant values, such as links and paths.
  -}
-
-module Test.WebDriverWrapper.Constants (geckoDriverPath, defaultPath, defaultSeleniumJarUrl, desiredPlatform, getGeckoDriverDownloadUrl, geckoDriverVersionSource, downloadPath, geckoArchivePath, fileFormat, seleniumPath, seleniumLogPath) where
+module Test.WebDriverWrapper.Constants (chromeDriverArchiveDirectory, chromeDriverArchivePath, chromeDriverArchIndex, chromeDriverVersionsUrl, chromeDriverPath, geckoDriverPath, defaultPath, defaultSeleniumJarUrl, desiredPlatform, getGeckoDriverDownloadUrl, geckoDriverVersionSource, downloadPath, geckoArchivePath, fileFormat, seleniumPath, seleniumLogPath) where
 
 import Data.String.Interpolate (i)
 import qualified System.Info as SI
@@ -34,6 +33,18 @@
 geckoDriverPath :: IO FilePath
 geckoDriverPath = (</> "geckodriver") <$> downloadPath
 
+-- | Intermediary path for the compressed version of chromedriver. Inside `downloadPath`.
+chromeDriverArchivePath :: IO FilePath
+chromeDriverArchivePath = (</> "chromedriver.zip") <$> downloadPath
+
+-- | Where chromedriver initially gets unziped to
+chromeDriverArchiveDirectory :: IO FilePath
+chromeDriverArchiveDirectory = (</> chromeDriverRelativeZipPath) <$> downloadPath
+
+-- | Path for chromedriver. Inside `downloadPath`. 
+chromeDriverPath :: IO FilePath
+chromeDriverPath = (</> "chromedriver") <$> downloadPath
+
 -- | Path for selenium.jar. Inside `downloadPath`.
 seleniumPath :: IO FilePath
 seleniumPath = (</> "selenium.jar") <$> downloadPath
@@ -58,6 +69,10 @@
         platform = desiredPlatform
         format = fileFormat
 
+-- | API to get chromedriver's download url.
+chromeDriverVersionsUrl :: String
+chromeDriverVersionsUrl = "https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json"
+
 -- Platform-dependent variables. 
 -- | Archive format for geckodriver's download. @.zip@ for Windows, @.tar.gz@ for everyone else. 
 fileFormat :: String
@@ -99,3 +114,28 @@
     ("linux", "i386")       -> "linux32"
 
     _ -> "linux64"
+
+-- | Index for `chromeDriverVersionsUrl`, which provides a list of urls where each platform is represented by an entry.
+--  If the platform is not identified, @linux64@'s index is used.
+chromeDriverArchIndex :: Int
+chromeDriverArchIndex = case (SI.os, SI.arch) of
+    ("linux", "x86_64")   -> 0
+    ("darwin", "aarch64") -> 1
+    ("darwin", "x86_64")  -> 2
+    ("windows", "i386")   -> 3
+    ("mingw32", "i386")   -> 3
+    ("windows", "x86_64") -> 4
+
+    _ -> 0
+
+chromeDriverRelativeZipPath :: FilePath
+chromeDriverRelativeZipPath = "chromedriver-" <> case (SI.os, SI.arch) of
+    ("linux", "x86_64")   -> "linux64"
+    ("darwin", "aarch64") -> "mac-arm64"
+    ("darwin", "x86_64")  -> "max-x64"
+    ("windows", "i386")   -> "win32"
+    ("mingw32", "i386")   -> "win32"
+    ("windows", "x86_64") -> "win64"
+
+    _ -> "linux64"
+    
diff --git a/src/Test/WebDriverWrapper/GeckoDriver.hs b/src/Test/WebDriverWrapper/GeckoDriver.hs
--- a/src/Test/WebDriverWrapper/GeckoDriver.hs
+++ b/src/Test/WebDriverWrapper/GeckoDriver.hs
@@ -4,7 +4,7 @@
 
 import qualified Data.Text as T
 import Network.HTTP.Simple (setRequestMethod, httpLBS, parseRequest, setRequestHeader)
-import Test.WebDriverWrapper.Helpers (download, decompress)
+import Test.WebDriverWrapper.Helpers (download, decompressGecko)
 import Test.WebDriverWrapper.Constants (getGeckoDriverDownloadUrl, geckoDriverVersionSource, geckoArchivePath, geckoDriverPath, downloadPath)
 import Network.HTTP.Client.Conduit (Response(responseBody))
 import Data.Aeson (eitherDecode)
@@ -25,14 +25,14 @@
 getGeckoDriver = do
     version <- getGeckoDriverVersion
     dPath <- downloadPath
-    tarballPath <- geckoArchivePath
+    geckoArchivePath' <- geckoArchivePath
 
     createDirectoryIfMissing True dPath
 
     let url = getGeckoDriverDownloadUrl version
-    download url tarballPath
-    decompress tarballPath dPath
-    removeFile tarballPath
+    download url geckoArchivePath'
+    decompressGecko geckoArchivePath' dPath
+    removeFile geckoArchivePath'
     
 getGeckoDriverVersion :: IO String
 getGeckoDriverVersion = do
diff --git a/src/Test/WebDriverWrapper/Helpers.hs b/src/Test/WebDriverWrapper/Helpers.hs
--- a/src/Test/WebDriverWrapper/Helpers.hs
+++ b/src/Test/WebDriverWrapper/Helpers.hs
@@ -3,17 +3,19 @@
 Module : Test.WebDriverWrapper.Helpers
 Description : Generic functions.
 -}
-module Test.WebDriverWrapper.Helpers (download, decompress) where
+module Test.WebDriverWrapper.Helpers (download, decompressGecko, decompressZip, evalUntillSuccess) where
 
 import Test.WebDriverWrapper.Constants (fileFormat, geckoDriverPath)
 import Network.HTTP.Simple (setRequestHeader, setRequestMethod, httpLBS)
 import Network.HTTP.Types (hUserAgent)
 import Network.HTTP.Conduit (Response(..), parseRequest)
 import qualified Data.ByteString.Lazy as BS
-import Codec.Archive.Zip (toArchive, fromArchive)
+import Codec.Archive.Zip (toArchive, extractFilesFromArchive, ZipOption (OptDestination))
 import qualified Codec.Compression.GZip as G
 import qualified Codec.Archive.Tar as Tar
 import System.Posix ( setFileMode, accessModes )
+import Control.Exception (catch)
+import Control.Exception.Base (SomeException)
 
 -- | Downloads from @url@ at @output@ filepath. 
 download :: String -> FilePath -> IO()
@@ -29,17 +31,31 @@
 
 -- | Decompresses geckodriver's download, which comes in @.zip@ for Windows or @.tar.gz@ for everyone else. 
 -- Takes in the archive's filepath and the output filepath. 
-decompress :: FilePath -> FilePath -> IO()
-decompress file outputPath = do
+decompressGecko :: FilePath -> FilePath -> IO()
+decompressGecko file outputPath = do
     case fileFormat of
-        ".zip"    -> do
-            archive <- toArchive <$> BS.readFile file
-            BS.writeFile outputPath $ fromArchive archive
-        ".tar.gz" -> do
-            tarball <- G.decompress <$> BS.readFile file
-            Tar.unpack outputPath $ Tar.read tarball
+        ".zip"    -> decompressZip file outputPath
+        ".tar.gz" -> decompressTarball file outputPath
+        _ -> error "unknown file"
 
-            geckoDriver <- geckoDriverPath
+-- | Decompresses a Zip file.
+-- Takes in the archive's filepath and the output filepath. 
+decompressZip :: FilePath -> FilePath -> IO()
+decompressZip file outputPath = do
+    archive <- toArchive <$> BS.readFile file
+    extractFilesFromArchive [OptDestination outputPath] archive
 
-            setFileMode geckoDriver accessModes
-        _ -> error "unknown file"
+-- | Deccompresses a .tar.gz file.
+-- Takes in the archive's filepath and the output filepath. 
+decompressTarball :: FilePath -> FilePath -> IO()
+decompressTarball file outputPath = do
+    tarball <- G.decompress <$> BS.readFile file
+    Tar.unpack outputPath $ Tar.read tarball
+    geckoDriver <- geckoDriverPath
+    setFileMode geckoDriver accessModes
+
+-- | Evaluates each IO individually and returns the first one that doesn't throw an error. 
+-- Throws an error if none succeed. 
+evalUntillSuccess :: [IO String] -> IO String
+evalUntillSuccess [] = error "None succeeded on evalUntillSuccess!"
+evalUntillSuccess (x:xs) = catch x (const $ evalUntillSuccess xs :: SomeException -> IO String)
diff --git a/src/Test/WebDriverWrapper/Selenium.hs b/src/Test/WebDriverWrapper/Selenium.hs
--- a/src/Test/WebDriverWrapper/Selenium.hs
+++ b/src/Test/WebDriverWrapper/Selenium.hs
@@ -4,7 +4,7 @@
 
 module Test.WebDriverWrapper.Selenium (startSelenium, getSeleniumIfNeeded) where
 
-import Test.WebDriverWrapper.Constants (defaultSeleniumJarUrl, seleniumPath, downloadPath, geckoDriverPath, seleniumLogPath)
+import Test.WebDriverWrapper.Constants (defaultSeleniumJarUrl, seleniumPath, downloadPath, geckoDriverPath, seleniumLogPath, chromeDriverPath)
 import Test.WebDriverWrapper.Helpers (download)
 import System.Directory (createDirectoryIfMissing, doesFileExist)
 import Control.Monad (unless)
@@ -19,17 +19,26 @@
 import Data.Foldable.Extra (orM)
 import Data.List (isInfixOf)
 import System.Process.Run (proc)
+import Test.WebDriver.Capabilities (Browser)
+import Test.WebDriver (Browser(..))
 
 -- | Starts Selenium and waits for its ok message ( "Selenium Server is up and running" ) to show up at the log file.
+-- Takes in a `Browser` (since it needs to use the correct webdriver).
 -- Returns the handles for the Selenium process.
-startSelenium :: IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
-startSelenium = do
-    geckoPath <- geckoDriverPath
+startSelenium :: Browser -> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
+startSelenium browser = do
+    geckoPath  <- geckoDriverPath
+    chromePath <- chromeDriverPath
     selPath <- seleniumPath
     logFile <- seleniumLogPath
     writeFile logFile "" -- Create file if it doesn't exist, clears it if it does. Needs to happen for "logFileHasReadyMessage" to work correctly. 
     let
-        selArgs = [[i|-Dwebdriver.gecko.driver=#{geckoPath}|], "-jar", selPath ,"-log", logFile]
+        webdriverArgs = case browser of 
+            Firefox {} -> [i|-Dwebdriver.gecko.driver=#{geckoPath}|]
+            Chrome {}  -> [i|-Dwebdriver.chrome.driver=#{chromePath}|]
+            _          -> error "unsuported browser"
+
+        selArgs = webdriverArgs : ["-jar", selPath ,"-log", logFile]
         processParams = proc "java" selArgs
     processHandles <- createProcess processParams
     waitForSeleniumStart
diff --git a/webdriver-wrapper.cabal b/webdriver-wrapper.cabal
--- a/webdriver-wrapper.cabal
+++ b/webdriver-wrapper.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           webdriver-wrapper
-version:        0.1.0.1
+version:        0.2.0.0
 synopsis:       Wrapper around the webdriver package that automatically manages Selenium
 description:    Please see the README on GitHub at <https://github.com/gtollini/webdriver-wrapper#readme>
 category:       browser, selenium, testing, web, webdriver, geckodriver
@@ -28,6 +28,7 @@
 library
   exposed-modules:
       Test.WebDriverWrapper
+      Test.WebDriverWrapper.ChromeDriver
       Test.WebDriverWrapper.Constants
       Test.WebDriverWrapper.GeckoDriver
       Test.WebDriverWrapper.Helpers
@@ -57,6 +58,7 @@
     , text >=2.0.2 && <2.2
     , unix >=2.8.4 && <2.9
     , unordered-containers >=0.2.20 && <0.3
+    , vector >=0.13.1 && <0.14
     , webdriver >=0.12.0 && <0.13
     , zip-archive >=0.4.3 && <0.5
     , zlib >=0.6.3 && <0.8