diff --git a/headers/enduro2d/math/trs2.hpp b/headers/enduro2d/math/trs2.hpp
index 0814e919..45d737ee 100644
--- a/headers/enduro2d/math/trs2.hpp
+++ b/headers/enduro2d/math/trs2.hpp
@@ -26,17 +26,18 @@ namespace e2d
         rad<T> rotation = rad<T>(0);
         vec2<T> scale = vec2<T>::unit();
     public:
-        static const trs2& zero() noexcept;
-        static const trs2& identity() noexcept;
+        static constexpr trs2 zero() noexcept;
+        static constexpr trs2 identity() noexcept;
     public:
-        trs2() noexcept = default;
-        trs2(const trs2& other) noexcept = default;
-        trs2& operator=(const trs2& other) noexcept = default;
+        constexpr trs2() noexcept = default;
+        constexpr trs2(const trs2& other) noexcept = default;
+        constexpr trs2& operator=(const trs2& other) noexcept = default;
 
         template < typename AngleTag >
-        trs2(const vec2<T>& t,
-             const unit<T, AngleTag>& r,
-             const vec2<T>& s) noexcept;
+        constexpr trs2(
+            const vec2<T>& t,
+            const unit<T, AngleTag>& r,
+            const vec2<T>& s) noexcept;
 
         template < typename To >
         trs2<To> cast_to() const noexcept;
