diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## Inflections 0.4.0.0
+
+* Update megaparsec to version 6.
+
 ## Inflections 0.3.0.0
 
 * A more type-safe API forbidding creation of invalid words.
diff --git a/Text/Inflections.hs b/Text/Inflections.hs
--- a/Text/Inflections.hs
+++ b/Text/Inflections.hs
@@ -96,6 +96,7 @@
   , camelizeCustom
   , dasherize
   , humanize
+  , humanizeCustom
   , underscore
   , titleize
   , Transliterations
@@ -110,15 +111,17 @@
   , toUnderscore
   , toDashed
   , toCamelCased
+  , toHumanized
   , betterThrow )
 where
 
 import Control.Monad.Catch (MonadThrow (..))
 import Data.Text (Text)
+import Data.Void (Void)
 import Text.Inflections.Camelize (camelize, camelizeCustom)
 import Text.Inflections.Dasherize (dasherize)
 import Text.Inflections.Data (Transliterations, defaultTransliterations)
-import Text.Inflections.Humanize (humanize)
+import Text.Inflections.Humanize (humanize, humanizeCustom)
 import Text.Inflections.Ordinal (ordinal, ordinalize)
 import Text.Inflections.Parameterize (parameterize, parameterizeCustom)
 import Text.Inflections.Parse.CamelCase (parseCamelCase)
@@ -139,7 +142,7 @@
 --
 -- >>> toUnderscore "FooBarBazz"
 -- "foo_bar_bazz"
-toUnderscore :: Text -> Either (ParseError Char Dec) Text
+toUnderscore :: Text -> Either (ParseError Char Void) Text
 toUnderscore = fmap underscore . parseCamelCase []
 
 -- | Transforms CamelCasedString to snake-cased-string-with-dashes.
@@ -148,26 +151,45 @@
 --
 -- >>> toDashed "FooBarBazz"
 -- "foo-bar-bazz"
-toDashed :: Text -> Either (ParseError Char Dec) Text
+toDashed :: Text -> Either (ParseError Char Void) Text
 toDashed = fmap dasherize . parseCamelCase []
 
 -- | Transforms underscored_text to CamelCasedText. If first argument is
--- 'True' then FirstCharacter in result string will be in upper case. If
--- 'False' then firstCharacter will be in lower case.
+-- 'True' then the first character in the result string will be in upper case. If
+-- 'False' then the first character will be in lower case.
 --
--- > toCamelCased t = fmap (camelizeCustom t) . parseSnakeCase []
+-- > toCamelCased c = fmap (camelizeCustom c) . parseSnakeCase []
 --
 -- >>> toCamelCased True "foo_bar_bazz"
 -- "FooBarBazz"
 -- >>> toCamelCased False "foo_bar_bazz"
 -- "fooBarBazz"
 toCamelCased
-   :: Bool              -- ^ Capitalize the first character
-  -> Text              -- ^ Input
-  -> Either (ParseError Char Dec) Text -- ^ Ouput
-toCamelCased t = fmap (camelizeCustom t) . parseSnakeCase []
+  :: Bool               -- ^ Capitalize the first character
+  -> Text               -- ^ Input
+  -> Either (ParseError Char Void) Text -- ^ Output
+toCamelCased c = fmap (camelizeCustom c) . parseSnakeCase []
 
--- | Lift something of type @'Either' ('ParseError' 'Char' 'Dec') a@ to
+-- | Transforms underscored_text to space-separated human-readable text.
+-- If first argument is 'True' then the first character in the result
+-- string will be in upper case. If 'False' then the first character will be
+-- in lower case.
+--
+-- > toHumanized c = fmap (humanizeCustom c) . parseSnakeCase []
+--
+-- >>> toHumanized True "foo_bar_bazz"
+-- "Foo bar bazz"
+-- >>> toHumanized False "foo_bar_bazz"
+-- "foo bar bazz"
+--
+-- /since 0.3.0.0/
+toHumanized
+  :: Bool               -- ^ Capitalize the first character
+  -> Text               -- ^ Input
+  -> Either (ParseError Char Void) Text -- ^ Output
+toHumanized c = fmap (humanizeCustom c) . parseSnakeCase []
+
+-- | Lift something of type @'Either' ('ParseError' 'Char' 'Void') a@ to
 -- an instance of 'MonadThrow'. Useful when you want to shortcut on parsing
 -- failures and you're in an instance of 'MonadThrow'.
 --
