feat: add AST caching for faster template rendering

Add in-memory LRU cache and optional disk-based cache for compiled
template ASTs. This avoids repeated parsing of the same templates.

New Config options:
- CachePath: directory for disk-based gob cache
- MaxCacheSize: max entries in memory cache (0 = unlimited)
- EnableSIGHUP: clear cache on SIGHUP signal

Breaking change: New() now returns (*Renderer, error)

cache.go

···
+package gott
+
+import (
+    "container/list"
+    "sync"
+)
+
+// cacheEntry holds a cached template AST
+type cacheEntry struct {
+    key     string
+    tmpl    *Template
+    element *list.Element // pointer to LRU list element
+}
+
+// astCache is a thread-safe LRU cache for parsed template ASTs
+type astCache struct {
+    mu       sync.RWMutex
+    items    map[string]*cacheEntry
+    lru      *list.List // front = most recently used, back = least recently used
+    maxSize  int        // 0 = unlimited
+}
+
+// newCache creates a new LRU cache with the specified max size.
+// If maxSize is 0, the cache has no size limit.
+func newCache(maxSize int) *astCache {
+    return &astCache{
+        items:   make(map[string]*cacheEntry),
+        lru:     list.New(),
+        maxSize: maxSize,
+    }
+}
+
+// Get retrieves a cached template by key.
+// Returns the template and true if found, nil and false otherwise.
+// Accessing an entry moves it to the front of the LRU list.
+func (c *astCache) Get(key string) (*Template, bool) {
+    c.mu.Lock()
+    defer c.mu.Unlock()
+
+    entry, ok := c.items[key]
+    if !ok {
+        return nil, false
+    }
+
+    // Move to front of LRU list (most recently used)
+    c.lru.MoveToFront(entry.element)
+    return entry.tmpl, true
+}
+
+// Put stores a template in the cache.
+// If the cache is at capacity, the least recently used entry is evicted.
+func (c *astCache) Put(key string, tmpl *Template) {
+    c.mu.Lock()
+    defer c.mu.Unlock()
+
+    // Check if key already exists
+    if entry, ok := c.items[key]; ok {
+        // Update existing entry
+        entry.tmpl = tmpl
+        c.lru.MoveToFront(entry.element)
+        return
+    }
+
+    // Evict LRU entry if at capacity
+    if c.maxSize > 0 && len(c.items) >= c.maxSize {
+        c.evictLRU()
+    }
+
+    // Create new entry
+    entry := &cacheEntry{
+        key:  key,
+        tmpl: tmpl,
+    }
+    entry.element = c.lru.PushFront(entry)
+    c.items[key] = entry
+}
+
+// evictLRU removes the least recently used entry.
+// Caller must hold the write lock.
+func (c *astCache) evictLRU() {
+    oldest := c.lru.Back()
+    if oldest == nil {
+        return
+    }
+
+    entry := oldest.Value.(*cacheEntry)
+    c.lru.Remove(oldest)
+    delete(c.items, entry.key)
+}
+
+// Clear removes all entries from the cache.
+func (c *astCache) Clear() {
+    c.mu.Lock()
+    defer c.mu.Unlock()
+
+    c.items = make(map[string]*cacheEntry)
+    c.lru.Init()
+}
+
+// Len returns the number of entries in the cache.
+func (c *astCache) Len() int {
+    c.mu.RLock()
+    defer c.mu.RUnlock()
+    return len(c.items)
+}

cache_disk.go

