Are you happy with your logging solution? Would you help us out by taking a 30-second survey? Click here


Simple and fast template engine for Go

Subscribe to updates I use fasttemplate

Statistics on fasttemplate

Number of watchers on Github 178
Number of open issues 3
Average time to close an issue about 2 hours
Main language Go
Average time to merge a PR about 1 month
Open pull requests 1+
Closed pull requests 1+
Last commit almost 3 years ago
Repo Created over 4 years ago
Repo Last Updated almost 2 years ago
Size 23 KB
Organization / Authorvalyala
Page Updated
Do you use fasttemplate? Leave a review!
View open issues (3)
View fasttemplate activity
View on github
Fresh, new opensource launches 🚀🚀🚀
Trendy new open source projects in your inbox! View examples

Subscribe to our mailing list

Evaluating fasttemplate for your project? Score Explanation
Commits Score (?)
Issues & PR Score (?)


Simple and fast template engine for Go.

Fasttemplate peforms only a single task - it substitutes template placeholders with user-defined values. At high speed :)

Take a look at quicktemplate if you need fast yet powerful html template engine.

Please note that fasttemplate doesn't do any escaping on template values unlike html/template do. So values must be properly escaped before passing them to fasttemplate.

Fasttemplate is faster than text/template, strings.Replace, strings.Replacer and fmt.Fprintf on placeholders' substitution.

Below are benchmark results comparing fasttemplate performance to text/template, strings.Replace, strings.Replacer and fmt.Fprintf:

$ go test -bench=. -benchmem
BenchmarkFmtFprintf-4                        2000000           790 ns/op           0 B/op          0 allocs/op
BenchmarkStringsReplace-4                     500000          3474 ns/op        2112 B/op         14 allocs/op
BenchmarkStringsReplacer-4                    500000          2657 ns/op        2256 B/op         23 allocs/op
BenchmarkTextTemplate-4                       500000          3333 ns/op         336 B/op         19 allocs/op
BenchmarkFastTemplateExecuteFunc-4           5000000           349 ns/op           0 B/op          0 allocs/op
BenchmarkFastTemplateExecute-4               3000000           383 ns/op           0 B/op          0 allocs/op
BenchmarkFastTemplateExecuteFuncString-4     3000000           549 ns/op         144 B/op          1 allocs/op
BenchmarkFastTemplateExecuteString-4         3000000           572 ns/op         144 B/op          1 allocs/op
BenchmarkFastTemplateExecuteTagFunc-4        2000000           743 ns/op         144 B/op          3 allocs/op


See .


    template := "http://{{host}}/?q={{query}}&foo={{bar}}{{bar}}"
    t := fasttemplate.New(template, "{{", "}}")
    s := t.ExecuteString(map[string]interface{}{
        "host":  "",
        "query": url.QueryEscape("hello=world"),
        "bar":   "foobar",
    fmt.Printf("%s", s)

    // Output:

Advanced usage

    template := "Hello, [user]! You won [prize]!!! [foobar]"
    t, err := fasttemplate.NewTemplate(template, "[", "]")
    if err != nil {
        log.Fatalf("unexpected error when parsing template: %s", err)
    s := t.ExecuteFuncString(func(w io.Writer, tag string) (int, error) {
        switch tag {
        case "user":
            return w.Write([]byte("John"))
        case "prize":
            return w.Write([]byte("$100500"))
            return w.Write([]byte(fmt.Sprintf("[unknown tag %q]", tag)))
    fmt.Printf("%s", s)

    // Output:
    // Hello, John! You won $100500!!! [unknown tag "foobar"]
fasttemplate open pull requests (View All Pulls)
  • adding Tags() method
fasttemplate list of languages used
Other projects in Go