@@ -175,6 +197,6 @@
 --
 -- /since 0.3.0.0/
 
-betterThrow :: MonadThrow m => Either (ParseError Char Dec) a -> m a
+betterThrow :: MonadThrow m => Either (ParseError Char Void) a -> m a
 betterThrow (Left err) = throwM (InflectionParsingFailed err)
 betterThrow (Right  x) = return x
diff --git a/Text/Inflections/Humanize.hs b/Text/Inflections/Humanize.hs
--- a/Text/Inflections/Humanize.hs
+++ b/Text/Inflections/Humanize.hs
@@ -13,7 +13,8 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Text.Inflections.Humanize
-  ( humanize )
+  ( humanize
+  , humanizeCustom )
 where
 
 import Data.Text (Text)
@@ -36,7 +37,27 @@
 humanize
   :: [SomeWord]  -- ^ List of words, first of which will be capitalized
   -> Text        -- ^ The humanized output
-humanize xs' =
+humanize = humanizeCustom True
+
+
+-- | Separate words with spaces, optionally capitalizing the first word. Like
+-- 'Text.Inflections.Titleize.titleize', this is meant for creating pretty
+-- output.
+--
+-- >>> foo  <- SomeWord <$> mkWord "foo"
+-- >>> bar  <- SomeWord <$> mkAcronym "bar"
+-- >>> bazz <- SomeWord <$> mkWord "bazz"
+-- >>> humanizeCustom True [foo,bar,bazz]
+-- "Foo bar bazz"
+-- >>> humanizeCustom False [foo,bar,bazz]
+-- "foo bar bazz"
+--
+-- /since 0.3.0.0/
+humanizeCustom
+  :: Bool       -- ^ Whether to capitalize the first character in the output String
+  -> [SomeWord]  -- ^ List of words, first of which will be capitalized
+  -> Text        -- ^ The humanized output
+humanizeCustom c xs' =
   case unSomeWord (T.replace "_" " ") <$> xs' of
     []     -> ""
-    (x:xs) -> T.unwords $ T.toTitle x : (T.toLower <$> xs)
+    (x:xs) -> T.unwords $ (if c then T.toTitle else T.toLower) x : (T.toLower <$> xs)
diff --git a/Text/Inflections/Parse/CamelCase.hs b/Text/Inflections/Parse/CamelCase.hs
--- a/Text/Inflections/Parse/CamelCase.hs
+++ b/Text/Inflections/Parse/CamelCase.hs
@@ -19,9 +19,10 @@
 
 import Control.Applicative
 import Data.Text (Text)
+import Data.Void (Void)
 import Text.Inflections.Types
 import Text.Megaparsec
-import Text.Megaparsec.Text
+import Text.Megaparsec.Char
 import qualified Data.Text as T
 
 #if MIN_VERSION_base(4,8,0)
@@ -31,6 +32,8 @@
 import Prelude hiding (elem)
 #endif
 
+type Parser = Parsec Void Text
+
 -- | Parse a CamelCase string.
 --
 -- >>> bar <- mkAcronym "bar"