@@ -46,26 +47,24 @@ namespace e2d
 namespace e2d
 {
     template < typename T >
-    const trs2<T>& trs2<T>::zero() noexcept {
-        static const trs2<T> zero{
+    constexpr trs2<T> trs2<T>::zero() noexcept {
+        return {
             vec2<T>::zero(),
             rad<T>(0),
             vec2<T>::zero()};
-        return zero;
     }
 
     template < typename T >
-    const trs2<T>& trs2<T>::identity() noexcept {
-        static const trs2<T> identity{
+    constexpr trs2<T> trs2<T>::identity() noexcept {
+        return {
             vec2<T>::zero(),
             rad<T>(0),
             vec2<T>::unit()};
-        return identity;
     }
 
     template < typename T >
     template < typename AngleTag >
-    trs2<T>::trs2(
+    constexpr trs2<T>::trs2(
         const vec2<T>& t,
         const unit<T, AngleTag>& r,
         const vec2<T>& s) noexcept
@@ -90,7 +89,7 @@ namespace e2d
     //
 
     template < typename T, typename AngleTag >
-    trs2<T> make_trs2(
+    constexpr trs2<T> make_trs2(
         const vec2<T>& t,
         const unit<T, AngleTag>& r,
         const vec2<T>& s) noexcept
diff --git a/headers/enduro2d/math/trs3.hpp b/headers/enduro2d/math/trs3.hpp
index 487f1a31..3f300540 100644
--- a/headers/enduro2d/math/trs3.hpp
+++ b/headers/enduro2d/math/trs3.hpp
@@ -25,16 +25,17 @@ namespace e2d
         quat<T> rotation = quat<T>::identity();
         vec3<T> scale = vec3<T>::unit();
     public:
-        static const trs3& zero() noexcept;
-        static const trs3& identity() noexcept;
+        static constexpr trs3 zero() noexcept;
+        static constexpr trs3 identity() noexcept;
     public:
-        trs3() noexcept = default;
-        trs3(const trs3& other) noexcept = default;
-        trs3& operator=(const trs3& other) noexcept = default;
+        constexpr trs3() noexcept = default;
+        constexpr trs3(const trs3& other) noexcept = default;
+        constexpr trs3& operator=(const trs3& other) noexcept = default;
 
-        trs3(const vec3<T>& t,
-             const quat<T>& r,
-             const vec3<T>& s) noexcept;
+        constexpr trs3(
+            const vec3<T>& t,
+            const quat<T>& r,
+            const vec3<T>& s) noexcept;
 
         template < typename To >
         trs3<To> cast_to() const noexcept;
@@ -44,25 +45,23 @@ namespace e2d
 namespace e2d
 {
     template < typename T >
-    const trs3<T>& trs3<T>::zero() noexcept {
-        static const trs3<T> zero{
+    constexpr trs3<T> trs3<T>::zero() noexcept {
+        return {
             vec3<T>::zero(),
             quat<T>::zero(),
             vec3<T>::zero()};
-        return zero;
     }
 
     template < typename T >
-    const trs3<T>& trs3<T>::identity() noexcept {
-        static const trs3<T> identity{
+    constexpr trs3<T> trs3<T>::identity() noexcept {
+        return {
             vec3<T>::zero(),
             quat<T>::identity(),
             vec3<T>::unit()};
-        return identity;
     }
 
     template < typename T >
-    trs3<T>::trs3(
+    constexpr trs3<T>::trs3(
         const vec3<T>& t,
         const quat<T>& r,
         const vec3<T>& s) noexcept
@@ -87,7 +86,7 @@ namespace e2d
     //
 
     template < typename T >
-    trs3<T> make_trs3(
+    constexpr trs3<T> make_trs3(
         const vec3<T>& t,
         const quat<T>& r,
         const vec3<T>& s) noexcept
diff --git a/sources/enduro2d/high/bindings/math_binds.cpp b/sources/enduro2d/high/bindings/math_binds.cpp
index 099b8d86..dacbf108 100644
--- a/sources/enduro2d/high/bindings/math_binds.cpp
+++ b/sources/enduro2d/high/bindings/math_binds.cpp
@@ -603,6 +603,59 @@ namespace
 
             "contains_nan", sol::resolve<bool(const aabb<T>&)>(&math::contains_nan));
     }
+
+    template < typename T >
+    void bind_trs2(const str& name, sol::state& l) {
+        l.new_usertype<trs2<T>>(name,
+            sol::constructors<
+                trs2<T>(),
+                trs2<T>(trs2<T>),
+                trs2<T>(vec2<T>,deg<T>,vec2<T>),
+                trs2<T>(vec2<T>,rad<T>,vec2<T>)>(),
+
+            "zero", &trs2<T>::zero,
+            "unit", &trs2<T>::identity,
+
+            "translation", &trs2<T>::translation,
+            "rotation", &trs2<T>::rotation,
+            "scale", &trs2<T>::scale,
+
+            sol::meta_function::equal_to, sol::resolve<bool(const trs2<T>&, const trs2<T>&)>(::operator==),
+
+            "make_translation_trs2", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_translation_trs2),
+            "make_rotation_trs2", sol::overload(
+                sol::resolve<trs2<T>(const deg<T>&)>(&math::make_rotation_trs2),
+                sol::resolve<trs2<T>(const rad<T>&)>(&math::make_rotation_trs2)),
+            "make_scale_trs2", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_scale_trs2),
+
+            "approximately", [](const trs2<T>& l, const trs2<T>& r){ return math::approximately(l,r); },
+            "contains_nan", sol::resolve<bool(const trs2<T>&)>(&math::contains_nan));
+    }
+
+    template < typename T >
+    void bind_trs3(const str& name, sol::state& l) {
+        l.new_usertype<trs3<T>>(name,
+            sol::constructors<
+                trs3<T>(),
+                trs3<T>(trs3<T>),
+                trs3<T>(vec3<T>,quat<T>,vec3<T>)>(),
+
+            "zero", &trs3<T>::zero,
+            "unit", &trs3<T>::identity,
+
+            "translation", &trs3<T>::translation,
+            "rotation", &trs3<T>::rotation,
+            "scale", &trs3<T>::scale,
+
+            sol::meta_function::equal_to, sol::resolve<bool(const trs3<T>&, const trs3<T>&)>(::operator==),
+
+            "make_translation_trs3", sol::resolve<trs3<T>(const vec3<T>&)>(&math::make_translation_trs3),
+            "make_rotation_trs3", sol::resolve<trs3<T>(const quat<T>&)>(&math::make_rotation_trs3),
+            "make_scale_trs3", sol::resolve<trs3<T>(const vec3<T>&)>(&math::make_scale_trs3),
+
+            "approximately", [](const trs3<T>& l, const trs3<T>& r){ return math::approximately(l,r); },
+            "contains_nan", sol::resolve<bool(const trs3<T>&)>(&math::contains_nan));
+    }
 }
 
 namespace e2d::bindings
@@ -619,5 +672,7 @@ namespace e2d::bindings
         bind_mat4<f32>("m4f", l);
         bind_rect<f32>("b2f", l);
         bind_aabb<f32>("b3f", l);
+        bind_trs2<f32>("t2f", l);
+        bind_trs3<f32>("t3f", l);
     }
 }
diff --git a/untests/sources/untests_high/luasol.cpp b/untests/sources/untests_high/luasol.cpp
index fa47ba5c..b29d41c7 100644
--- a/untests/sources/untests_high/luasol.cpp
+++ b/untests/sources/untests_high/luasol.cpp
@@ -89,4 +89,17 @@ TEST_CASE("luasol") {
         )lua");
         REQUIRE(r1);
     }
+
+    SECTION("trs2/trs3") {
+        radf r0 = l.lua().script(R"lua(
+            local t = t2f.make_rotation_trs2(degf.new(45))
+            return t.rotation
+        )lua");
+        REQUIRE(r0 == math::to_rad(degf(45.f)));
+        v3f r1 = l.lua().script(R"lua(
+            local t = t3f.make_translation_trs3(v3f.new(1,2,3))
+            return t.translation
+        )lua");
+        REQUIRE(r1 == v3f(1,2,3));
+    }
 }