gohtml

GoHTML

中文 | English

A collection of powerful and easy-to-use Go HTML template engines with unified interfaces, featuring template inheritance, hot reload, and rich built-in functions.

Template Engines

GoHTML provides three template engine implementations:

📦 template - Go Standard Library Based

Built on Go's standard html/template library with template inheritance support.

Features:

• 🎯 Template inheritance with {{ extends "parent.gohtml" }}
• 🔒 Auto-escaping for XSS protection
• 🧩 20+ built-in functions
• 0️⃣ Zero external dependencies

→ View template package documentation

⚡ jet - High Performance

Wrapper for the Jet template engine with Django/Jinja2-like syntax.

Features:

• ⚡ One of the fastest Go template engines
• 🎨 Django/Jinja2-style syntax
• 🔧 Highly extensible
• 🌐 Built-in template inheritance

→ View jet package documentation

🎨 pongo2 - Django Compatible

Wrapper for the Pongo2 template engine with Django template compatibility.

Features:

• 🎨 Django-compatible syntax
• 🔒 Auto-escaping with XSS protection
• 🔧 Custom filters and tags
• 🌐 Built-in template inheritance

→ View pongo2 package documentation

Installation

go get github.com/h3go/gohtml

Quick Start

Using the template package (Standard Library)

package main

import (
    "bytes"
    "fmt"
    "github.com/h3go/gohtml/template"
)

func main() {
    engine := template.New()
    engine.JoinDir("./templates")
    
    var buf bytes.Buffer
    engine.Render(&buf, "index", map[string]any{
        "Title":   "Welcome",
        "Message": "Hello, GoHTML!",
    })
    
    fmt.Println(buf.String())
}

Using the jet package

package main

import (
    "bytes"
    "github.com/h3go/gohtml/jet"
)

func main() {
    engine := jet.New()
    engine.JoinDir("./templates")
    
    var buf bytes.Buffer
    engine.Render(&buf, "index.jet", map[string]any{
        "Title":   "Welcome",
        "Message": "Hello, Jet!",
    })
}

Using the pongo2 package

package main

import (
    "bytes"
    "github.com/h3go/gohtml/pongo2"
)

func main() {
    engine := pongo2.New()
    engine.JoinDir("./templates")
    
    var buf bytes.Buffer
    engine.Render(&buf, "index.html", map[string]any{
        "Title":   "Welcome",
        "Message": "Hello, Pongo2!",
    })
}

HTTP Middleware Integration

GoHTML provides HTTP middleware for easy integration with web applications:

package main

import (
    "net/http"
    "github.com/h3go/gohtml"
    "github.com/h3go/gohtml/template"
)

func main() {
    engine := template.New()
    engine.JoinDir("./templates")
    
    mux := http.NewServeMux()
    
    // Use middleware to inject engine and global data
    handler := gohtml.Middleware(engine, map[string]any{
        "SiteName": "My Website",
        "Version":  "1.0.0",
    })(mux)
    
    // Route handler
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        err := gohtml.Render(r.Context(), w, "index", map[string]any{
            "Title":   "Home",
            "Content": "Welcome",
        })
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
        }
    })
    
    http.ListenAndServe(":8080", handler)
}

Context Functions API

import "github.com/h3go/gohtml"

// Store engine in context
func WithEngine(ctx context.Context, engine Engine) context.Context

// Get engine from context
func FromContext(ctx context.Context) (Engine, bool)

// Store single data item in context
func WithDatum(ctx context.Context, key string, value any) context.Context

// Store multiple data items in context
func WithData(ctx context.Context, dataMap map[string]any) context.Context

// Get all data from context
func GetData(ctx context.Context) map[string]any

// Get engine from context and render template (auto-merge global data)
func Render(ctx context.Context, w io.Writer, name string, data map[string]any) error

HTTP Middleware API

import "github.com/h3go/gohtml"

// Create HTTP middleware
// engine: the template engine to inject into requests
// globals: optional global data to inject into all templates
func Middleware(engine Engine, globals ...map[string]any) func(next http.Handler) http.Handler

Choosing a Template Engine

Documentation

• template package - Standard library based engine
• jet package - High-performance engine
• pongo2 package - Django-compatible engine

License

MIT License - See LICENSE

Contributing

Issues and Pull Requests are welcome!

Author

h3go