---

name: cljr-performance description: Optimize Cljr compiler and runtime performance. Use when optimizing emitter output, runtime collections, REPL evaluation, or leveraging .NET 10/C# 14 features. Covers Span, FrozenDictionary, AggressiveInlining, benchmarking, and allocation reduction strategies.

Cljr Performance Optimization

This skill guides performance optimization for the Cljr Clojure-to-.NET compiler, targeting .NET 10 with C# 14 preview features.

When to use this skill

• Optimizing emitter-generated C# code
• Improving runtime collection performance
• Reducing memory allocations
• Leveraging .NET 10 / C# 14 performance features
• Writing or analyzing benchmarks
• Optimizing REPL evaluation performance

Project Performance Profile

Target Framework

• Runtime: .NET 10 (LTS)
• Language: C# 14 preview (Runtime, CLI, REPL) / C# 12 (Compiler, SourceGenerator)

Existing Optimizations

Opportunities for Further Optimization

Performance Optimization Workflow

Step 1: Measure First

Never optimize without benchmarks. Run existing benchmarks:

Copycd tests/Cljr.Benchmarks
dotnet run -c Release -- --filter "*"

Or specific benchmarks:

Copydotnet run -c Release -- --filter "VectorBenchmarks"
dotnet run -c Release -- --filter "*Conj*"

Step 2: Identify Hot Paths

Use profiling or benchmark results to identify:

• High-frequency operations
• Allocation-heavy code paths
• Cache miss patterns

Step 3: Apply Optimizations

See reference files for specific patterns:

• .NET 10 / C# 14 Features
• Emitter Patterns
• Benchmarking Guide

Step 4: Verify Improvement

Re-run benchmarks and compare:

Copydotnet run -c Release -- --filter "YourBenchmark" --runtimes net10.0

Quick Reference: Key Optimizations

AggressiveInlining

For small, frequently-called methods:

Copy[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T GetValue() => _value;

Span for Zero-Copy

Copy// Instead of creating arrays
public ReadOnlySpan<object?> ArrayFor(int i) => _tail.AsSpan();

// Span-based construction (already in PersistentVector)
public static PersistentVector Create(ReadOnlySpan<object?> items)

FrozenDictionary for Read-Heavy Lookups

Copyusing System.Collections.Frozen;

// Mutable during construction
private readonly ConcurrentDictionary<Type, Cache> _impls = new();
// Frozen for fast reads
private volatile FrozenDictionary<Type, Cache>? _frozen;

public void Freeze() => _frozen = _impls.ToFrozenDictionary();

Symbol/Keyword Interning

Already implemented - ensures reference equality:

Copy// Good: reference equality after interning
if (ReferenceEquals(sym1, sym2)) { ... }

// Avoid: value equality is slower
if (sym1.Equals(sym2)) { ... }

Transients for Batch Operations

Copy// Slow: O(n²) allocations
var vec = PersistentVector.Empty;
foreach (var item in items)
    vec = vec.Conj(item);

// Fast: O(n) with transient
var transient = PersistentVector.Empty.AsTransient();
foreach (var item in items)
    transient.ConjBang(item);
return transient.Persistent();

Key Files

References

• .NET 10 / C# 14 Features - Latest platform features
• Emitter Patterns - Optimized C# code generation
• Benchmarking Guide - How to measure and compare

External Resources

• What's new in .NET 10
• What's new in C# 14
• .NET 10 Runtime Improvements