diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,15 @@
 
+## 3.2.0.0
+
+*   Add support for pretty-printing Haskell character literals.
+    [#57](https://github.com/cdepillabout/pretty-simple/pull/57)
+    Thanks again [sjakobi](https://github.com/sjakobi)!
+
 ## 3.1.1.0
 
 *   Added a `pPrintString` function for pretty-printing a `String` that is the
     output of `show`.  Implemented in
-    [54](https://github.com/cdepillabout/pretty-simple/pull/54). Thanks
+    [#54](https://github.com/cdepillabout/pretty-simple/pull/54). Thanks
     [sureyeaah](https://github.com/sureyeaah)!
 *   Fix build on GHC-7.10.3.
     [#55](https://github.com/cdepillabout/pretty-simple/pull/55).  Thanks
diff --git a/pretty-simple.cabal b/pretty-simple.cabal
--- a/pretty-simple.cabal
+++ b/pretty-simple.cabal
@@ -1,5 +1,5 @@
 name:                pretty-simple
-version:             3.1.1.0
+version:             3.2.0.0
 synopsis:            pretty printer for data types with a 'Show' instance.
 description:         Please see <https://github.com/cdepillabout/pretty-simple#readme README.md>.
 homepage:            https://github.com/cdepillabout/pretty-simple
diff --git a/src/Text/Pretty/Simple.hs b/src/Text/Pretty/Simple.hs
--- a/src/Text/Pretty/Simple.hs
+++ b/src/Text/Pretty/Simple.hs
@@ -542,10 +542,10 @@
 --
 -- __Simple Haskell data type__
 --
--- >>> data Foo a = Foo a String deriving Show
+-- >>> data Foo a = Foo a String Char deriving Show
 --
--- >>> pPrint $ Foo 3 "hello"
--- Foo 3 "hello"
+-- >>> pPrint $ Foo 3 "hello" 'a'
+-- Foo 3 "hello" 'a'
 --
 -- __List__
 --
@@ -557,19 +557,19 @@
 --
 -- __Slightly more complicated list__
 --
--- >>> pPrint $ [ Foo [ (), () ] "hello" ]
+-- >>> pPrint $ [ Foo [ (), () ] "hello" 'b' ]
 -- [ Foo
 --     [ ()
 --     , ()
---     ] "hello"
+--     ] "hello" 'b'
 -- ]
 --
--- >>> pPrint $ [ Foo [ "bar", "baz" ] "hello", Foo [] "bye" ]
+-- >>> pPrint $ [ Foo [ "bar", "baz" ] "hello" 'a', Foo [] "bye" 'b' ]
 -- [ Foo
 --     [ "bar"
 --     , "baz"
---     ] "hello"
--- , Foo [] "bye"
+--     ] "hello" 'a'
+-- , Foo [] "bye" 'b'
 -- ]
 --
 -- __Record__
@@ -582,7 +582,7 @@
 --   } deriving Show
 -- :}
 --
--- >>> pPrint $ Bar 1 [10, 11] [Foo 1.1 "", Foo 2.2 "hello"]
+-- >>> pPrint $ Bar 1 [10, 11] [Foo 1.1 "" 'a', Foo 2.2 "hello" 'b']
 -- Bar
 --     { barInt = 1
 --     , barA =
@@ -590,8 +590,8 @@
 --         , 11
 --         ]
 --     , barList =
---         [ Foo 1.1 ""
---         , Foo 2.2 "hello"
+--         [ Foo 1.1 "" 'a'
+--         , Foo 2.2 "hello" 'b'
 --         ]
 --     }
 --
diff --git a/src/Text/Pretty/Simple/Internal/Expr.hs b/src/Text/Pretty/Simple/Internal/Expr.hs
--- a/src/Text/Pretty/Simple/Internal/Expr.hs
+++ b/src/Text/Pretty/Simple/Internal/Expr.hs
@@ -36,6 +36,7 @@
   | Braces !(CommaSeparated [Expr])
   | Parens !(CommaSeparated [Expr])
   | StringLit !String
+  | CharLit !String
   | NumberLit !String
   -- ^ We could store this as a 'Rational', say, instead of a 'String'.
   -- However, we will never need to use its value for anything. Indeed, the
diff --git a/src/Text/Pretty/Simple/Internal/ExprParser.hs b/src/Text/Pretty/Simple/Internal/ExprParser.hs
--- a/src/Text/Pretty/Simple/Internal/ExprParser.hs
+++ b/src/Text/Pretty/Simple/Internal/ExprParser.hs
@@ -39,15 +39,21 @@
 parseExpr ('[':rest) = first (Brackets . CommaSeparated) $ parseCSep ']' rest
 parseExpr ('{':rest) = first (Braces . CommaSeparated) $ parseCSep '}' rest
 parseExpr ('"':rest) = first StringLit $ parseStringLit rest
+parseExpr ('\'':rest) = first CharLit $ parseCharLit rest
 parseExpr (c:rest) | isDigit c = first NumberLit $ parseNumberLit c rest
 parseExpr other      = first Other $ parseOther other
 
--- |
+-- | Parse multiple expressions.
 --
+-- >>> parseExprs "Just 'a'"
+-- ([Other "Just ",CharLit "a"],"")
+--
 -- Handle escaped characters correctly
 --
 -- >>> parseExprs $ "Foo \"hello \\\"world!\""
 -- ([Other "Foo ",StringLit "hello \\\"world!"],"")
+-- >>> parseExprs $ "'\\''"
+-- ([CharLit "\\'"],"")
 parseExprs :: String -> ([Expr], String)
 parseExprs [] = ([], "")
 parseExprs s@(c:_)
@@ -68,6 +74,15 @@
                     (toParse, rest) = parseCSep end rest'
                  in (parsed : toParse, rest)
 
+-- | Parse string literals until a trailing double quote.
+--
+-- >>> parseStringLit "foobar\" baz"
+-- ("foobar"," baz")
+--
+-- Keep literal back slashes:
+--
+-- >>> parseStringLit "foobar\\\" baz\" after"
+-- ("foobar\\\" baz"," after")
 parseStringLit :: String -> (String, String)
 parseStringLit [] = ("", "")
 parseStringLit ('"':rest) = ("", rest)
@@ -76,6 +91,23 @@
 parseStringLit (c:cs) = (c:cs', rest)
   where (cs', rest) = parseStringLit cs
 
+-- | Parse character literals until a trailing single quote.
+--
+-- >>> parseCharLit "a' foobar"
+-- ("a"," foobar")
+--
+-- Keep literal back slashes:
+--
+-- >>> parseCharLit "\\'' hello"
+-- ("\\'"," hello")
+parseCharLit :: String -> (String, String)
+parseCharLit [] = ("", "")
+parseCharLit ('\'':rest) = ("", rest)
+parseCharLit ('\\':c:cs) = ('\\':c:cs', rest)
+  where (cs', rest) = parseCharLit cs
+parseCharLit (c:cs) = (c:cs', rest)
+  where (cs', rest) = parseCharLit cs
+
 -- | Parses integers and reals, like @123@ and @45.67@.
 --
 -- To be more precise, any numbers matching the regex @\\d+(\\.\\d+)?@ should
@@ -130,7 +162,7 @@
       -> (String, String)
     go _ [] = ("", "")
     go insideIdent cs@(c:cs')
-      | c `elem` ("{[()]}\"," :: String) = ("", cs)
+      | c `elem` ("{[()]}\"'," :: String) = ("", cs)
       | isDigit c && not insideIdent = ("", cs)
       | insideIdent = first (c :) (go (isIdentRest c) cs')
       | otherwise = first (c :) (go (isIdentBegin c) cs')
diff --git a/src/Text/Pretty/Simple/Internal/ExprToOutput.hs b/src/Text/Pretty/Simple/Internal/ExprToOutput.hs
--- a/src/Text/Pretty/Simple/Internal/ExprToOutput.hs
+++ b/src/Text/Pretty/Simple/Internal/ExprToOutput.hs
@@ -227,6 +227,10 @@
   nest <- gets nestLevel
   when (nest < 0) $ addToNestLevel 1
   addOutputs [OutputStringLit string, OutputOther " "]
+putExpression (CharLit string) = do
+  nest <- gets nestLevel
+  when (nest < 0) $ addToNestLevel 1
+  addOutputs [OutputCharLit string, OutputOther " "]
 putExpression (NumberLit integer) = do
   nest <- gets nestLevel
   when (nest < 0) $ addToNestLevel 1
diff --git a/src/Text/Pretty/Simple/Internal/Output.hs b/src/Text/Pretty/Simple/Internal/Output.hs
--- a/src/Text/Pretty/Simple/Internal/Output.hs
+++ b/src/Text/Pretty/Simple/Internal/Output.hs
@@ -70,6 +70,8 @@
   -- of the other tokens.
   | OutputStringLit !String
   -- ^ This represents a string literal.  For instance, @\"foobar\"@.
+  | OutputCharLit !String
+  -- ^ This represents a char literal.  For example, @'x'@ or @'\b'@
   | OutputNumberLit !String
   -- ^ This represents a numeric literal.  For example, @12345@ or @3.14159@.
   deriving (Data, Eq, Generic, Read, Show, Typeable)
diff --git a/src/Text/Pretty/Simple/Internal/OutputPrinter.hs b/src/Text/Pretty/Simple/Internal/OutputPrinter.hs
--- a/src/Text/Pretty/Simple/Internal/OutputPrinter.hs
+++ b/src/Text/Pretty/Simple/Internal/OutputPrinter.hs
@@ -184,6 +184,18 @@
 
         readStr :: String -> String
         readStr s = fromMaybe s . readMaybe $ '"':s ++ "\""
+renderOutput (Output _ (OutputCharLit string)) = do
+  sequenceFold
+    [ useColorQuote
+    , pure "'"
+    , useColorReset
+    , useColorString
+    , pure (fromString string)
+    , useColorReset
+    , useColorQuote
+    , pure "'"
+    , useColorReset
+    ]
 
 -- | Replace non-printable characters with hex escape sequences.
 --