feat(template): V8 compiled expressions and true execution plan runtime

- compile expressions into instructions (VariableInstr, JumpIfFalseInstr)
- remove runtime expression parsing (no Lexer/Parser during render)
- add deep cloning of expression AST in compiler
- use direct expression evaluation in renderer
- optimize render_template_by_name() fast path (no RenderResult allocations)
- improve execution plan efficiency and CPU locality

Performance:
- variable: ~2.5x faster
- expression: ~4x faster
- if: ~4x faster
- loops: ~2x faster
- mixed templates: ~2x faster
- cached templates: ~3–4x faster

Rendering now exceeds V6 performance on core paths.

Note:
- include/composition remains the main bottleneck (next focus)

Author: GaspardKirira

CHANGELOG.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## v0.8.0
+
+Make rendering truly compiled by eliminating runtime expression parsing.
+
+### Highlights
+
+V8 turns the execution plan into a real compiled runtime by removing expression reparsing during rendering.
+
+Expressions are now compiled once and evaluated directly, unlocking major performance gains across the entire rendering pipeline.
+
+### Features
+
+- Compile expressions into instructions
+  - `VariableInstr` now stores compiled expressions
+  - `JumpIfFalseInstr` uses compiled conditions
+- Remove runtime expression parsing
+  - no more Lexer/Parser during render
+  - direct evaluation from execution plan
+- Improve execution plan efficiency
+  - fully compiled rendering path
+  - better CPU cache locality
+
+### Performance Improvements
+
+- Variable rendering: ~2.5x faster
+- Expression rendering: ~4x faster
+- Conditional rendering (`if`): ~4x faster
+- Loops: ~2x faster
+- Mixed templates: ~2x faster
+- Engine cached templates: ~3–4x faster
+
+Rendering performance now exceeds V6 across most scenarios.
+
+### Renderer Improvements
+
+- Remove `evaluate_compiled_expression(std::string, ...)`
+- Use `evaluate_expression(Expression, ...)` directly
+- Avoid temporary parsing structures during execution
+- Optimize `render_template_by_name()`:
+  - reduce allocations
+  - avoid unnecessary `RenderResult` copies
+  - use `execute_plan()` directly on fast path
+
+### Compiler Improvements
+
+- Add deep cloning of expression AST
+- Store compiled expressions inside execution plan
+- Remove `expression_to_string()` path
+
+### Performance Notes
+
+- Core rendering path is now significantly faster than V6
+- Include and template composition still remain the main bottleneck
+- Cache lookup remains sub-microsecond
+
+### Why this release matters
+
+V6 introduced execution plans.
+V7 introduced correctness (cache + inheritance).
+
+V8 completes the model:
+
+- no runtime parsing
+- true compiled execution
+- predictable performance
+
+This version marks the transition from a partially compiled engine to a fully compiled template runtime.
+
+### Next Focus
+
+- Optimize include and template composition
+- Reduce loader and cache overhead
+- Further improve inheritance execution path
+
 ## v0.7.0
 
 Add cache-aware template freshness and safer inheritance rendering.

include/vix/template/Compiler.hpp

@@ -21,6 +21,7 @@
 
 #include <vix/template/AST.hpp>
 #include <vix/template/ExecutionPlan.hpp>
+#include <vix/template/Instruction.hpp>
 #include <vix/template/Loader.hpp>
 #include <vix/template/Optimizer.hpp>
 #include <vix/template/Template.hpp>
@@ -48,6 +49,9 @@ namespace vix::template_
    * - faster rendering
    * - better CPU cache locality
    * - compiled template caching in V7
+   *
+   * In V8, expressions stored in instructions are kept in compiled form
+   * so the renderer can evaluate them directly without reparsing text.
    */
   class Compiler
   {
@@ -161,6 +165,30 @@ namespace vix::template_
         const BlockNode &node,
         ExecutionPlan &plan) const;
 