···
+package gott
+
+import (
+    "crypto/sha256"
+    "encoding/gob"
+    "encoding/hex"
+    "os"
+    "path/filepath"
+)
+
+func init() {
+    // Register all AST types with gob for serialization.
+    // Gob requires concrete types to be registered when encoding/decoding interfaces.
+
+    // Root and text nodes
+    gob.Register(&Template{})
+    gob.Register(&TextNode{})
+
+    // Expression nodes
+    gob.Register(&IdentExpr{})
+    gob.Register(&LiteralExpr{})
+    gob.Register(&BinaryExpr{})
+    gob.Register(&UnaryExpr{})
+    gob.Register(&CallExpr{})
+    gob.Register(&FilterExpr{})
+    gob.Register(&DefaultExpr{})
+
+    // Statement nodes
+    gob.Register(&OutputStmt{})
+    gob.Register(&IfStmt{})
+    gob.Register(&UnlessStmt{})
+    gob.Register(&ForeachStmt{})
+    gob.Register(&BlockStmt{})
+    gob.Register(&IncludeStmt{})
+    gob.Register(&WrapperStmt{})
+    gob.Register(&SetStmt{})
+
+    // Supporting types
+    gob.Register(&ElsIfClause{})
+}
+
+// diskCache persists compiled templates to disk using gob encoding.
+type diskCache struct {
+    path string // directory for cache files
+}
+
+// newDiskCache creates a new disk cache at the specified path.
+// Creates the directory if it doesn't exist.
+func newDiskCache(path string) (*diskCache, error) {
+    if err := os.MkdirAll(path, 0755); err != nil {
+        return nil, err
+    }
+    return &diskCache{path: path}, nil
+}
+
+// hashKey creates a safe filename from a cache key using SHA256.
+func hashKey(key string) string {
+    h := sha256.Sum256([]byte(key))
+    return hex.EncodeToString(h[:]) + ".gob"
+}
+
+// Get retrieves a cached template from disk.
+// Returns nil and no error if the file doesn't exist.
+func (d *diskCache) Get(key string) (*Template, error) {
+    filename := filepath.Join(d.path, hashKey(key))
+
+    file, err := os.Open(filename)
+    if err != nil {
+        if os.IsNotExist(err) {
+            return nil, nil
+        }
+        return nil, err
+    }
+    defer file.Close()
+
+    var tmpl Template
+    decoder := gob.NewDecoder(file)
+    if err := decoder.Decode(&tmpl); err != nil {
+        // Corrupted cache file - remove it
+        os.Remove(filename)
+        return nil, nil
+    }
+
+    return &tmpl, nil
+}
+
+// Put stores a template to disk.
+func (d *diskCache) Put(key string, tmpl *Template) error {
+    filename := filepath.Join(d.path, hashKey(key))
+
+    file, err := os.Create(filename)
+    if err != nil {
+        return err
+    }
+    defer file.Close()
+
+    encoder := gob.NewEncoder(file)
+    return encoder.Encode(tmpl)
+}
+
+// Clear removes all cached templates from disk.
+func (d *diskCache) Clear() error {
+    entries, err := os.ReadDir(d.path)
+    if err != nil {
+        return err
+    }
+
+    for _, entry := range entries {
+        if entry.IsDir() {
+            continue
+        }
+        // Only remove .gob files to avoid deleting unrelated files
+        if filepath.Ext(entry.Name()) == ".gob" {
+            os.Remove(filepath.Join(d.path, entry.Name()))
+        }
+    }
+    return nil
+}

cache_test.go

