diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,9 @@
 
 # Changelog by versions
 
+## From 3.22.1.0 to 3.22.2.0
+* New render method: renderBuilder.
+
 ## From 3.22.0.0 to 3.22.1.0
 * Export PlainDOI type synonym.
 * Comment out QuickCheck parser test. See https://github.com/Daniel-Diaz/HaTeX/issues/144.
diff --git a/HaTeX.cabal b/HaTeX.cabal
--- a/HaTeX.cabal
+++ b/HaTeX.cabal
@@ -1,5 +1,5 @@
 Name: HaTeX
-Version: 3.22.1.0
+Version: 3.22.2.0
 Author: Daniel Díaz
 Category: LaTeX
 Build-type: Simple
diff --git a/Text/LaTeX/Base/Render.hs b/Text/LaTeX/Base/Render.hs
--- a/Text/LaTeX/Base/Render.hs
+++ b/Text/LaTeX/Base/Render.hs
@@ -22,15 +22,20 @@
  , showFloat
    ) where
 
-import Data.Text (Text,lines,unlines)
 import Text.LaTeX.Base.Syntax
 import Text.LaTeX.Base.Class
 import Data.String
-import Data.Text.Encoding
 import Data.List (intersperse)
 import qualified Data.ByteString as B
 import Data.Word (Word8)
 import Numeric (showFFloat)
+import Data.Text (Text,lines,unlines)
+import Data.Text.Encoding
+import Data.Text.Lazy (toStrict)
+import Data.Text.Lazy.Builder (Builder)
+import qualified Data.Text.Lazy.Builder as Builder
+import qualified Data.Text.Lazy.Builder.Int as Builder
+import qualified Data.Text.Lazy.Builder.RealFloat as Builder
 
 -- | Class of values that can be transformed to 'Text'.
 -- You mainly will use this to obtain the 'Text' output
@@ -47,9 +52,14 @@
 --
 class Show a => Render a where
  render :: a -> Text
+ renderBuilder :: a -> Builder
  --
  render = fromString . show
+ renderBuilder = Builder.fromText . render
 
+renderDefault :: Render a => a -> Text
+renderDefault = toStrict . Builder.toLazyText . renderBuilder
+
 -- | This instance escapes LaTeX reserved characters.
 instance Render Text where
  render = protectText
@@ -58,16 +68,25 @@
 renderAppend :: Render a => [a] -> Text
 renderAppend = mconcat . fmap render
 
+renderAppendBuilder :: Render a => [a] -> Builder
+renderAppendBuilder = foldMap renderBuilder
+
 -- | Render every element of a list and append results,
 --   separated by the given 'Char'.
 renderChars :: Render a => Char -> [a] -> Text
 renderChars c = mconcat . intersperse (fromString [c]) . fmap render
 
+renderCharsBuilder :: Render a => Char -> [a] -> Builder
+renderCharsBuilder c = mconcat . intersperse (Builder.singleton c) . fmap renderBuilder
+
 -- | Render every element of a list and append results,
 --   separated by commas.
 renderCommas :: Render a => [a] -> Text
 renderCommas = renderChars ','
 
+renderCommasBuilder :: Render a => [a] -> Builder
+renderCommasBuilder = renderCharsBuilder ','
+
 -- | Use this function to render a 'LaTeX' (or another
 --   one in the 'Render' class) value directly
 --   in a file.
@@ -104,53 +123,56 @@
 
 instance Render LaTeX where
   
-  render (TeXRaw t) = t
+  renderBuilder (TeXRaw t) = Builder.fromText t
   
-  render (TeXComm name []) = "\\" <> fromString name <> "{}"
-  render (TeXComm name args) =
+  renderBuilder (TeXComm name []) = "\\" <> fromString name <> "{}"
+  renderBuilder (TeXComm name args) =
       "\\"
    <> fromString name
-   <> renderAppend args
-  render (TeXCommS name) = "\\" <> fromString name
+   <> renderAppendBuilder args
+  renderBuilder (TeXCommS name) = "\\" <> fromString name
   
-  render (TeXEnv name args c) =
+  renderBuilder (TeXEnv name args c) =
       "\\begin{"
    <> fromString name
    <> "}"
-   <> renderAppend args
-   <> render c
+   <> renderAppendBuilder args
+   <> renderBuilder c
    <> "\\end{"
    <> fromString name
    <> "}"
 
