diff --git a/include/rive/bones/bone.hpp b/include/rive/bones/bone.hpp
index 357b855..74a4028 100644
--- a/include/rive/bones/bone.hpp
+++ b/include/rive/bones/bone.hpp
@@ -20,7 +20,7 @@
         inline const std::vector<Bone*> childBones() { return m_ChildBones; }
 
         void addChildBone(Bone* bone);
-        void tipWorldTranslation(Vec2D& result);
+        Vec2D tipWorldTranslation() const;
         void addPeerConstraint(Constraint* peer);
         const std::vector<Constraint*>& peerConstraints() const { return m_PeerConstraints; }
 
diff --git a/include/rive/bones/weight.hpp b/include/rive/bones/weight.hpp
index e7a1979..7145d59 100644
--- a/include/rive/bones/weight.hpp
+++ b/include/rive/bones/weight.hpp
@@ -14,13 +14,11 @@
 
         StatusCode onAddedDirty(CoreContext* context) override;
 
-        static void deform(float x,
-                           float y,
-                           unsigned int indices,
-                           unsigned int weights,
-                           const Mat2D& world,
-                           const float* boneTransforms,
-                           Vec2D& result);
+        static Vec2D deform(Vec2D inPoint,
+                            unsigned int indices,
+                            unsigned int weights,
+                            const Mat2D& world,
+                            const float* boneTransforms);
     };
 } // namespace rive
 
diff --git a/include/rive/command_path.hpp b/include/rive/command_path.hpp
index f22d4a2..9c61674 100644
--- a/include/rive/command_path.hpp
+++ b/include/rive/command_path.hpp
@@ -32,10 +32,10 @@
             close();
         }
 
-        void move(Vec2D v) { this->moveTo(v.x(), v.y()); }
-        void line(Vec2D v) { this->lineTo(v.x(), v.y()); }
+        void move(Vec2D v) { this->moveTo(v.x, v.y); }
+        void line(Vec2D v) { this->lineTo(v.x, v.y); }
         void cubic(Vec2D a, Vec2D b, Vec2D c) {
-            this->cubicTo(a.x(), a.y(), b.x(), b.y(), c.x(), c.y());
+            this->cubicTo(a.x, a.y, b.x, b.y, c.x, c.y);
         }
     };
 } // namespace rive
diff --git a/include/rive/math/mat2d.hpp b/include/rive/math/mat2d.hpp
index 0e492ab..f14e269 100644
--- a/include/rive/math/mat2d.hpp
+++ b/include/rive/math/mat2d.hpp
@@ -55,6 +55,8 @@
         float tx() const { return m_Buffer[4]; }
         float ty() const { return m_Buffer[5]; }
 
+        Vec2D translation() const { return {m_Buffer[4], m_Buffer[5]}; }
+
         void xx(float value) { m_Buffer[0] = value; }
         void xy(float value) { m_Buffer[1] = value; }
         void yx(float value) { m_Buffer[2] = value; }
@@ -65,8 +67,8 @@
 
     inline Vec2D operator*(const Mat2D& m, Vec2D v) {
         return {
-            m[0] * v.x() + m[2] * v.y() + m[4],
-            m[1] * v.x() + m[3] * v.y() + m[5],
+            m[0] * v.x + m[2] * v.y + m[4],
+            m[1] * v.x + m[3] * v.y + m[5],
         };
     }
 