···
+package gott
+
+import (
+    "io/fs"
+    "os"
+    "path/filepath"
+    "testing"
+    "testing/fstest"
+)
+
+// TestInMemoryCache tests the LRU cache behavior
+func TestInMemoryCache(t *testing.T) {
+    t.Run("basic get and put", func(t *testing.T) {
+        cache := newCache(0) // unlimited
+
+        // Put a template
+        tmpl := &Template{Nodes: []Node{&TextNode{Text: "hello"}}}
+        cache.Put("key1", tmpl)
+
+        // Get it back
+        got, ok := cache.Get("key1")
+        if !ok {
+            t.Fatal("expected to find key1 in cache")
+        }
+        if got != tmpl {
+            t.Error("got different template than stored")
+        }
+    })
+
+    t.Run("cache miss", func(t *testing.T) {
+        cache := newCache(0)
+
+        _, ok := cache.Get("nonexistent")
+        if ok {
+            t.Error("expected cache miss for nonexistent key")
+        }
+    })
+
+    t.Run("LRU eviction", func(t *testing.T) {
+        cache := newCache(2) // max 2 entries
+
+        tmpl1 := &Template{Nodes: []Node{&TextNode{Text: "1"}}}
+        tmpl2 := &Template{Nodes: []Node{&TextNode{Text: "2"}}}
+        tmpl3 := &Template{Nodes: []Node{&TextNode{Text: "3"}}}
+
+        cache.Put("key1", tmpl1)
+        cache.Put("key2", tmpl2)
+
+        // Verify both are present
+        if cache.Len() != 2 {
+            t.Errorf("expected 2 entries, got %d", cache.Len())
+        }
+
+        // Add a third, should evict key1 (LRU)
+        cache.Put("key3", tmpl3)
+
+        if cache.Len() != 2 {
+            t.Errorf("expected 2 entries after eviction, got %d", cache.Len())
+        }
+
+        // key1 should be gone (LRU)
+        _, ok := cache.Get("key1")
+        if ok {
+            t.Error("key1 should have been evicted")
+        }
+
+        // key2 and key3 should still be present
+        if _, ok := cache.Get("key2"); !ok {
+            t.Error("key2 should still be in cache")
+        }
+        if _, ok := cache.Get("key3"); !ok {
+            t.Error("key3 should still be in cache")
+        }
+    })
+
+    t.Run("LRU access updates order", func(t *testing.T) {
+        cache := newCache(2)
+
+        tmpl1 := &Template{Nodes: []Node{&TextNode{Text: "1"}}}
+        tmpl2 := &Template{Nodes: []Node{&TextNode{Text: "2"}}}
+        tmpl3 := &Template{Nodes: []Node{&TextNode{Text: "3"}}}
+
+        cache.Put("key1", tmpl1)
+        cache.Put("key2", tmpl2)
+
+        // Access key1 to make it recently used
+        cache.Get("key1")
+
+        // Add key3, should evict key2 (now LRU)
+        cache.Put("key3", tmpl3)
+
+        // key1 should still be present
+        if _, ok := cache.Get("key1"); !ok {
+            t.Error("key1 should still be in cache after being accessed")
+        }
+
+        // key2 should be gone
+        if _, ok := cache.Get("key2"); ok {
+            t.Error("key2 should have been evicted")
+        }
+    })
+
+    t.Run("clear cache", func(t *testing.T) {
+        cache := newCache(0)
+
+        cache.Put("key1", &Template{})
+        cache.Put("key2", &Template{})
+
+        cache.Clear()
+
+        if cache.Len() != 0 {
+            t.Errorf("expected empty cache after clear, got %d entries", cache.Len())
+        }
+
+        if _, ok := cache.Get("key1"); ok {
+            t.Error("key1 should not be in cache after clear")
+        }
+    })
+
+    t.Run("update existing key", func(t *testing.T) {
+        cache := newCache(0)
+
+        tmpl1 := &Template{Nodes: []Node{&TextNode{Text: "1"}}}
+        tmpl2 := &Template{Nodes: []Node{&TextNode{Text: "2"}}}
+
+        cache.Put("key1", tmpl1)
+        cache.Put("key1", tmpl2) // update
+
+        if cache.Len() != 1 {
+            t.Errorf("expected 1 entry after update, got %d", cache.Len())
+        }
+
+        got, _ := cache.Get("key1")
+        if got != tmpl2 {
+            t.Error("expected updated template")
+        }
+    })
+}
+
+// TestDiskCache tests the disk-based cache
+func TestDiskCache(t *testing.T) {
+    // Create a temp directory for cache
+    tmpDir := filepath.Join(os.TempDir(), "gott-cache-test")
+    defer os.RemoveAll(tmpDir)
+
+    t.Run("create disk cache", func(t *testing.T) {
+        dc, err := newDiskCache(tmpDir)
+        if err != nil {
+            t.Fatalf("newDiskCache() error = %v", err)
+        }
+        if dc == nil {
+            t.Fatal("expected non-nil diskCache")
+        }
+    })
+
+    t.Run("put and get", func(t *testing.T) {
+        dc, _ := newDiskCache(tmpDir)
+
+        // Create a template with various node types to test serialization
+        tmpl := &Template{
+            Position: Position{Line: 1, Column: 1},
+            Nodes: []Node{
+                &TextNode{Text: "Hello "},
+                &OutputStmt{
+                    Expr: &IdentExpr{Parts: []string{"name"}},
+                },
+                &IfStmt{
+                    Condition: &BinaryExpr{
+                        Op:    TokenEq,
+                        Left:  &IdentExpr{Parts: []string{"x"}},
+                        Right: &LiteralExpr{Value: float64(1)},
+                    },
+                    Body: []Node{&TextNode{Text: "yes"}},
+                },
+            },
+        }
+
+        err := dc.Put("test-key", tmpl)
+        if err != nil {
+            t.Fatalf("Put() error = %v", err)
+        }
+
+        got, err := dc.Get("test-key")
+        if err != nil {
+            t.Fatalf("Get() error = %v", err)
+        }
+        if got == nil {
+            t.Fatal("expected non-nil template from disk cache")
+        }
+
+        // Verify structure was preserved
+        if len(got.Nodes) != 3 {
+            t.Errorf("expected 3 nodes, got %d", len(got.Nodes))
+        }
+
+        // Check text node
+        if textNode, ok := got.Nodes[0].(*TextNode); !ok || textNode.Text != "Hello " {
+            t.Error("text node not preserved correctly")
+        }
+
+        // Check output stmt with ident
+        if outputStmt, ok := got.Nodes[1].(*OutputStmt); !ok {
+            t.Error("expected OutputStmt")
+        } else if identExpr, ok := outputStmt.Expr.(*IdentExpr); !ok || identExpr.Parts[0] != "name" {
+            t.Error("ident expr not preserved correctly")
+        }
+    })
+
+    t.Run("get nonexistent key", func(t *testing.T) {
+        dc, _ := newDiskCache(tmpDir)
+
+        got, err := dc.Get("nonexistent")
+        if err != nil {
+            t.Errorf("Get() error = %v", err)
+        }
+        if got != nil {
+            t.Error("expected nil for nonexistent key")
+        }
+    })
+
+    t.Run("clear disk cache", func(t *testing.T) {
+        dc, _ := newDiskCache(tmpDir)
+
+        // Add some entries
+        dc.Put("key1", &Template{})
+        dc.Put("key2", &Template{})
+
+        err := dc.Clear()
+        if err != nil {
+            t.Fatalf("Clear() error = %v", err)
+        }
+
+        // Verify entries are gone
+        if got, _ := dc.Get("key1"); got != nil {
+            t.Error("key1 should be cleared")
+        }
+        if got, _ := dc.Get("key2"); got != nil {
+            t.Error("key2 should be cleared")
+        }
+    })
+}
+
+// TestCachingIntegration tests that caching works with the Renderer
+func TestCachingIntegration(t *testing.T) {
+    memFS := fstest.MapFS{
+        "test.html": &fstest.MapFile{Data: []byte("Hello [% name %]")},
+    }
+
+    t.Run("memory cache speeds up processing", func(t *testing.T) {
+        r, err := New(&Config{
+            IncludePaths: []fs.FS{memFS},
+            MaxCacheSize: 10,
+        })
+        if err != nil {
+            t.Fatalf("New() error = %v", err)
+        }
+
+        vars := map[string]any{"name": "World"}
+
+        // First call parses and caches
+        result1, err := r.ProcessFile("test.html", vars)
+        if err != nil {
+            t.Fatalf("ProcessFile() error = %v", err)
+        }
+        if result1 != "Hello World" {
+            t.Errorf("got %q, want %q", result1, "Hello World")
+        }
+
+        // Verify it's in cache
+        if r.cache.Len() != 1 {
+            t.Errorf("expected 1 entry in cache, got %d", r.cache.Len())
+        }
+
+        // Second call should use cache
+        result2, err := r.ProcessFile("test.html", vars)
+        if err != nil {
+            t.Fatalf("ProcessFile() error = %v", err)
+        }
+        if result2 != "Hello World" {
+            t.Errorf("got %q, want %q", result2, "Hello World")
+        }
+    })
+
+    t.Run("disk cache persistence", func(t *testing.T) {
+        tmpDir := filepath.Join(os.TempDir(), "gott-disk-cache-test")
+        defer os.RemoveAll(tmpDir)
+
+        r1, err := New(&Config{
+            IncludePaths: []fs.FS{memFS},
+            CachePath:    tmpDir,
+        })
+        if err != nil {
+            t.Fatalf("New() error = %v", err)
+        }
+
+        // Process to populate cache
+        _, err = r1.ProcessFile("test.html", map[string]any{"name": "Test"})
+        if err != nil {
+            t.Fatalf("ProcessFile() error = %v", err)
+        }
+
+        // Create new renderer with same cache path
+        r2, err := New(&Config{
+            IncludePaths: []fs.FS{memFS},
+            CachePath:    tmpDir,
+        })
+        if err != nil {
+            t.Fatalf("New() error = %v", err)
+        }
+
+        // Memory cache should be empty in new renderer
+        if r2.cache.Len() != 0 {
+            t.Errorf("expected empty memory cache in new renderer, got %d", r2.cache.Len())
+        }
+
+        // But processing should load from disk cache
+        result, err := r2.ProcessFile("test.html", map[string]any{"name": "FromDisk"})
+        if err != nil {
+            t.Fatalf("ProcessFile() error = %v", err)
+        }
+        if result != "Hello FromDisk" {
+            t.Errorf("got %q, want %q", result, "Hello FromDisk")
+        }
+
+        // Now memory cache should have the entry
+        if r2.cache.Len() != 1 {
+            t.Errorf("expected 1 entry in memory cache after disk load, got %d", r2.cache.Len())
+        }
+    })
+
+    t.Run("ClearCache clears both caches", func(t *testing.T) {
+        tmpDir := filepath.Join(os.TempDir(), "gott-clear-cache-test")
+        defer os.RemoveAll(tmpDir)
+
+        r, err := New(&Config{
+            IncludePaths: []fs.FS{memFS},
+            CachePath:    tmpDir,
+        })
+        if err != nil {
+            t.Fatalf("New() error = %v", err)
+        }
+
+        // Populate caches
+        _, _ = r.ProcessFile("test.html", map[string]any{"name": "Test"})
+
+        // Clear
+        r.ClearCache()
+
+        // Memory cache should be empty
+        if r.cache.Len() != 0 {
+            t.Errorf("expected empty memory cache after clear, got %d", r.cache.Len())
+        }
+
+        // Disk cache should also be empty - verify by checking that
+        // the file no longer exists
+        entries, _ := os.ReadDir(tmpDir)
+        gobCount := 0
+        for _, e := range entries {
+            if filepath.Ext(e.Name()) == ".gob" {
+                gobCount++
+            }
+        }
+        if gobCount != 0 {
+            t.Errorf("expected 0 .gob files after clear, got %d", gobCount)
+        }
+    })
+
+    t.Run("Process caches by content hash", func(t *testing.T) {
+        r, err := New(&Config{
+            MaxCacheSize: 10,
+        })
+        if err != nil {
+            t.Fatalf("New() error = %v", err)
+        }
+
+        template := "Hello [% name %]!"
+
+        // First call
+        result1, _ := r.Process(template, map[string]any{"name": "Alice"})
+        if result1 != "Hello Alice!" {
+            t.Errorf("got %q, want %q", result1, "Hello Alice!")
+        }
+
+        // Second call with same template (different vars)
+        result2, _ := r.Process(template, map[string]any{"name": "Bob"})
+        if result2 != "Hello Bob!" {
+            t.Errorf("got %q, want %q", result2, "Hello Bob!")
+        }
+
+        // Should only have one cache entry (same template content)
+        if r.cache.Len() != 1 {
+            t.Errorf("expected 1 entry in cache for same template, got %d", r.cache.Len())
+        }
+
+        // Different template should add another entry
+        _, _ = r.Process("Different template", nil)
+        if r.cache.Len() != 2 {
+            t.Errorf("expected 2 entries for different templates, got %d", r.cache.Len())
+        }
+    })
+}
+
+// TestCacheWithIncludes tests that includes also use caching
+func TestCacheWithIncludes(t *testing.T) {
+    memFS := fstest.MapFS{
+        "main.html":    &fstest.MapFile{Data: []byte("Main: [% INCLUDE header.html %]")},
+        "header.html":  &fstest.MapFile{Data: []byte("Header: [% title %]")},
+    }
+
+    r, err := New(&Config{
+        IncludePaths: []fs.FS{memFS},
+        MaxCacheSize: 10,
+    })
+    if err != nil {
+        t.Fatalf("New() error = %v", err)
+    }
+
+    result, err := r.ProcessFile("main.html", map[string]any{"title": "Test"})
+    if err != nil {
+        t.Fatalf("ProcessFile() error = %v", err)
+    }
+
+    expected := "Main: Header: Test"
+    if result != expected {
+        t.Errorf("got %q, want %q", result, expected)
+    }
+
+    // Both templates should be cached
+    if r.cache.Len() != 2 {
+        t.Errorf("expected 2 entries in cache (main + header), got %d", r.cache.Len())
+    }
+}
+
+// TestRendererClose tests that Close stops the SIGHUP handler
+func TestRendererClose(t *testing.T) {
+    r, err := New(&Config{
+        EnableSIGHUP: true,
+    })
+    if err != nil {
+        t.Fatalf("New() error = %v", err)
+    }
+
+    // Close should not panic
+    r.Close()
+
+    // Second close should also not panic (idempotent-ish)
+    // Note: This will panic with "close of closed channel" if we don't handle it
+    // But for simplicity, we document that Close should only be called once
+}

