diff --git a/apps/components_tests/lua/test_utilpackage.cpp b/apps/components_tests/lua/test_utilpackage.cpp
index 559b69a699..a61c0e0306 100644
--- a/apps/components_tests/lua/test_utilpackage.cpp
+++ b/apps/components_tests/lua/test_utilpackage.cpp
@@ -51,6 +51,8 @@ namespace
         EXPECT_TRUE(get<bool>(lua, "util.vector2(4, 6):ediv(util.vector2(2, 3)) == util.vector2(2, 2)"));
         lua.safe_script("swizzle = util.vector2(1, 2)");
         EXPECT_TRUE(get<bool>(lua, "swizzle.xx == util.vector2(1, 1) and swizzle.yy == util.vector2(2, 2)"));
+        EXPECT_TRUE(get<bool>(lua, "swizzle.y0 == util.vector2(2, 0) and swizzle.x1 == util.vector2(1, 1)"));
+        EXPECT_TRUE(get<bool>(lua, "swizzle['01'] == util.vector2(0, 1) and swizzle['0y'] == util.vector2(0, 2)"));
     }
 
     TEST(LuaUtilPackageTest, Vector3)
@@ -87,6 +89,9 @@ namespace
         lua.safe_script("swizzle = util.vector3(1, 2, 3)");
         EXPECT_TRUE(get<bool>(lua, "swizzle.xxx == util.vector3(1, 1, 1)"));
         EXPECT_TRUE(get<bool>(lua, "swizzle.xyz == swizzle.zyx.zyx"));
+        EXPECT_TRUE(get<bool>(lua, "swizzle.xy0 == util.vector3(1, 2, 0) and swizzle.x11 == util.vector3(1, 1, 1)"));
+        EXPECT_TRUE(
+            get<bool>(lua, "swizzle['001'] == util.vector3(0, 0, 1) and swizzle['0yx'] == util.vector3(0, 2, 1)"));
     }
 
     TEST(LuaUtilPackageTest, Vector4)
@@ -125,6 +130,10 @@ namespace
         EXPECT_TRUE(get<bool>(lua, "swizzle.wwww == util.vector4(4, 4, 4, 4)"));
         EXPECT_TRUE(get<bool>(lua, "swizzle.xyzw == util.vector4(1, 2, 3, 4)"));
         EXPECT_TRUE(get<bool>(lua, "swizzle.xyzw == swizzle.wzyx.wzyx"));
+        EXPECT_TRUE(
+            get<bool>(lua, "swizzle.xyz0 == util.vector4(1, 2, 3, 0) and swizzle.w110 == util.vector4(4, 1, 1, 0)"));
+        EXPECT_TRUE(get<bool>(
+            lua, "swizzle['0001'] == util.vector4(0, 0, 0, 1) and swizzle['0yx1'] == util.vector4(0, 2, 1, 1)"));
     }
 
     TEST(LuaUtilPackageTest, Color)
