From 08082506372bfc4ca3dcc83e2c6e25e938e9f0c8 Mon Sep 17 00:00:00 2001
From: Andreew Gregory <grinadand@gmail.com>
Date: Mon, 13 Apr 2026 15:05:12 +0300
Subject: [PATCH] Removed all vibecoded code. Now Alice API is fully exposed to
 C++

---
 src/l1/allie_cpp/anne/geom.hpp | 735 ++++++++++-----------------------
 src/l1/allie_cpp/codegen.hpp   |  23 ++
 src/l3/r4/r4c.cpp              |   2 +-
 3 files changed, 250 insertions(+), 510 deletions(-)

diff --git a/src/l1/allie_cpp/anne/geom.hpp b/src/l1/allie_cpp/anne/geom.hpp
index cc378bc..5559999 100644
--- a/src/l1/allie_cpp/anne/geom.hpp
+++ b/src/l1/allie_cpp/anne/geom.hpp
@@ -1,533 +1,250 @@
-#pragma once
-
+#include <string>
+#include <functional>
 #include "../codegen.hpp"
 
-#include <array>
-#include <concepts>
-#include <functional>
-#include <string>
-#include <string_view>
-#include <utility>
-
-/* This file is vibecoded. It requires more rewriting */
-
-inline constexpr std::array<std::string_view, 4> kGeomFieldNames = {"x", "y", "z", "w"};
-
-struct GeomVecFamilySpec {
-    std::string_view prefix;
-    std::string_view scalar;
-    bool geometric_methods;
+template <class F>
+concept CallableMatCordToStr = requires(F&& f) {
+    {std::invoke(std::forward<F>(f), int{}, int{})} -> std::convertible_to<std::string>;
 };
 
-struct GeomMatFamilySpec {
-    std::string_view mat_prefix;
-    std::string_view vec_prefix;
-    std::string_view scalar;
-};
-
-template <class F>
-concept GeomIndexCallable =
-    requires(F&& f) {
-        std::invoke(std::forward<F>(f), int{});
-    };
-
-template <class F>
-concept GeomIndexStringCallable =
-    requires(F&& f) {
-        { std::invoke(std::forward<F>(f), int{}) } -> std::convertible_to<std::string>;
-    };
-
-template <class F>
-concept GeomIndexPairStringCallable =
-    requires(F&& f) {
-        { std::invoke(std::forward<F>(f), int{}, int{}) } -> std::convertible_to<std::string>;
-    };
-
-template <GeomIndexCallable F>
-inline void geom_append_joined(std::string& out, int count, std::string_view separator, F&& emit_one) {
-    for (int i = 0; i < count; ++i) {
-        if (i > 0) {
-            out += separator;
-        }
-        emit_one(i);
-    }
-}
-
-inline std::string_view geom_field_name(int index) {
-    return kGeomFieldNames[index];
-}
-
-inline std::string geom_vec_name(std::string_view prefix, int n) {
-    return std::string(prefix) + std::to_string(n);
-}
-
-inline std::string geom_mat_name(std::string_view prefix, int cols, int rows) {
-    if (cols == rows) {
-        return std::string(prefix) + std::to_string(cols);
-    }
-    return std::string(prefix) + std::to_string(cols) + "x" + std::to_string(rows);
-}
-
-template <GeomIndexStringCallable F>
-inline void geom_append_constructor_call(std::string& out, std::string_view type_name, int count, F&& arg_expression) {
-    out += std::string(type_name);
-    out += "(";
-    geom_append_joined(out, count, ", ", [&](int index) {
-        out += arg_expression(index);
-    });
-    out += ")";
-}
-
-template <GeomIndexStringCallable F>
-inline void geom_append_vector_return(std::string& out, std::string_view vec_name, int count, F&& component_expression) {
-    out += "    return ";
-    geom_append_constructor_call(out, vec_name, count, component_expression);
-    out += ";\n";
-}
-
-template <GeomIndexPairStringCallable F>
-inline void geom_append_matrix_return(
-    std::string& out,
-    std::string_view mat_name,
-    std::string_view vec_name,
-    int cols,
-    int rows,
-    F&& component_expression) {
-    out += "    return ";
-    out += std::string(mat_name);
-    out += "(";
-    geom_append_joined(out, cols, ", ", [&](int col) {
-        geom_append_constructor_call(out, vec_name, rows, [&](int row) {
-            return component_expression(col, row);
-        });
-    });
-    out += ");\n";
-}
-
-template <GeomIndexStringCallable F>
-inline void geom_append_matrix_column_return(std::string& out, std::string_view mat_name, int cols, F&& column_expression) {
-    out += "    return ";
-    geom_append_constructor_call(out, mat_name, cols, column_expression);
-    out += ";\n";
-}
-
-inline void geom_append_vector_family(std::string& out, GeomVecFamilySpec spec, int n) {
-    const std::string vec_name = geom_vec_name(spec.prefix, n);
-
-    out += "struct " + vec_name + " {\n";
+template <CallableMatCordToStr F>
+void codegen_append_matrix(std::string& res, int n, int m, int TABS, F&& emit_elem) {
+    res += "{\n";
     for (int i = 0; i < n; ++i) {
-        out += "    " + std::string(spec.scalar) + " " + std::string(geom_field_name(i)) + ";\n";
+        res += gen_tabs(TABS + 1) + "{";
+        for (int j = 0; j < m; j++) {
+            if (j)
+                res += ", ";
+            res += emit_elem(i, j);
+        }
+        res += "},\n";
     }
-    out += "\n";
-    out += "    constexpr " + vec_name + "() noexcept = default;\n";
-    out += "    constexpr " + vec_name + "(";
-    geom_append_joined(out, n, ", ", [&](int index) {
-        out += std::string(spec.scalar) + " " + std::string(geom_field_name(index));
-    });
-    out += ") noexcept : ";
-    geom_append_joined(out, n, ", ", [&](int index) {
-        const std::string field = std::string(geom_field_name(index));
-        out += field + "(" + field + ")";
-    });
-    out += " {}\n";
-    out += "};\n\n";
+    res += gen_tabs(TABS) + "}";
+}
 
-    out += "inline " + vec_name + " operator+(" + vec_name + " A, " + vec_name + " B) noexcept {\n";
-    geom_append_vector_return(out, vec_name, n, [&](int index) {
-        const std::string field = std::string(geom_field_name(index));
-        return "A." + field + " + B." + field;
+template <CallableMatCordToStr F>
+void codegen_append_matrix_long(std::string& res, int n, int m, int TABS, F&& emit_elem) {
+    res += "{\n" + gen_tabs(TABS + 1);
+    for (int i = 0; i < n; ++i) {
+        res +=  "{\n";
+        for (int j = 0; j < m; j++) {
+            res += gen_tabs(TABS + 2) + emit_elem(i, j) + ",\n";
+        }
+        res += gen_tabs(TABS + 1) + "}, ";
+    }
+    res += "\n" + gen_tabs(TABS) + "}";
+}
+
+
+constexpr std::string vec_field(int ci) {
+    constexpr std::array<std::string_view, 4> geom_field_names = {"x", "y", "z", "w"};
+    return std::string(geom_field_names[ci]);
+}
+
+void codegen_append_xvecn_binary_operator(std::string& res, const std::string& xvecn, int n, const std::string& op) {
+    res +=
+        xvecn + " operator" + op + "(" + xvecn + " A, " + xvecn + " B) noexcept {\n"
+        SPACE "return " + xvecn + "{";
+    res += joined_str(n, ", ", [&](int ci) {
+        return "A." + vec_field(ci) + " " + op + " B." + vec_field(ci);
     });
-    out += "}\n\n";
+    res += "};\n}\n\n";
+}
 
-    out += "inline " + vec_name + " operator-(" + vec_name + " A, " + vec_name + " B) noexcept {\n";
-    geom_append_vector_return(out, vec_name, n, [&](int index) {
-        const std::string field = std::string(geom_field_name(index));
-        return "A." + field + " - B." + field;
-    });
-    out += "}\n\n";
-
-    out += "inline " + vec_name + " operator-(" + vec_name + " A) noexcept {\n";
-    geom_append_vector_return(out, vec_name, n, [&](int index) {
-        return "-A." + std::string(geom_field_name(index));
-    });
-    out += "}\n\n";
-
-    out += "inline " + vec_name + " operator*(" + vec_name + " A, " + std::string(spec.scalar) + " B) noexcept {\n";
-    geom_append_vector_return(out, vec_name, n, [&](int index) {
-        return "A." + std::string(geom_field_name(index)) + " * B";
-    });
-    out += "}\n\n";
-
-    out += "inline " + vec_name + " operator*(" + std::string(spec.scalar) + " A, " + vec_name + " B) noexcept {\n";
-    out += "    return B * A;\n}\n\n";
-
-    out += "inline " + vec_name + " operator/(" + vec_name + " A, " + std::string(spec.scalar) + " B) noexcept {\n";
-    geom_append_vector_return(out, vec_name, n, [&](int index) {
-        return "A." + std::string(geom_field_name(index)) + " / B";
-    });
-    out += "}\n\n";
-
-    out += "inline " + vec_name + " operator*(" + vec_name + " A, " + vec_name + " B) noexcept {\n";
-    geom_append_vector_return(out, vec_name, n, [&](int index) {
-        const std::string field = std::string(geom_field_name(index));
-        return "A." + field + " * B." + field;
-    });
-    out += "}\n\n";
-
-    out += "inline " + std::string(spec.scalar) + " dot(" + vec_name + " A, " + vec_name + " B) noexcept {\n";
-    out += "    return " + [&]() {
-        std::string expression;
-        geom_append_joined(expression, n, " + ", [&](int index) {
-            const std::string field = std::string(geom_field_name(index));
-            expression += "A." + field + " * B." + field;
+void codegen_append_xvecn_class(std::string& res, const std::string& xvec, const std::string& memb, int n,
+    bool arithmetic, bool real_arithmetic) {
+    std::string xvecn = std::string(xvec) + std::to_string(n);
+    res += "struct " + xvecn + " {\n";
+    for (int ci = 0; ci < n; ci++) {
+        res += SPACE + memb + " " + vec_field(ci) + ";\n";
+    }
+    if (real_arithmetic) {
+        res += "\n";
+        res +=
+            memb + " length() const noexcept {\n"
+            SPACE "return ";
+        res += joined_str(n, " + ", [](int ci) {
+            return vec_field(ci) + " * " + vec_field(ci);
         });
-        return expression;
-    }() + ";\n}\n\n";
+        res += ";\n}\n\n";
 
-    if (spec.geometric_methods) {
-        out += "inline " + std::string(spec.scalar) + " length(" + vec_name + " A) noexcept {\n";
-        out += "    return std::sqrt(dot(A, A));\n}\n\n";
-
-        out += "inline " + vec_name + " normalize(" + vec_name + " A) noexcept {\n";
-        out += "    return A / length(A);\n}\n\n";
-
-        if (n == 3) {
-            out += "inline " + vec_name + " cross(" + vec_name + " A, " + vec_name + " B) noexcept {\n";
-            geom_append_vector_return(out, vec_name, 3, [&](int index) {
-                if (index == 0) {
-                    return "A.y * B.z - A.z * B.y";
-                }
-                if (index == 1) {
-                    return "-A.x * B.z + A.z * B.x";
-                }
-                return "A.x * B.y - A.y * B.x";
-            });
-            out += "}\n\n";
-        }
-    }
-}
-
-inline void geom_append_vector_and_one(std::string& out, GeomVecFamilySpec spec, int n) {
-    const std::string vec_name = geom_vec_name(spec.prefix, n);
-    const std::string vec_next = geom_vec_name(spec.prefix, n + 1);
-
-    out += "inline " + vec_next + " and_one(" + vec_name + " A) noexcept {\n";
-    geom_append_vector_return(out, vec_next, n + 1, [&](int index) {
-        if (index == n) {
-            return std::string("1");
-        }
-        return "A." + std::string(geom_field_name(index));
-    });
-    out += "}\n\n";
-}
-
-inline void geom_append_matrix_struct(std::string& out, GeomMatFamilySpec spec, int cols, int rows) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, cols, rows);
-    const std::string vec_rows = geom_vec_name(spec.vec_prefix, rows);
-
-    out += "struct " + mat_name + " {\n";
-    for (int col = 0; col < cols; ++col) {
-        out += "    " + vec_rows + " " + std::string(geom_field_name(col)) + ";\n";
-    }
-    out += "\n";
-    out += "    constexpr " + mat_name + "() noexcept = default;\n";
-    out += "    constexpr " + mat_name + "(";
-    geom_append_joined(out, cols, ", ", [&](int col) {
-        out += vec_rows + " " + std::string(geom_field_name(col));
-    });
-    out += ") noexcept : ";
-    geom_append_joined(out, cols, ", ", [&](int col) {
-        const std::string field = std::string(geom_field_name(col));
-        out += field + "(" + field + ")";
-    });
-    out += " {}\n";
-    out += "};\n\n";
-}
-
-inline void geom_append_matrix_new(std::string& out, GeomMatFamilySpec spec, int cols, int rows) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, cols, rows);
-    const std::string vec_rows = geom_vec_name(spec.vec_prefix, rows);
-
-    out += "inline " + mat_name + " " + mat_name + "_new(";
-    bool first = true;
-    for (int row = 0; row < rows; ++row) {
-        for (int col = 0; col < cols; ++col) {
-            if (!first) {
-                out += ", ";
-            }
-            first = false;
-            out += std::string(spec.scalar) + " ";
-            out += std::string(geom_field_name(col));
-            out += std::string(geom_field_name(row));
-        }
-    }
-    out += ") noexcept {\n";
-    geom_append_matrix_return(out, mat_name, vec_rows, cols, rows, [&](int col, int row) {
-        return std::string(geom_field_name(col)) + std::string(geom_field_name(row));
-    });
-    out += "}\n\n";
-}
-
-inline void geom_append_matrix_base_operators(std::string& out, GeomMatFamilySpec spec, int cols, int rows) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, cols, rows);
-    const std::string scalar = std::string(spec.scalar);
-    const std::string vec_cols = geom_vec_name(spec.vec_prefix, cols);
-    const std::string vec_rows = geom_vec_name(spec.vec_prefix, rows);
-
-    out += "inline " + mat_name + " operator+(" + mat_name + " A, " + mat_name + " B) noexcept {\n";
-    geom_append_matrix_column_return(out, mat_name, cols, [&](int col) {
-        const std::string field = std::string(geom_field_name(col));
-        return "A." + field + " + B." + field;
-    });
-    out += "}\n\n";
-
-    out += "inline " + mat_name + " operator-(" + mat_name + " A, " + mat_name + " B) noexcept {\n";
-    geom_append_matrix_column_return(out, mat_name, cols, [&](int col) {
-        const std::string field = std::string(geom_field_name(col));
-        return "A." + field + " - B." + field;
-    });
-    out += "}\n\n";
-
-    out += "inline " + mat_name + " operator-(" + mat_name + " A) noexcept {\n";
-    geom_append_matrix_column_return(out, mat_name, cols, [&](int col) {
-        return "-A." + std::string(geom_field_name(col));
-    });
-    out += "}\n\n";
-
-    out += "inline " + mat_name + " operator*(" + mat_name + " A, " + scalar + " B) noexcept {\n";
-    geom_append_matrix_column_return(out, mat_name, cols, [&](int col) {
-        return "A." + std::string(geom_field_name(col)) + " * B";
-    });
-    out += "}\n\n";
-
-    out += "inline " + mat_name + " operator*(" + scalar + " A, " + mat_name + " B) noexcept {\n";
-    out += "    return B * A;\n}\n\n";
-
-    out += "inline " + mat_name + " operator/(" + mat_name + " A, " + scalar + " B) noexcept {\n";
-    geom_append_matrix_column_return(out, mat_name, cols, [&](int col) {
-        return "A." + std::string(geom_field_name(col)) + " / B";
-    });
-    out += "}\n\n";
-
-    out += "inline " + vec_rows + " operator*(" + mat_name + " A, " + vec_cols + " B) noexcept {\n";
-    geom_append_vector_return(out, vec_rows, rows, [&](int row) {
-        std::string expression;
-        geom_append_joined(expression, cols, " + ", [&](int col) {
-            expression += "A." + std::string(geom_field_name(col));
-            expression += ".";
-            expression += std::string(geom_field_name(row));
-            expression += " * B.";
-            expression += std::string(geom_field_name(col));
+        res +=
+            xvecn + " normalize() const noexcept {\n"
+            SPACE + memb + " r = 1 / length();\n"
+            SPACE "return " + xvecn + "{";
+        res += joined_str(n, ", ", [](int ci) {
+            return vec_field(ci) + " / r";
         });
-        return expression;
-    });
-    out += "}\n\n";
-}
-
-inline void geom_append_matrix_transpose(std::string& out, GeomMatFamilySpec spec, int cols, int rows) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, cols, rows);
-    const std::string mat_transposed = geom_mat_name(spec.mat_prefix, rows, cols);
-    const std::string vec_cols = geom_vec_name(spec.vec_prefix, cols);
-
-    out += "inline " + mat_transposed + " transpose(" + mat_name + " A) noexcept {\n";
-    geom_append_matrix_return(out, mat_transposed, vec_cols, rows, cols, [&](int new_col, int new_row) {
-        return "A." + std::string(geom_field_name(new_row)) + "." + std::string(geom_field_name(new_col));
-    });
-    out += "}\n\n";
-}
-
-inline void geom_append_square_identity(std::string& out, GeomMatFamilySpec spec, int n) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, n, n);
-    const std::string vec_name = geom_vec_name(spec.vec_prefix, n);
-
-    out += "inline constexpr " + mat_name + " " + mat_name + "_E = ";
-    geom_append_constructor_call(out, mat_name, n, [&](int col) {
-        std::string column;
-        geom_append_constructor_call(column, vec_name, n, [&](int row) {
-            return std::string(col == row ? "1" : "0");
+        res += "};\n}\n\n";
+    }
+    res += "};\n\n";
+    if (arithmetic) {
+        res +=
+            xvecn + " operator-(" + xvecn + " A) noexcept {\n"
+            SPACE "return " + xvecn + "{";
+        res += joined_str(n, ", ", [](int ci) {
+            return "-A." + vec_field(ci);
         });
-        return column;
-    });
-    out += ";\n\n";
-}
+        res += "};\n}\n\n";
 
-inline void geom_append_square_outer_product(std::string& out, GeomMatFamilySpec spec, int n) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, n, n);
-    const std::string vec_name = geom_vec_name(spec.vec_prefix, n);
+        codegen_append_xvecn_binary_operator(res, xvecn, n, "+");
+        codegen_append_xvecn_binary_operator(res, xvecn, n, "-");
 