@@ -44,7 +47,7 @@
 parseCamelCase :: (Foldable f, Functor f)
   => f (Word 'Acronym) -- ^ Collection of acronyms
   -> Text              -- ^ Input
-  -> Either (ParseError Char Dec) [SomeWord] -- ^ Result of parsing
+  -> Either (ParseError Char Void) [SomeWord] -- ^ Result of parsing
 parseCamelCase acronyms = parse (parser acronyms) ""
 
 parser :: (Foldable f, Functor f)
@@ -59,7 +62,7 @@
   => f (Word 'Acronym)
   -> Parser (Word 'Acronym)
 acronym acronyms = do
-  x <- T.pack <$> choice (string . T.unpack . unWord <$> acronyms)
+  x <- choice (string . unWord <$> acronyms)
   case mkAcronym x of
     Nothing -> empty -- cannot happen if the system is sound
     Just acr -> return acr
diff --git a/Text/Inflections/Parse/SnakeCase.hs b/Text/Inflections/Parse/SnakeCase.hs
--- a/Text/Inflections/Parse/SnakeCase.hs
+++ b/Text/Inflections/Parse/SnakeCase.hs
@@ -18,9 +18,10 @@
 
 import Control.Applicative
 import Data.Text (Text)
+import Data.Void (Void)
 import Text.Inflections.Types
 import Text.Megaparsec
-import Text.Megaparsec.Text
+import Text.Megaparsec.Char
 import qualified Data.Text as T
 
 #if MIN_VERSION_base(4,8,0)
@@ -30,6 +31,8 @@
 import Prelude hiding (elem)
 #endif
 
+type Parser = Parsec Void Text
+
 -- | Parse a snake_case string.
 --
 -- >>> bar <- mkAcronym "bar"
@@ -43,7 +46,7 @@
 parseSnakeCase :: (Foldable f, Functor f)
   => f (Word 'Acronym) -- ^ Collection of acronyms
   -> Text              -- ^ Input
-  -> Either (ParseError Char Dec) [SomeWord] -- ^ Result of parsing
+  -> Either (ParseError Char Void) [SomeWord] -- ^ Result of parsing
 parseSnakeCase acronyms = parse (parser acronyms) ""
 
 parser :: (Foldable f, Functor f)
diff --git a/Text/Inflections/Titleize.hs b/Text/Inflections/Titleize.hs
--- a/Text/Inflections/Titleize.hs
+++ b/Text/Inflections/Titleize.hs
@@ -17,7 +17,7 @@
 import Text.Inflections.Types
 import qualified Data.Text as T
 
--- | Capitalize all the Words in the input list.
+-- | Capitalize all the 'SomeWord' words in the input list.
 --
 -- >>> foo  <- SomeWord <$> mkWord "foo"
 -- >>> bar  <- SomeWord <$> mkAcronym "bar"
@@ -25,6 +25,6 @@
 -- >>> titleize [foo,bar,bazz]
 -- "Foo bar Bazz"
 titleize
-  :: [SomeWord] -- ^ List of words, first of which will be capitalized
+  :: [SomeWord] -- ^ List of words, of which all 'SomeWord' words will be capitalized and all acronyms will be left as is
   -> Text       -- ^ The titleized 'Text'
 titleize = T.unwords . fmap (unSomeWord T.toTitle)
diff --git a/Text/Inflections/Types.hs b/Text/Inflections/Types.hs
--- a/Text/Inflections/Types.hs
+++ b/Text/Inflections/Types.hs
@@ -33,6 +33,7 @@
 import Control.Monad.Catch
 import Data.Char (isAlphaNum)
 import Data.Data (Data)
+import Data.Void (Void)
 import Data.Text (Text)
 import Data.Typeable (Typeable)
 import GHC.Generics (Generic)
@@ -135,7 +136,7 @@
 -- /since 0.3.0.0/
 
 data InflectionException
-  = InflectionParsingFailed (ParseError Char Dec)
+  = InflectionParsingFailed (ParseError Char Void)
   | InflectionInvalidWord Text
   | InflectionInvalidAcronym Text
   deriving (Eq, Show, Typeable, Data, Generic)
diff --git a/inflections.cabal b/inflections.cabal
--- a/inflections.cabal
+++ b/inflections.cabal
@@ -1,5 +1,5 @@
 name:                inflections
-version:             0.3.0.0
+version:             0.4.0.0
 synopsis:            Inflections library for Haskell
 description:
   Inflections provides methods for singularization, pluralization,
@@ -49,9 +49,12 @@
     ghc-options:      -O2 -Wall
   build-depends:       base         >= 4.6   && < 5.0
                      , exceptions   >= 0.6   && < 0.9
-                     , megaparsec   >= 5.0   && < 6.0
+                     , megaparsec   >= 6.0   && < 7.0
                      , text         >= 0.2   && < 1.3
                      , unordered-containers >= 0.2.7 && < 0.3
+  if !impl(ghc >= 7.10)
+    build-depends:      void         == 0.7.*
+
   default-language:    Haskell2010
 
 test-suite test
@@ -61,10 +64,17 @@
   build-depends:       inflections
                      , QuickCheck   >= 2.7.6 && < 3.0
                      , base         >= 4.6   && < 5.0
+                     , containers   >= 0.5   && < 0.7
                      , hspec        >= 2.0   && < 3.0
-                     , hspec-megaparsec >= 0.3 && < 0.4
-                     , megaparsec   >= 5.1   && < 6.0
+                     , hspec-megaparsec >= 1.0 && < 2.0
+                     , megaparsec
                      , text         >= 0.2   && < 1.3
+  if !impl(ghc >= 7.10)
+    build-depends:      void         == 0.7.*
+
+  if !impl(ghc >= 8.0)
+    build-depends:      semigroups   == 0.18.*
+
   if flag(dev)
     ghc-options:      -Wall -Werror
   else
diff --git a/test/Text/Inflections/HumanizeSpec.hs b/test/Text/Inflections/HumanizeSpec.hs
--- a/test/Text/Inflections/HumanizeSpec.hs
+++ b/test/Text/Inflections/HumanizeSpec.hs
@@ -12,16 +12,43 @@
 #endif
 
 spec :: Spec
-spec = describe "humazine" $ do
-  it "converts snake case to a human-readable string" $ do
-    employee <- SomeWord <$> mkWord "employee"
-    salary   <- SomeWord <$> mkWord "salary"
-    humanize [employee,salary] `shouldBe` "Employee salary"
-  it "turns underscores into spaces" $ do
-    employee  <- SomeWord <$> mkWord "employee"
-    has       <- SomeWord <$> mkWord "has"
-    salary    <- SomeWord <$> mkWord "salary"
-    humanize [employee, has, salary] `shouldBe` "Employee has salary"
-  it "capitalizes the first word of a sentence" $ do
-    underground <- SomeWord <$> mkWord "underground"
-    humanize [underground] `shouldBe` "Underground"
+spec = do
+  describe "humanize" $ do
+    it "converts snake case to a human-readable string" $ do
+      employee <- SomeWord <$> mkWord "employee"
+      salary   <- SomeWord <$> mkWord "salary"
+      humanize [employee,salary] `shouldBe` "Employee salary"
+    it "turns underscores into spaces" $ do
+      employee  <- SomeWord <$> mkWord "employee"
+      has       <- SomeWord <$> mkWord "has"
+      salary    <- SomeWord <$> mkWord "salary"
+      humanize [employee, has, salary] `shouldBe` "Employee has salary"
+    it "capitalizes the first word of a sentence" $ do
+      underground <- SomeWord <$> mkWord "underground"
+      humanize [underground] `shouldBe` "Underground"
+  describe "humanizeCustom False" $ do
+    it "converts snake case to a human-readable string" $ do
+      employee <- SomeWord <$> mkWord "employee"
+      salary   <- SomeWord <$> mkWord "salary"
+      humanizeCustom False [employee,salary] `shouldBe` "employee salary"
+    it "turns underscores into spaces" $ do
+      employee  <- SomeWord <$> mkWord "employee"
+      has       <- SomeWord <$> mkWord "has"
+      salary    <- SomeWord <$> mkWord "salary"
+      humanizeCustom False [employee, has, salary] `shouldBe` "employee has salary"
+    it "lower-cases the first word of a sentence" $ do
+      underground <- SomeWord <$> mkWord "underground"
+      humanizeCustom False [underground] `shouldBe` "underground"
+  describe "humanizeCustom True" $ do
+    it "converts snake case to a human-readable string" $ do
+      employee <- SomeWord <$> mkWord "employee"
+      salary   <- SomeWord <$> mkWord "salary"
+      humanizeCustom True [employee,salary] `shouldBe` "Employee salary"
+    it "turns underscores into spaces" $ do
+      employee  <- SomeWord <$> mkWord "employee"
+      has       <- SomeWord <$> mkWord "has"
+      salary    <- SomeWord <$> mkWord "salary"
+      humanizeCustom True [employee, has, salary] `shouldBe` "Employee has salary"
+    it "capitalizes the first word of a sentence" $ do
+      underground <- SomeWord <$> mkWord "underground"
+      humanizeCustom True [underground] `shouldBe` "Underground"
diff --git a/test/Text/InflectionsSpec.hs b/test/Text/InflectionsSpec.hs
--- a/test/Text/InflectionsSpec.hs
+++ b/test/Text/InflectionsSpec.hs
@@ -1,11 +1,45 @@
+{-# LANGUAGE CPP               #-}
 {-# LANGUAGE OverloadedStrings #-}
 
 module Text.InflectionsSpec (spec) where
 
+import Data.Void
 import Test.Hspec
 import Test.QuickCheck
 import Text.Inflections
+import Text.Megaparsec
 
+import qualified Data.List.NonEmpty as NE
+import qualified Data.Set as S
+
+#if !MIN_VERSION_base(4,8,0)
+import Control.Applicative
+#endif
+
+arbitraryParseError :: Gen (ParseError Char Void)
+arbitraryParseError = oneof [trivialError, fancyError]
+    where
+      trivialError = TrivialError <$> nonEmptyArbitrary <*> maybeErrorItem <*> setErrorItem
+      fancyError = FancyError <$> nonEmptyArbitrary <*> setErrorFancy
+      nonEmptyArbitrary = NE.fromList <$> listOf1 arbitrarySourcePos
+      setErrorFancy = S.fromList <$> listOf arbitraryErrorFancy
+      maybeErrorItem = oneof [ Just <$> arbitraryErrorItem, return Nothing]
+      setErrorItem = S.fromList <$> listOf arbitraryErrorItem
+
+arbitrarySourcePos :: Gen SourcePos
+arbitrarySourcePos = SourcePos <$> arbitrary <*> posArbitrary <*> posArbitrary
+    where
+      posArbitrary = mkPos <$> ((+1) . abs <$> arbitrary)
+
+arbitraryErrorFancy :: Gen (ErrorFancy e)
+arbitraryErrorFancy = oneof [ ErrorFail <$> arbitrary ]
+
+arbitraryErrorItem :: (Arbitrary e) => Gen (ErrorItem e)
+arbitraryErrorItem = oneof [ tokens_, labels_, return EndOfInput ]
+    where
+      tokens_ = Tokens <$> (NE.fromList <$> listOf1 arbitrary)
+      labels_ = Label <$> (NE.fromList <$> listOf1 arbitrary)
+
 spec :: Spec
 spec = do
 
@@ -27,12 +61,21 @@
       it "converts snake case to camel case with the first word capitalized" $
         toCamelCased True "underscored_text" `shouldBe` Right "UnderscoredText"
 
+  describe "toHumanized" $ do
+    context "when the first argument is False" $
+      it "converts snake case to human-readable form with lower-case initial letter" $
+        toHumanized False "underscored_text" `shouldBe` Right "underscored text"
+    context "when the first argument is True" $
+      it "converts snake case to human-readable form with the first word capitalized" $
+        toHumanized True "underscored_text" `shouldBe` Right "Underscored text"
+
   describe "betterThrow" $ do
     context "when given a parse error" $
       it "throws the correct exception" $
-        property $ \err ->
+        property $ forAll arbitraryParseError $ \err ->
           betterThrow (Left err) `shouldThrow`
             (== InflectionParsingFailed err)
+
     context "when given a value in Right" $
       it "returns the value" $
         property $ \x ->