diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,12 @@
 `small-bytearray-builder` is now just a compatibility shim
 to ease the migration process.
 
+## 0.3.7.0 -- 2020-11-06
+
+* Fix build error in test suite.
+* Add `ascii7` and `ascii8`.
+* Performance tweak for json string escape builder.
+
 ## 0.3.6.0 -- 2020-06-30
 
 * Add `replicate`.
diff --git a/bytebuild.cabal b/bytebuild.cabal
--- a/bytebuild.cabal
+++ b/bytebuild.cabal
@@ -1,6 +1,6 @@
 cabal-version: 2.2
 name: bytebuild
-version: 0.3.6.0
+version: 0.3.7.0
 synopsis: Serialize to a small byte arrays
 description:
   This is similar to the builder facilities provided by
diff --git a/src/Data/Bytes/Builder.hs b/src/Data/Bytes/Builder.hs
--- a/src/Data/Bytes/Builder.hs
+++ b/src/Data/Bytes/Builder.hs
@@ -64,6 +64,8 @@
   , ascii4
   , ascii5
   , ascii6
+  , ascii7
+  , ascii8
   , char
     -- ** Machine-Readable
     -- *** One
@@ -649,17 +651,18 @@
         then case indexChar8Array (ByteArray src#) soff of
           '\\' -> write2 dst doff '\\' '\\' *> go (soff + 1) (slen - 1) (doff + 2)
           '\"' -> write2 dst doff '\\' '\"' *> go (soff + 1) (slen - 1) (doff + 2)
-          '\n' -> write2 dst doff '\\' 'n' *> go (soff + 1) (slen - 1) (doff + 2)
-          '\r' -> write2 dst doff '\\' 'r' *> go (soff + 1) (slen - 1) (doff + 2)
-          '\t' -> write2 dst doff '\\' 't' *> go (soff + 1) (slen - 1) (doff + 2)
           c -> if c >= '\x20'
             then PM.writeByteArray dst doff (c2w c) *> go (soff + 1) (slen - 1) (doff + 1)
-            else do
-              write2 dst doff '\\' 'u'
-              doff' <- UnsafeBounded.pasteST
-                (Bounded.word16PaddedUpperHex (fromIntegral (c2w c)))
-                dst (doff + 2)
-              go (soff + 1) (slen - 1) doff'
+            else case c of
+              '\n' -> write2 dst doff '\\' 'n' *> go (soff + 1) (slen - 1) (doff + 2)
+              '\r' -> write2 dst doff '\\' 'r' *> go (soff + 1) (slen - 1) (doff + 2)
+              '\t' -> write2 dst doff '\\' 't' *> go (soff + 1) (slen - 1) (doff + 2)
+              _ -> do
+                write2 dst doff '\\' 'u'
+                doff' <- UnsafeBounded.pasteST
+                  (Bounded.word16PaddedUpperHex (fromIntegral (c2w c)))
+                  dst (doff + 2)
+                go (soff + 1) (slen - 1) doff'
         else pure doff
   doffRes <- go (I# soff0#) (I# slen0#) (doff0 + 1)
   PM.writeByteArray dst doffRes (c2w '"')
@@ -860,10 +863,20 @@
 ascii5 :: Char -> Char -> Char -> Char -> Char -> Builder
 ascii5 a b c d e = fromBounded Nat.constant (Bounded.ascii5 a b c d e)
 
--- | Encode five ASCII characters.
+-- | Encode six ASCII characters.
 -- Precondition: Must be an ASCII characters. This is not checked.
 ascii6 :: Char -> Char -> Char -> Char -> Char -> Char -> Builder
 ascii6 a b c d e f = fromBounded Nat.constant (Bounded.ascii6 a b c d e f)
+
+-- | Encode seven ASCII characters.
+-- Precondition: Must be an ASCII characters. This is not checked.
+ascii7 :: Char -> Char -> Char -> Char -> Char -> Char -> Char -> Builder
+ascii7 a b c d e f g = fromBounded Nat.constant (Bounded.ascii7 a b c d e f g)
+
+-- | Encode eight ASCII characters.
+-- Precondition: Must be an ASCII characters. This is not checked.
+ascii8 :: Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Builder
+ascii8 a b c d e f g h = fromBounded Nat.constant (Bounded.ascii8 a b c d e f g h)
 
 -- | Encode a UTF-8 char. This only uses as much space as is required.
 char :: Char -> Builder
diff --git a/src/Data/Bytes/Builder/Bounded.hs b/src/Data/Bytes/Builder/Bounded.hs
--- a/src/Data/Bytes/Builder/Bounded.hs
+++ b/src/Data/Bytes/Builder/Bounded.hs
@@ -65,6 +65,8 @@
   , ascii4
   , ascii5
   , ascii6
+  , ascii7
+  , ascii8
   , char
     -- ** Native
   , wordPaddedDec2
@@ -794,6 +796,33 @@
   primitive_ (writeCharArray# arr (off +# 4# ) c4)
   primitive_ (writeCharArray# arr (off +# 5# ) c5)
   pure (I# (off +# 6# ))
+
+-- | Encode seven ASCII characters. Precondition: Must be an ASCII characters.
+-- This is not checked.
+ascii7 :: Char -> Char -> Char -> Char -> Char -> Char -> Char -> Builder 7
+ascii7 (C# c0) (C# c1) (C# c2) (C# c3) (C# c4) (C# c5) (C# c6) = Unsafe.construct $ \(MutableByteArray arr) (I# off) -> do
+  primitive_ (writeCharArray# arr off c0)
+  primitive_ (writeCharArray# arr (off +# 1# ) c1)
+  primitive_ (writeCharArray# arr (off +# 2# ) c2)
+  primitive_ (writeCharArray# arr (off +# 3# ) c3)
+  primitive_ (writeCharArray# arr (off +# 4# ) c4)
+  primitive_ (writeCharArray# arr (off +# 5# ) c5)
+  primitive_ (writeCharArray# arr (off +# 6# ) c6)
+  pure (I# (off +# 7# ))
+
+-- | Encode eight ASCII characters. Precondition: Must be an ASCII characters.
+-- This is not checked.
+ascii8 :: Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Builder 8
+ascii8 (C# c0) (C# c1) (C# c2) (C# c3) (C# c4) (C# c5) (C# c6) (C# c7) = Unsafe.construct $ \(MutableByteArray arr) (I# off) -> do
+  primitive_ (writeCharArray# arr off c0)
+  primitive_ (writeCharArray# arr (off +# 1# ) c1)
+  primitive_ (writeCharArray# arr (off +# 2# ) c2)
+  primitive_ (writeCharArray# arr (off +# 3# ) c3)
+  primitive_ (writeCharArray# arr (off +# 4# ) c4)
+  primitive_ (writeCharArray# arr (off +# 5# ) c5)
+  primitive_ (writeCharArray# arr (off +# 6# ) c6)
+  primitive_ (writeCharArray# arr (off +# 7# ) c7)
+  pure (I# (off +# 8# ))
 
 -- | Encode a machine-sized word with LEB-128.
 wordLEB128 :: Word -> Builder 10
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -5,6 +5,8 @@
 
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
+import Prelude hiding (replicate)
+
 import Control.Applicative (liftA2)
 import Control.Monad.ST (runST)
 import Data.Bytes.Builder
@@ -35,6 +37,7 @@
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as TE
 import qualified GHC.Exts as Exts
+import qualified Prelude
 import qualified Test.Tasty.HUnit as THU
 import qualified Test.Tasty.QuickCheck as TQC
 
@@ -321,7 +324,7 @@
 
 zeroPadL :: Int -> String -> String
 zeroPadL n s
-  | length s < n = replicate (n - length s) '0' ++ s
+  | length s < n = Prelude.replicate (n - length s) '0' ++ s
   | otherwise = s
 
 naiveLeb128 :: Natural -> ByteArray