eval.go

···
         return nil
     }
 
-    // Parse and evaluate the included template
-    parser := NewParser(content)
-    tmpl, parseErrs := parser.Parse()
-    if len(parseErrs) > 0 {
-        return parseErrs[0]
+    // Parse with caching
+    tmpl, err := e.renderer.parseTemplate(n.Name, content)
+    if err != nil {
+        return err
     }
 
     // Evaluate with same scope
···
 
     // Load the wrapper template
     var wrapperSource string
+    var wrapperName string
     if block, ok := e.blocks[n.Name]; ok {
         // Wrapper is a defined block - evaluate it
         blockEval := NewEvaluator(e.renderer, e.copyVars())
···
             }
         }
         wrapperSource = blockEval.output.String()
+        wrapperName = "block:" + n.Name
     } else {
         content, err := e.renderer.loadFile(n.Name)
         if err != nil {
···
             return nil
         }
         wrapperSource = content
+        wrapperName = n.Name
     }
 
-    // Parse the wrapper template
-    parser := NewParser(wrapperSource)
-    tmpl, parseErrs := parser.Parse()
-    if len(parseErrs) > 0 {
-        return parseErrs[0]
+    // Parse the wrapper template with caching
+    tmpl, err := e.renderer.parseTemplate(wrapperName, wrapperSource)
+    if err != nil {
+        return err
     }
 
     // Evaluate wrapper with "content" variable set to wrapped content

gott.go

···
 package gott
 
 import (
+    "crypto/sha256"
+    "encoding/hex"
     "encoding/json"
     "errors"
     "html"
     "io/fs"
     "net/http"
     "net/url"
+    "os"
+    "os/signal"
     "path"
     "strings"
     "sync"
+    "syscall"
 )
 
 // Renderer is the main template engine. It processes TT2-style templates
···
     includePaths   []fs.FS                                   // filesystems for INCLUDE lookups, searched in order
     filters        map[string]func(string, ...string) string // text transformation filters
     virtualMethods map[string]func(any) (any, bool)          // custom virtual methods for variables
+    cache          *astCache                                 // in-memory LRU cache for parsed templates
+    diskCache      *diskCache                                // optional disk-based cache (nil if not configured)
+    stopSIGHUP     chan struct{}                             // channel to stop SIGHUP handler goroutine
 }
 
 // Config holds initialization options for creating a new Renderer.
 type Config struct {
     IncludePaths []fs.FS                                   // filesystems for template includes (e.g., os.DirFS, embed.FS)
     Filters      map[string]func(string, ...string) string // custom filters to register
+    CachePath    string                                    // directory for disk-based cache (optional, empty = memory only)
+    MaxCacheSize int                                       // max entries in memory cache (0 = unlimited)
+    EnableSIGHUP bool                                      // if true, clears cache on SIGHUP signal
 }
 
 var ErrTemplateNotFound = errors.New("template not found")