-    out += "inline " + mat_name + " outer_product(" + vec_name + " v) noexcept {\n";
-    geom_append_matrix_return(out, mat_name, vec_name, n, n, [&](int col, int row) {
-        const std::string col_field = std::string(geom_field_name(col));
-        return "v." + col_field + " * v." + std::string(geom_field_name(row));
-    });
-    out += "}\n\n";
-
-    out += "inline " + mat_name + " " + mat_name + "_new_for_proj(" + vec_name + " v) noexcept {\n";
-    out += "    return outer_product(v);\n}\n\n";
-}
-
-inline void geom_append_matrix_times_matrix(std::string& out, GeomMatFamilySpec spec, int n, int m, int k) {
-    const std::string left_name = geom_mat_name(spec.mat_prefix, n, m);
-    const std::string right_name = geom_mat_name(spec.mat_prefix, k, n);
-    const std::string result_name = geom_mat_name(spec.mat_prefix, k, m);
-    const std::string vec_m = geom_vec_name(spec.vec_prefix, m);
-
-    out += "inline " + result_name + " operator*(" + left_name + " A, " + right_name + " B) noexcept {\n";
-    geom_append_matrix_return(out, result_name, vec_m, k, m, [&](int result_col, int result_row) {
-        std::string expression;
-        geom_append_joined(expression, n, " + ", [&](int inner) {
-            expression += "A." + std::string(geom_field_name(inner));
-            expression += ".";
-            expression += std::string(geom_field_name(result_row));
-            expression += " * B.";
-            expression += std::string(geom_field_name(result_col));
-            expression += ".";
-            expression += std::string(geom_field_name(inner));
+        res +=
+            xvecn + " operator+(" + xvecn + " A, " + memb + " b) noexcept {\n"
+            SPACE "return " + xvecn + "{";
+        res += joined_str(n, ", ", [](int ci) {
+            return "A." + vec_field(ci) + " + b";
         });
-        return expression;
-    });
-    out += "}\n\n";
+        res += "};\n}\n\n";
+
+        res +=
+            xvecn + " operator-(" + xvecn + " A, " + memb + " b) noexcept {\n"
+            SPACE "return " + xvecn + "{";
+        res += joined_str(n, ", ", [](int ci) {
+            return "A." + vec_field(ci) + " - b";
+        });
+        res += "};\n}\n\n";
+    }
+
+    if (real_arithmetic) {
+        codegen_append_xvecn_binary_operator(res, xvecn, n, "*");
+        codegen_append_xvecn_binary_operator(res, xvecn, n, "/");
+
+        res +=
+            xvecn + " operator*(" + xvecn + " A, " + memb + " b) noexcept {\n"
+            SPACE "return " + xvecn + "{";
+        res += joined_str(n, ", ", [](int ci) {
+            return "A." + vec_field(ci) + " * b";
+        });
+        res += "};\n}\n\n";
+
+        res +=
+            xvecn + " operator/(" + xvecn + " A, " + memb + " b) noexcept {\n"
+            SPACE + memb + " r = 1 / b;\n"
+            SPACE "return " + xvecn + "{";
+        res += joined_str(n, ", ", [](int ci) {
+            return "A." + vec_field(ci) + " * r";
+        });
+        res += "};\n}\n\n";
+
+        res +=
+            memb + " dot(" + xvecn + " A, " + xvecn + " B) noexcept {\n"
+            SPACE "return ";
+        res += joined_str(n, " + ", [](int ci) {
+            return "A." + vec_field(ci) + " * B." + vec_field(ci);
+        });
+        res += ";\n}\n\n";
+    }
 }
 
-inline void geom_append_det_function(std::string& out, GeomMatFamilySpec spec, int n) {
-    const std::string mat_name = geom_mat_name(spec.mat_prefix, n, n);
-    const std::string scalar = std::string(spec.scalar);
+void codegen_append_and_one_func(std::string& res, const std::string& xvec, int n) {
+    res +=
+        xvec + std::to_string(n + 1) + " and_one(" + xvec + std::to_string(n) + " A) noexcept {\n"
+        SPACE "return " + xvec + std::to_string(n + 1) + "{";
+    for (int ci = 0; ci < n; ci++) {
+        res += "A." + vec_field(ci) + ", ";
+    }
+    res += "1};\n}\n\n";
+}
 
-    out += "inline " + scalar + " det(" + mat_name + " a) noexcept {\n";
-    out += "    return " + [&]() {
-        std::string expression;
-        if (n == 2) {
-            expression = "a.x.x * a.y.y - a.x.y * a.y.x";
-            return expression;
+std::string get_matrix_name(const std::string& xmat, int n, int m) {
+    if (n == m)
+        return xmat + std::to_string(n);
+    return xmat + std::to_string(n) + "x" + std::to_string(m);
+}
+
+void codegen_append_xmatnm_binary_operator(std::string& res, const std::string& xmatnm, int n, int m, const std::string& op) {
+    res +=
+        xmatnm + " operator" + op + "(" + xmatnm + " A, " + xmatnm + " B) noexcept {\n"
+        SPACE "return ";
+    codegen_append_matrix(res, n, m, 1, [&](int i, int j) {
+        return "A." + vec_field(i) + "." + vec_field(j) + " " + op + " "
+            + "B." + vec_field(i) + "." + vec_field(j);
+    });
+    res += ";\n}\n\n";
+}
+
+void codegen_append_xmatnm_structure(std::string& res, const std::string& xmat,
+    const std::string& xvec, const std::string& memb, int n, int m) {
+    std::string xmatnm = get_matrix_name(xmat, n, m);
+    std::string xvecm = xvec + std::to_string(m);
+    res += "struct " + xmatnm + " {\n";
+    for (int i = 0; i < n; i++) {
+        res += SPACE + xvecm + " " + vec_field(i) + ";\n";
+    }
+    res += "};\n\n";
+
+    if (n == m) {
+        res += "constexpr " + xmatnm + " " + xmatnm + "_E = ";
+        codegen_append_matrix(res, n, n, 0, [](int i, int j) {
+            return i == j ? "1" : "0";
+        });
+        res += ";\n\n";
+    }
+
+    codegen_append_xmatnm_binary_operator(res, xmatnm, n, m, "+");
+    codegen_append_xmatnm_binary_operator(res, xmatnm, n, m, "-");
+
+    res +=
+        xmatnm + " operator-" + "(" + xmatnm + " A) noexcept {\n"
+        SPACE "return ";
+    codegen_append_matrix(res, n, m, 1, [&](int i, int j) {
+        return "-A." + vec_field(i) + "." + vec_field(j);
+    });
+    res += ";\n}\n\n";
+
+    res += "constexpr " + xmatnm + " " + xmatnm + "_new(\n";
+    res += joined_str(m, ",\n", [&](int y) {
+        return SPACE + joined_str(n, ", ", [&](int x) {
+            return memb + " " + vec_field(x) + vec_field(y);
+        });
+    });
+    res += "\n" SPACE "){\n" SPACE "return ";
+    codegen_append_matrix(res, n, m, 1, [](int x, int y){ return vec_field(x) + vec_field(y); });
+    res += ";\n}\n\n";
+}
+
+void codegen_append_xmatnm_multiplication(std::string& res, const std::string& xmat, int n, int m, int k) {
+    std::string matnm = get_matrix_name(xmat, n, m);
+    std::string matkm = get_matrix_name(xmat, k, m);
+    std::string matkn = get_matrix_name(xmat, k, n);
+    res += matkm + " operator*(" + matnm + " A, " + matkn + " B) noexcept {\n"
+        SPACE + "return ";
+    codegen_append_matrix_long(res, k, m, 1, [&](int x, int y) {
+        return joined_str(n, " + ", [&](int z) {
+            return "A." + vec_field(z) + "." + vec_field(y) + " * " + "B." + vec_field(x) + "." + vec_field(z);
+        });
+    });
+    res += ";\n}\n\n";
+}
+
+void l1_generate_geom_hpp() {
+    std::string res;
+    res += "#pragma once\n"
+        "/* Automatically generated file. Do not edit it. */\n\n"
+        "#include <cmath>\n"
+        "#include <cstdint>\n\n";
+    for (int n = 2; n <= 4; n++) {
+        codegen_append_xvecn_class(res, "vec", "float", n, true, true);
+        codegen_append_xvecn_class(res, "ivec", "int32_t", n, true, false);
+        codegen_append_xvecn_class(res, "uvec", "uint32_t", n, false, false);
+        codegen_append_xvecn_class(res, "cvec", "uint8_t", n, false, false);
+    }
+    for (int n = 2; n < 4; n++) {
+        codegen_append_and_one_func(res, "vec", n);
+    }
+    for (int n = 2; n <= 4; n++) {
+        for (int m = 2; m <= 4; m++) {
+            codegen_append_xmatnm_structure(res, "mat", "vec", "float", n, m);
         }
-        geom_append_joined(expression, n, "\n        ", [&](int i) {
-            if (i > 0) {
-                expression += "";
-            }
-            for (int j = 0; j < n; ++j) {
-                if (j == i) {
-                    continue;
-                }
-                const int k = (n == 3) ? (3 - i - j) : -1;
-                if (n == 3) {
-                    const bool minus =
-                        (((i > j) ? 1 : 0) + ((j > k) ? 1 : 0) + ((i > k) ? 1 : 0)) % 2 != 0;
-                    if (!expression.empty()) {
-                        expression += " ";
-                    }
-                    expression += minus ? "-" : "+";
-                    expression += " a.x.";
-                    expression += std::string(geom_field_name(i));
-                    expression += " * a.y.";
-                    expression += std::string(geom_field_name(j));
-                    expression += " * a.z.";
-                    expression += std::string(geom_field_name(k));
-                }
-            }
-            if (n == 4) {
-                for (int j = 0; j < 4; ++j) {
-                    if (j == i) {
-                        continue;
-                    }
-                    for (int k = 0; k < 4; ++k) {
-                        if (k == i || k == j) {
-                            continue;
-                        }
-                        const int u = 6 - i - j - k;
-                        const bool minus =
-                            (((i > j) ? 1 : 0) + ((j > k) ? 1 : 0) + ((i > k) ? 1 : 0) +
-                             ((i > u) ? 1 : 0) + ((j > u) ? 1 : 0) + ((k > u) ? 1 : 0)) % 2 != 0;
-                        if (!expression.empty()) {
-                            expression += " ";
-                        }
-                        expression += minus ? "-" : "+";
-                        expression += " a.x.";
-                        expression += std::string(geom_field_name(i));
-                        expression += " * a.y.";
-                        expression += std::string(geom_field_name(j));
-                        expression += " * a.z.";
-                        expression += std::string(geom_field_name(k));
-                        expression += " * a.w.";
-                        expression += std::string(geom_field_name(u));
-                    }
-                }
-            }
-        });
-        return expression;
-    }() + ";\n}\n\n";
-}
-
-inline std::string geom_build_hpp() {
-    std::string out;
-    out.reserve(131072);
-
-    out += "#pragma once\n";
-    out += "/* Automatically generated file. Do not edit it. */\n\n";
-    out += "#include <cmath>\n";
-    out += "#include <cstdint>\n\n";
-
-    constexpr std::array<GeomVecFamilySpec, 6> vec_specs = {{
-        {"cvec", "std::uint8_t", false},
-        {"uvec", "std::uint32_t", false},
-        {"s64vec", "std::int64_t", false},
-        {"ivec", "std::int32_t", false},
-        {"vec", "float", true},
-        {"dvec", "double", true},
-    }};
-
-    for (const GeomVecFamilySpec& spec : vec_specs) {
-        for (int n = 2; n <= 4; ++n) {
-            geom_append_vector_family(out, spec, n);
-        }
-        if (spec.geometric_methods) {
-            for (int n = 2; n <= 3; ++n) {
-                geom_append_vector_and_one(out, spec, n);
+    }
+    for (int n = 2; n <= 4; n++) {
+        for (int m = 2; m <= 4; m++) {
+            for (int k = 2; k <= 4; k++) {
+                codegen_append_xmatnm_multiplication(res, "mat", n, m, k);
             }
         }
     }
-
-    for (int n = 2; n <= 4; ++n) {
-        out += "using s32vec" + std::to_string(n) + " = ivec" + std::to_string(n) + ";\n";
-    }
-    out += "\n";
-
-    constexpr std::array<GeomMatFamilySpec, 2> mat_specs = {{
-        {"mat", "vec", "float"},
-        {"s64mat", "s64vec", "std::int64_t"},
-    }};
-
-    for (const GeomMatFamilySpec& spec : mat_specs) {
-        for (int cols = 2; cols <= 4; ++cols) {
-            for (int rows = 2; rows <= 4; ++rows) {
-                geom_append_matrix_struct(out, spec, cols, rows);
-                geom_append_matrix_new(out, spec, cols, rows);
-                geom_append_matrix_base_operators(out, spec, cols, rows);
-            }
-        }
-        for (int cols = 2; cols <= 4; ++cols) {
-            for (int rows = 2; rows <= 4; ++rows) {
-                geom_append_matrix_transpose(out, spec, cols, rows);
-            }
-        }
-        for (int n = 2; n <= 4; ++n) {
-            geom_append_square_identity(out, spec, n);
-            geom_append_square_outer_product(out, spec, n);
-        }
-        for (int n = 2; n <= 4; ++n) {
-            for (int m = 2; m <= 4; ++m) {
-                for (int k = 2; k <= 4; ++k) {
-                    geom_append_matrix_times_matrix(out, spec, n, m, k);
-                }
-            }
-        }
-        for (int n = 2; n <= 4; ++n) {
-            geom_append_det_function(out, spec, n);
-        }
-    }
-
-    return out;
-}
-
-inline void l1_generate_geom_hpp() {
-    write_text_file("l1/allie_cpp/geom.hpp", geom_build_hpp());
+    write_text_file("l1/allie_cpp/geom.hpp", res);
 }
diff --git a/src/l1/allie_cpp/codegen.hpp b/src/l1/allie_cpp/codegen.hpp
index f786da7..1263f9d 100644
--- a/src/l1/allie_cpp/codegen.hpp
+++ b/src/l1/allie_cpp/codegen.hpp
@@ -6,6 +6,25 @@
 #include <string>
 #include <string_view>
 
+#define SPACE "    "
+
+template <class F>
+concept CallableIntToString = requires(F&& f) {
+    {std::invoke(std::forward<F>(f), int{})} -> std::convertible_to<std::string>;
+};
+
+template <CallableIntToString F>
+std::string joined_str(int count, std::string_view separator, F&& emit_one) {
+    std::string res;
+    for (int i = 0; i < count; ++i) {
+        if (i > 0) {
+            res += separator;
+        }
+        res += emit_one(i);
+    }
+    return res;
+}
+
 inline void write_text_file(std::string_view path_string, std::string_view text) {
     const std::filesystem::path path(path_string);
     std::ofstream out(path);
@@ -18,3 +37,7 @@ inline void write_text_file(std::string_view path_string, std::string_view text)
 inline void touch_file(std::string_view path_string) {
     write_text_file(path_string, "");
 }
+
+std::string gen_tabs(int TABS) {
+    return std::string(TABS * 4, ' ');
+}
diff --git a/src/l3/r4/r4c.cpp b/src/l3/r4/r4c.cpp
index 1ead836..d67a6c3 100644
--- a/src/l3/r4/r4c.cpp
+++ b/src/l3/r4/r4c.cpp
@@ -26,7 +26,7 @@ vec4 funky_color(float time) {
 }
 
 vec3 project_dir_onto_plane_xz(vec3 v){
-    vec2 xz = normalize(vec2(v.x, v.z));
+    vec2 xz = vec2(v.x, v.z).normalize();
     return (vec3){xz.x, 0, xz.y};
 }