diff --git a/include/rive/math/vec2d.hpp b/include/rive/math/vec2d.hpp
index 1e462d8..21dcdd4 100644
--- a/include/rive/math/vec2d.hpp
+++ b/include/rive/math/vec2d.hpp
@@ -6,44 +6,50 @@
 namespace rive {
     class Mat2D;
     class Vec2D {
-    private:
-        float m_Buffer[2];
-
     public:
-        constexpr Vec2D() : m_Buffer{0.0f, 0.0f} {}
-        constexpr Vec2D(float x, float y) : m_Buffer{x, y} {}
+        float x, y;
+
+        constexpr Vec2D() : x(0), y(0) {}
+        constexpr Vec2D(float x, float y) : x(x), y(y) {}
         constexpr Vec2D(const Vec2D&) = default;
 
-        float x() const { return m_Buffer[0]; }
-        float y() const { return m_Buffer[1]; }
-        inline const float* values() const { return m_Buffer; }
-
-        float& operator[](std::size_t idx) { return m_Buffer[idx]; }
-        const float& operator[](std::size_t idx) const { return m_Buffer[idx]; }
-
-        float lengthSquared() const { return x() * x() + y() * y(); }
+        float lengthSquared() const { return x * x + y * y; }
         float length() const;
         Vec2D normalized() const;
 
-        Vec2D operator-() const { return {-x(), -y()}; }
+        // Normalize this Vec, and return its previous length
+        float normalizeLength() {
+            const float len = this->length();
+            x /= len;
+            y /= len;
+            return len;
+        }
+
+        Vec2D operator-() const { return {-x, -y}; }
 
         void operator*=(float s) {
-            m_Buffer[0] *= s;
-            m_Buffer[1] *= s;
+            x *= s;
+            y *= s;
+        }
+
+        void operator/=(float s) {
+            x /= s;
+            y /= s;
         }
 
         friend inline Vec2D operator-(const Vec2D& a, const Vec2D& b) {
-            return {a[0] - b[0], a[1] - b[1]};
+            return {a.x - b.x, a.y - b.y};
         }
 
-        static Vec2D lerp(const Vec2D& a, const Vec2D& b, float f);
+        static inline Vec2D lerp(Vec2D a, Vec2D b, float f);
+
         static Vec2D transformDir(const Vec2D& a, const Mat2D& m);
 
-        static float dot(Vec2D a, Vec2D b) { return a[0] * b[0] + a[1] * b[1]; }
+        static float dot(Vec2D a, Vec2D b) { return a.x * b.x + a.y * b.y; }
         static Vec2D scaleAndAdd(Vec2D a, Vec2D b, float scale) {
             return {
-                a[0] + b[0] * scale,
-                a[1] + b[1] * scale,
+                a.x + b.x * scale,
+                a.y + b.y * scale,
             };
         }
         static float distance(const Vec2D& a, const Vec2D& b) { return (a - b).length(); }
@@ -52,24 +58,29 @@
         }
 
         Vec2D& operator+=(Vec2D v) {
-            m_Buffer[0] += v[0];
-            m_Buffer[1] += v[1];
+            x += v.x;
+            y += v.y;
             return *this;
         }
         Vec2D& operator-=(Vec2D v) {
-            m_Buffer[0] -= v[0];
-            m_Buffer[1] -= v[1];
+            x -= v.x;
+            y -= v.y;
             return *this;
         }
     };
 
-    inline Vec2D operator*(const Vec2D& v, float s) { return {v[0] * s, v[1] * s}; }
-    inline Vec2D operator*(float s, const Vec2D& v) { return {v[0] * s, v[1] * s}; }
-    inline Vec2D operator/(const Vec2D& v, float s) { return {v[0] / s, v[1] / s}; }
+    inline Vec2D operator*(const Vec2D& v, float s) { return {v.x * s, v.y * s}; }
+    inline Vec2D operator*(float s, const Vec2D& v) { return {v.x * s, v.y * s}; }
+    inline Vec2D operator/(const Vec2D& v, float s) { return {v.x / s, v.y / s}; }
 
-    inline Vec2D operator+(const Vec2D& a, const Vec2D& b) { return {a[0] + b[0], a[1] + b[1]}; }
+    inline Vec2D operator+(const Vec2D& a, const Vec2D& b) { return {a.x + b.x, a.y + b.y}; }
 
-    inline bool operator==(const Vec2D& a, const Vec2D& b) { return a[0] == b[0] && a[1] == b[1]; }
-    inline bool operator!=(const Vec2D& a, const Vec2D& b) { return a[0] != b[0] || a[1] != b[1]; }
+    inline bool operator==(const Vec2D& a, const Vec2D& b) { return a.x == b.x && a.y == b.y; }
+    inline bool operator!=(const Vec2D& a, const Vec2D& b) { return a.x != b.x || a.y != b.y; }
+
+    Vec2D Vec2D::lerp(Vec2D a, Vec2D b, float t) {
+        return a + (b - a) * t;
+    }
+
 } // namespace rive
 #endif
diff --git a/include/rive/world_transform_component.hpp b/include/rive/world_transform_component.hpp
index 320ba86..b7769b1 100644
--- a/include/rive/world_transform_component.hpp
+++ b/include/rive/world_transform_component.hpp
@@ -16,7 +16,7 @@
         virtual float childOpacity();
         Mat2D& mutableWorldTransform();
         const Mat2D& worldTransform() const;
