diff --git a/bezier.cpp b/bezier.cpp
index 5eb647f8..bec9acf8 100644
--- a/bezier.cpp
+++ b/bezier.cpp
@@ -26,6 +26,22 @@
 #include <iterator>
 
 
+//-----------------------------------------------------------------------------
+// HACK: point multiplication isn't defined, but it's way more convenient than
+// casting between vector/coord
+namespace util {
+    template <typename T>
+    util::point2f
+    operator* (T a, util::point2f b)
+    {
+        return {
+            a * b.data[0],
+            a * b.data[1]
+        };
+    }
+}
+
+
 //-----------------------------------------------------------------------------
 template <size_t S>
 util::bezier<S>::bezier (const util::point2f (&_points)[S+1])
@@ -65,7 +81,7 @@ namespace util {
 
         auto v0 =    pow2 (1 - t) * m_points[0];
         auto v1 = 2 * (1 - t) * t * m_points[1];
-        auto v2 =        pow2 (t) * m_points[2];
+        auto v2 =    pow2 (t)     * m_points[2];
 
         return {
             v0.x + v1.x + v2.x,
@@ -84,10 +100,10 @@ namespace util {
         CHECK_GE (t, 0);
         CHECK_LE (t, 1);
 
-        auto v0 = pow (1 - t, 3) * m_points[0];
+        auto v0 =     pow  (1 - t, 3)  * m_points[0];
         auto v1 = 3 * pow2 (1 - t) * t * m_points[1];
         auto v2 = 3 * pow2 (1 - t) * t * m_points[2];
-        auto v3 = pow (t, 3) * m_points[3];
+        auto v3 =     pow  (t, 3)      * m_points[3];
 
         return {
             v0.x + v1.x + v2.x + v3.x,
diff --git a/point.cpp b/point.cpp
index 03f6a722..3a1626e7 100644
--- a/point.cpp
+++ b/point.cpp
@@ -159,32 +159,6 @@ template <size_t S, typename T>
 const util::point<S,T> util::point<S,T>::ORIGIN (T {0});
 
 
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::point<S,T>
-util::operator* (const vector<S,T> &v, const point<S,T> &p) {
-    point<S,T> out;
-    for (size_t i = 0; i < S; ++i)
-        out.data[i] = p.data[i] + v.data[i];
-
-    return out;
-}
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::point<S,T>
-util::operator* (const point<S,T> &p, const vector<S,T> &v)
-    { return v * p; }
-
-
-//-----------------------------------------------------------------------------
-template <size_t S, typename T>
-util::point<S,T>
-util::operator* (T a, const point<S,T> &b)
-    { return b * a; }
-
-
 //-----------------------------------------------------------------------------
 template <size_t S, typename T>
 std::ostream&
@@ -204,9 +178,6 @@ util::operator<< (std::ostream &os, const util::point<S,T> &p) {
 #define INSTANTIATE_S_T(S,T)                                                            \
 template struct util::point<S,T>;                                                       \
 template std::ostream& util::operator<< (std::ostream &os, const util::point<S,T>&);    \
-template util::point<S,T> util::operator* (const point<S,T>&, const vector<S,T>&);      \
-template util::point<S,T> util::operator* (const vector<S,T>&, const point<S,T>&);      \
-template util::point<S,T> util::operator* (T, const point<S,T>&);
 
 #define INSTANTIATE(T)  \
 INSTANTIATE_S_T(1,T)    \
diff --git a/point.hpp b/point.hpp
index f12be728..897de0ee 100644
--- a/point.hpp
+++ b/point.hpp
@@ -46,7 +46,7 @@ namespace util {
         point<S,T>  operator*  (T) const;
         point<S,T>  operator/  (T) const;
 
-        vector<S,T>  operator-  (const point<S,T>&) const;
+        vector<S,T>  operator- (const point<S,T>&) const;
 
         point<S,T>  operator-  (const vector<S,T>&) const;
         point<S,T>& operator-= (const vector<S,T>&);
@@ -66,11 +66,6 @@ namespace util {
         void sanity (void) const;
     };
 
-    // free maths operators
-    template <size_t S, typename T> point<S,T> operator* (const vector<S,T>&, const point<S,T>&);
-    template <size_t S, typename T> point<S,T> operator* (const point<S,T>&, const vector<S,T>&);
-    template <size_t S, typename T> point<S,T> operator* (T, const point<S,T>&);
-
     // iostream operators
     template <size_t S, typename T>
     std::ostream& operator<< (std::ostream&, const point<S,T>&);
diff --git a/vector.cpp b/vector.cpp
index b85dcba6..2c1c5a03 100644
--- a/vector.cpp
+++ b/vector.cpp
@@ -230,6 +230,7 @@ util::vector<S,T>::magnitude (void) const {
 }
 
 
+//-----------------------------------------------------------------------------
 template <size_t S, typename T>
 T
 util::vector<S,T>::magnitude2 (void) const {
@@ -353,24 +354,30 @@ util::vector<S,T>::sanity (void) const {
 
 
 //-----------------------------------------------------------------------------
-template <size_t S, typename T>
+template <size_t S, typename T, typename U>
 util::vector<S,T>
-util::operator* (T a, const util::vector<S,T> &b)
-    { return b * a; }
+util::operator* (U a, const util::vector<S,T> &b)
+{
+    return b * T(a);
+}
 
 
 //-----------------------------------------------------------------------------
-template <size_t S, typename T>
+template <size_t S, typename T, typename U>
 util::vector<S,T>
-util::operator+ (T a, const util::vector<S,T> &b)
-    { return b + a; }
+util::operator+ (U a, const util::vector<S,T> &b)
+{
+    return b + T(a);
+}
 
 
 //-----------------------------------------------------------------------------
-template <size_t S, typename T>
+template <size_t S, typename T, typename U>
 util::vector<S,T>
-util::operator- (T a, const util::vector<S,T> &b)
-    { return a + (-b); }
+util::operator- (U a, const util::vector<S,T> &b)
+{
+    return a + (-b);
+}
 
 
 //-----------------------------------------------------------------------------
@@ -407,7 +414,9 @@ util::operator>> (const json::node &node, util::vector<S,T> &v) {
 
 #define INSTANTIATE_S_T(S,T)                                                        \
 template struct util::vector<S,T>;                                                  \
-template util::vector<S,T> util::operator* (T, const util::vector<S,T>&);           \
+template util::vector<S,T> util::operator* (int, const util::vector<S,T>&);         \
+template util::vector<S,T> util::operator* (unsigned, const util::vector<S,T>&);    \
+template util::vector<S,T> util::operator* (float, const util::vector<S,T>&);       \
 template util::vector<S,T> util::operator+ (T, const util::vector<S,T>&);           \
 template util::vector<S,T> util::operator- (T, const util::vector<S,T>&);           \
 template std::ostream& util::operator<< (std::ostream&, const util::vector<S,T> &v);\
diff --git a/vector.hpp b/vector.hpp
index 8bf86c32..95b6ccb5 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -72,9 +72,11 @@ namespace util {
         vector<S,T>& normalise  (void);
         vector<S,T>  normalised [[gnu::warn_unused_result]] (void) const;
 
+        // size operations
         template <size_t D> vector<D,T> redim (void) const;
         template <size_t D> vector<D,T> redim (const util::vector<D,T> &fill) const;
 
+        // constants
         static const vector<S,T> ZERO;
 
         void sanity (void) const;
@@ -87,9 +89,9 @@ namespace util {
     template <typename T> vector<3,T> spherical_to_cartesian (const vector<3,T>&);
     template <typename T> vector<3,T> cartesian_to_spherical (const vector<3,T>&);
 
-    template <size_t S, typename T> vector<S,T> operator* (T, const vector<S,T>&);
-    template <size_t S, typename T> vector<S,T> operator+ (T, const vector<S,T>&);
-    template <size_t S, typename T> vector<S,T> operator- (T, const vector<S,T>&);
+    template <size_t S, typename T, typename U> vector<S,T> operator* (U, const vector<S,T>&);
+    template <size_t S, typename T, typename U> vector<S,T> operator+ (U, const vector<S,T>&);
+    template <size_t S, typename T, typename U> vector<S,T> operator- (U, const vector<S,T>&);
 
     // output and serialisation operators
     template <size_t S, typename T> std::ostream& operator<< (std::ostream&, const vector<S,T>&);