···
 
 // New creates a Renderer with the given config. Registers default filters
 // (upper, lower, html, uri) unless overridden in config.
-func New(config *Config) *Renderer {
+// Returns an error if disk cache path is specified but cannot be created.
+func New(config *Config) (*Renderer, error) {
     r := &Renderer{
         filters:        make(map[string]func(string, ...string) string),
         virtualMethods: make(map[string]func(any) (any, bool)),
     }
 
+    maxCacheSize := 0
     if config != nil {
         r.includePaths = config.IncludePaths
+        maxCacheSize = config.MaxCacheSize
         if config.Filters != nil {
             for k, v := range config.Filters {
                 r.filters[k] = v
             }
         }
+
+        // Initialize disk cache if path is specified
+        if config.CachePath != "" {
+            dc, err := newDiskCache(config.CachePath)
+            if err != nil {
+                return nil, err
+            }
+            r.diskCache = dc
+        }
+
+        // Set up SIGHUP handler if enabled
+        if config.EnableSIGHUP {
+            r.stopSIGHUP = make(chan struct{})
+            go r.handleSIGHUP()
+        }
     }
+
+    // Initialize in-memory cache
+    r.cache = newCache(maxCacheSize)
 
     // Default filters
     if r.filters["upper"] == nil {
···
         }
     }
 
-    return r
+    return r, nil
+}
+
+// handleSIGHUP listens for SIGHUP signals and clears the cache.
+func (r *Renderer) handleSIGHUP() {
+    sigChan := make(chan os.Signal, 1)
+    signal.Notify(sigChan, syscall.SIGHUP)
+
+    for {
+        select {
+        case <-sigChan:
+            r.ClearCache()
+        case <-r.stopSIGHUP:
+            signal.Stop(sigChan)
+            return
+        }
+    }
+}
+
+// ClearCache removes all entries from both memory and disk caches.
+func (r *Renderer) ClearCache() {
+    if r.cache != nil {
+        r.cache.Clear()
+    }
+    if r.diskCache != nil {
+        r.diskCache.Clear()
+    }
+}
+
+// Close stops background goroutines and releases resources.
+// Should be called when the Renderer is no longer needed.
+func (r *Renderer) Close() {
+    if r.stopSIGHUP != nil {
+        close(r.stopSIGHUP)
+    }
 }
 
 // AddFilter registers a custom filter function. Returns the Renderer for chaining.
