performance improvements

Author: ardan-bkennedy

bench_test.go

@@ -92,6 +92,33 @@ func BenchmarkRender_Qwen3(b *testing.B) {
 	}
 }
 
+// =============================================================================
+// Chat template benchmarks – Qwen3.6 (hybrid model used by kronk benchmarks)
+// =============================================================================
+
+func BenchmarkCompile_Qwen36(b *testing.B) {
+	source := chatTemplates["Qwen3.6-35B-A3B-UD-Q4_K_M"]
+	for b.Loop() {
+		if _, err := jinja.Compile(source); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkRender_Qwen36(b *testing.B) {
+	tmpl, err := jinja.Compile(chatTemplates["Qwen3.6-35B-A3B-UD-Q4_K_M"])
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+	for b.Loop() {
+		if _, err := tmpl.Render(chatBenchData); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
 // =============================================================================
 // Complex template benchmarks – Gemma4 multi-turn tool calling (heaviest)
 // =============================================================================

builtins.go

@@ -3,36 +3,26 @@ package jinja
 import (
 	"encoding/json"
 	"fmt"
-	"maps"
 	"math"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 	"unicode"
 )
 
 // cachedBuiltins is a read-only scope populated once with all built-in
-// globals and filters. Each render clones it cheaply via cloneScope.
+// globals and filters. It is shared across every render — no code path
+// writes to the builtins scope (only chained reads through parent
+// links and lookupFilter), so a single shared instance is safe and
+// avoids ~20 allocations per render.
 var cachedBuiltins = func() *scope {
 	s := newScope(nil)
 	registerGlobals(s)
 	registerFilters(s)
 	return s
 }()
 
-// cloneBuiltins returns a shallow copy of the cached builtins scope so
-// each render gets its own scope without re-registering every function.
-func cloneBuiltins() *scope {
-	return cloneScope(cachedBuiltins)
-}
-
-// cloneScope creates a shallow copy of a scope (same parent, copied vars map).
-func cloneScope(s *scope) *scope {
-	vars := make(map[string]Value, len(s.vars))
-	maps.Copy(vars, s.vars)
-	return &scope{vars: vars, parent: s.parent}
-}
-
 // =============================================================================
 // Global functions
 // =============================================================================
@@ -353,25 +343,105 @@ func filterTojson(args []Value, kwargs map[string]Value) (Value, error) {
 		return NewString(""), nil
 	}
 
-	goVal := valueToGo(args[0])
-
-	var data []byte
-	var err error
-
+	// The indented form is used rarely in chat templates; fall back to
+	// the reflection-based encoder for correctness instead of duplicating
+	// indent state in the direct encoder.
 	if indent, ok := kwargs["indent"]; ok && !indent.IsNone() && !indent.IsUndefined() {
 		n := int(toInt64(indent))
-		prefix := ""
-		indentStr := strings.Repeat(" ", n)
-		data, err = json.MarshalIndent(goVal, prefix, indentStr)
-	} else {
-		data, err = json.Marshal(goVal)
+		data, err := json.MarshalIndent(valueToGo(args[0]), "", strings.Repeat(" ", n))
+		if err != nil {
+			return NewString(""), nil
+		}
+		return NewString(string(data)), nil
 	}
 
-	if err != nil {
+	// Direct Value-tree encoder. Bypasses valueToGo's intermediate
+	// map[string]any/[]any allocations and json.Marshal's reflection
+	// path. Per-render allocations drop from ~80 (Dict.Set + valueToGo
+	// + reflect) to a handful (one strings.Builder grow + one Marshal
+	// per leaf string for escaping).
+	var sb strings.Builder
+	if err := encodeValueJSON(&sb, args[0]); err != nil {
 		return NewString(""), nil
 	}
+	return NewString(sb.String()), nil
+}
+
+// encodeValueJSON writes the JSON encoding of v directly into sb without
+// going through an intermediate Go-typed tree. Strings are delegated to
+// encoding/json so escaping rules match the standard library exactly.
+func encodeValueJSON(sb *strings.Builder, v Value) error {
+	switch v.kind {
+	case KindUndefined, KindNone, KindCallable:
+		sb.WriteString("null")
+		return nil
+
+	case KindBool:
+		if v.AsBool() {
+			sb.WriteString("true")
+		} else {
+			sb.WriteString("false")
+		}
+		return nil
+
+	case KindInt:
+		var buf [20]byte
+		sb.Write(strconv.AppendInt(buf[:0], v.AsInt(), 10))
+		return nil
+
+	case KindFloat:
+		f := v.AsFloat()
+		if math.IsInf(f, 0) || math.IsNaN(f) {
+			return fmt.Errorf("tojson: cannot encode %v", f)
+		}
+		var buf [32]byte
+		sb.Write(strconv.AppendFloat(buf[:0], f, 'g', -1, 64))
+		return nil
+
+	case KindString:
+		data, err := json.Marshal(v.AsString())
+		if err != nil {
+			return err
+		}
+		sb.Write(data)
+		return nil
+
+	case KindList:
+		sb.WriteByte('[')
+		for i, item := range v.AsList().Items {
+			if i > 0 {
+				sb.WriteByte(',')
+			}
+			if err := encodeValueJSON(sb, item); err != nil {
+				return err
+			}
+		}
+		sb.WriteByte(']')
+		return nil
+
+	case KindDict:
+		sb.WriteByte('{')
+		d := v.AsDict()
+		for i, key := range d.Keys {
+			if i > 0 {
+				sb.WriteByte(',')
+			}
+			data, err := json.Marshal(key)
+			if err != nil {
+				return err
+			}
+			sb.Write(data)
+			sb.WriteByte(':')
+			if err := encodeValueJSON(sb, d.Data[key]); err != nil {
+				return err
+			}
+		}
+		sb.WriteByte('}')
+		return nil
+	}
 
-	return NewString(string(data)), nil
+	sb.WriteString("null")
+	return nil
 }
 
 func filterFromjson(args []Value, kwargs map[string]Value) (Value, error) {

eval.go

@@ -589,26 +589,101 @@ func (e *evaluator) evalSlice(n *sliceExpr) (Value, error) {
 
 	if obj.IsList() {
 		list := obj.AsList()
-		start, stop, step := resolveSlice(n, e, list.Len())
+		length := list.Len()
+		start, stop, step := resolveSlice(n, e, length)
+
+		// Fast path for the overwhelmingly common step==1 case
+		// (e.g. messages[1:] in chat templates). A single allocation
+		// of the exact size avoids the geometric growth of append.
+		// Aliasing the source slice would be unsafe because List.Append
+		// could later mutate beyond Len() into the backing array.
+		if step == 1 {
+			if start < 0 {
+				start = 0
+			}
+			if stop > length {
+				stop = length
+			}
+			if start >= stop {
+				return NewList(nil), nil
+			}
+			items := make([]Value, stop-start)
+			copy(items, list.Items[start:stop])
+			return NewList(items), nil
+		}
+
 		var items []Value
 		if step > 0 {
+			// Pre-size to the maximum possible iteration count to
+			// avoid append's geometric growth allocations.
+			count := (stop - start + step - 1) / step
+			if count > 0 {
+				items = make([]Value, 0, count)
+			}
 			for i := start; i < stop; i += step {
-				if i >= 0 && i < list.Len() {
-					items = append(items, list.Get(i))
+				if i >= 0 && i < length {
+					items = append(items, list.Items[i])
 				}
 			}
 		} else if step < 0 {
+			count := (start - stop - step - 1) / -step
+			if count > 0 {
+				items = make([]Value, 0, count)
+			}
 			for i := start; i > stop; i += step {
-				if i >= 0 && i < list.Len() {
-					items = append(items, list.Get(i))
+				if i >= 0 && i < length {
+					items = append(items, list.Items[i])
 				}
 			}
 		}
 		return NewList(items), nil
 	}
 
 	if obj.IsString() {
-		runes := []rune(obj.AsString())
+		s := obj.AsString()
+
+		// ASCII fast path. Most chat-template string slicing operates
+		// on tag/role names or message content that is ASCII; for those
+		// we can index by byte and skip the []rune conversion entirely.
+		// This is the dominant cost in the kronk dense profile because
+		// the system prompt can be tens of thousands of bytes.
+		if isASCII(s) {
+			length := len(s)
+			start, stop, step := resolveSlice(n, e, length)
+
+			if step == 1 {
+				if start < 0 {
+					start = 0
+				}
+				if stop > length {
+					stop = length
+				}
+				if start >= stop {
+					return NewString(""), nil
+				}
+				return NewString(s[start:stop]), nil
+			}
+
+			if step == -1 {
+				if start >= length {
+					start = length - 1
+				}
+				if stop < -1 {
+					stop = -1
+				}
+				if start <= stop {
+					return NewString(""), nil
+				}
+				buf := make([]byte, 0, start-stop)
+				for i := start; i > stop; i-- {
+					buf = append(buf, s[i])
+				}
+				return NewString(string(buf)), nil
+			}
+			// Fall through to the general path for unusual steps.
+		}
+
+		runes := []rune(s)
 		length := len(runes)
 		start, stop, step := resolveSlice(n, e, length)
 		var result []rune
@@ -631,6 +706,18 @@ func (e *evaluator) evalSlice(n *sliceExpr) (Value, error) {
 	return Undefined(), nil
 }
 
+// isASCII reports whether s contains only 7-bit ASCII bytes. Used to
+// skip the []rune conversion in evalSlice's string branch when byte
+// indexing produces the same result as code-point indexing.
+func isASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] >= 0x80 {
+			return false
+		}
+	}
+	return true
+}
+
 func resolveSlice(n *sliceExpr, e *evaluator, length int) (int, int, int) {
 	step := 1
 	if n.step != nil {