+    /**
+     * @brief Clone an expression tree into a shared compiled form.
+     *
+     * Instructions store shared compiled expressions so they remain
+     * copyable and cheap to move while avoiding expression reparsing
+     * during rendering.
+     *
+     * @param expression Expression AST to clone.
+     * @return Shared pointer to an immutable compiled expression tree.
+     */
+    [[nodiscard]] CompiledExprPtr clone_expression(
+        const Expression &expression) const;
+
+    /**
+     * @brief Clone an expression tree into a unique expression node.
+     *
+     * This helper performs the recursive deep copy of the expression AST.
+     *
+     * @param expression Expression AST to clone.
+     * @return Deep-copied unique expression node.
+     */
+    [[nodiscard]] ExprPtr clone_expression_node(
+        const Expression &expression) const;
+
   private:
     /**
      * @brief AST optimizer used before execution plan generation.

include/vix/template/Instruction.hpp

@@ -16,14 +16,28 @@
 #ifndef VIX_TEMPLATE_INSTRUCTION_HPP
 #define VIX_TEMPLATE_INSTRUCTION_HPP
 
+#include <cstdint>
+#include <memory>
 #include <string>
+#include <utility>
 #include <variant>
-#include <cstdint>
 #include <vector>
+
 #include <vix/template/AST.hpp>
 
 namespace vix::template_
 {
+  /**
+   * @brief Shared compiled expression pointer used by the execution plan.
+   *
+   * The execution plan must keep expressions in compiled form so the renderer
+   * can evaluate them directly at runtime without reparsing expression text.
+   *
+   * Shared ownership is used here to keep Instruction copyable and movable
+   * while still storing precompiled expression trees.
+   */
+  using CompiledExprPtr = std::shared_ptr<const Expression>;
+
   /**
    * @brief Enumeration of all instruction types used by the execution plan.
    *
@@ -80,27 +94,41 @@ namespace vix::template_
    */
   struct TextInstr
   {
+    /**
+     * @brief Literal text emitted directly to output.
+     */
     std::string text;
   };
 
   /**
    * @brief Payload for EmitVariable instruction.
    *
-   * Stores the variable name to resolve at runtime.
+   * Stores the already compiled expression to evaluate at runtime.
+   * This avoids reparsing the variable expression during rendering.
    */
   struct VariableInstr
   {
-    std::string expression;
+    /**
+     * @brief Precompiled expression to evaluate.
+     */
+    CompiledExprPtr expression;
+
+    /**
+     * @brief Filter pipeline applied after expression evaluation.
+     */
     std::vector<FilterNode> filters;
   };
 
   /**
    * @brief Payload for jump instructions.
    *
-   * Offset represents the index to jump to in the instruction list.
+   * Target represents the index to jump to in the instruction list.
    */
   struct JumpInstr
   {
+    /**
+     * @brief Destination instruction index.
+     */
     std::size_t target{0};
   };
 
@@ -111,20 +139,38 @@ namespace vix::template_
    */
   struct ForEachInstr
   {
+    /**
+     * @brief Iterable variable name resolved at runtime.
+     */
     std::string iterable_name;
+
+    /**
+     * @brief Loop item variable name bound for each iteration.
+     */
     std::string item_name;
+
+    /**
+     * @brief Instruction index to jump to when the loop ends.
+     */
     std::size_t jump_end{0};
   };
 
   /**
    * @brief Payload for conditional jump instructions.
    *
-   * The expression is evaluated at runtime.
-   * If the result is falsy, execution jumps to target.
+   * The condition is stored in compiled form and evaluated directly
+   * at runtime. If the result is falsy, execution jumps to target.
    */
   struct JumpIfFalseInstr
   {
-    std::string expression;
+    /**
+     * @brief Precompiled condition expression.
+     */
+    CompiledExprPtr expression;
+
+    /**
+     * @brief Destination instruction index when condition is false.
+     */
     std::size_t target{0};
   };
 
@@ -133,6 +179,9 @@ namespace vix::template_
    */
   struct IncludeInstr
   {
+    /**
+     * @brief Logical template name to include.
+     */
     std::string template_name;
   };
 

include/vix/template/Renderer.hpp

@@ -27,6 +27,7 @@
 #include <vix/template/Cache.hpp>
 #include <vix/template/Context.hpp>
 #include <vix/template/ExecutionPlan.hpp>
+#include <vix/template/Instruction.hpp>
 #include <vix/template/Loader.hpp>
 #include <vix/template/RenderResult.hpp>
 #include <vix/template/Value.hpp>
@@ -47,13 +48,17 @@ namespace vix::template_
    * - cache locality
    *
    * The AST is still used for:
-   * - expression evaluation
+   * - direct evaluation of compiled expressions
    * - include / extends support
    * - block inheritance
    * - future advanced compilation features
    *
    * In V7, Renderer can optionally use a compiled template cache in order
    * to avoid re-loading and re-compiling included templates repeatedly.
+   *
+   * In V8, execution-plan instructions carry compiled expressions directly,
+   * allowing the renderer to evaluate them without reparsing expression text
+   * during rendering.
    */
   class Renderer
   {
@@ -169,6 +174,9 @@ namespace vix::template_
     /**
      * @brief Execute a variable emission instruction.
      *
+     * The instruction already carries a compiled expression, which is
+     * evaluated directly at runtime.
+     *
      * @param instr Variable instruction payload.
      * @param context Runtime rendering context.
      * @param output Output string buffer.
@@ -181,6 +189,8 @@ namespace vix::template_
     /**
      * @brief Execute a conditional jump instruction.
      *
+     * The condition expression is already compiled in the instruction.
+     *
      * @param instr Conditional jump payload.
      * @param instruction_index Mutable instruction pointer.
      * @param context Runtime rendering context.
@@ -234,20 +244,12 @@ namespace vix::template_
         const Context &context,
         std::string &output) const;
 
-    /**
-     * @brief Evaluate an expression represented as text.
-     *
-     * @param expression_text Canonical expression string.
-     * @param context Runtime rendering context.
-     * @return Evaluated value.
-     */
-    [[nodiscard]] Value evaluate_compiled_expression(
-        const std::string &expression_text,
-        const Context &context) const;
-
     /**
      * @brief Evaluate an expression AST node.
      *
+     * This is the primary evaluation path for expressions stored in the
+     * execution plan.
+     *
      * @param expr Expression to evaluate.
      * @param context Runtime rendering context.
      * @return Evaluated value.