···
 }
 
 // ProcessFile loads a template file and processes it with the given variables.
+// Uses cached AST if available, otherwise parses and caches.
 func (r *Renderer) ProcessFile(filename string, vars map[string]any) (string, error) {
-    content, err := r.loadFile(filename)
+    // Sanitize the path first to get a consistent cache key
+    safeName, err := sanitizePath(filename)
+    if err != nil {
+        return "", err
+    }
+
+    // Use file path as cache key (prefixed to distinguish from content hashes)
+    cacheKey := "file:" + safeName
+
+    tmpl, err := r.getOrParseCached(cacheKey, func() (string, error) {
+        return r.loadFile(filename)
+    })
     if err != nil {
         return "", err
     }
-    return r.Process(content, vars)
+
+    // Evaluate the AST
+    eval := NewEvaluator(r, vars)
+    return eval.Eval(tmpl)
 }
 
 // Process processes a template string with the given variables.
 // Uses an AST-based parser and evaluator for template processing.
+// Caches the parsed AST using a hash of the input content.
 func (r *Renderer) Process(input string, vars map[string]any) (string, error) {
-    // Parse the template into an AST
-    parser := NewParser(input)
-    tmpl, parseErrs := parser.Parse()
-    if len(parseErrs) > 0 {
-        return "", parseErrs[0]
+    // Use content hash as cache key
+    cacheKey := "content:" + hashContent(input)
+
+    tmpl, err := r.getOrParseCached(cacheKey, func() (string, error) {
+        return input, nil
+    })
+    if err != nil {
+        return "", err
     }
 
     // Evaluate the AST
     eval := NewEvaluator(r, vars)
     return eval.Eval(tmpl)
+}
+
+// hashContent creates a SHA256 hash of the template content for use as a cache key.
+func hashContent(content string) string {
+    h := sha256.Sum256([]byte(content))
+    return hex.EncodeToString(h[:])
+}
+
+// getOrParseCached retrieves a cached template or parses and caches it.
+// The loadContent function is called only if the template is not in cache.
+func (r *Renderer) getOrParseCached(cacheKey string, loadContent func() (string, error)) (*Template, error) {
+    // Check in-memory cache first
+    if tmpl, ok := r.cache.Get(cacheKey); ok {
+        return tmpl, nil
+    }
+
+    // Check disk cache if available
+    if r.diskCache != nil {
+        tmpl, err := r.diskCache.Get(cacheKey)
+        if err != nil {
+            return nil, err
+        }
+        if tmpl != nil {
+            // Found on disk, add to memory cache
+            r.cache.Put(cacheKey, tmpl)
+            return tmpl, nil
+        }
+    }
+
+    // Load and parse the template
+    content, err := loadContent()
+    if err != nil {
+        return nil, err
+    }
+
+    parser := NewParser(content)
+    tmpl, parseErrs := parser.Parse()
+    if len(parseErrs) > 0 {
+        return nil, parseErrs[0]
+    }
+
+    // Store in both caches
+    r.cache.Put(cacheKey, tmpl)
+    if r.diskCache != nil {
+        // Best effort - don't fail if disk write fails
+        r.diskCache.Put(cacheKey, tmpl)
+    }
+
+    return tmpl, nil
+}
+
+// parseTemplate parses a template for use by includes/wrappers with caching.
+// This is used internally by the evaluator.
+func (r *Renderer) parseTemplate(name string, content string) (*Template, error) {
+    // Use the include/wrapper path as the cache key
+    cacheKey := "file:" + name
+
+    return r.getOrParseCached(cacheKey, func() (string, error) {
+        return content, nil
+    })
 }
 
 // Render processes a template file and writes the result to an http.ResponseWriter.

gott_test.go

···
 
 // TestNewFeatures tests ELSIF, arithmetic, string concatenation, and map iteration
 func TestNewFeatures(t *testing.T) {
-	r := New(nil)
+	r, err := New(nil)
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
 
 	tests := []struct {
 		name     string
···
 }
 
 func TestSimpleIfCondition(t *testing.T) {
-	r := New(nil)
+	r, err := New(nil)
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
 	
 	tests := []struct {
 		name     string
···
         "templates/partials/footer.html": &fstest.MapFile{Data: []byte("FOOTER")},
     }
 
-    r := New(&Config{
+    r, err := New(&Config{
         IncludePaths: []fs.FS{memFS},
     })
+    if err != nil {
+        t.Fatalf("New() error = %v", err)
+    }
 
     tests := []struct {
         name     string
···
         "layouts/main.html": &fstest.MapFile{Data: []byte("<main>[% content %]</main>")},
     }
 
-    r := New(&Config{
+    r, err := New(&Config{
         IncludePaths: []fs.FS{memFS},
     })
+    if err != nil {
+        t.Fatalf("New() error = %v", err)
+    }
 
     tests := []struct {
         name     string
···
         "index.html": &fstest.MapFile{Data: []byte("INDEX")},
     }
 
-    r := New(&Config{
+    r, err := New(&Config{
         IncludePaths: []fs.FS{memFS},
     })
+    if err != nil {
+        t.Fatalf("New() error = %v", err)
+    }
 
     tests := []struct {
         name     string