-        void worldTranslation(Vec2D& result) const;
+        Vec2D worldTranslation() const { return m_WorldTransform.translation(); }
         void opacityChanged() override;
     };
 } // namespace rive
diff --git a/skia/renderer/include/to_skia.hpp b/skia/renderer/include/to_skia.hpp
index a80848a..e92649c 100644
--- a/skia/renderer/include/to_skia.hpp
+++ b/skia/renderer/include/to_skia.hpp
@@ -24,8 +24,8 @@
             return SkMatrix::MakeAll(m[0], m[2], m[4], m[1], m[3], m[5], 0, 0, 1);
         }
 
-        static SkPoint convert(const rive::Vec2D& point) {
-            return SkPoint::Make(point[0], point[1]);
+        static SkPoint convert(rive::Vec2D point) {
+            return SkPoint::Make(point.x, point.y);
         }
 
         // clang-format off
diff --git a/src/animation/state_machine_instance.cpp b/src/animation/state_machine_instance.cpp
index 69fbf73..e6d2a60 100644
--- a/src/animation/state_machine_instance.cpp
+++ b/src/animation/state_machine_instance.cpp
@@ -240,11 +240,11 @@
     position -= Vec2D(m_ArtboardInstance->originX() * m_ArtboardInstance->width(),
                       m_ArtboardInstance->originY() * m_ArtboardInstance->height());
 
-    const int hitRadius = 2;
-    auto hitArea = AABB(position.x() - hitRadius,
-                        position.y() - hitRadius,
-                        position.x() + hitRadius,
-                        position.y() + hitRadius)
+    const float hitRadius = 2;
+    auto hitArea = AABB(position.x - hitRadius,
+                        position.y - hitRadius,
+                        position.x + hitRadius,
+                        position.y + hitRadius)
                        .round();
 
     for (const auto& hitShape : m_HitShapes) {
diff --git a/src/bones/bone.cpp b/src/bones/bone.cpp
index ec72eb9..f5e7a4b 100644
--- a/src/bones/bone.cpp
+++ b/src/bones/bone.cpp
@@ -25,7 +25,9 @@
 
 float Bone::y() const { return 0.0f; }
 
-void Bone::tipWorldTranslation(Vec2D& result) { result = worldTransform() * Vec2D(length(), 0); }
+Vec2D Bone::tipWorldTranslation() const {
+    return worldTransform() * Vec2D(length(), 0);
+}
 
 void Bone::addPeerConstraint(Constraint* peer) {
     assert(std::find(m_PeerConstraints.begin(), m_PeerConstraints.end(), peer) ==
diff --git a/src/bones/weight.cpp b/src/bones/weight.cpp
index 287972d..9f00714 100644
--- a/src/bones/weight.cpp
+++ b/src/bones/weight.cpp
@@ -22,16 +22,12 @@
     return (data >> (index * 8)) & 0xFF;
 }
 
-void Weight::deform(float x,
-                    float y,
+Vec2D Weight::deform(Vec2D inPoint,
                     unsigned int indices,
                     unsigned int weights,
                     const Mat2D& world,
-                    const float* boneTransforms,
-                    Vec2D& result) {
+                    const float* boneTransforms) {
     float xx = 0, xy = 0, yx = 0, yy = 0, tx = 0, ty = 0;
-    float rx = world[0] * x + world[2] * y + world[4];
-    float ry = world[1] * x + world[3] * y + world[5];
     for (int i = 0; i < 4; i++) {
         int weight = encodedWeightValue(i, weights);
         if (weight == 0) {
@@ -48,6 +44,6 @@
         tx += boneTransforms[startBoneTransformIndex++] * normalizedWeight;
         ty += boneTransforms[startBoneTransformIndex++] * normalizedWeight;
     }
-    result[0] = xx * rx + yx * ry + tx;
-    result[1] = xy * rx + yy * ry + ty;
-}
\ No newline at end of file
+
+    return Mat2D(xx, xy, yx, yy, tx, ty) * (world * inPoint);
+}
diff --git a/src/constraints/distance_constraint.cpp b/src/constraints/distance_constraint.cpp
index 0df5022..6f79f93 100644
--- a/src/constraints/distance_constraint.cpp
+++ b/src/constraints/distance_constraint.cpp
@@ -12,14 +12,12 @@
         return;
     }
 
-    Vec2D targetTranslation;
-    m_Target->worldTranslation(targetTranslation);
-
-    Vec2D ourTranslation;
-    component->worldTranslation(ourTranslation);
-
+    const Vec2D targetTranslation = m_Target->worldTranslation();
+    const Vec2D ourTranslation = component->worldTranslation();
+    
     Vec2D toTarget = ourTranslation - targetTranslation;
     float currentDistance = toTarget.length();
+
     switch (static_cast<Mode>(modeValue())) {
         case Mode::Closer:
             if (currentDistance < distance()) {
@@ -43,6 +41,6 @@
     Mat2D& world = component->mutableWorldTransform();
     Vec2D position = targetTranslation + toTarget;
     position = Vec2D::lerp(ourTranslation, position, strength());
-    world[4] = position[0];
-    world[5] = position[1];
+    world[4] = position.x;
+    world[5] = position.y;
 }
diff --git a/src/constraints/ik_constraint.cpp b/src/constraints/ik_constraint.cpp
index 7985526..bb07b3a 100644
--- a/src/constraints/ik_constraint.cpp
+++ b/src/constraints/ik_constraint.cpp
@@ -7,7 +7,7 @@
 using namespace rive;
 
 static float atan2(Vec2D v) {
-    return std::atan2(v.y(), v.x());
+    return std::atan2(v.y, v.x);
 }
 
 void IKConstraint::buildDependencies() {
@@ -87,8 +87,7 @@
 
 void IKConstraint::solve1(BoneChainLink* fk1, const Vec2D& worldTargetTranslation) {
     Mat2D iworld = fk1->parentWorldInverse;
-    Vec2D pA;
-    fk1->bone->worldTranslation(pA);
+    Vec2D pA = fk1->bone->worldTranslation();
     Vec2D pBT(worldTargetTranslation);
 
     // To target in worldspace
@@ -111,10 +110,9 @@
 
     const Mat2D& iworld = fk1->parentWorldInverse;
 
-    Vec2D pA, pC, pB;
-    b1->worldTranslation(pA);
-    firstChild->bone->worldTranslation(pC);
-    b2->tipWorldTranslation(pB);
+    Vec2D pA = b1->worldTranslation();
+    Vec2D pC = firstChild->bone->worldTranslation();
+    Vec2D pB = b2->tipWorldTranslation();
     Vec2D pBT(worldTargetTranslation);
 
     pA = iworld * pA;
@@ -135,8 +133,8 @@
 
         const Mat2D& secondChildWorldInverse = secondChild.parentWorldInverse;
 
-        firstChild->bone->worldTranslation(pC);
-        b2->tipWorldTranslation(pB);
+        pC = firstChild->bone->worldTranslation();
+        pB = b2->tipWorldTranslation();
 
         Vec2D avLocal = Vec2D::transformDir(pB - pC, secondChildWorldInverse);
         float angleCorrection = -atan2(avLocal);
@@ -202,8 +200,7 @@
         return;
     }
 
-    Vec2D worldTargetTranslation;
-    m_Target->worldTranslation(worldTargetTranslation);
+    Vec2D worldTargetTranslation = m_Target->worldTranslation();
 
     // Decompose the chain.
     for (BoneChainLink& item : m_FkChain) {
diff --git a/src/constraints/translation_constraint.cpp b/src/constraints/translation_constraint.cpp
index 4ade22b..7bc56b5 100644
--- a/src/constraints/translation_constraint.cpp
+++ b/src/constraints/translation_constraint.cpp
@@ -23,25 +23,24 @@
             }
             transformB = inverse * transformB;
         }
-        translationB[0] = transformB[4];
-        translationB[1] = transformB[5];
+        translationB = transformB.translation();
 
         if (!doesCopy()) {
-            translationB[0] = destSpace() == TransformSpace::local ? 0.0f : translationA[0];
+            translationB.x = destSpace() == TransformSpace::local ? 0.0f : translationA.x;
         } else {
-            translationB[0] *= copyFactor();
+            translationB.x *= copyFactor();
             if (offset()) {
-                translationB[0] += component->x();
+                translationB.x += component->x();
             }
         }
 
         if (!doesCopyY()) {
-            translationB[1] = destSpace() == TransformSpace::local ? 0.0f : translationA[1];
+            translationB.y = destSpace() == TransformSpace::local ? 0.0f : translationA.y;
         } else {
-            translationB[1] *= copyFactorY();
+            translationB.y *= copyFactorY();
 
             if (offset()) {
-                translationB[1] += component->y();
+                translationB.y += component->y();
             }
         }
 
@@ -62,17 +61,17 @@
         // Get our target world coordinates in parent local.
         translationB = inverse * translationB;
     }
-    if (max() && translationB[0] > maxValue()) {
-        translationB[0] = maxValue();
+    if (max() && translationB.x > maxValue()) {
+        translationB.x = maxValue();
     }
-    if (min() && translationB[0] < minValue()) {
-        translationB[0] = minValue();
+    if (min() && translationB.x < minValue()) {
+        translationB.x = minValue();
     }
-    if (maxY() && translationB[1] > maxValueY()) {
-        translationB[1] = maxValueY();
+    if (maxY() && translationB.y > maxValueY()) {
+        translationB.y = maxValueY();
     }
-    if (minY() && translationB[1] < minValueY()) {
-        translationB[1] = minValueY();
+    if (minY() && translationB.y < minValueY()) {
+        translationB.y = minValueY();
     }
     if (clampLocal) {
         // Transform back to world.
@@ -83,6 +82,6 @@
     float ti = 1.0f - t;
 
     // Just interpolate world translation
-    transformA[4] = translationA[0] * ti + translationB[0] * t;
-    transformA[5] = translationA[1] * ti + translationB[1] * t;
+    transformA[4] = translationA.x * ti + translationB.x * t;
+    transformA[5] = translationA.y * ti + translationB.y * t;
 }
diff --git a/src/math/aabb.cpp b/src/math/aabb.cpp
index 028e213..f4ae193 100644
--- a/src/math/aabb.cpp
+++ b/src/math/aabb.cpp
@@ -10,13 +10,13 @@
         return;
     }
 
-    float L = pts[0].x(), R = L, T = pts[0].y(), B = T;
+    float L = pts[0].x, R = L, T = pts[0].y, B = T;
 
     for (size_t i = 1; i < pts.size(); ++i) {
-        L = std::min(L, pts[i].x());
-        R = std::max(R, pts[i].x());
-        T = std::min(T, pts[i].y());
-        B = std::max(B, pts[i].y());
+        L = std::min(L, pts[i].x);
+        R = std::max(R, pts[i].x);
+        T = std::min(T, pts[i].y);
+        B = std::max(B, pts[i].y);
     }
     minX = L;
     maxX = R;
diff --git a/src/math/hit_test.cpp b/src/math/hit_test.cpp
index 0e4d142..7b4c7f5 100644
--- a/src/math/hit_test.cpp
+++ b/src/math/hit_test.cpp
@@ -22,7 +22,7 @@
 
     Point() {}
     Point(float xx, float yy) : x(xx), y(yy) {}
-    Point(const Vec2D& src) : x(src.x()), y(src.y()) {}
+    Point(const Vec2D& src) : x(src.x), y(src.y) {}
 
     Point operator+(Point v) const { return {x + v.x, y + v.y}; }
     Point operator-(Point v) const { return {x - v.x, y - v.y}; }
@@ -317,7 +317,7 @@
 /////////////////////////
 
 static bool cross_lt(Vec2D a, Vec2D b) {
-    return a.x() * b.y() < a.y() * b.x();
+    return a.x * b.y < a.y * b.x;
 }
 
 bool HitTester::testMesh(Vec2D pt, Span<Vec2D> verts, Span<uint16_t> indices) {
@@ -330,8 +330,8 @@
     if (CULL_BOUNDS) {
         const auto bounds = AABB(verts);
 
-        if (bounds.bottom() < pt.y() || pt.y() < bounds.top() ||
-            bounds.right()  < pt.x() || pt.x() < bounds.left()) {
+        if (bounds.bottom() < pt.y || pt.y < bounds.top() ||
+            bounds.right()  < pt.x || pt.x < bounds.left()) {
             return false;
         }
     }
diff --git a/src/math/mat2d.cpp b/src/math/mat2d.cpp
index eb9b8ec..601dd6c 100644
--- a/src/math/mat2d.cpp
+++ b/src/math/mat2d.cpp
@@ -16,10 +16,10 @@
 
 Mat2D Mat2D::scale(Vec2D vec) const {
     return {
-        m_Buffer[0] * vec.x(),
-        m_Buffer[1] * vec.x(),
-        m_Buffer[2] * vec.y(),
-        m_Buffer[3] * vec.y(),
+        m_Buffer[0] * vec.x,
+        m_Buffer[1] * vec.x,
+        m_Buffer[2] * vec.y,
+        m_Buffer[3] * vec.y,
         m_Buffer[4],
         m_Buffer[5],
     };
diff --git a/src/math/raw_path.cpp b/src/math/raw_path.cpp
index 651eb79..2461c3d 100644
--- a/src/math/raw_path.cpp
+++ b/src/math/raw_path.cpp
@@ -13,11 +13,11 @@
     }
 
     float l, t, r, b;
-    l = r = m_Points[0].x();
-    t = b = m_Points[0].y();
+    l = r = m_Points[0].x;
+    t = b = m_Points[0].y;
     for (size_t i = 1; i < m_Points.size(); ++i) {
-        const float x = m_Points[i].x();
-        const float y = m_Points[i].y();
+        const float x = m_Points[i].x;
+        const float y = m_Points[i].y;
         l = std::min(l, x);
         r = std::max(r, x);
         t = std::min(t, y);
@@ -68,24 +68,14 @@
 
     path.m_Points.resize(m_Points.size());
     for (size_t i = 0; i < m_Points.size(); ++i) {
-        const float x = m_Points[i].x();
-        const float y = m_Points[i].y();
-        path.m_Points[i] = {
-            m[0] * x + m[2] * y + m[4],
-            m[1] * x + m[3] * y + m[5],
-        };
+        path.m_Points[i] = m * m_Points[i];
     }
     return path;
 }
 
 void RawPath::transformInPlace(const Mat2D& m) {
     for (auto& p : m_Points) {
-        const float x = p.x();
-        const float y = p.y();
-        p = {
-            m[0] * x + m[2] * y + m[4],
-            m[1] * x + m[3] * y + m[5],
-        };
+        p = m * p;
     }
 }
 
@@ -131,13 +121,13 @@
     };
 
     const auto center = r.center();
-    const float dx = center.x();
-    const float dy = center.y();
+    const float dx = center.x;
+    const float dy = center.y;
     const float sx = r.width() * 0.5f;
     const float sy = r.height() * 0.5f;
 
     auto map = [dx, dy, sx, sy](rive::Vec2D p) {
-        return rive::Vec2D(p.x() * sx + dx, p.y() * sy + dy);
+        return rive::Vec2D(p.x * sx + dx, p.y * sy + dy);
     };
 
     m_Points.reserve(13);
diff --git a/src/math/vec2d.cpp b/src/math/vec2d.cpp
index 52b27a8..f8b2f90 100644
--- a/src/math/vec2d.cpp
+++ b/src/math/vec2d.cpp
@@ -6,8 +6,8 @@
 
 Vec2D Vec2D::transformDir(const Vec2D& a, const Mat2D& m) {
     return {
-        m[0] * a.x() + m[2] * a.y(),
-        m[1] * a.x() + m[3] * a.y(),
+        m[0] * a.x + m[2] * a.y,
+        m[1] * a.x + m[3] * a.y,
     };
 }
 float Vec2D::length() const { return std::sqrt(lengthSquared()); }
@@ -17,10 +17,3 @@
     auto scale = len2 > 0 ? (1 / std::sqrt(len2)) : 1;
     return *this * scale;
 }
-
-Vec2D Vec2D::lerp(const Vec2D& a, const Vec2D& b, float f) {
-    return {
-        a.x() + f * (b[0] - a.x()),
-        a.y() + f * (b[1] - a.y()),
-    };
-}
diff --git a/src/shapes/cubic_vertex.cpp b/src/shapes/cubic_vertex.cpp
index c359f01..5964ede 100644
--- a/src/shapes/cubic_vertex.cpp
+++ b/src/shapes/cubic_vertex.cpp
@@ -58,21 +58,15 @@
 
     auto cubicWeight = weight<CubicWeight>();
 
-    auto inp = inPoint();
-    Weight::deform(inp[0],
-                   inp[1],
-                   cubicWeight->inIndices(),
-                   cubicWeight->inValues(),
-                   worldTransform,
-                   boneTransforms,
-                   cubicWeight->inTranslation());
+    cubicWeight->inTranslation() = Weight::deform(inPoint(),
+                                                  cubicWeight->inIndices(),
+                                                  cubicWeight->inValues(),
+                                                  worldTransform,
+                                                  boneTransforms);
 
-    auto outp = outPoint();
-    Weight::deform(outp[0],
-                   outp[1],
-                   cubicWeight->outIndices(),
-                   cubicWeight->outValues(),
-                   worldTransform,
-                   boneTransforms,
-                   cubicWeight->outTranslation());
+    cubicWeight->outTranslation() = Weight::deform(outPoint(),
+                                                   cubicWeight->outIndices(),
+                                                   cubicWeight->outValues(),
+                                                   worldTransform,
+                                                   boneTransforms);
 }
diff --git a/src/shapes/mesh.cpp b/src/shapes/mesh.cpp
index e98d853..baac40a 100644
--- a/src/shapes/mesh.cpp
+++ b/src/shapes/mesh.cpp
@@ -113,8 +113,8 @@
         std::size_t index = 0;
         for (auto vertex : m_Vertices) {
             auto translation = vertex->renderTranslation();
-            vertices[index++] = translation[0];
-            vertices[index++] = translation[1];
+            vertices[index++] = translation.x;
+            vertices[index++] = translation.y;
         }
 
         auto factory = artboard()->factory();
diff --git a/src/shapes/metrics_path.cpp b/src/shapes/metrics_path.cpp
index 0190008..86754f6 100644
--- a/src/shapes/metrics_path.cpp
+++ b/src/shapes/metrics_path.cpp
@@ -70,7 +70,8 @@
 static const float distTooFar = 1.0f;
 
 static bool tooFar(const Vec2D& a, const Vec2D& b) {
-    return std::max(std::abs(a[0] - b[0]), std::abs(a[1] - b[1])) > distTooFar;
+    auto diff = a - b;
+    return std::max(std::abs(diff.x), std::abs(diff.y)) > distTooFar;
 }
 
 static bool
diff --git a/src/shapes/paint/linear_gradient.cpp b/src/shapes/paint/linear_gradient.cpp
index 06a7a3b..5071b8d 100644
--- a/src/shapes/paint/linear_gradient.cpp
+++ b/src/shapes/paint/linear_gradient.cpp
@@ -100,7 +100,7 @@
     Vec2D start, Vec2D end, const ColorInt colors[], const float stops[], size_t count) {
     auto factory = artboard()->factory();
     renderPaint()->shader(factory->makeLinearGradient(
-        start[0], start[1], end[0], end[1], colors, stops, count, RenderTileMode::clamp));
+        start.x, start.y, end.x, end.y, colors, stops, count, RenderTileMode::clamp));
 }
 
 void LinearGradient::markGradientDirty() { addDirt(ComponentDirt::Paint); }
diff --git a/src/shapes/paint/radial_gradient.cpp b/src/shapes/paint/radial_gradient.cpp
index 6c6b481..92e3b28 100644
--- a/src/shapes/paint/radial_gradient.cpp
+++ b/src/shapes/paint/radial_gradient.cpp
@@ -7,8 +7,8 @@
 void RadialGradient::makeGradient(
     Vec2D start, Vec2D end, const ColorInt colors[], const float stops[], size_t count) {
     auto factory = artboard()->factory();
-    renderPaint()->shader(factory->makeRadialGradient(start[0],
-                                                      start[1],
+    renderPaint()->shader(factory->makeRadialGradient(start.x,
+                                                      start.y,
                                                       Vec2D::distance(start, end),
                                                       colors,
                                                       stops,
diff --git a/src/shapes/path.cpp b/src/shapes/path.cpp
index 0b11b30..28efb10 100644
--- a/src/shapes/path.cpp
+++ b/src/shapes/path.cpp
@@ -80,18 +80,14 @@
                                                     : prev->renderTranslation()) -
                            pos;
 
-            auto toPrevLength = toPrev.length();
-            toPrev[0] /= toPrevLength;
-            toPrev[1] /= toPrevLength;
+            auto toPrevLength = toPrev.normalizeLength();
 
             auto next = vertices[1];
 
             Vec2D toNext = (next->is<CubicVertex>() ? next->as<CubicVertex>()->renderIn()
                                                     : next->renderTranslation()) -
                            pos;
-            auto toNextLength = toNext.length();
-            toNext[0] /= toNextLength;
-            toNext[1] /= toNextLength;
+            auto toNextLength = toNext.normalizeLength();
 
             float renderRadius = std::min(toPrevLength, std::min(toNextLength, radius));
 
@@ -127,18 +123,14 @@
 
             if (auto radius = point.radius(); radius > 0.0f) {
                 Vec2D toPrev = out - pos;
-                auto toPrevLength = toPrev.length();
-                toPrev[0] /= toPrevLength;
-                toPrev[1] /= toPrevLength;
+                auto toPrevLength = toPrev.normalizeLength();
 
                 auto next = vertices[(i + 1) % length];
 
                 Vec2D toNext = (next->is<CubicVertex>() ? next->as<CubicVertex>()->renderIn()
                                                         : next->renderTranslation()) -
                                pos;
-                auto toNextLength = toNext.length();
-                toNext[0] /= toNextLength;
-                toNext[1] /= toNextLength;
+                auto toNextLength = toNext.normalizeLength();
 
                 float renderRadius = std::min(toPrevLength, std::min(toNextLength, radius));
 
@@ -219,8 +211,8 @@
         m_OutPoint = out;
         m_InValid = true;
         m_OutValid = true;
-        x(translation[0]);
-        y(translation[1]);
+        x(translation.x);
+        y(translation.y);
     }
 
     void computeIn() override {}
@@ -263,14 +255,10 @@
                     Vec2D pos = point.renderTranslation();
 
                     Vec2D toPrev = prevPoint - pos;
-                    auto toPrevLength = toPrev.length();
-                    toPrev[0] /= toPrevLength;
-                    toPrev[1] /= toPrevLength;
+                    auto toPrevLength = toPrev.normalizeLength();
 
                     Vec2D toNext = nextPoint - pos;
-                    auto toNextLength = toNext.length();
-                    toNext[0] /= toNextLength;
-                    toNext[1] /= toNextLength;
+                    auto toNextLength = toNext.normalizeLength();
 
                     auto renderRadius =
                         std::min(toPrevLength, std::min(toNextLength, point.radius()));
@@ -330,8 +318,8 @@
     } else {
         auto point = new PathVertex();
         Vec2D translation = transform * vertex->renderTranslation();
-        point->x(translation[0]);
-        point->y(translation[1]);
+        point->x(translation.x);
+        point->y(translation.y);
         m_Vertices.push_back(point);
     }
 }
diff --git a/src/shapes/vertex.cpp b/src/shapes/vertex.cpp
index 4375555..a7c6890 100644
--- a/src/shapes/vertex.cpp
+++ b/src/shapes/vertex.cpp
@@ -13,11 +13,9 @@
 void Vertex::yChanged() { markGeometryDirty(); }
 
 void Vertex::deform(const Mat2D& worldTransform, const float* boneTransforms) {
-    Weight::deform(x(),
-                   y(),
-                   m_Weight->indices(),
-                   m_Weight->values(),
-                   worldTransform,
-                   boneTransforms,
-                   m_Weight->translation());
+    m_Weight->translation() = Weight::deform(Vec2D(x(), y()),
+                                             m_Weight->indices(),
+                                             m_Weight->values(),
+                                             worldTransform,
+                                             boneTransforms);
 }
\ No newline at end of file
diff --git a/src/world_transform_component.cpp b/src/world_transform_component.cpp
index d4e19dc..0a0ea78 100644
--- a/src/world_transform_component.cpp
+++ b/src/world_transform_component.cpp
@@ -16,8 +16,3 @@
 Mat2D& WorldTransformComponent::mutableWorldTransform() { return m_WorldTransform; }
 
 void WorldTransformComponent::opacityChanged() { addDirt(ComponentDirt::RenderOpacity, true); }
-
-void WorldTransformComponent::worldTranslation(Vec2D& result) const {
-    result[0] = m_WorldTransform[4];
-    result[1] = m_WorldTransform[5];
-}
diff --git a/test/distance_constraint_test.cpp b/test/distance_constraint_test.cpp
index dfb7b26..ece41f0 100644
--- a/test/distance_constraint_test.cpp
+++ b/test/distance_constraint_test.cpp
@@ -28,8 +28,7 @@
     b->y(137.87f);
     artboard->advance(0.0f);
 
-    rive::Vec2D at;
-    a->worldTranslation(at);
-    rive::Vec2D expectedTranslation(259.2808837890625, 62.87000274658203);
+    rive::Vec2D at = a->worldTranslation();
+    rive::Vec2D expectedTranslation(259.2808837890625f, 62.87000274658203f);
     REQUIRE(rive::Vec2D::distance(at, expectedTranslation) < 0.001f);
 }