diff --git a/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/en_us.flatten.json5 b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/en_us.flatten.json5
new file mode 100644
index 000000000000..16cec10d6b9e
--- /dev/null
+++ b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/en_us.flatten.json5
@@ -0,0 +1,159 @@
+{
+  "pages.hextrapats":{
+    "hextrapats_consts.title": "Hextra Constants",
+    "hextrapats_logic.title": "Hextra Logic",
+    "hextrapats_nocon.title": "Non-consuming Logic",
+    "hextrapats_vec_literals.title": "Vector Literals",
+    "hextrapats_math.title": "Hextra Math",
+    "hextrapats_lists.title": "Hextra Lists",
+  },
+  hextrapats: {
+    page: {
+      consts: {
+        one: "The left-hand counter-clockwise pattern adds (1, 1, 1) to the stack; the right-hand clockwise pattern adds (-1, -1, -1)."
+      },
+      logic: {
+        greater: "If the first vector is longer than the second, return True. Otherwise, return False.",
+        less: "If the first vector is shorter than the second, return True. Otherwise, return False.",
+        greater_eq: "If the first vector is longer or the same length as the second, return True. Otherwise, return False.",
+        less_eq: "If the first vector is shorter or the same length as the second, return True. Otherwise, return False.",
+        len_eq: "If the two vectors are the same length (within small tolerance), return True. Otherwise, return False.",
+        len_neq: "If the two vectors are not the same length (outside small tolerance), return True. Otherwise, return False.",
+        in_range: "If the first number is between the second and third, return True. Otherwise, return False. If the first value is a vector, compare its length instead.",
+        "in_range.ops": "The fourth number seems to describe how to check if the value is in the range.$(li)0: min < val < max$(li)1: min <= val < max$(li)2: min < val <= max$(li)3: min <= val <= max",
+        out_range: "If the first number is not between the second and third, return True. Otherwise, return False. If the first value is a vector, compare its length instead.",
+        "out_range.ops": "The fourth number seems to describe how to check if the value is outside the range.$(li)0: val < min or max < val$(li)1: val <= min or max < val$(li)2: val < min or max <= val$(li)3: val <= min or max <= val"
+      },
+      nocon: {
+        intro: "Sometimes, I want operate on two iotas after comparing them, but it gets rather annoying to have to execute $(l:patterns/stackmanip#hexcasting:2dup)$(action)Dioscuri Gambit/$ every time I do.",
+        name: "Comparison Gambit",
+        detail: "With some experimentation, I have found that prepending a comparison with a clockwise triangle will cause the two inputs to not be consumed.",
+      },
+      vec_literals: {
+        intro: "Interestingly, attaching the tail of any Vector Reflection to the start of $(l:patterns/numbers)$(action)Number Reflection/$ makes it return a vector.",
+        x: "A head that sharply bends to the left will output a vector along the $(l:patterns/consts#hexcasting:const/vec/x)$(action)X axis/$.",
+        y: "A head that doesn't bend will output a vector along the $(l:patterns/consts#hexcasting:const/vec/y)$(action)Y axis/$.",
+        z: "A head that sharply bends to the right will output a vector along the $(l:patterns/consts#hexcasting:const/vec/z)$(action)Z axis/$.",
+        "1": "A head that slightly bends to the left will output a vector where $(l:patterns/hextrapats_consts#hextrapats:haha_ha_one)$(action)all 3 components are the same/$.",
+        detail: "First, I draw one of the eight shapes shown on the prior pages. Next, the $(italic)angles/$ following will modify a running count starting at 0.$(li)Forward: Add 1$(li)Left: Add 5$(li)Right: Add 10$(li)Sharp Left: Multiply by 2$(li)Sharp Right: Divide by 2.$(br)The clockwise version of the pattern, on the right of the other page, will negate the value at the very end. (The left-hand counter-clockwise version keeps the number positive).$(p)Once I finish drawing, a vector's pushed to the top of the stack.",
+
+        example: {
+          "x10.header": "Example 1",
+          "x10": "This pattern pushes (10, 0, 0).",
+          "y7.header": "Example 2",
+          "y7": "This pattern pushes (0, 7, 0): 5 + 1 + 1.",
+          "z-32.header": "Example 3",
+          "z-32": "This pattern pushes (0, 0, -32): negate 1 + 5 + 10 * 2.",
+          "a4.5.header": "Example 4",
+          "a4.5": "This pattern pushes (4.5, 4.5, 4.5): 5 / 2 + 1 + 1."
+        }
+      },
+      math: {
+        deg_to_rad: "Converts an angle in degrees to an angle in radians. Essentially multiplies by $(l:patterns/consts#hexcasting:const/double/pi)$(action)pi/$ then divides by 180.",
+        rad_to_deg: "Converts an angle in radians to an angle in degrees. Essentially multiplies by 180 then divides by $(l:patterns/consts#hexcasting:const/double/pi)$(action)pi/$.",
+        normalize: "Sets the length of the vector to one.",
+        invert: "Multiplies the number/vector by -1.",
+        rand_zero: "Returns a random number between 0 (inclusive) and the number (exclusive).",
+        rand_range: "Returns a random number between the first number (inclusive) and the second (exclusive).",
+        rand_vec: "Returns a unit vector facing a random direction.",
+        rot_about_x: "Rotates the vector by the given angle in radians around the X axis.",
+        rot_about_y: "Rotates the vector by the given angle in radians around the Y axis.",
+        rot_about_z: "Rotates the vector by the given angle in radians around the Z axis.",
+        cons_about_x: "Converts an angle in radians to a unit vector where X=0. +Z at 0 radians and +Y at pi/4 radians.",
+        cons_about_y: "Converts an angle in radians to a unit vector where Y=0. +Z at 0 radians and -X at pi/4 radians. I've seen some texts related to this pattern mentioning something called $(thing)F3/$, but I couldn't figure out what that means.",
+        cons_about_z: "Converts an angle in radians to a unit vector where Z=0. -X at 0 radians and +Y at pi/4 radians.",
+        scientific_exp: "Multiplies the number/vector by 10^n or 10^-n, where n is the length of the tail, depending on whether the start is similar to $(l:patterns/math#hexcasting:mul)$(action)Multiplicative Distillation/$ or $(l:patterns/math#hexcasting:div)$(action)Division Distillation/$."
+      },
+      lists: {
+        split: "Splits a list at the given index. [a, b, c, d, e], 2 will return [a, b], [c, d, e].",
+        "del_element/": {
+          first: "Remove the iota at the top of the stack, then remove the first instance of it from the list. If that iota was in the list, return True. Otherwise, return False.",
+          all: "Remove the iota at the top of the stack, then remove $(italic)all/$ instances of it from the list. Returns the number of occurrences of that iota."
+        },
+        swindle: "Reorders the elements of a list the same way $(l:patterns/stackmanip#hexcasting:swizzle)$(action)Swindler's Gambit/$ reorders the stack. Inputting a negative code will reorder the elements at the start instead of the end."
+      }
+    }
+  },
+  hexcasting: {
+    action: {
+      "hextrapats:": {
+        haha_ha_one: "Vector Reflection +1",
+        eno_ah_ahah: "Vector Reflection -1",
+
+        len_eq: "Length Equality Distillation",
+        len_neq: "Length Inequality Distillation",
+
+        in_range: "Range Exaltation",
+        out_range: "Range Exaltation II",
+
+        scaled_vec_x: "Vector Reflection X II",
+        scaled_vec_y: "Vector Reflection Y II",
+        scaled_vec_z: "Vector Reflection Z II",
+        scaled_vec_all: "Vector Reflection 1 II",
+
+        deg_to_rad: "Radian Purification",
+        rad_to_deg: "Degree Purification",
+        normalize: "Norm Purification",
+        invert: "Reversal Purification",
+        rand_zero: "Entropy Purification",
+        rand_range: "Entropy Distillation",
+        rand_vec: "Chaos Reflection",
+        rot_about_x: "Pitch Distillation",
+        rot_about_y: "Yaw Distillation",
+        rot_about_z: "Roll Distillation",
+        cons_about_x: "Pitch Purification",
+        cons_about_y: "Yaw Purification",
+        cons_about_z: "Roll Purification",
+        scientific_exp: "Scientific Purification",
+
+        "nocon/": {
+          greater: "Comparison Gambit: Maximus",
+          less: "Comparison Gambit: Minimus",
+          greater_eq: "Comparison Gambit: Maximus II",
+          less_eq: "Comparison Gambit: Minimus II",
+          eq: "Comparison Gambit: Equality",
+          neq: "Comparison Gambit: Inequality",
+          len_eq: "Comparison Gambit: Length Equality",
+          len_neq: "Comparison Gambit: Length Inequality",
+        },
+
+        split_list: "Separation Gambit",
+        "del_element/": {
+          first: "Elimination Gambit",
+          all: "Elimination Gambit II"
+        },
+        swindle_list: "Swindler's Distillation"
+      },
+
+      "book.hextrapats:": {
+        haha_ha_one:  "Vector Rfln. +1/-1",
+
+        len_eq: "Length Equality Dstl.",
+        len_neq: "Length Inequality Dstl.",
+
+        scaled_vec_x: "Vector Rfln. +X/-X II",
+        scaled_vec_y: "Vector Rfln. +Y/-Y II",
+        scaled_vec_z: "Vector Rfln. +Z/-Z II",
+        scaled_vec_all: "Vector Rfln. +1/-1 II",
+
+        "nocon/": {
+          greater: "Comp. Gambit: Maximus",
+          less: "Comp. Gambit: Minimus",
+          greater_eq: "Comp. Gambit: Maximus II",
+          less_eq: "Comp. Gambit: Minimus II",
+          eq: "Comp. Gambit: Equality",
+          neq: "Comp. Gambit: Inequality",
+          len_eq: "Comp. Gambit: Len. Eq.",
+          len_neq: "Comp. Gambit: Len. Ineq."
+        }
+      }
+    },
+    "special.hextrapats:": {
+      scaled_vec_x: "Vector Reflection: (%s, 0, 0)",
+      scaled_vec_y: "Vector Reflection: (0, %s, 0)",
+      scaled_vec_z: "Vector Reflection: (0, 0, %s)",
+      scaled_vec_all: "Vector Reflection: (%s, %s, %s)",
+      scientific_exp: "Scientific Purification: 10^%s"
+    }
+  }
+}
diff --git a/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/zh_cn.flatten.json5 b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/zh_cn.flatten.json5
new file mode 100644
index 000000000000..1224f5b0229e
--- /dev/null
+++ b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/zh_cn.flatten.json5
@@ -0,0 +1,159 @@
+{
+  "pages.hextrapats":{
+    "hextrapats_consts.title": "咒法新增：常量",
+    "hextrapats_logic.title": "咒法新增：逻辑",
+    "hextrapats_nocon.title": "保留式比较",
+    "hextrapats_vec_literals.title": "向量常量",
+    "hextrapats_math.title": "咒法新增：数学",
+    "hextrapats_lists.title": "咒法新增：列表",
+  },
+  hextrapats: {
+    page: {
+      consts: {
+        one: "左图即逆时针图案会压入 (1, 1, 1)；右图即顺时针图案会压入 (-1, -1, -1)。"
+      },
+      logic: {
+        greater: "若第一个向量的长度长于第二个的，返回 True；否则返回 False。",
+        less: "若第一个向量的长度短于第二个的，返回 True；否则返回 False。",
+        greater_eq: "若第一个向量的长度长于或等于第二个的，返回 True；否则返回 False。",
+        less_eq: "若第一个向量的长度短于或等于第二个的，返回 True；否则返回 False。",
+        len_eq: "若两向量的长度相等（允许较小误差），返回 True；否则返回 False。",
+        len_neq: "若两向量的长度不相等（不计较小误差），返回 True；否则返回 False。",
+        in_range: "若第一个数在第二个和第三个之间，返回 True；否则返回 False。若第一个参数是向量，则比较其长度。",
+        "in_range.ops": "第四个数似乎描述了检验的方式。$(li)0：min < val < max$(li)1：min <= val < max$(li)2：min < val <= max$(li)3：min <= val <= max",
+        out_range: "若第一个数不在第二个和第三个之间，返回 True；否则返回 False。若第一个参数是向量，则比较其长度。",
+        "out_range.ops": "第四个数似乎描述了检验的方式。$(li)0：val < min 或 max < val$(li)1：val <= min 或 max < val$(li)2：val < min 或 max <= val$(li)3：val <= min 或 max <= val"
+      },
+      nocon: {
+        intro: "总有些时候，我会想要在比较两个 iota 之后还继续对它们执行操作，但这就需要每次都先运行$(l:patterns/stackmanip#hexcasting:2dup)$(action)狄俄斯库里之策略/$，确实有些麻烦。",
+        name: "比较之策略",
+        detail: "通过实验，我发现：在比较图案前加上一个顺时针的三角形，就可以保留两个输入参数了。",
+      },
+      vec_literals: {
+        intro: "返回数的图案有种神奇的性质：把向量之精思的尾部加到$(l:patterns/numbers)$(action)数之精思/$的开头，就能返回一个向量。",
+        x: "向左急转的头部会返回 $(l:patterns/consts#hexcasting:const/vec/x)$(action)X 轴/$上的向量。",
+        y: "直线形状的头部会返回 $(l:patterns/consts#hexcasting:const/vec/y)$(action)Y 轴/$上的向量。",
+        z: "向右急转的头部会返回 $(l:patterns/consts#hexcasting:const/vec/z)$(action)Z 轴/$上的向量。",
+        "1": "向左微偏的头部会返回$(l:patterns/hextrapats_consts#hextrapats:haha_ha_one)$(action)所有 3 个分量都相等/$的向量。",
+        detail: "首先，绘制前页八种图案中的一种，默认数值为 0。然后，每一画的$(italic)方向/$会以对应方式修改该数值。$(li)前方：加 1$(li)左前方：加 5$(li)右前方：加 10$(li)左后方：乘 2$(li)右后方：除以 2$(br)顺时针绘制，也即各页右图，会在绘制完成后取相反数（如左图逆时针绘制则不取）。$(p)绘制完成后会返回对应向量。",
+
+        example: {
+          "x10.header": "例图一",
+          "x10": "该图案会返回 (10, 0, 0)。",
+          "y7.header": "例图二",
+          "y7": "该图案会返回 (0, 7, 0)：5 + 1 + 1。",
+          "z-32.header": "例图三",
+          "z-32": "该图案会返回 (0, 0, -32)：(1 + 5 + 10) * 2 的相反数。",
+          "a4.5.header": "例图四",
+          "a4.5": "该图案会返回 (4.5, 4.5, 4.5)：5 / 2 + 1 + 1。"
+        }
+      },
+      math: {
+        deg_to_rad: "将角度变为弧度。相当于乘以 $(l:patterns/consts#hexcasting:const/double/pi)$(action)π/$ 再除以 180。",
+        rad_to_deg: "将弧度变为角度。相当于乘以 180 再除以 $(l:patterns/consts#hexcasting:const/double/pi)$(action)π/$。",
+        normalize: "将向量的长度变为 1。",
+        invert: "求所给数/向量与 -1 相乘的积。",
+        rand_zero: "返回 0（包含）到所给数（不包含）之间的随机数。",
+        rand_range: "返回从第一个数（包含）到第二个数（不包含）之间的随机数。",
+        rand_vec: "返回朝向随机方向的单位向量。",
+        rot_about_x: "绕 X 轴将所给向量旋转所给弧度。",
+        rot_about_y: "绕 Y 轴将所给向量旋转所给弧度。",
+        rot_about_z: "绕 Z 轴将所给向量旋转所给弧度。",
+        cons_about_x: "将弧度角变为单位向量。该向量的 X 分量为 0。0 弧度对应 +Z，π/4 弧度对应 +Y。",
+        cons_about_y: "将弧度角变为单位向量。该向量的 Y 分量为 0。0 弧度对应 +Z，π/4 弧度对应 -X。我曾读到过某些文献提到某种叫 $(thing)F3/$ 的东西，但我还找不出它的意义。",
+        cons_about_z: "将弧度角变为单位向量。该向量的 Z 分量为 0。0 弧度对应 -X，π/4 弧度对应 +Y。",
+        scientific_exp: "求所给数/向量与 10^n 或 10^-n 相乘的积。其中 n 为尾部的长度，指数有无负号取决于图案开头更近似于$(l:patterns/math#hexcasting:mul)$(action)乘法之馏化/$还是$(l:patterns/math#hexcasting:div)$(action)除法之馏化/$。"
+      },
+      lists: {
+        split: "在所给下标处分割列表。[a, b, c, d, e], 2 会返回 [a, b], [c, d, e]。",
+        "del_element/": {
+          first: "移除栈顶 iota，而后移除列表中该 iota 第一次出现的实例。若列表中存在该 iota，返回 True；否则返回 False。",
+          all: "移除栈顶 iota，而后移除列表中该 iota 的$(italic)全部/$实例。返回该 iota 在列表中出现的次数。"
+        },
+        swindle: "重排列表的元素，方式与$(l:patterns/stackmanip#hexcasting:swizzle)$(action)骗徒之策略/$重排栈的一致。给定负值会从开头起进行重排，而非从末尾起。"
+      }
+    }
+  },
+  hexcasting: {
+    action: {
+      "hextrapats:": {
+        haha_ha_one: "向量之精思，+1型",
+        eno_ah_ahah: "向量之精思，-1型",
+
+        len_eq: "长度相等之馏化",
+        len_neq: "长度不等之馏化",
+
+        in_range: "范围之提整",
+        out_range: "范围之提整，第二型",
+
+        scaled_vec_x: "向量之精思，X第二型",
+        scaled_vec_y: "向量之精思，Y第二型",
+        scaled_vec_z: "向量之精思，Z第二型",
+        scaled_vec_all: "向量之精思，1第二型",
+
+        deg_to_rad: "弧度之纯化",
+        rad_to_deg: "角度之纯化",
+        normalize: "归一之纯化",
+        invert: "反向之纯化",
+        rand_zero: "熵之纯化",
+        rand_range: "熵之馏化",
+        rand_vec: "混沌之精思",
+        rot_about_x: "俯仰之馏化",
+        rot_about_y: "偏航之馏化",
+        rot_about_z: "滚转之馏化",
+        cons_about_x: "俯仰之纯化",
+        cons_about_y: "偏航之纯化",
+        cons_about_z: "滚转之纯化",
+        scientific_exp: "科学计数之纯化",
+
+        "nocon/": {
+          greater: "比较之策略：至大",
+          less: "比较之策略：至小",
+          greater_eq: "比较之策略：至大第二型",
+          less_eq: "比较之策略：至小第二型",
+          eq: "比较之策略：相等",
+          neq: "比较之策略：不等",
+          len_eq: "比较之策略：长度相等",
+          len_neq: "比较之策略：长度不等",
+        },
+
+        split_list: "分割之策略",
+        "del_element/": {
+          first: "消除之策略",
+          all: "消除之策略，第二型"
+        },
+        swindle_list: "骗徒之馏化"
+      },
+
+      "book.hextrapats:": {
+        haha_ha_one:  "向量之精思，+1/-1型",
+
+        len_eq: "长度相等之馏化",
+        len_neq: "长度不等之馏化",
+
+        scaled_vec_x: "向量之精思，+X/-X第二型",
+        scaled_vec_y: "向量之精思，+Y/-Y第二型",
+        scaled_vec_z: "向量之精思，+Z/-Z第二型",
+        scaled_vec_all: "向量之精思，+1/-1第二型",
+
+        "nocon/": {
+          greater: "比较之策略：至大",
+          less: "比较之策略：至小",
+          greater_eq: "比较之策略：至大第二型",
+          less_eq: "比较之策略：至小第二型",
+          eq: "比较之策略：相等",
+          neq: "比较之策略：不等",
+          len_eq: "比较之策略：长度相等",
+          len_neq: "比较之策略：长度不等"
+        }
+      }
+    },
+    "special.hextrapats:": {
+      scaled_vec_x: "向量之精思：(%s, 0, 0)",
+      scaled_vec_y: "向量之精思：(0, %s, 0)",
+      scaled_vec_z: "向量之精思：(0, 0, %s)",
+      scaled_vec_all: "向量之精思：(%s, %s, %s)",
+      scientific_exp: "科学计数之纯化：10^%s"
+    }
+  }
+}