-  render (TeXMath Dollar l) = "$" <> render l <> "$"
-  render (TeXMath DoubleDollar l) = "$$" <> render l <> "$$"
-  render (TeXMath Square l) = "\\[" <> render l <> "\\]"
-  render (TeXMath Parentheses l) = "\\(" <> render l <> "\\)"
+  renderBuilder (TeXMath Dollar l) = "$" <> renderBuilder l <> "$"
+  renderBuilder (TeXMath DoubleDollar l) = "$$" <> renderBuilder l <> "$$"
+  renderBuilder (TeXMath Square l) = "\\[" <> renderBuilder l <> "\\]"
+  renderBuilder (TeXMath Parentheses l) = "\\(" <> renderBuilder l <> "\\)"
 
-  render (TeXLineBreak m b) = "\\\\" <> maybe mempty (\x -> "[" <> render x <> "]") m <> ( if b then "*" else mempty )
+  renderBuilder (TeXLineBreak m b) = "\\\\" <> maybe mempty (\x -> "[" <> renderBuilder x <> "]") m <> ( if b then "*" else mempty )
 
-  render (TeXBraces l) = "{" <> render l <> "}"
+  renderBuilder (TeXBraces l) = "{" <> renderBuilder l <> "}"
 
-  render (TeXComment c) =
+  renderBuilder (TeXComment c) =
    let xs = Data.Text.lines c
    in if null xs then "%\n"
-                 else Data.Text.unlines $ fmap ("%" <>) xs
+                 else Builder.fromText $ Data.Text.unlines $ fmap ("%" <>) xs
 
-  render (TeXSeq l1 l2) = render l1 <> render l2
-  render TeXEmpty = mempty
+  renderBuilder (TeXSeq l1 l2) = renderBuilder l1 <> renderBuilder l2
+  renderBuilder TeXEmpty = mempty
 
+  render = renderDefault
+
 instance Render TeXArg where
- render (FixArg l) = "{" <> render l <> "}"
- render (OptArg l) = "[" <> render l <> "]"
- render (MOptArg []) = mempty
- render (MOptArg ls) = "[" <> renderCommas ls <> "]"
- render (SymArg l) = "<" <> render l <> ">"
- render (MSymArg []) = mempty
- render (MSymArg ls) = "<" <> renderCommas ls <> ">"
- render (ParArg l) = "(" <> render l <> ")"
- render (MParArg []) = mempty
- render (MParArg ls) = "(" <> renderCommas ls <> ")"
+ renderBuilder (FixArg l) = "{" <> renderBuilder l <> "}"
+ renderBuilder (OptArg l) = "[" <> renderBuilder l <> "]"
+ renderBuilder (MOptArg []) = mempty
+ renderBuilder (MOptArg ls) = "[" <> renderCommasBuilder ls <> "]"
+ renderBuilder (SymArg l) = "<" <> renderBuilder l <> ">"
+ renderBuilder (MSymArg []) = mempty
+ renderBuilder (MSymArg ls) = "<" <> renderCommasBuilder ls <> ">"
+ renderBuilder (ParArg l) = "(" <> renderBuilder l <> ")"
+ renderBuilder (MParArg []) = mempty
+ renderBuilder (MParArg ls) = "(" <> renderCommasBuilder ls <> ")"
+ render = renderDefault
 
 -- Other instances
 
@@ -159,12 +181,24 @@
 showFloat x = showFFloat (Just 5) x []
 
 instance Render Int where
+  renderBuilder = Builder.decimal
+  render = renderDefault
+
 instance Render Integer where
+  renderBuilder = Builder.decimal
+  render = renderDefault
+
 instance Render Float where
-  render = fromString . showFloat
+  renderBuilder = Builder.formatRealFloat Builder.Fixed (Just 5)
+  render = renderDefault
+
 instance Render Double where
-  render = fromString . showFloat
+  renderBuilder = Builder.formatRealFloat Builder.Fixed (Just 5)
+  render = renderDefault
+
 instance Render Word8 where
+  renderBuilder = Builder.decimal
+  render = renderDefault
 
 -- | 'Render' instance for 'Bool'. It satisfies @render True = "true"@ and @render False = "false"@.
 instance Render Bool where
@@ -172,4 +206,5 @@
   render _ = "false"
 
 instance Render a => Render [a] where
- render xs = "[" <> renderCommas xs <> "]"
+ renderBuilder xs = "[" <> renderCommasBuilder xs <> "]"
+ render = renderDefault