diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.2.0.0
+
+* Changed `format` and `formatLn` to be polyvariadic.
+
 # 0.1.0.0
 
 * Added `genericF` for formatting arbitrary data.
diff --git a/fmt.cabal b/fmt.cabal
--- a/fmt.cabal
+++ b/fmt.cabal
@@ -1,5 +1,5 @@
 name:                fmt
-version:             0.1.0.0
+version:             0.2.0.0
 synopsis:            A new formatting library
 description:
   A new formatting library that tries to be simple to understand while still
diff --git a/lib/Fmt.hs b/lib/Fmt.hs
--- a/lib/Fmt.hs
+++ b/lib/Fmt.hs
@@ -158,7 +158,6 @@
 -- 'Buildable' and text-format
 import Data.Text.Buildable
 import qualified Data.Text.Format as TF
-import qualified Data.Text.Format.Params as TF
 -- Text 'Builder'
 import Data.Text.Lazy.Builder hiding (fromString)
 -- 'Foldable' and 'IsList' for list/map formatters
@@ -449,31 +448,24 @@
 {- | An old-style formatting function taken from @text-format@ (see
 "Data.Text.Format"). Unlike 'Data.Text.Format.format' from
 "Data.Text.Format", it can produce 'String' and strict 'Text' as well (and
-print to console too).
-
-To provide substitution arguments, use a tuple:
+print to console too). Also it's polyvariadic:
 
->>> format "{} + {} = {}" (2, 2, 4)
+>>> format "{} + {} = {}" 2 2 4
 "2 + 2 = 4"
 
 You can use arbitrary formatters:
 
->>> format "0x{} + 0x{} = 0x{}" (hexF 130, hexF 270, hexF (130+270))
-"2 + 2 = 4"
-
-To provide just one argument, use a list instead of a tuple:
-
->>> format "Hello {}!" ["world"]
-"Hello world!"
+>>> format "0x{} + 0x{} = 0x{}" (hexF 130) (hexF 270) (hexF (130+270))
+"0x82 + 0x10e = 0x190"
 -}
-format :: (FromBuilder b, TF.Params ps) => TF.Format -> ps -> b
-format f ps = fromBuilder (TF.build f ps)
+format :: FormatType r => TF.Format -> r
+format f = format' f []
 {-# INLINE format #-}
 
 {- | Like 'format', but adds a newline.
 -}
-formatLn :: (FromBuilder b, TF.Params ps) => TF.Format -> ps -> b
-formatLn f ps = fromBuilder (TF.build f ps <> "\n")
+formatLn :: FormatType r => TF.Format -> r
+formatLn f = format' (f <> "\n") []
 {-# INLINE formatLn #-}
 
 ----------------------------------------------------------------------------
@@ -1189,11 +1181,11 @@
   --   * And ":|" can be prefix when defined as "(:|) a b"
   gbuild c@(M1 x) = case conFixity c of
     Infix _ _
-      | [a, b] <- fields -> format "({} {} {})" (a, infixName, b)
+      | [a, b] <- fields -> format "({} {} {})" a infixName b
       -- this case should never happen, but still
       | otherwise        -> format "<{}: {}>"
-                              ( prefixName
-                              , mconcat (intersperse ", " fields) )
+                              prefixName
+                              (mconcat (intersperse ", " fields))
     Prefix
       | isTuple -> tupleLikeF fields
       | conIsRecord c -> nameF (build prefixName) (blockMapF fieldsWithNames)
@@ -1201,8 +1193,8 @@
       -- I believe that there will be only one field in this case
       | null (conName c) -> mconcat (intersperse ", " fields)
       | otherwise -> format "<{}: {}>"
-                       ( prefixName
-                       , mconcat (intersperse ", " fields) )
+                       prefixName
+                       (mconcat (intersperse ", " fields))
     where
       (prefixName, infixName)
         | ":" `isPrefixOf` conName c = ("(" ++ conName c ++ ")", conName c)
diff --git a/lib/Fmt/Internal.hs b/lib/Fmt/Internal.hs
--- a/lib/Fmt/Internal.hs
+++ b/lib/Fmt/Internal.hs
@@ -4,9 +4,16 @@
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE CPP #-}
 
--- for FormatAsHex
+-- for FormatAsHex and FormatType
 #if __GLASGOW_HASKELL__ < 710
 {-# LANGUAGE OverlappingInstances #-}
+#  define _OVERLAPPING_
+#  define _OVERLAPPABLE_
+#  define _OVERLAPS_
+#else
+#  define _OVERLAPPING_ {-# OVERLAPPING #-}
+#  define _OVERLAPPABLE_ {-# OVERLAPPABLE #-}
+#  define _OVERLAPS_ {-# OVERLAPS #-}
 #endif
 
 {- | A module providing access to internals (in case you really need them). Can
@@ -25,6 +32,9 @@
   GetFields(..),
   Buildable'(..),
 
+  -- * Polyvariadic 'format'
+  FormatType(..),
+  
   -- * Helpers
   groupInt,
   atBase,
@@ -109,13 +119,8 @@
 instance FormatAsHex BSL.ByteString where
   hexF = fromLazyText . TL.decodeLatin1 . B16L.encode
 
-#if __GLASGOW_HASKELL__ >= 710
-instance {-# OVERLAPPABLE #-} Integral a => FormatAsHex a where
-  hexF = TF.hex
-#else
-instance Integral a => FormatAsHex a where
+instance _OVERLAPPABLE_ Integral a => FormatAsHex a where
   hexF = TF.hex
-#endif
 
 ----------------------------------------------------------------------------
 -- Base64
@@ -128,7 +133,7 @@
 >>> base64F ("\0\50\63\80" :: BS.ByteString)
 "ADI/UA=="
   -}
-  base64F    :: a -> Builder
+  base64F :: a -> Builder
   {- |
 Convert a bytestring to base64url (a variant of base64 which omits @\/@ and
 thus can be used in URLs):
@@ -186,6 +191,20 @@
 -- tuples, lists, maps, etc., as well as combinations thereof.
 class Buildable' a where
   build' :: a -> Builder
+
+----------------------------------------------------------------------------
+-- Classes used for polyvariadic 'format'
+----------------------------------------------------------------------------
+
+-- | Something like 'Text.Printf.PrintfType' in "Text.Printf".
+class FormatType r where
+  format' :: TF.Format -> [Builder] -> r
+
+instance (Buildable a, FormatType r) => FormatType (a -> r) where
+  format' f xs = \x -> format' f (build x : xs)
+
+instance _OVERLAPPABLE_ FromBuilder r => FormatType r where
+  format' f xs = fromBuilder $ TF.build f (reverse xs)
 
 ----------------------------------------------------------------------------
 -- Helpers