diff --git a/components/lua/utilpackage.cpp b/components/lua/utilpackage.cpp
index 852144576a..2f223f4f44 100644
--- a/components/lua/utilpackage.cpp
+++ b/components/lua/utilpackage.cpp
@@ -56,38 +56,75 @@ namespace LuaUtil
 {
     namespace
     {
-        template <typename TNew, typename T, typename... Indices>
-        void swizzle(sol::usertype<T>& type, Indices... indices)
+        template <typename T>
+        float zero(const T& v)
+        {
+            return 0.f;
+        };
+
+        template <typename T>
+        float one(const T& v)
         {
-            constexpr std::array<char, 4> components = { 'x', 'y', 'z', 'w' };
+            return 1.f;
+        };
 
-            std::string field = { components[indices]... };
-            type[field] = sol::readonly_property([=](const T& v) -> TNew { return { v[indices]... }; });
+        template <typename T, std::size_t I>
+        float get(const T& v)
+        {
+            return v[I];
         }
 
         // Creates bindings for all possible permutations (repetition allowed) of x,y,z,w fields
         template <typename T>
         void addSwizzleFields(sol::usertype<T>& type)
         {
-            for (size_t a = 0; a < T::num_components; ++a)
+            // Generate mapping of swizzle characters to their getter functions
+            constexpr auto components = []() {
+                std::array<std::pair<char, float (*)(const T&)>, T::num_components + 2> arr;
+
+                // 0/1 Components
+                arr[T::num_components] = { '0', zero<T> };
+                arr[T::num_components + 1] = { '1', one<T> };
+
+                // x,y,z,w components
+                if constexpr (T::num_components > 1)
+                {
+                    arr[0] = { 'x', get<T, 0> };
+                    arr[1] = { 'y', get<T, 1> };
+                }
+
+                if constexpr (T::num_components > 2)
+                    arr[2] = { 'z', get<T, 2> };
+
+                if constexpr (T::num_components > 3)
+                    arr[3] = { 'w', get<T, 3> };
+
+                return arr;
+            }();
+
+            // Iterate over the permutations
+            for (const auto [comp1, func1] : components)
             {
-                // Single component swizzles
-                swizzle<float>(type, a);
+                // Single component swizzle
+                type[std::string{ comp1 }] = sol::readonly_property([=](const T& v) { return func1(v); });
 
-                for (size_t b = 0; b < T::num_components; ++b)
+                for (const auto [comp2, func2] : components)
                 {
                     // Two component swizzles
-                    swizzle<Vec2>(type, a, b);
+                    type[std::string{ comp1, comp2 }]
+                        = sol::readonly_property([=](const T& v) { return Vec2(func1(v), func2(v)); });
 
-                    for (size_t c = 0; c < T::num_components; ++c)
+                    for (const auto [comp3, func3] : components)
                     {
                         // Three component swizzles
-                        swizzle<Vec3>(type, a, b, c);
+                        type[std::string{ comp1, comp2, comp3 }]
+                            = sol::readonly_property([=](const T& v) { return Vec3(func1(v), func2(v), func3(v)); });
 
-                        for (size_t d = 0; d < T::num_components; ++d)
+                        for (const auto [comp4, func4] : components)
                         {
                             // Four component swizzles
-                            swizzle<Vec4>(type, a, b, c, d);
+                            type[std::string{ comp1, comp2, comp3, comp4 }] = sol::readonly_property(
+                                [=](const T& v) { return Vec4(func1(v), func2(v), func3(v), func4(v)); });
                         }
                     }
                 }
diff --git a/files/lua_api/openmw/util.lua b/files/lua_api/openmw/util.lua
index e6a20d1bf9..9c6fd7985e 100644
--- a/files/lua_api/openmw/util.lua
+++ b/files/lua_api/openmw/util.lua
@@ -94,7 +94,7 @@
 -- @type Vector2
 -- @field #number x
 -- @field #number y
--- @field #string xy swizzle support, any combination of fields can be used to construct a new vector
+-- @field #string xy01 swizzle support, any combination of fields can be used to construct a new vector including the 0/1 constants
 -- @usage
 -- v = util.vector2(3, 4)
 -- v.x, v.y       -- 3.0, 4.0
@@ -109,7 +109,9 @@
 -- v1 - v2        -- vector subtraction
 -- v1 * x         -- multiplication by a number
 -- v1 / x         -- division by a number
--- v1.xx, v1.xyx  -- new vectors can be created with swizzles
+-- v1.xx, v1.xyx  -- swizzle with standard fields
+-- v1.y1y, v1.x00 -- swizzle with 0/1 constant
+-- v1['0xy']      -- swizzle with 0/1 constant starting with 0 or 1
 
 ---
 -- Creates a new 2D vector. Vectors are immutable and can not be changed after creation.
@@ -197,7 +199,7 @@
 -- @field #number x
 -- @field #number y
 -- @field #number z
--- @field #string xyz swizzle support, any combination of fields can be used to construct a new vector
+-- @field #string xyz01 swizzle support, any combination of fields can be used to construct a new vector including the 0/1 constants
 -- @usage
 -- v = util.vector3(3, 4, 5)
 -- v.x, v.y, v.z  -- 3.0, 4.0, 5.0
@@ -213,7 +215,9 @@
 -- v1 - v2        -- vector subtraction
 -- v1 * x         -- multiplication by a number
 -- v1 / x         -- division by a number
--- v1.zyz, v1.yx  -- new vectors can be created with swizzles
+-- v1.zyz, v1.yx  -- swizzle with standard fields
+-- v1.w1y, v1.z0z -- swizzle with 0/1 constant
+-- v1['0xy']      -- swizzle with 0/1 constant starting with 0 or 1
 
 ---
 -- Creates a new 3D vector. Vectors are immutable and can not be changed after creation.
@@ -308,7 +312,7 @@
 -- @field #number y
 -- @field #number z
 -- @field #number w
--- @field #string xyzw swizzle support, any combination of fields can be used to construct a new vector
+-- @field #string xyzw01 swizzle support, any combination of fields can be used to construct a new vector including the 0/1 constants
 -- @usage
 -- v = util.vector4(3, 4, 5, 6)
 -- v.x, v.y, v.z, v.w  -- 3.0, 4.0, 5.0, 6.0
@@ -322,7 +326,9 @@
 -- v1 - v2          -- vector subtraction
 -- v1 * x           -- multiplication by a number
 -- v1 / x           -- division by a number
--- v1.zzzz, v1.zyz  -- new vectors can be created with swizzles
+-- v1.zyz, v1.wwwx  -- swizzle with standard fields
+-- v1.w1, v1.z000   -- swizzle with 0/1 constant
+-- v1['000w']       -- swizzle with 0/1 constant starting with 0 or 1
 
 ---
 -- Creates a new 4D vector. Vectors are immutable and can not be changed after creation.