diff --git a/include/array.h b/include/array.h
index 3005087c85..a60d78db23 100644
--- a/include/array.h
+++ b/include/array.h
@@ -24,6 +24,12 @@ namespace quda
 
     array<T, n> &operator=(const array<T, n> &) = default;
     array<T, n> &operator=(array<T, n> &&) = default;
+
+    template <typename U> constexpr array<T, n> &operator=(const array<U, n> &other)
+    {
+      for (int i = 0; i < n; i++) data[i] = other[i];
+      return *this;
+    }
   };
 
   template <typename T, int n> std::ostream &operator<<(std::ostream &output, const array<T, n> &a)
diff --git a/include/blas_helper.cuh b/include/blas_helper.cuh
index 80e974c0c9..100f1387cf 100644
--- a/include/blas_helper.cuh
+++ b/include/blas_helper.cuh
@@ -23,48 +23,6 @@ namespace quda
     static constexpr bool V = V_;
   };
 
-  __host__ __device__ inline double set(double &x) { return x; }
-  __host__ __device__ inline double2 set(double2 &x) { return x; }
-  __host__ __device__ inline double3 set(double3 &x) { return x; }
-  __host__ __device__ inline double4 set(double4 &x) { return x; }
-  __host__ __device__ inline void sum(double &a, double &b) { a += b; }
-  __host__ __device__ inline void sum(double2 &a, double2 &b)
-  {
-    a.x += b.x;
-    a.y += b.y;
-  }
-  __host__ __device__ inline void sum(double3 &a, double3 &b)
-  {
-    a.x += b.x;
-    a.y += b.y;
-    a.z += b.z;
-  }
-  __host__ __device__ inline void sum(double4 &a, double4 &b)
-  {
-    a.x += b.x;
-    a.y += b.y;
-    a.z += b.z;
-    a.w += b.w;
-  }
-
-#ifdef QUAD_SUM
-  __host__ __device__ inline double set(doubledouble &a) { return a.head(); }
-  __host__ __device__ inline double2 set(doubledouble2 &a) { return make_double2(a.x.head(), a.y.head()); }
-  __host__ __device__ inline double3 set(doubledouble3 &a) { return make_double3(a.x.head(), a.y.head(), a.z.head()); }
-  __host__ __device__ inline void sum(double &a, doubledouble &b) { a += b.head(); }
-  __host__ __device__ inline void sum(double2 &a, doubledouble2 &b)
-  {
-    a.x += b.x.head();
-    a.y += b.y.head();
-  }
-  __host__ __device__ inline void sum(double3 &a, doubledouble3 &b)
-  {
-    a.x += b.x.head();
-    a.y += b.y.head();
-    a.z += b.z.head();
-  }
-#endif
-
   // Vector types used for AoS load-store on CPU
   template <> struct VectorType<double, 24> {
     using type = array<double, 24>;
diff --git a/include/blas_quda.h b/include/blas_quda.h
index 8df40df452..8bb711af38 100644
--- a/include/blas_quda.h
+++ b/include/blas_quda.h
@@ -49,14 +49,14 @@ namespace quda {
        @param[in] x input vector
        @param[out] y output vector
     */
-    void axy(double a, const ColorSpinorField &x, ColorSpinorField &y);
+    void axy(real_t a, const ColorSpinorField &x, ColorSpinorField &y);
 
     /**
        @brief Apply the rescale operation x = a * x
        @param[in] a scalar multiplier
        @param[in] x input vector
     */
-    inline void ax(double a, ColorSpinorField &x) { axy(a, x, x); }
+    inline void ax(real_t a, ColorSpinorField &x) { axy(a, x, x); }
 
     /**
        @brief Apply the operation z = a * x + b * y
@@ -66,7 +66,7 @@ namespace quda {
        @param[in] y input vector
        @param[out] z output vector
     */
-    void axpbyz(double a, const ColorSpinorField &x, double b, const ColorSpinorField &y, ColorSpinorField &z);
+    void axpbyz(real_t a, const ColorSpinorField &x, real_t b, const ColorSpinorField &y, ColorSpinorField &z);
 
     /**
        @brief Apply the operation y += x
@@ -88,7 +88,7 @@ namespace quda {
        @param[in] x input vector
        @param[in,out] y update vector
     */
-    inline void axpy(double a, const ColorSpinorField &x, ColorSpinorField &y) { axpbyz(a, x, 1.0, y, y); }
+    inline void axpy(real_t a, const ColorSpinorField &x, ColorSpinorField &y) { axpbyz(a, x, 1.0, y, y); }
 
     /**
        @brief Apply the operation y = a * x + b * y
@@ -97,7 +97,7 @@ namespace quda {
        @param[in] b scalar multiplier
        @param[in,out] y update vector
     */
-    inline void axpby(double a, const ColorSpinorField &x, double b, ColorSpinorField &y) { axpbyz(a, x, b, y, y); }
+    inline void axpby(real_t a, const ColorSpinorField &x, real_t b, ColorSpinorField &y) { axpbyz(a, x, b, y, y); }
 
     /**
        @brief Apply the operation y = x + a * y
@@ -105,7 +105,7 @@ namespace quda {
        @param[in] a scalar multiplier
        @param[in,out] y update vector
     */
-    inline void xpay(const ColorSpinorField &x, double a, ColorSpinorField &y) { axpbyz(1.0, x, a, y, y); }
+    inline void xpay(const ColorSpinorField &x, real_t a, ColorSpinorField &y) { axpbyz(1.0, x, a, y, y); }
 
     /**
        @brief Apply the operation z = x + a * y
@@ -114,7 +114,7 @@ namespace quda {
        @param[in] y update vector
        @param[out] z output vector
     */
-    inline void xpayz(const ColorSpinorField &x, double a, const ColorSpinorField &y, ColorSpinorField &z) { axpbyz(1.0, x, a, y, z); }
+    inline void xpayz(const ColorSpinorField &x, real_t a, const ColorSpinorField &y, ColorSpinorField &z) { axpbyz(1.0, x, a, y, z); }
 
     /**
        @brief Apply the operation y = a * x + y, x = z + b * x
@@ -124,7 +124,7 @@ namespace quda {
        @param[in] z input vector
        @param[in] b scalar multiplier
     */
-    void axpyZpbx(double a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z, double b);
+    void axpyZpbx(real_t a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z, real_t b);
 
     /**
        @brief Apply the operation y = a * x + y, x = b * z + c * x
@@ -135,7 +135,7 @@ namespace quda {
        @param[in] z input vector
        @param[in] c scalar multiplier
     */
-    void axpyBzpcx(double a, ColorSpinorField& x, ColorSpinorField& y, double b, const ColorSpinorField& z, double c);
+    void axpyBzpcx(real_t a, ColorSpinorField& x, ColorSpinorField& y, real_t b, const ColorSpinorField& z, real_t c);
 
     /**
        @brief Apply the operation w = a * x + b * y + c * z
@@ -147,8 +147,8 @@ namespace quda {
        @param[in] z input vector
        @param[out] w output vector
     */
-    void axpbypczw(double a, const ColorSpinorField &x, double b, const ColorSpinorField &y,
-                   double c, const ColorSpinorField &z, ColorSpinorField &w);
+    void axpbypczw(real_t a, const ColorSpinorField &x, real_t b, const ColorSpinorField &y,
+                   real_t c, const ColorSpinorField &z, ColorSpinorField &w);
 
     /**
        @brief Apply the operation y = a * x + b * y
@@ -158,7 +158,7 @@ namespace quda {
        @param[in] y input vector
        @param[out] z output vector
     */
-    void caxpby(const Complex &a, const ColorSpinorField &x, const Complex &b, ColorSpinorField &y);
+    void caxpby(const complex_t &a, const ColorSpinorField &x, const complex_t &b, ColorSpinorField &y);
 
     /**
        @brief Apply the operation y += a * x
@@ -166,7 +166,7 @@ namespace quda {
        @param[in] x input vector
        @param[in] y update vector
     */
-    void caxpy(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y);
+    void caxpy(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y);
 
     /**
        @brief Apply the operation z = x + a * y + b * z
@@ -176,8 +176,8 @@ namespace quda {
        @param[in] b scalar multiplier
        @param[in,out] z update vector
     */
-    void cxpaypbz(const ColorSpinorField &x, const Complex &a, const ColorSpinorField &y,
-                  const Complex &b, ColorSpinorField &z);
+    void cxpaypbz(const ColorSpinorField &x, const complex_t &a, const ColorSpinorField &y,
+                  const complex_t &b, ColorSpinorField &z);
 
     /**
        @brief Apply the operation z += a * x + b * y, y-= b * w
@@ -188,7 +188,7 @@ namespace quda {
        @param[in,out] z update vector
        @param[in] w input vector
     */
-    void caxpbypzYmbw(const Complex &a, const ColorSpinorField &x, const Complex &b, ColorSpinorField &y,
+    void caxpbypzYmbw(const complex_t &a, const ColorSpinorField &x, const complex_t &b, ColorSpinorField &y,
                       ColorSpinorField &z, const ColorSpinorField &w);
 
     /**
@@ -199,8 +199,8 @@ namespace quda {
        @param[in] b scalar multiplier
        @param[in] z input vector
     */
-    void caxpyBzpx(const Complex &a, ColorSpinorField &x, ColorSpinorField &y,
-                   const Complex &b, const ColorSpinorField &z);
+    void caxpyBzpx(const complex_t &a, ColorSpinorField &x, ColorSpinorField &y,
+                   const complex_t &b, const ColorSpinorField &z);
 
     /**
        @brief Apply the operation y += a * x, z += b * x
@@ -210,8 +210,8 @@ namespace quda {
        @param[in] b scalar multiplier
        @param[in,out] z update vector
     */
-    void caxpyBxpz(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y,
-                   const Complex &b, ColorSpinorField &z);
+    void caxpyBxpz(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y,
+                   const complex_t &b, ColorSpinorField &z);
 
     /**
        @brief Apply the operation y += a * b * x, x = a * x
@@ -220,7 +220,7 @@ namespace quda {
        @param[in,out] x update vector
        @param[in,out] y update vector
     */
-    void cabxpyAx(double a, const Complex &b, ColorSpinorField &x, ColorSpinorField &y);
+    void cabxpyAx(real_t a, const complex_t &b, ColorSpinorField &x, ColorSpinorField &y);
 
     /**
        @brief Apply the operation y += a * x, x -= a * z
@@ -229,7 +229,7 @@ namespace quda {
        @param[in,out] y update vector
        @param[in] z input vector
     */
-    void caxpyXmaz(const Complex &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z);
+    void caxpyXmaz(const complex_t &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z);
 
     /**
        @brief Apply the operation y += a * x, x = x - a * z.  Special
@@ -240,7 +240,7 @@ namespace quda {
        @param[in,out] y update vector
        @param[in] z input vector
     */
-    void caxpyXmazMR(const double &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z);
+    void caxpyXmazMR(const real_t &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z);
 
     /**
        @brief Apply the operation y += a * w, z -= a * x, w = z + b * w
@@ -251,7 +251,7 @@ namespace quda {
        @param[in,out] z update vector
        @param[in,out] w update vector
     */
-    void tripleCGUpdate(double a, double b, const ColorSpinorField &x,
+    void tripleCGUpdate(real_t a, real_t b, const ColorSpinorField &x,
 			ColorSpinorField &y, ColorSpinorField &z, ColorSpinorField &w);
 
     // reduction kernels - defined in reduce_quda.cu
@@ -260,7 +260,7 @@ namespace quda {
        @brief Compute the maximum absolute real element of a field
        @param[in] a The field we are reducing
     */
-    double max(const ColorSpinorField &x);
+    real_t max(const ColorSpinorField &x);
 
     /**
        @brief Compute the maximum real-valued deviation between two
@@ -268,19 +268,19 @@ namespace quda {
        @param[in] x The field we want to compare
        @param[in] y The reference field to which we are comparing against
     */
-    array<double, 2> max_deviation(const ColorSpinorField &x, const ColorSpinorField &y);
+    array<real_t, 2> max_deviation(const ColorSpinorField &x, const ColorSpinorField &y);
 
     /**
        @brief Compute the L1 norm of a field
        @param[in] x The field we are reducing
     */
-    double norm1(const ColorSpinorField &x);
+    real_t norm1(const ColorSpinorField &x);
 
     /**
        @brief Compute the L2 norm (||x||^2) of a field
        @param[in] x The field we are reducing
     */
-    double norm2(const ColorSpinorField &x);
+    real_t norm2(const ColorSpinorField &x);
 
     /**
        @brief Compute y += a * x and then (x, y)
@@ -288,14 +288,14 @@ namespace quda {
        @param[in] x input vector
        @param[in,out] y update vector
     */
-    double axpyReDot(double a, const ColorSpinorField &x, ColorSpinorField &y);
+    real_t axpyReDot(real_t a, const ColorSpinorField &x, ColorSpinorField &y);
 
     /**
        @brief Compute the real-valued inner product (x, y)
        @param[in] x input vector
        @param[in] y input vector
     */
-    double reDotProduct(const ColorSpinorField &x, const ColorSpinorField &y);
+    real_t reDotProduct(const ColorSpinorField &x, const ColorSpinorField &y);
 
     /**
        @brief Compute z = a * x + b * y and then ||z||^2
@@ -305,7 +305,7 @@ namespace quda {
        @param[in] y input vector
        @param[in,out] z update vector
     */
-    double axpbyzNorm(double a, const ColorSpinorField &x, double b, const ColorSpinorField &y, ColorSpinorField &z);
+    real_t axpbyzNorm(real_t a, const ColorSpinorField &x, real_t b, const ColorSpinorField &y, ColorSpinorField &z);
 
     /**
        @brief Compute y += a * x and then ||y||^2
@@ -313,38 +313,38 @@ namespace quda {
        @param[in] x input vector
        @param[in,out] y update vector
     */
-    inline double axpyNorm(double a, const ColorSpinorField &x, ColorSpinorField &y) { return axpbyzNorm(a, x, 1.0, y, y); }
+    inline real_t axpyNorm(real_t a, const ColorSpinorField &x, ColorSpinorField &y) { return axpbyzNorm(a, x, 1.0, y, y); }
 
     /**
        @brief Compute y -= x and then ||y||^2
        @param[in] x input vector
        @param[in,out] y update vector
     */
-    inline double xmyNorm(const ColorSpinorField &x, ColorSpinorField &y) { return axpbyzNorm(1.0, x, -1.0, y, y); }
+    inline real_t xmyNorm(const ColorSpinorField &x, ColorSpinorField &y) { return axpbyzNorm(1.0, x, -1.0, y, y); }
 
     /**
        @brief Compute the complex-valued inner product (x, y)
        @param[in] x input vector
        @param[in] y input vector
     */
-    Complex cDotProduct(const ColorSpinorField &x, const ColorSpinorField &y);
+    complex_t cDotProduct(const ColorSpinorField &x, const ColorSpinorField &y);
 
     /**
        @brief Return complex-valued inner product (x,y), ||x||^2 and ||y||^2
        @param[in] x input vector
        @param[in] y input vector
     */
-    double4 cDotProductNormAB(const ColorSpinorField &x, const ColorSpinorField &y);
+    array<real_t, 4> cDotProductNormAB(const ColorSpinorField &x, const ColorSpinorField &y);
 
     /**
        @brief Return complex-valued inner product (x,y) and ||x||^2
        @param[in] x input vector
        @param[in] y input vector
      */
-    inline double3 cDotProductNormA(const ColorSpinorField &x, const ColorSpinorField &y)
+    inline array<real_t, 3> cDotProductNormA(const ColorSpinorField &x, const ColorSpinorField &y)
     {
       auto a4 = cDotProductNormAB(x, y);
-      return make_double3(a4.x, a4.y, a4.z);
+      return {a4[0], a4[1], a4[2]};
     }
 
     /**
@@ -352,10 +352,10 @@ namespace quda {
        @param[in] x input vector
        @param[in] y input vector
      */
-    inline double3 cDotProductNormB(const ColorSpinorField &x, const ColorSpinorField &y)
+    inline array<real_t, 3> cDotProductNormB(const ColorSpinorField &x, const ColorSpinorField &y)
     {
       auto a4 = cDotProductNormAB(x, y);
-      return make_double3(a4.x, a4.y, a4.w);
+      return {a4[0], a4[1], a4[2]};
     }
 
     /**
@@ -369,7 +369,7 @@ namespace quda {
        @param[in] w input vector
        @param[in] v input vector
     */
-    double3 caxpbypzYmbwcDotProductUYNormY(const Complex &a, const ColorSpinorField &x, const Complex &b,
+    array<real_t, 3> caxpbypzYmbwcDotProductUYNormY(const complex_t &a, const ColorSpinorField &x, const complex_t &b,
                                            ColorSpinorField &y, ColorSpinorField &z,
                                            const ColorSpinorField &w, const ColorSpinorField &u);
 
@@ -379,7 +379,7 @@ namespace quda {
        @param[in] x input vector
        @param[in,out] y update vector
     */
-    double caxpyNorm(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y);
+    real_t caxpyNorm(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y);
 
     /**
        @brief Compute z = a * b * x + y, x = a * x, and then ||x||^2
@@ -389,7 +389,7 @@ namespace quda {
        @param[in] y input vector
        @param[in,out] z update vector
     */
-    double cabxpyzAxNorm(double a, const Complex &b, ColorSpinorField &x, const ColorSpinorField &y,
+    real_t cabxpyzAxNorm(real_t a, const complex_t &b, ColorSpinorField &x, const ColorSpinorField &y,
                          ColorSpinorField &z);
 
     /**
@@ -399,7 +399,7 @@ namespace quda {
        @param[in,out] y update vector
        @param[in] z input vector
     */
-    Complex caxpyDotzy(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y,
+    complex_t caxpyDotzy(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y,
 		       const ColorSpinorField &z);
 
     /**
@@ -409,7 +409,7 @@ namespace quda {
        @param[in] x input vector
        @param[in,out] y update vector
     */
-    double2 axpyCGNorm(double a, const ColorSpinorField &x, ColorSpinorField &y);
+    array<real_t, 2> axpyCGNorm(real_t a, const ColorSpinorField &x, ColorSpinorField &y);
 
     /**
        @brief Computes ||x||^2, ||r||^2 and the MILC/FNAL heavy quark
@@ -417,7 +417,7 @@ namespace quda {
        @param[in] x input vector
        @param[in] r input vector (residual vector)
     */
-    double3 HeavyQuarkResidualNorm(const ColorSpinorField &x, const ColorSpinorField &r);
+    array<real_t, 3> HeavyQuarkResidualNorm(const ColorSpinorField &x, const ColorSpinorField &r);
 
     /**
        @brief Computes y += x, ||y||^2, ||r||^2 and the MILC/FNAL heavy quark
@@ -426,7 +426,7 @@ namespace quda {
        @param[in,out] y update vector
        @param[in] r input vector (residual vector)
     */
-    double3 xpyHeavyQuarkResidualNorm(const ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &r);
+    array<real_t, 3> xpyHeavyQuarkResidualNorm(const ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &r);
 
     /**
        @brief Computes ||x||^2, ||y||^2, and real-valued inner product (y, z)
@@ -434,7 +434,7 @@ namespace quda {
        @param[in] y input vector
        @param[in] z input vector
     */
-    double3 tripleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z);
+    array<real_t, 3> tripleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z);
 
     /**
        @brief Computes ||x||^2, ||y||^2, the real-valued inner product (y, z), and ||z||^2
@@ -442,7 +442,7 @@ namespace quda {
        @param[in] y input vector
        @param[in] z input vector
     */
-    double4 quadrupleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z);
+    array<real_t, 4> quadrupleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z);
 
     /**
        @brief Computes z = x, w = y, x += a * y, y -= a * v and ||y||^2
@@ -453,7 +453,7 @@ namespace quda {
        @param[in,out] w update vector
        @param[in] v input vector
     */
-    double quadrupleCG3InitNorm(double a, ColorSpinorField &x, ColorSpinorField &y,
+    real_t quadrupleCG3InitNorm(real_t a, ColorSpinorField &x, ColorSpinorField &y,
                                 ColorSpinorField &z, ColorSpinorField &w, const ColorSpinorField &v);
 
     /**
@@ -468,7 +468,7 @@ namespace quda {
        @param[in,out] w update vector
        @param[in] v input vector
     */
-    double quadrupleCG3UpdateNorm(double a, double b, ColorSpinorField &x, ColorSpinorField &y,
+    real_t quadrupleCG3UpdateNorm(real_t a, real_t b, ColorSpinorField &x, ColorSpinorField &y,
                                   ColorSpinorField &z, ColorSpinorField &w, const ColorSpinorField &v);
 
     // multi-blas kernels - defined in multi_blas.cu
@@ -477,7 +477,7 @@ namespace quda {
        @brief Compute the block "axpy" with over the set of
               ColorSpinorFields.  E.g., it computes y = x * a + y
               The dimensions of a can be rectangular, e.g., the width of x and y need not be same.
-       @tparam T The type of a coefficients (double or Complex)
+       @tparam T The type of a coefficients (real_t or complex_t)
        @param a[in] Matrix of real coefficients
        @param x[in] vector of input ColorSpinorFields
        @param y[in,out] vector of input/output ColorSpinorFields
@@ -493,7 +493,7 @@ namespace quda {
 
        Where 'a' must be a square, upper triangular matrix.
 
-       @tparam T The type of a coefficients (double or Complex)
+       @tparam T The type of a coefficients (real_t or complex_t)
        @param a[in] Matrix of coefficients
        @param x[in] vector of input ColorSpinorFields
        @param y[in,out] vector of input/output ColorSpinorFields
@@ -509,7 +509,7 @@ namespace quda {
 
        Where 'a' must be a square, lower triangular matrix.
 
-       @tparam T The type of a coefficients (double or Complex)
+       @tparam T The type of a coefficients (real_t or complex_t)
        @param a[in] Matrix of coefficients
        @param x[in] vector of input ColorSpinorFields
        @param y[in,out] vector of input/output ColorSpinorFields
@@ -530,7 +530,7 @@ namespace quda {
        @param x[in] vector of input ColorSpinorFields
        @param y[in,out] vector of input/output ColorSpinorFields
     */
-    void caxpy(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y);
+    void caxpy(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y);
 
     /**
        @brief Compute the block "caxpy_U" with over the set of
@@ -544,7 +544,7 @@ namespace quda {
        @param x[in] vector of input ColorSpinorFields
        @param y[in,out] vector of input/output ColorSpinorFields
     */
-    void caxpy_U(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y);
+    void caxpy_U(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y);
 
     /**
        @brief Compute the block "caxpy_L" with over the set of
@@ -558,7 +558,7 @@ namespace quda {
        @param x[in] vector of input ColorSpinorFields
        @param y[in,out] vector of input/output ColorSpinorFields
     */
-    void caxpy_L(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y);
+    void caxpy_L(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y);
 
     /**
        @brief Compute the block "axpyz" with over the set of
@@ -575,7 +575,7 @@ namespace quda {
        @param y[in] vector of input ColorSpinorFields
        @param z[out] vector of output ColorSpinorFields
     */
-    void axpyz(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x,
+    void axpyz(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x,
                cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z);
 
     /**
@@ -591,7 +591,7 @@ namespace quda {
        @param y[in] vector of input ColorSpinorFields
        @param z[out] vector of output ColorSpinorFields
     */
-    void axpyz_U(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x,
+    void axpyz_U(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x,
                  cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z);
 
     /**
@@ -607,7 +607,7 @@ namespace quda {
        @param y[in] vector of input ColorSpinorFields
        @param z[out] vector of output ColorSpinorFields
     */
-    void axpyz_L(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x,
+    void axpyz_L(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x,
                  cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z);
 
     /**
@@ -625,7 +625,7 @@ namespace quda {
        @param y[in] vector of input ColorSpinorFields
        @param z[out] vector of output ColorSpinorFields
     */
-    void caxpyz(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x,
+    void caxpyz(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x,
                 cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z);
 
     /**
@@ -641,7 +641,7 @@ namespace quda {
        @param y[in] vector of input ColorSpinorFields
        @param z[out] vector of output ColorSpinorFields
     */
-    void caxpyz_U(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x,
+    void caxpyz_U(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x,
                   cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z);
 
     /**
@@ -657,7 +657,7 @@ namespace quda {
        @param y[in] vector of input ColorSpinorFields
        @param z[out] vector of output ColorSpinorFields
     */
-    void caxpyz_L(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x,
+    void caxpyz_L(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x,
                   cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z);
 
     /**
@@ -678,9 +678,9 @@ namespace quda {
        @param z[in] input ColorSpinorField
        @param c[in] Array of coefficients
     */
-    void axpyBzpcx(const std::vector<double> &a, cvector_ref<ColorSpinorField> &x,
-                   cvector_ref<ColorSpinorField> &y, const std::vector<double> &b, ColorSpinorField &z,
-                   const std::vector<double> &c);
+    void axpyBzpcx(const std::vector<real_t> &a, cvector_ref<ColorSpinorField> &x,
+                   cvector_ref<ColorSpinorField> &y, const std::vector<real_t> &b, ColorSpinorField &z,
+                   const std::vector<real_t> &c);
 
     /**
        @brief Compute the vectorized "caxpyBxpz" over the set of
@@ -699,8 +699,8 @@ namespace quda {
        @param b[in] Array of coefficients
        @param z[in,out] input ColorSpinorField
     */
-    void caxpyBxpz(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, ColorSpinorField &y,
-                   const std::vector<Complex> &b, ColorSpinorField &z);
+    void caxpyBxpz(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, ColorSpinorField &y,
+                   const std::vector<complex_t> &b, ColorSpinorField &z);
 
     // multi-reduce kernels - defined in multi_reduce.cu
 
@@ -711,7 +711,7 @@ namespace quda {
        @param a[in] set of input ColorSpinorFields
        @param b[in] set of input ColorSpinorFields
     */
-    void reDotProduct(std::vector<double> &result, cvector_ref<const ColorSpinorField> &a,
+    void reDotProduct(std::vector<real_t> &result, cvector_ref<const ColorSpinorField> &a,
                       cvector_ref<const ColorSpinorField> &b);
 
     /**
@@ -721,7 +721,7 @@ namespace quda {
        @param a[in] set of input ColorSpinorFields
        @param b[in] set of input ColorSpinorFields
     */
-    void cDotProduct(std::vector<Complex> &result, cvector_ref<const ColorSpinorField> &a,
+    void cDotProduct(std::vector<complex_t> &result, cvector_ref<const ColorSpinorField> &a,
                      cvector_ref<const ColorSpinorField> &b);
 
     /**
@@ -734,7 +734,7 @@ namespace quda {
        @param a[in] set of input ColorSpinorFields
        @param b[in] set of input ColorSpinorFields
     */
-    void hDotProduct(std::vector<Complex> &result, cvector_ref<const ColorSpinorField> &a,
+    void hDotProduct(std::vector<complex_t> &result, cvector_ref<const ColorSpinorField> &a,
                      cvector_ref<const ColorSpinorField> &b);
 
     /**
@@ -749,47 +749,47 @@ namespace quda {
         @param a[in] set of input ColorSpinorFields
         @param b[in] set of input ColorSpinorFields
      */
-    void hDotProduct_Anorm(std::vector<Complex> &result, cvector_ref<const ColorSpinorField> &a,
+    void hDotProduct_Anorm(std::vector<complex_t> &result, cvector_ref<const ColorSpinorField> &a,
                            cvector_ref<const ColorSpinorField> &b);
 
     // compatibility wrappers until we switch to
     // std::vector<ColorSpinorField> and
     // std::vector<std::reference_wrapper<...>> more broadly
 
-    void axpy(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
-    void axpy(const double *a, ColorSpinorField &x, ColorSpinorField &y);
-    void axpy_U(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
-    void axpy_U(const double *a, ColorSpinorField &x, ColorSpinorField &y);
-    void axpy_L(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
-    void axpy_L(const double *a, ColorSpinorField &x, ColorSpinorField &y);
-    void caxpy(const Complex *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
-    void caxpy(const Complex *a, ColorSpinorField &x, ColorSpinorField &y);
-    void caxpy_U(const Complex *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
-    void caxpy_U(const Complex *a, ColorSpinorField &x, ColorSpinorField &y);
-    void caxpy_L(const Complex *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
-    void caxpy_L(const Complex *a, ColorSpinorField &x, ColorSpinorField &y);
-    void axpyz(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+    void axpy(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
+    void axpy(const real_t *a, ColorSpinorField &x, ColorSpinorField &y);
+    void axpy_U(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
+    void axpy_U(const real_t *a, ColorSpinorField &x, ColorSpinorField &y);
+    void axpy_L(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
+    void axpy_L(const real_t *a, ColorSpinorField &x, ColorSpinorField &y);
+    void caxpy(const complex_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
+    void caxpy(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y);
+    void caxpy_U(const complex_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
+    void caxpy_U(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y);
+    void caxpy_L(const complex_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
+    void caxpy_L(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y);
+    void axpyz(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
                std::vector<ColorSpinorField *> &z);
-    void axpyz(const double *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
-    void axpyz_U(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+    void axpyz(const real_t *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
+    void axpyz_U(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
                  std::vector<ColorSpinorField *> &z);
-    void axpyz_L(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+    void axpyz_L(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
                  std::vector<ColorSpinorField *> &z);
-    void caxpyz(const Complex *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+    void caxpyz(const complex_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
                 std::vector<ColorSpinorField *> &z);
-    void caxpyz(const Complex *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
-    void caxpyz_U(const Complex *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+    void caxpyz(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
+    void caxpyz_U(const complex_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
                   std::vector<ColorSpinorField *> &z);
-    void caxpyz_L(const Complex *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+    void caxpyz_L(const complex_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
                   std::vector<ColorSpinorField *> &z);
-    void axpyBzpcx(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
-                   const double *b, ColorSpinorField &z, const double *c);
-    void caxpyBxpz(const Complex *a_, std::vector<ColorSpinorField *> &x_, ColorSpinorField &y_, const Complex *b_,
+    void axpyBzpcx(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+                   const real_t *b, ColorSpinorField &z, const real_t *c);
+    void caxpyBxpz(const complex_t *a_, std::vector<ColorSpinorField *> &x_, ColorSpinorField &y_, const complex_t *b_,
                    ColorSpinorField &z_);
 
-    void reDotProduct(double *result, std::vector<ColorSpinorField *> &a, std::vector<ColorSpinorField *> &b);
-    void cDotProduct(Complex *result, std::vector<ColorSpinorField *> &a, std::vector<ColorSpinorField *> &b);
-    void hDotProduct(Complex *result, std::vector<ColorSpinorField *> &a, std::vector<ColorSpinorField *> &b);
+    void reDotProduct(real_t *result, std::vector<ColorSpinorField *> &a, std::vector<ColorSpinorField *> &b);
+    void cDotProduct(complex_t *result, std::vector<ColorSpinorField *> &a, std::vector<ColorSpinorField *> &b);
+    void hDotProduct(complex_t *result, std::vector<ColorSpinorField *> &a, std::vector<ColorSpinorField *> &b);
 
   } // namespace blas
 
diff --git a/include/clover_field.h b/include/clover_field.h
index 380a399492..0e34f9b6e7 100644
--- a/include/clover_field.h
+++ b/include/clover_field.h
@@ -98,13 +98,13 @@ namespace quda {
     bool inverse = true;       /** Whether to create the inverse clover field */
     void *clover = nullptr;    /** Pointer to the clover field */
     void *cloverInv = nullptr; /** Pointer to the clover inverse field */
-    double csw = 0.0;          /** C_sw clover coefficient */
-    double coeff = 0.0;        /** Overall clover coefficient */
+    real_t csw = 0.0;          /** C_sw clover coefficient */
+    real_t coeff = 0.0;        /** Overall clover coefficient */
     QudaTwistFlavorType twist_flavor = QUDA_TWIST_INVALID; /** Twisted-mass flavor type */
     bool twisted = false;                                  /** Whether to create twisted mass clover */
-    double mu2 = 0.0;                                      /** Chiral twisted mass term */
-    double epsilon2 = 0.0;                                 /** Flavor twisted mass term */
-    double rho = 0.0;                                      /** Hasenbusch rho term */
+    real_t mu2 = 0.0;                                      /** Chiral twisted mass term */
+    real_t epsilon2 = 0.0;                                 /** Flavor twisted mass term */
+    real_t rho = 0.0;                                      /** Hasenbusch rho term */
 
     QudaCloverFieldOrder order = QUDA_INVALID_CLOVER_ORDER; /** Field order */
     QudaFieldCreate create = QUDA_INVALID_FIELD_CREATE;     /** Creation type */
@@ -182,20 +182,20 @@ namespace quda {
     quda_ptr cloverInv = {};
 
     bool inverse = false;
-    double diagonal = 0.0;
-    array<double, 2> max = {};
+    real_t diagonal = 0.0;
+    array<real_t, 2> max = {};
 
-    double csw = 0.0;
-    double coeff = 0.0;
+    real_t csw = 0.0;
+    real_t coeff = 0.0;
     QudaTwistFlavorType twist_flavor = QUDA_TWIST_INVALID;
-    double mu2 = 0.0;      // chiral twisted mass squared
-    double epsilon2 = 0.0; // flavour twisted mass squared
-    double rho = 0.0;
+    real_t mu2 = 0.0;      // chiral twisted mass squared
+    real_t epsilon2 = 0.0; // flavour twisted mass squared
+    real_t rho = 0.0;
 
     QudaCloverFieldOrder order = QUDA_INVALID_CLOVER_ORDER;
     QudaFieldCreate create = QUDA_INVALID_FIELD_CREATE;
 
-    mutable array<double, 2> trlog = {};
+    mutable array<real_t, 2> trlog = {};
 
     /**
        @brief Set the vol_string and aux_string for use in tuning
@@ -230,12 +230,12 @@ namespace quda {
     /**
        @return diagonal scaling factor applied to the identity
     */
-    double Diagonal() const { return diagonal; }
+    real_t Diagonal() const { return diagonal; }
 
     /**
        @return set diagonal scaling factor applied to the identity
     */
-    void Diagonal(double diagonal) { this->diagonal = diagonal; }
+    void Diagonal(real_t diagonal) { this->diagonal = diagonal; }
 
     /**
        @return max element in the clover field for fixed-point scaling
@@ -296,12 +296,12 @@ namespace quda {
     /**
        @return Csw coefficient (does not include kappa)
     */
-    double Csw() const { return csw; }
+    real_t Csw() const { return csw; }
 
     /**
        @return Clover coefficient (explicitly includes kappa)
     */
-    double Coeff() const { return coeff; }
+    real_t Coeff() const { return coeff; }
 
     /**
        @return If the clover field is associated with twisted-clover fermions and which flavor type thereof
@@ -311,24 +311,24 @@ namespace quda {
     /**
        @return mu^2 factor baked into inverse clover field (for twisted-clover inverse)
     */
-    double Mu2() const { return mu2; }
+    real_t Mu2() const { return mu2; }
 
     /**
        @return epsilon^2 factor baked into inverse clover field (for non-deg twisted-clover inverse)
     */
-    double Epsilon2() const { return epsilon2; }
+    real_t Epsilon2() const { return epsilon2; }
 
     /**
        @return rho factor backed into the clover field, (for real
        diagonal additive Hasenbusch), e.g., A + rho
     */
-    double Rho() const { return rho; }
+    real_t Rho() const { return rho; }
 
     /**
        @brief Bakes in the rho factor into the clover field, (for real
        diagonal additive Hasenbusch), e.g., A + rho
     */
-    void setRho(double rho);
+    void setRho(real_t rho) { this->rho = rho; }
 
     /**
        @brief Copy into this CloverField from CloverField src
@@ -348,25 +348,25 @@ namespace quda {
        @brief Compute the L1 norm of the field
        @return L1 norm
      */
-    double norm1(bool inverse = false) const;
+    real_t norm1(bool inverse = false) const;
 
     /**
        @brief Compute the L2 norm squared of the field
        @return L2 norm squared
      */
-    double norm2(bool inverse = false) const;
+    real_t norm2(bool inverse = false) const;
 
     /**
        @brief Compute the absolute maximum of the field (Linfinity norm)
        @return Absolute maximum value
      */
-    double abs_max(bool inverse = false) const;
+    real_t abs_max(bool inverse = false) const;
 
     /**
        @brief Compute the absolute minimum of the field
        @return Absolute minimum value
      */
-    double abs_min(bool inverse = false) const;
+    real_t abs_min(bool inverse = false) const;
 
     /**
        @brief Backs up the CloverField
@@ -421,7 +421,7 @@ namespace quda {
      @param a The clover field that we want the norm of
      @return The L1 norm of the gauge field
   */
-  double norm1(const CloverField &u, bool inverse=false);
+  real_t norm1(const CloverField &u, bool inverse=false);
 
   /**
      This is a debugging function, where we cast a clover field into a
@@ -429,7 +429,7 @@ namespace quda {
      @param a The clover field that we want the norm of
      @return The L2 norm squared of the gauge field
   */
-  double norm2(const CloverField &a, bool inverse=false);
+  real_t norm2(const CloverField &a, bool inverse=false);
 
   /**
      @brief Driver for computing the clover field from the field
@@ -438,7 +438,7 @@ namespace quda {
      @param[in] fmunu Field strength tensor
      @param[in] coefft Clover coefficient
   */
-  void computeClover(CloverField &clover, const GaugeField &fmunu, double coeff);
+  void computeClover(CloverField &clover, const GaugeField &fmunu, real_t coeff);
 
   /**
      @brief This generic function is used for copying the clover field where
@@ -482,7 +482,7 @@ namespace quda {
    */
   void computeCloverForce(GaugeField& force, const GaugeField& U,
 			  std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &p,
-			  std::vector<double> &coeff);
+			  std::vector<real_t> &coeff);
   /**
      @brief Compute the outer product from the solver solution fields
      arising from the diagonal term of the fermion bilinear in
@@ -496,7 +496,7 @@ namespace quda {
   void computeCloverSigmaOprod(GaugeField& oprod,
 			       std::vector<ColorSpinorField*> &x,
 			       std::vector<ColorSpinorField*> &p,
-			       std::vector< std::vector<double> > &coeff);
+			       std::vector< std::vector<real_t> > &coeff);
   /**
      @brief Compute the matrix tensor field necessary for the force calculation from
      the clover trace action.  This computes a tensor field [mu,nu].
@@ -505,7 +505,7 @@ namespace quda {
      @param clover The input clover field
      @param coeff  Scalar coefficient multiplying the result (e.g., stepsize)
    */
-  void computeCloverSigmaTrace(GaugeField &output, const CloverField &clover, double coeff);
+  void computeCloverSigmaTrace(GaugeField &output, const CloverField &clover, real_t coeff);
 
   /**
      @brief Compute the derivative of the clover matrix in the direction
@@ -518,7 +518,7 @@ namespace quda {
      @param coeff Multiplicative coefficient (e.g., clover coefficient)
      @param parity The field parity we are working on
    */
-  void cloverDerivative(GaugeField &force, GaugeField &gauge, GaugeField &oprod, double coeff, QudaParity parity);
+  void cloverDerivative(GaugeField &force, GaugeField &gauge, GaugeField &oprod, real_t coeff, QudaParity parity);
 
   /**
     @brief This function is used for copying from a source clover field to a destination clover field
diff --git a/include/clover_field_order.h b/include/clover_field_order.h
index 65d5ef6cff..8ecac235fe 100644
--- a/include/clover_field_order.h
+++ b/include/clover_field_order.h
@@ -291,9 +291,9 @@ namespace quda {
          @tparam helper The helper functor which acts as the transformer
          in transform_reduce
       */
-      template <typename reducer, typename helper> constexpr double transform_reduce(QudaFieldLocation, helper) const
+      template <typename reducer, typename helper> constexpr auto transform_reduce(QudaFieldLocation, helper) const
       {
-        return 0.0;
+        return real_t(0.0);
       }
     };
 
@@ -316,7 +316,7 @@ namespace quda {
         stride(A.VolumeCB()),
         offset_cb(A.Bytes() / (2 * sizeof(Float))),
         compressed_block_size(A.compressed_block_size()),
-        recon(A.Diagonal())
+        recon(double(A.Diagonal()))
       {
       }
 
@@ -361,7 +361,7 @@ namespace quda {
          in transform_reduce
        */
       template <typename reducer, typename helper>
-      __host__ double transform_reduce(QudaFieldLocation location, helper h) const
+      auto transform_reduce(QudaFieldLocation location, helper h) const
       {
         // just use offset_cb, since factor of two from parity is equivalent to complexity
         return ::quda::transform_reduce<reducer>(location, reinterpret_cast<const complex<Float> *>(a), offset_cb, h);
@@ -440,7 +440,7 @@ namespace quda {
          in transform_reduce
        */
       template <typename reducer, typename helper>
-      __host__ double transform_reduce(QudaFieldLocation location, helper h) const
+      auto transform_reduce(QudaFieldLocation location, helper h) const
       {
         return ::quda::transform_reduce<reducer>(location, reinterpret_cast<complex<Float> *>(a), offset_cb, h);
       }
@@ -518,11 +518,10 @@ namespace quda {
 	 * @param[in] dim Which dimension we are taking the norm of (dummy for clover)
 	 * @return L1 norm
 	 */
-        __host__ double norm1(int = -1, bool global = true) const
+        auto norm1(int = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double nrm1
-            = accessor.scale() * accessor.template transform_reduce<plus<double>>(location, abs_<double, Float>());
+          real_t nrm1 = real_t(accessor.scale() * accessor.template transform_reduce<plus<device_reduce_t>>(location, abs_<double, Float>()));
           commGlobalReductionPop();
           return nrm1;
         }
@@ -532,11 +531,11 @@ namespace quda {
          * @param[in] dim Which dimension we are taking the norm of (dummy for clover)
          * @return L1 norm
          */
-        __host__ double norm2(int = -1, bool global = true) const
+        auto norm2(int = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double nrm2 = accessor.scale() * accessor.scale()
-            * accessor.template transform_reduce<plus<double>>(location, square_<double, Float>());
+          real_t nrm2 = real_t(accessor.scale() * accessor.scale()
+                               * accessor.template transform_reduce<plus<device_reduce_t>>(location, square_<double, Float>()));
           commGlobalReductionPop();
           return nrm2;
         }
@@ -546,11 +545,10 @@ namespace quda {
          * @param[in] dim Which dimension we are taking the Linfinity norm of (dummy for clover)
          * @return Linfinity norm
          */
-        __host__ double abs_max(int = -1, bool global = true) const
+        auto abs_max(int = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double absmax
-            = accessor.scale() * accessor.template transform_reduce<maximum<Float>>(location, abs_max_<Float, Float>());
+          real_t absmax = real_t(accessor.scale() * accessor.template transform_reduce<maximum<Float>>(location, abs_max_<Float, Float>()));
           commGlobalReductionPop();
           return absmax;
         }
@@ -560,11 +558,10 @@ namespace quda {
          * @param[in] dim Which dimension we are taking the minimum abs of (dummy for clover)
          * @return Minimum norm
          */
-        __host__ double abs_min(int = -1, bool global = true) const
+        auto abs_min(int = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double absmin
-            = accessor.scale() * accessor.template transform_reduce<minimum<Float>>(location, abs_min_<Float, Float>());
+          real_t absmin = real_t(accessor.scale() * accessor.template transform_reduce<minimum<Float>>(location, abs_min_<Float, Float>()));
           commGlobalReductionPop();
           return absmin;
         }
@@ -618,7 +615,7 @@ namespace quda {
 	void *backup_h; //! host memory for backing up the field when tuning
 
         FloatNOrder(const CloverField &clover, bool is_inverse, Float *clover_ = nullptr) :
-          recon(clover.Diagonal()),
+          recon(double(clover.Diagonal())),
           nrm(clover.max_element(is_inverse)
               / (2 * (isFixed<Float>::value ? fixedMaxValue<Float>::value : 1))), // factor of two in normalization
           nrm_inv(1.0 / nrm),
diff --git a/include/color_spinor_field_order.h b/include/color_spinor_field_order.h
index 87f10bce60..27dc9ba241 100644
--- a/include/color_spinor_field_order.h
+++ b/include/color_spinor_field_order.h
@@ -703,7 +703,7 @@ namespace quda
         nParity(field.SiteSubset()), ghostAccessor(field, nFace)
       {
         resetGhost(ghost_ ? ghost_ : field.Ghost());
-        resetScale(field.Scale());
+        resetScale(double(field.Scale()));
       }
 
       GhostOrder &operator=(const GhostOrder &) = default;
@@ -803,8 +803,8 @@ namespace quda
         commGlobalReductionPush(global);
         Float scale_inv = 1.0;
         if constexpr (fixed && !block_float_ghost) scale_inv = ghost.scale_inv;
-        auto nrm2 = transform_reduce<plus<double>>(dim, field.Location(), field.SiteSubset(),
-                                                   square_<double, ghostFloat>(scale_inv));
+        real_t nrm2 = real_t(transform_reduce<plus<device_reduce_t>>(dim, field.Location(), field.SiteSubset(),
+                                                                     square_<double, ghostFloat>(scale_inv)));
         commGlobalReductionPop();
         return nrm2;
       }
@@ -821,8 +821,8 @@ namespace quda
         commGlobalReductionPush(global);
         Float scale_inv = 1.0;
         if constexpr (fixed && !block_float_ghost) scale_inv = ghost.scale_inv;
-        auto absmax = transform_reduce<maximum<Float>>(field.Location(), field.SiteSubset(),
-                                                       abs_max_<Float, ghostFloat>(scale_inv));
+        real_t absmax = real_t(transform_reduce<maximum<Float>>(field.Location(), field.SiteSubset(),
+                                                                abs_max_<Float, ghostFloat>(scale_inv)));
         commGlobalReductionPop();
         return absmax;
       }
@@ -878,7 +878,7 @@ namespace quda
         GhostOrder(field, nFace, ghost_), volumeCB(field.VolumeCB()), accessor(field)
       {
         v.v = v_ ? static_cast<complex<storeFloat> *>(const_cast<void *>(v_)) : field.data<complex<storeFloat> *>();
-        resetScale(field.Scale());
+        resetScale(double(field.Scale()));
 
         if constexpr (fixed && block_float) {
           if constexpr (nColor == 3 && nSpin == 1 && nVec == 1 && order == 2)
@@ -1022,8 +1022,8 @@ namespace quda
         commGlobalReductionPush(global);
         Float scale_inv = 1.0;
         if constexpr (fixed && !block_float) scale_inv = v.scale_inv;
-        auto nrm2
-          = transform_reduce<plus<double>>(field.Location(), field.SiteSubset(), square_<double, storeFloat>(scale_inv));
+        real_t nrm2 = real_t(transform_reduce<plus<device_reduce_t>>(field.Location(), field.SiteSubset(),
+                                                                     square_<double, storeFloat>(scale_inv)));
         commGlobalReductionPop();
         return nrm2;
       }
@@ -1039,8 +1039,8 @@ namespace quda
         commGlobalReductionPush(global);
         Float scale_inv = 1.0;
         if constexpr (fixed && !block_float) scale_inv = v.scale_inv;
-        auto absmax = transform_reduce<maximum<Float>>(field.Location(), field.SiteSubset(),
-                                                       abs_max_<Float, storeFloat>(scale_inv));
+        auto absmax = real_t(transform_reduce<maximum<Float>>(field.Location(), field.SiteSubset(),
+                                                              abs_max_<Float, storeFloat>(scale_inv)));
         commGlobalReductionPop();
         return absmax;
       }
diff --git a/include/communicator_quda.h b/include/communicator_quda.h
index 0dc22fdfab..c9c59c3dbd 100644
--- a/include/communicator_quda.h
+++ b/include/communicator_quda.h
@@ -14,6 +14,7 @@
 #include <field_cache.h>
 #include <comm_key.h>
 #include <float_vector.h>
+#include "reducer.h"
 
 #if defined(MPI_COMMS) || defined(QMP_COMMS)
 #include <mpi.h>
@@ -733,21 +734,19 @@ namespace quda
 
   int comm_query(MsgHandle *mh);
 
-  template <typename T> T deterministic_reduce(T *array, int n)
+  template <typename T> T deterministic_sum_reduce(T *array, int n)
   {
     std::sort(array, array + n); // sort reduction into ascending order for deterministic reduction
-    return std::accumulate(array, array + n, 0.0);
+    return std::accumulate(array, array + n, T(0.0));
   }
 
-  void comm_allreduce_sum_array(double *data, size_t size);
+  template <typename T> void comm_allreduce_sum_array(T *data, size_t size);
 
-  void comm_allreduce_sum(size_t &a);
-
-  void comm_allreduce_max_array(double *data, size_t size);
+  template <typename T> void comm_allreduce_max_array(T *data, size_t size);
 
-  void comm_allreduce_max_array(deviation_t<double> *data, size_t size);
+  void comm_allreduce_sum(size_t &a);
 
-  void comm_allreduce_min_array(double *data, size_t size);
+  template <typename T> void comm_allreduce_min_array(T *data, size_t size);
 
   void comm_allreduce_int(int &data);
 
diff --git a/include/complex_quda.h b/include/complex_quda.h
index 66b5eee609..28bf74be05 100644
--- a/include/complex_quda.h
+++ b/include/complex_quda.h
@@ -26,6 +26,7 @@
 #include <cstdint>
 #include <type_traits>
 #include <quda_arch.h> // for double2 / float2
+#include "dbldbl.h"
 
 namespace quda {
   namespace gauge {
@@ -124,6 +125,7 @@ namespace quda
 
   __host__ __device__ inline float conj(float x) { return x; }
   __host__ __device__ inline double conj(double x) { return x; }
+  __host__ __device__ inline doubledouble conj(doubledouble x) { return x; }
 
   template <typename ValueType> struct complex;
   //template <> struct complex<float>;
@@ -427,10 +429,10 @@ struct complex
       return *this;
     }
 
-  __host__ __device__ inline ValueType real() const;
-  __host__ __device__ inline ValueType imag() const;
-  __host__ __device__ inline void real(ValueType);
-  __host__ __device__ inline void imag(ValueType);
+    constexpr ValueType real() const;
+    constexpr ValueType imag() const;
+    __host__ __device__ inline void real(ValueType);
+    __host__ __device__ inline void imag(ValueType);
 };
 
 template <> struct complex<float> : public float2 {
@@ -617,25 +619,25 @@ struct complex <short> : public short2
     real(real() + z.real());
     imag(imag() + z.imag());
     return *this;
-    }
-
-    __host__ __device__ inline complex<short> &operator-=(const complex<short> &z)
-    {
-      real(real()-z.real());
-      imag(imag()-z.imag());
-      return *this;
-    }
+  }
 
-    constexpr short real() const { return x; }
-    constexpr short imag() const { return y; }
-    __host__ __device__ inline void real(short re) { x = re; }
-    __host__ __device__ inline void imag(short im) { y = im; }
+  __host__ __device__ inline complex<short> &operator-=(const complex<short> &z)
+  {
+    real(real() - z.real());
+    imag(imag() - z.imag());
+    return *this;
+  }
 
-    // cast operators
-    template <typename T> inline __host__ __device__ operator complex<T>() const
-    {
-      return complex<T>(static_cast<T>(real()), static_cast<T>(imag())); }
+  constexpr short real() const { return x; }
+  constexpr short imag() const { return y; }
+  __host__ __device__ inline void real(short re) { x = re; }
+  __host__ __device__ inline void imag(short im) { y = im; }
 
+  // cast operators
+  template <typename T> inline __host__ __device__ operator complex<T>() const
+  {
+    return complex<T>(static_cast<T>(real()), static_cast<T>(imag()));
+  }
 };
 
 template<>
@@ -653,25 +655,62 @@ struct complex <int> : public int2
     real(real() + z.real());
     imag(imag() + z.imag());
     return *this;
-    }
+  }
 
-    __host__ __device__ inline complex<int> &operator-=(const complex<int> &z)
-    {
-      real(real()-z.real());
-      imag(imag()-z.imag());
-      return *this;
-    }
+  __host__ __device__ inline complex<int> &operator-=(const complex<int> &z)
+  {
+    real(real() - z.real());
+    imag(imag() - z.imag());
+    return *this;
+  }
 
-    constexpr int real() const { return x; }
-    constexpr int imag() const { return y; }
-    __host__ __device__ inline void real(int re) { x = re; }
-    __host__ __device__ inline void imag(int im) { y = im; }
+  constexpr int real() const { return x; }
+  constexpr int imag() const { return y; }
+  __host__ __device__ inline void real(int re) { x = re; }
+  __host__ __device__ inline void imag(int im) { y = im; }
 
-    // cast operators
-    template <typename T> inline __host__ __device__ operator complex<T>() const
-    {
-      return complex<T>(static_cast<T>(real()), static_cast<T>(imag())); }
+  // cast operators
+  template <typename T> inline __host__ __device__ operator complex<T>() const
+  {
+    return complex<T>(static_cast<T>(real()), static_cast<T>(imag()));
+  }
+};
+
+template <> struct complex<doubledouble> : public doubledouble2 {
+public:
+  typedef doubledouble value_type;
+
+  complex<doubledouble>() = default;
+
+  constexpr complex<doubledouble>(const doubledouble &re, const doubledouble &im = doubledouble()) :
+    doubledouble2 {re, im}
+  {
+  }
+
+  __host__ __device__ inline complex<doubledouble> &operator+=(const complex<doubledouble> &z)
+  {
+    real(real() + z.real());
+    imag(imag() + z.imag());
+    return *this;
+  }
 
+  __host__ __device__ inline complex<doubledouble> &operator-=(const complex<doubledouble> &z)
+  {
+    real(real() - z.real());
+    imag(imag() - z.imag());
+    return *this;
+  }
+
+  constexpr doubledouble real() const { return x; }
+  constexpr doubledouble imag() const { return y; }
+  __host__ __device__ inline void real(doubledouble re) { x = re; }
+  __host__ __device__ inline void imag(doubledouble im) { y = im; }
+
+  // cast operators
+  template <typename T> inline __host__ __device__ operator complex<T>() const
+  {
+    return complex<T>(static_cast<T>(real()), static_cast<T>(imag()));
+  }
 };
 
   // Binary arithmetic operations
@@ -1169,9 +1208,9 @@ lhs.real()*rhs.imag()+lhs.imag()*rhs.real());
   {
     complex<real> w;
     w.x = x.real() * y.real();
-    w.x -= x.imag() * y.imag();
+    w.x = fma(-x.imag(), y.imag(), w.x);
     w.y = x.imag() * y.real();
-    w.y += x.real() * y.imag();
+    w.y = fma(x.real(), y.imag(), w.y);
     return w;
   }
 
@@ -1179,10 +1218,10 @@ lhs.real()*rhs.imag()+lhs.imag()*rhs.real());
   __host__ __device__ inline complex<real> cmac(const complex<real> &x, const complex<real> &y, const complex<real> &z)
   {
     complex<real> w = z;
-    w.x += x.real() * y.real();
-    w.x -= x.imag() * y.imag();
-    w.y += x.imag() * y.real();
-    w.y += x.real() * y.imag();
+    w.x = fma( x.real(), y.real(), w.x);
+    w.x = fma(-x.imag(), y.imag(), w.x);
+    w.y = fma( x.imag(), y.real(), w.y);
+    w.y = fma( x.real(), y.imag(), w.y);
     return w;
   }
 
@@ -1197,10 +1236,10 @@ lhs.real()*rhs.imag()+lhs.imag()*rhs.real());
     complex<real> X = x;
     complex<real> Y = y;
     complex<real> Z = z;
-    Z.real(Z.real() + X.real() * Y.real());
-    Z.real(Z.real() - X.imag() * Y.imag());
-    Z.imag(Z.imag() + X.imag() * Y.real());
-    Z.imag(Z.imag() + X.real() * Y.imag());
+    Z.real(fma( X.real(), Y.real(), Z.real()));
+    Z.real(fma(-X.imag(), Y.imag(), Z.real()));
+    Z.imag(fma( X.imag(), Y.real(), Z.imag()));
+    Z.imag(fma( X.real(), Y.imag(), Z.imag()));
     return Z;
   }
 
diff --git a/include/dbldbl.h b/include/dbldbl.h
index f4b198e373..084ba41fde 100644
--- a/include/dbldbl.h
+++ b/include/dbldbl.h
@@ -66,7 +66,7 @@ typedef double2 dbldbl;
    requirement. To create a double-double from two arbitrary double-precision
    numbers, use add_double_to_dbldbl().
 */
-__device__ __forceinline__ dbldbl make_dbldbl (double head, double tail)
+__device__ __host__ __forceinline__ dbldbl make_dbldbl (double head, double tail)
 {
     dbldbl z;
     z.x = tail;
@@ -75,42 +75,42 @@ __device__ __forceinline__ dbldbl make_dbldbl (double head, double tail)
 }
 
 /* Return the head of a double-double number */
-__device__ __forceinline__ double get_dbldbl_head (dbldbl a)
+__device__ __host__ __forceinline__ double get_dbldbl_head (dbldbl a)
 {
     return a.y;
 }
 
 /* Return the tail of a double-double number */
-__device__ __forceinline__ double get_dbldbl_tail (dbldbl a)
+__device__ __host__ __forceinline__ double get_dbldbl_tail (dbldbl a)
 {
     return a.x;
 }
 
 /* Compute error-free sum of two unordered doubles. See Knuth, TAOCP vol. 2 */
-__device__ __forceinline__ dbldbl add_double_to_dbldbl (double a, double b)
+__device__ __host__ __forceinline__ dbldbl add_double_to_dbldbl (double a, double b)
 {
     double t1, t2;
     dbldbl z;
-    z.y = __dadd_rn (a, b);
-    t1 = __dadd_rn (z.y, -a);
-    t2 = __dadd_rn (z.y, -t1);
-    t1 = __dadd_rn (b, -t1);
-    t2 = __dadd_rn (a, -t2);
-    z.x = __dadd_rn (t1, t2);
+    z.y = quda::dadd_rn (a, b);
+    t1 = quda::dadd_rn (z.y, -a);
+    t2 = quda::dadd_rn (z.y, -t1);
+    t1 = quda::dadd_rn (b, -t1);
+    t2 = quda::dadd_rn (a, -t2);
+    z.x = quda::dadd_rn (t1, t2);
     return z;
 }
 
 /* Compute error-free product of two doubles. Take full advantage of FMA */
-__device__ __forceinline__ dbldbl mul_double_to_dbldbl (double a, double b)
+__device__ __host__ __forceinline__ dbldbl mul_double_to_dbldbl (double a, double b)
 {
     dbldbl z;
-    z.y = __dmul_rn (a, b);
-    z.x = __fma_rn (a, b, -z.y);
+    z.y = quda::dmul_rn (a, b);
+    z.x = quda::fma_rn (a, b, -z.y);
     return z;
 }
 
 /* Negate a double-double number, by separately negating head and tail */
-__device__ __forceinline__ dbldbl neg_dbldbl (dbldbl a)
+__device__ __host__ __forceinline__ dbldbl neg_dbldbl (dbldbl a)
 {
     dbldbl z;
     z.y = -a.y;
@@ -125,22 +125,22 @@ __device__ __forceinline__ dbldbl neg_dbldbl (dbldbl a)
    Floating-Point Numbers for GPU Computation. Retrieved on 7/12/2011
    from http://andrewthall.org/papers/df64_qf128.pdf.
 */
-__device__ __forceinline__ dbldbl add_dbldbl (dbldbl a, dbldbl b)
+__device__ __host__ __forceinline__ dbldbl add_dbldbl (dbldbl a, dbldbl b)
 {
     dbldbl z;
     double t1, t2, t3, t4, t5, e;
-    t1 = __dadd_rn (a.y, b.y);
-    t2 = __dadd_rn (t1, -a.y);
-    t3 = __dadd_rn (__dadd_rn (a.y, t2 - t1), __dadd_rn (b.y, -t2));
-    t4 = __dadd_rn (a.x, b.x);
-    t2 = __dadd_rn (t4, -a.x);
-    t5 = __dadd_rn (__dadd_rn (a.x, t2 - t4), __dadd_rn (b.x, -t2));
-    t3 = __dadd_rn (t3, t4);
-    t4 = __dadd_rn (t1, t3);
-    t3 = __dadd_rn (t1 - t4, t3);
-    t3 = __dadd_rn (t3, t5);
-    z.y = e = __dadd_rn (t4, t3);
-    z.x = __dadd_rn (t4 - e, t3);
+    t1 = quda::dadd_rn (a.y, b.y);
+    t2 = quda::dadd_rn (t1, -a.y);
+    t3 = quda::dadd_rn (quda::dadd_rn (a.y, t2 - t1), quda::dadd_rn (b.y, -t2));
+    t4 = quda::dadd_rn (a.x, b.x);
+    t2 = quda::dadd_rn (t4, -a.x);
+    t5 = quda::dadd_rn (quda::dadd_rn (a.x, t2 - t4), quda::dadd_rn (b.x, -t2));
+    t3 = quda::dadd_rn (t3, t4);
+    t4 = quda::dadd_rn (t1, t3);
+    t3 = quda::dadd_rn (t1 - t4, t3);
+    t3 = quda::dadd_rn (t3, t5);
+    z.y = e = quda::dadd_rn (t4, t3);
+    z.x = quda::dadd_rn (t4 - e, t3);
     return z;
 }
 
@@ -151,22 +151,22 @@ __device__ __forceinline__ dbldbl add_dbldbl (dbldbl a, dbldbl b)
    Floating-Point Numbers for GPU Computation. Retrieved on 7/12/2011
    from http://andrewthall.org/papers/df64_qf128.pdf.
 */
-__device__ __forceinline__ dbldbl sub_dbldbl (dbldbl a, dbldbl b)
+__device__ __host__ __forceinline__ dbldbl sub_dbldbl (dbldbl a, dbldbl b)
 {
     dbldbl z;
     double t1, t2, t3, t4, t5, e;
-    t1 = __dadd_rn (a.y, -b.y);
-    t2 = __dadd_rn (t1, -a.y);
-    t3 = __dadd_rn (__dadd_rn (a.y, t2 - t1), - __dadd_rn (b.y, t2));
-    t4 = __dadd_rn (a.x, -b.x);
-    t2 = __dadd_rn (t4, -a.x);
-    t5 = __dadd_rn (__dadd_rn (a.x, t2 - t4), - __dadd_rn (b.x, t2));
-    t3 = __dadd_rn (t3, t4);
-    t4 = __dadd_rn (t1, t3);
-    t3 = __dadd_rn (t1 - t4, t3);
-    t3 = __dadd_rn (t3, t5);
-    z.y = e = __dadd_rn (t4, t3);
-    z.x = __dadd_rn (t4 - e, t3);
+    t1 = quda::dadd_rn (a.y, -b.y);
+    t2 = quda::dadd_rn (t1, -a.y);
+    t3 = quda::dadd_rn (quda::dadd_rn (a.y, t2 - t1), - quda::dadd_rn (b.y, t2));
+    t4 = quda::dadd_rn (a.x, -b.x);
+    t2 = quda::dadd_rn (t4, -a.x);
+    t5 = quda::dadd_rn (quda::dadd_rn (a.x, t2 - t4), - quda::dadd_rn (b.x, t2));
+    t3 = quda::dadd_rn (t3, t4);
+    t4 = quda::dadd_rn (t1, t3);
+    t3 = quda::dadd_rn (t1 - t4, t3);
+    t3 = quda::dadd_rn (t3, t5);
+    z.y = e = quda::dadd_rn (t4, t3);
+    z.x = quda::dadd_rn (t4 - e, t3);
     return z;
 }
 
@@ -175,17 +175,17 @@ __device__ __forceinline__ dbldbl sub_dbldbl (dbldbl a, dbldbl b)
    relative error observed with 10 billion test cases was 5.238480533564479e-32
    (~= 2**-103.9125).
 */
-__device__ __forceinline__ dbldbl mul_dbldbl (dbldbl a, dbldbl b)
+__device__ __host__ __forceinline__ dbldbl mul_dbldbl (dbldbl a, dbldbl b)
 {
     dbldbl t, z;
     double e;
-    t.y = __dmul_rn (a.y, b.y);
-    t.x = __fma_rn (a.y, b.y, -t.y);
-    t.x = __fma_rn (a.x, b.x, t.x);
-    t.x = __fma_rn (a.y, b.x, t.x);
-    t.x = __fma_rn (a.x, b.y, t.x);
-    z.y = e = __dadd_rn (t.y, t.x);
-    z.x = __dadd_rn (t.y - e, t.x);
+    t.y = quda::dmul_rn (a.y, b.y);
+    t.x = quda::fma_rn (a.y, b.y, -t.y);
+    t.x = quda::fma_rn (a.x, b.x, t.x);
+    t.x = quda::fma_rn (a.y, b.x, t.x);
+    t.x = quda::fma_rn (a.x, b.y, t.x);
+    z.y = e = quda::dadd_rn (t.y, t.x);
+    z.x = quda::dadd_rn (t.y - e, t.x);
     return z;
 }
 
@@ -197,22 +197,22 @@ __device__ __forceinline__ dbldbl mul_dbldbl (dbldbl a, dbldbl b)
    maximum relative error observed with 10 billion test cases was
    1.0161322480099059e-31 (~= 2**-102.9566).
 */
-__device__ __forceinline__ dbldbl div_dbldbl (dbldbl a, dbldbl b)
+__device__ __host__ __forceinline__ dbldbl div_dbldbl (dbldbl a, dbldbl b)
 {
     dbldbl t, z;
     double e, r;
     r = 1.0 / b.y;
-    t.y = __dmul_rn (a.y, r);
-    e = __fma_rn (b.y, -t.y, a.y);
-    t.y = __fma_rn (r, e, t.y);
-    t.x = __fma_rn (b.y, -t.y, a.y);
-    t.x = __dadd_rn (a.x, t.x);
-    t.x = __fma_rn (b.x, -t.y, t.x);
-    e = __dmul_rn (r, t.x);
-    t.x = __fma_rn (b.y, -e, t.x);
-    t.x = __fma_rn (r, t.x, e);
-    z.y = e = __dadd_rn (t.y, t.x);
-    z.x = __dadd_rn (t.y - e, t.x);
+    t.y = quda::dmul_rn (a.y, r);
+    e = quda::fma_rn (b.y, -t.y, a.y);
+    t.y = quda::fma_rn (r, e, t.y);
+    t.x = quda::fma_rn (b.y, -t.y, a.y);
+    t.x = quda::dadd_rn (a.x, t.x);
+    t.x = quda::fma_rn (b.x, -t.y, t.x);
+    e = quda::dmul_rn (r, t.x);
+    t.x = quda::fma_rn (b.y, -e, t.x);
+    t.x = quda::fma_rn (r, t.x, e);
+    z.y = e = quda::dadd_rn (t.y, t.x);
+    z.x = quda::dadd_rn (t.y - e, t.x);
     return z;
 }
 
@@ -223,25 +223,25 @@ __device__ __forceinline__ dbldbl div_dbldbl (dbldbl a, dbldbl b)
    relative error observed with 10 billion test cases was
    3.7564109505601846e-32 (~= 2**-104.3923).
 */
-__device__ __forceinline__ dbldbl sqrt_dbldbl (dbldbl a)
+__device__ __host__ __forceinline__ dbldbl sqrt_dbldbl (dbldbl a)
 {
     dbldbl t, z;
     double e, y, s, r;
     r = quda::rsqrt(a.y);
     if (a.y == 0.0) r = 0.0;
-    y = __dmul_rn (a.y, r);
-    s = __fma_rn (y, -y, a.y);
-    r = __dmul_rn (0.5, r);
-    z.y = e = __dadd_rn (s, a.x);
-    z.x = __dadd_rn (s - e, a.x);
-    t.y = __dmul_rn (r, z.y);
-    t.x = __fma_rn (r, z.y, -t.y);
-    t.x = __fma_rn (r, z.x, t.x);
-    r = __dadd_rn (y, t.y);
-    s = __dadd_rn (y - r, t.y);
-    s = __dadd_rn (s, t.x);
-    z.y = e = __dadd_rn (r, s);
-    z.x = __dadd_rn (r - e, s);
+    y = quda::dmul_rn (a.y, r);
+    s = quda::fma_rn (y, -y, a.y);
+    r = quda::dmul_rn (0.5, r);
+    z.y = e = quda::dadd_rn (s, a.x);
+    z.x = quda::dadd_rn (s - e, a.x);
+    t.y = quda::dmul_rn (r, z.y);
+    t.x = quda::fma_rn (r, z.y, -t.y);
+    t.x = quda::fma_rn (r, z.x, t.x);
+    r = quda::dadd_rn (y, t.y);
+    s = quda::dadd_rn (y - r, t.y);
+    s = quda::dadd_rn (s, t.x);
+    z.y = e = quda::dadd_rn (r, s);
+    z.x = quda::dadd_rn (r - e, s);
     return z;
 }
 
@@ -250,26 +250,26 @@ __device__ __forceinline__ dbldbl sqrt_dbldbl (dbldbl a)
    the maximum relative error observed with 10 billion test cases was
    6.4937771666026349e-32 (~= 2**-103.6026)
 */
-__device__ __forceinline__ dbldbl rsqrt_dbldbl (dbldbl a)
+__device__ __host__ __forceinline__ dbldbl rsqrt_dbldbl (dbldbl a)
 {
     dbldbl z;
     double r, s, e;
     r = quda::rsqrt(a.y);
-    e = __dmul_rn (a.y, r);
-    s = __fma_rn (e, -r, 1.0);
-    e = __fma_rn (a.y, r, -e);
-    s = __fma_rn (e, -r, s);
-    e = __dmul_rn (a.x, r);
-    s = __fma_rn (e, -r, s);
+    e = quda::dmul_rn (a.y, r);
+    s = quda::fma_rn (e, -r, 1.0);
+    e = quda::fma_rn (a.y, r, -e);
+    s = quda::fma_rn (e, -r, s);
+    e = quda::dmul_rn (a.x, r);
+    s = quda::fma_rn (e, -r, s);
     e = 0.5 * r;
-    z.y = __dmul_rn (e, s);
-    z.x = __fma_rn (e, s, -z.y);
-    s = __dadd_rn (r, z.y);
-    r = __dadd_rn (r, -s);
-    r = __dadd_rn (r, z.y);
-    r = __dadd_rn (r, z.x);
-    z.y = e = __dadd_rn (s, r);
-    z.x = __dadd_rn (s - e, r);
+    z.y = quda::dmul_rn (e, s);
+    z.x = quda::fma_rn (e, s, -z.y);
+    s = quda::dadd_rn (r, z.y);
+    r = quda::dadd_rn (r, -s);
+    r = quda::dadd_rn (r, z.y);
+    r = quda::dadd_rn (r, z.x);
+    z.y = e = quda::dadd_rn (s, r);
+    z.x = quda::dadd_rn (s - e, r);
     return z;
 }
 
@@ -285,97 +285,162 @@ struct doubledouble {
 
   dbldbl a;
 
-  __device__ __host__ doubledouble() { a.x = 0.0; a.y = 0.0; }
-  __device__ __host__ doubledouble(const doubledouble &a) : a(a.a) { }
-  __device__ __host__ doubledouble(const dbldbl &a) : a(a) { }
-  __device__ __host__ doubledouble(const double &head, const double &tail) { a.y = head; a.x = tail; }
-  __device__ __host__ doubledouble(const double &head) { a.y = head; a.x = 0.0; }
+  doubledouble() = default;
+  constexpr doubledouble(const doubledouble &a) = default;
+  constexpr doubledouble(const dbldbl &a) : a(a) { }
+  constexpr doubledouble(const double &head, const double &tail) : a{tail, head} { }
+  constexpr doubledouble(const double &head) : a{0.0, head} { }
 
   __device__ __host__ doubledouble& operator=(const double &head) {
     this->a.y = head;
     this->a.x = 0.0;
+    return *this;
   }
 
-  __device__ doubledouble& operator+=(const doubledouble &a) {
+  __device__ __host__ doubledouble& operator+=(const doubledouble &a) {
     this->a = add_dbldbl(this->a, a.a);
     return *this;
   }
 
-  __device__ __host__ double head() const { return a.y; }
-  __device__ __host__ double tail() const { return a.x; }
+  __device__ __host__ doubledouble& operator-=(const doubledouble &a) {
+    this->a = sub_dbldbl(this->a, a.a);
+    return *this;
+  }
+
+  __device__ __host__ void operator*=(const doubledouble &a)
+  {
+    this->a = mul_dbldbl(this->a, a.a);
+  }
+
+  __device__ __host__ void operator/=(const doubledouble &a)
+  {
+    this->a = div_dbldbl(this->a, a.a);
+  }
+
+  constexpr double head() const { return a.y; }
+  constexpr double tail() const { return a.x; }
 
   __device__ __host__ void print() const { printf("scalar: %16.14e + %16.14e\n", head(), tail()); }
 
+  explicit constexpr operator double() const { return head(); }
+  explicit constexpr operator float() const { return static_cast<float>(head()); }
+  explicit constexpr operator int() const { return static_cast<int>(head()); }
 };
 
-__device__  inline bool operator>(const doubledouble &a, const double &b) {
-  return a.head() > b;
+__device__ __host__ inline doubledouble sqrt(const doubledouble &a) { return doubledouble(sqrt_dbldbl(a.a)); }
+
+__device__ __host__ inline doubledouble operator-(const doubledouble &a) { return doubledouble(neg_dbldbl(a.a)); }
+
+__device__ __host__ inline doubledouble abs(const doubledouble &a) { return (a.head() < 0 ? -a : a); }
+
+__device__ __host__ inline bool isinf(const doubledouble &a) { return isinf(a.head()); }
+
+__device__ __host__ inline bool isnan(const doubledouble &a) { return isnan(a.head()); }
+
+__device__ __host__ inline bool isfinite(const doubledouble &a) { return isfinite(a.head()); }
+
+__device__ __host__  inline bool operator>(const doubledouble &a, const doubledouble &b)
+{
+  if (a.head() > b.head()) {
+    return true;
+  } else if (a.head() == b.head() && a.tail() > b.tail()) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
-__device__  inline doubledouble operator+(const doubledouble &a, const doubledouble &b) {
-  return doubledouble(add_dbldbl(a.a,b.a));
+__device__ __host__  inline bool operator>=(const doubledouble &a, const doubledouble &b)
+{
+  if (a.head() >= b.head()) {
+    return true;
+  } else if (a.head() == b.head() && a.tail() >= b.tail()) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
-__device__  inline doubledouble operator-(const doubledouble &a, const doubledouble &b) {
-  return doubledouble(sub_dbldbl(a.a,b.a));
+__device__ __host__  inline bool operator<(const doubledouble &a, const doubledouble &b)
+{
+  if (a.head() < b.head()) {
+    return true;
+  } else if (a.head() == b.head() && a.tail() < b.tail()) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
-__device__ inline doubledouble operator*(const doubledouble &a, const doubledouble &b) {
-  return  doubledouble(mul_dbldbl(a.a,b.a));
+__device__ __host__  inline bool operator<=(const doubledouble &a, const doubledouble &b)
+{
+  if (a.head() <= b.head()) {
+    return true;
+  } else if (a.head() == b.head() && a.tail() <= b.tail()) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
-__device__ inline doubledouble operator/(const doubledouble &a, const doubledouble &b) {
-  return doubledouble(div_dbldbl(a.a,b.a));
+__device__ __host__  inline bool operator==(const doubledouble &a, const doubledouble &b) {
+  return (a.head() == b.head() && a.tail() == b.tail());
 }
 
-__device__ inline doubledouble add_double_to_doubledouble(const double &a, const double &b) {
-  return doubledouble(add_double_to_dbldbl(a,b));
+__device__ __host__  inline bool operator!=(const doubledouble &a, const doubledouble &b) {
+  return !(a == b);
 }
 
-__device__ inline doubledouble mul_double_to_doubledouble(const double &a, const double &b) {
-  return doubledouble(mul_double_to_dbldbl(a,b));
+__device__ __host__  inline bool operator>(const doubledouble &a, const double &b) {
+  return a.head() > b || (a.head() == b && a.tail() > 0);
 }
 
-struct doubledouble2 {
-  doubledouble x;
-  doubledouble y;
+__device__ __host__  inline doubledouble operator+(const doubledouble &a, const doubledouble &b) {
+  return doubledouble(add_dbldbl(a.a,b.a));
+}
 
-  __device__ __host__ doubledouble2() : x(), y() { }
-  __device__ __host__ doubledouble2(const doubledouble2 &a) : x(a.x), y(a.y) { }
-  __device__ __host__ doubledouble2(const double2 &a) : x(a.x), y(a.y) { }
-  __device__ __host__ doubledouble2(const doubledouble &x, const doubledouble &y) : x(x), y(y) { }
+__device__ __host__  inline doubledouble operator-(const doubledouble &a, const doubledouble &b) {
+  return doubledouble(sub_dbldbl(a.a,b.a));
+}
 
-  __device__ doubledouble2& operator+=(const doubledouble2 &a) {
-    x += a.x;
-    y += a.y;
-    return *this;
-  }
+__device__ __host__ inline doubledouble operator*(const doubledouble &a, const doubledouble &b) {
+  return  doubledouble(mul_dbldbl(a.a,b.a));
+}
 
-  __device__ __host__ void print() const { printf("vec2: (%16.14e + %16.14e) (%16.14e + %16.14e)\n", x.head(), x.tail(), y.head(), y.tail()); }
-};
+__device__ __host__ inline doubledouble operator/(const doubledouble &a, const doubledouble &b) {
+  return doubledouble(div_dbldbl(a.a,b.a));
+}
+
+/**
+   @brief This isn't really an fma for double-double, but just
+   provides a convenient overload to ensure that when using native
+   floating point types that we consistently use an fma.
+*/
+__device__ __host__ inline doubledouble fma(const doubledouble &a, const doubledouble &b, const doubledouble &c) { return a * b + c; }
 
-struct doubledouble3 {
+struct doubledouble2 {
   doubledouble x;
   doubledouble y;
-  doubledouble z;
 
-  __device__ __host__ doubledouble3() : x(), y() { }
-  __device__ __host__ doubledouble3(const doubledouble3 &a) : x(a.x), y(a.y), z(a.z) { }
-  __device__ __host__ doubledouble3(const double3 &a) : x(a.x), y(a.y), z(a.z) { }
-  __device__ __host__ doubledouble3(const doubledouble &x, const doubledouble &y, const doubledouble &z) : x(x), y(y), z(z) { }
+  doubledouble2() = default;
+  constexpr doubledouble2(const doubledouble2 &a) = default;
+  constexpr doubledouble2(const double2 &a) : x(a.x), y(a.y) { }
+  constexpr doubledouble2(const doubledouble &x, const doubledouble &y) : x(x), y(y) { }
 
-  __device__ doubledouble3& operator+=(const doubledouble3 &a) {
+  __device__ __host__ doubledouble2& operator+=(const doubledouble2 &a) {
     x += a.x;
     y += a.y;
-    z += a.z;
     return *this;
   }
 
-  __device__ __host__ void print() const { printf("vec3: (%16.14e + %16.14e) (%16.14e + %16.14e) (%16.14e + %16.14e)\n", x.head(), x.tail(), y.head(), y.tail(), z.head(), z.tail()); }
+  __device__ __host__ void print() const { printf("vec2: (%16.14e + %16.14e) (%16.14e + %16.14e)\n", x.head(), x.tail(), y.head(), y.tail()); }
 };
 
-__device__ doubledouble2 operator+(const doubledouble2 &a, const doubledouble2 &b)
+__device__ __host__ inline doubledouble2 operator+(const doubledouble2 &a, const doubledouble2 &b)
 { return doubledouble2(a.x + b.x, a.y + b.y); }
 
-__device__ doubledouble3 operator+(const doubledouble3 &a, const doubledouble3 &b)
-{ return doubledouble3(a.x + b.x, a.y + b.y, a.z + b.z); }
+inline std::ostream &operator<<(std::ostream &output, const doubledouble &a)
+{
+  output << "{" << a.head() << ", " << a.tail() << "}";
+  return output;
+}
diff --git a/include/deflation.h b/include/deflation.h
index b9d9132577..1f2aadb543 100644
--- a/include/deflation.h
+++ b/include/deflation.h
@@ -22,13 +22,13 @@ namespace quda {
     ColorSpinorField *RV;  
     
     /** Inverse Ritz values*/
-    double *invRitzVals;
+    real_t *invRitzVals;
 
      /** The Dirac operator to use for spinor deflation operation */
     DiracMatrix &matDeflation;
 
     /** Host  projection matrix (e.g. eigCG VH A V) */
-    Complex *matProj; 
+    complex_t *matProj;
 
     /** projection matrix leading dimension */
     int ld;
@@ -56,8 +56,8 @@ namespace quda {
         tot_dim      = param.np;
         ld           = ((tot_dim+15) / 16) * tot_dim;
         //allocate deflation resources:
-        matProj = static_cast<Complex *>(pool_pinned_malloc(ld * tot_dim * sizeof(Complex)));
-        invRitzVals  = new double[tot_dim];
+        matProj = static_cast<complex_t *>(pool_pinned_malloc(ld * tot_dim * sizeof(complex_t)));
+        invRitzVals  = new real_t[tot_dim];
 
         //Check that RV is a composite field:
         if(RV->IsComposite() == false) errorQuda("\nRitz vectors must be contained in a composite field.\n");
@@ -128,7 +128,7 @@ namespace quda {
        @param tol : keep all eigenvectors with residual norm less then tol
        @param max_n_ev : keep the lowest max_n_ev eigenvectors (conservative)
      */
-    void reduce(double tol, int max_n_ev);
+    void reduce(real_t tol, int max_n_ev);
 
     /**
        This applies deflation operation on a given spinor vector(s)
diff --git a/include/dirac_quda.h b/include/dirac_quda.h
index cfbba175d5..e0369eeaff 100644
--- a/include/dirac_quda.h
+++ b/include/dirac_quda.h
@@ -36,19 +36,19 @@ namespace quda {
 
   public:
     QudaDiracType type;
-    double kappa;
-    double mass;
-    double m5; // used by domain wall only
+    real_t kappa;
+    real_t mass;
+    real_t m5; // used by domain wall only
     int Ls;    // used by domain wall and twisted mass
-    Complex b_5[QUDA_MAX_DWF_LS]; // used by mobius domain wall only
-    Complex c_5[QUDA_MAX_DWF_LS]; // used by mobius domain wall only
+    complex_t b_5[QUDA_MAX_DWF_LS]; // used by mobius domain wall only
+    complex_t c_5[QUDA_MAX_DWF_LS]; // used by mobius domain wall only
 
     // The EOFA parameters. See the description in InvertParam
-    double eofa_shift;
+    real_t eofa_shift;
     int eofa_pm;
-    double mq1;
-    double mq2;
-    double mq3;
+    real_t mq1;
+    real_t mq2;
+    real_t mq3;
 
     QudaMatPCType matpcType;
     QudaDagType dagger;
@@ -59,10 +59,10 @@ namespace quda {
     CloverField *clover;
     GaugeField *xInvKD; // used for the Kahler-Dirac operator only
 
-    double mu; // used by twisted mass only
-    double mu_factor; // used by multigrid only
-    double epsilon; //2nd tm parameter (used by twisted mass only)
-    double tm_rho;  // "rho"-type Hasenbusch mass used for twisted clover (like regular rho but
+    real_t mu; // used by twisted mass only
+    real_t mu_factor; // used by multigrid only
+    real_t epsilon; //2nd tm parameter (used by twisted mass only)
+    real_t tm_rho;  // "rho"-type Hasenbusch mass used for twisted clover (like regular rho but
                     // applied like a twisted mass and ignored in the inverse)
 
     int commDim[QUDA_MAX_DIM]; // whether to do comms or not
@@ -114,24 +114,23 @@ namespace quda {
     void print() {
       printfQuda("Printing DslashParam\n");
       printfQuda("type = %d\n", type);
-      printfQuda("kappa = %g\n", kappa);
-      printfQuda("mass = %g\n", mass);
+      printfQuda("kappa = %g\n", double(kappa));
+      printfQuda("mass = %g\n", double(mass));
       printfQuda("laplace3D = %d\n", laplace3D);
-      printfQuda("m5 = %g\n", m5);
+      printfQuda("m5 = %g\n", double(m5));
       printfQuda("Ls = %d\n", Ls);
       printfQuda("matpcType = %d\n", matpcType);
       printfQuda("dagger = %d\n", dagger);
-      printfQuda("mu = %g\n", mu);
-      printfQuda("tm_rho = %g\n", tm_rho);
-      printfQuda("epsilon = %g\n", epsilon);
+      printfQuda("mu = %g\n", double(mu));
+      printfQuda("tm_rho = %g\n", double(tm_rho));
+      printfQuda("epsilon = %g\n", double(epsilon));
       printfQuda("halo_precision = %d\n", halo_precision);
       for (int i=0; i<QUDA_MAX_DIM; i++) printfQuda("commDim[%d] = %d\n", i, commDim[i]);
       for (int i = 0; i < Ls; i++)
-        printfQuda(
-            "b_5[%d] = %e %e \t c_5[%d] = %e %e\n", i, b_5[i].real(), b_5[i].imag(), i, c_5[i].real(), c_5[i].imag());
+        printfQuda("b_5[%d] = %e %e \t c_5[%d] = %e %e\n", i, static_cast<double>(b_5[i].real()), static_cast<double>(b_5[i].imag()), i, static_cast<double>(c_5[i].real()), static_cast<double>(c_5[i].imag()));
       printfQuda("setup_use_mma = %d\n", setup_use_mma);
       printfQuda("dslash_use_mma = %d\n", dslash_use_mma);
-      printfQuda("allow_truncation = %d\n", allow_truncation);
+     printfQuda("allow_truncation = %d\n", allow_truncation);
       printfQuda("use_mobius_fused_kernel = %s\n", use_mobius_fused_kernel ? "true" : "false");
     }
   };
@@ -169,8 +168,8 @@ namespace quda {
 
   protected:
     GaugeField *gauge;
-    double kappa;
-    double mass;
+    real_t kappa;
+    real_t mass;
     int laplace3D;
     QudaMatPCType matpcType;
     mutable QudaDagType dagger; // mutable to simplify implementation of Mdag
@@ -242,13 +241,13 @@ namespace quda {
        @brief Xpay version of Dslash
     */
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const = 0;
+                            const ColorSpinorField &x, const real_t &k) const = 0;
 
     /**
        @brief Xpay version of Dslash
     */
     virtual void DslashXpay(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &in,
-                            QudaParity parity, cvector_ref<const ColorSpinorField> &x, double k) const
+                            QudaParity parity, cvector_ref<const ColorSpinorField> &x, real_t k) const
     {
       for (auto i = 0u; i < in.size(); i++) DslashXpay(out[i], in[i], parity, x[i], k);
     }
@@ -258,7 +257,7 @@ namespace quda {
        smearing.
     */    
     virtual void SmearOp(ColorSpinorField &, const ColorSpinorField &, 
-                         const double, const double, const int, const QudaParity) const
+                         const real_t, const real_t, const int, const QudaParity) const
     {
       errorQuda("Not implemented.");
     }
@@ -371,7 +370,7 @@ namespace quda {
     */
     virtual bool hasSpecialMG() const { return false; }
 
-    void setMass(double mass){ this->mass = mass;}
+    void setMass(real_t mass){ this->mass = mass;}
 
     // Dirac operator factory
     /**
@@ -382,22 +381,22 @@ namespace quda {
     /**
        @brief accessor for Kappa (mass parameter)
     */
-    double Kappa() const { return kappa; }
+    real_t Kappa() const { return kappa; }
 
     /**
        @brief accessor for Mass (in case of a factor of 2 for staggered)
     */
-    virtual double Mass() const { return mass; } // in case of factor of 2 convention for staggered
+    virtual real_t Mass() const { return mass; } // in case of factor of 2 convention for staggered
 
     /**
        @brief accessor for twist parameter -- overrride can return better value
     */
-    virtual double Mu() const { return 0.; }
+    virtual real_t Mu() const { return 0.; }
 
     /**
        @brief accessor for mu factoo for MG/ -- override can return a better value
     */
-    virtual double MuFactor() const { return 0.; }
+    virtual real_t MuFactor() const { return 0.; }
 
     /**
        @brief accessor for if we let MG coarsening drop we can drop improvements, for ex long links for small aggregation dimensions
@@ -495,7 +494,7 @@ namespace quda {
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, for ex dropping long links for
      * small aggregate sizes
      */
-    virtual void createCoarseOp(GaugeField &, GaugeField &, const Transfer &, double, double, double, double, bool) const
+    virtual void createCoarseOp(GaugeField &, GaugeField &, const Transfer &, real_t, real_t, real_t, real_t, bool) const
     {errorQuda("Not implemented");}
 
     QudaPrecision HaloPrecision() const { return halo_precision; }
@@ -527,7 +526,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const;
+                            const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -556,8 +555,8 @@ namespace quda {
      * @param kappa Kappa parameter for the coarse operator
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for Wilson operator
      */
-    virtual void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass = 0.,
-                                double mu = 0., double mu_factor = 0., bool allow_truncation = false) const;
+    virtual void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass = 0.,
+                                real_t mu = 0., real_t mu_factor = 0., bool allow_truncation = false) const;
   };
 
   // Even-odd preconditioned Wilson
@@ -601,7 +600,7 @@ namespace quda {
     void Clover(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
 
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-			    const ColorSpinorField &x, const double &k) const;
+			    const ColorSpinorField &x, const real_t &k) const;
 
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -646,8 +645,8 @@ namespace quda {
      * @param mass Mass parameter for the coarse operator (hard coded to 0 when CoarseOp is called)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for clover operator
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass = 0., double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass = 0., real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -678,7 +677,7 @@ namespace quda {
 
     // out = x + k A_pp^{-1} D_p\bar{p}
     void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                    const ColorSpinorField &x, const double &k) const;
+                    const ColorSpinorField &x, const real_t &k) const;
 
     // Can implement: M as e.g. :  i) tmp_e = A^{-1}_ee D_eo in_o  (Dslash)
     //                            ii) out_o = in_o + A_oo^{-1} D_oe tmp_e (AXPY)
@@ -708,8 +707,8 @@ namespace quda {
      * @param mass Mass parameter for the coarse operator (set to zero)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for clover operator
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass = 0., double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass = 0., real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -734,7 +733,7 @@ namespace quda {
   {
 
   protected:
-    double mu;
+    real_t mu;
 
   public:
     DiracCloverHasenbuschTwist(const DiracParam &param);
@@ -757,15 +756,15 @@ namespace quda {
      * @param mass Mass parameter for the coarse operator (hard coded to 0 when CoarseOp is called)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for clover
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass = 0., double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass = 0., real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
   };
 
   // Even-odd preconditioned clover
   class DiracCloverHasenbuschTwistPC : public DiracCloverPC
   {
   protected:
-    double mu;
+    real_t mu;
 
   public:
     DiracCloverHasenbuschTwistPC(const DiracParam &param);
@@ -783,11 +782,11 @@ namespace quda {
 
     // out = (1 +/- ig5 mu A)x  + k A^{-1} D in
     void DslashXpayTwistClovInv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                const ColorSpinorField &x, const double &k, const double &b) const;
+                                const ColorSpinorField &x, const real_t &k, const real_t &b) const;
 
     // out = ( 1+/- i g5 mu A) x - D in
     void DslashXpayTwistNoClovInv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                  const ColorSpinorField &x, const double &k, const double &b) const;
+                                  const ColorSpinorField &x, const real_t &k, const real_t &b) const;
 
     // Can implement: M as e.g. :  i) tmp_e = A^{-1}_ee D_eo in_o  (Dslash)
     //                            ii) out_o = in_o + A_oo^{-1} D_oe tmp_e (AXPY)
@@ -811,16 +810,16 @@ namespace quda {
      * @param mass Mass parameter for the coarse operator (set to zero)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for clover hasenbusch
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass = 0., double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass = 0., real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
   };
 
   // Full domain wall
   class DiracDomainWall : public DiracWilson {
 
   protected:
-    double m5;
-    double kappa5;
+    real_t m5;
+    real_t kappa5;
     int Ls; // length of the fifth dimension
 
     /**
@@ -836,7 +835,7 @@ namespace quda {
 
     void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                    const ColorSpinorField &x, const double &k) const;
+                    const ColorSpinorField &x, const real_t &k) const;
 
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -886,8 +885,8 @@ namespace quda {
     void Dslash4(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     void Dslash5(ColorSpinorField &out, const ColorSpinorField &in) const;
     void Dslash4Xpay(ColorSpinorField &out, const ColorSpinorField &in,
-		     const QudaParity parity, const ColorSpinorField &x, const double &k) const;
-    void Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const double &k) const;
+		     const QudaParity parity, const ColorSpinorField &x, const real_t &k) const;
+    void Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const real_t &k) const;
 
     void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -910,7 +909,7 @@ namespace quda {
     DiracDomainWall4DPC &operator=(const DiracDomainWall4DPC &dirac);
 
     void M5inv(ColorSpinorField &out, const ColorSpinorField &in) const;
-    void M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const double &k) const;
+    void M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const real_t &k) const;
 
     void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -928,8 +927,8 @@ namespace quda {
 
   protected:
     //Mobius coefficients
-      Complex b_5[QUDA_MAX_DWF_LS];
-      Complex c_5[QUDA_MAX_DWF_LS];
+      complex_t b_5[QUDA_MAX_DWF_LS];
+      complex_t c_5[QUDA_MAX_DWF_LS];
 
       /**
          Whether we are using classical Mobius with constant real-valued
@@ -938,9 +937,9 @@ namespace quda {
       */
       bool zMobius;
 
-      double mobius_kappa_b;
-      double mobius_kappa_c;
-      double mobius_kappa;
+      real_t mobius_kappa_b;
+      real_t mobius_kappa_c;
+      real_t mobius_kappa;
 
       /**
         @brief Check whether the input and output are valid 5D fields. If zMobius, we require that they
@@ -959,11 +958,11 @@ namespace quda {
       void Dslash5(ColorSpinorField &out, const ColorSpinorField &in) const;
 
       void Dslash4Xpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                       const ColorSpinorField &x, const double &k) const;
+                       const ColorSpinorField &x, const real_t &k) const;
       void Dslash4preXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                          const double &k) const;
+                          const real_t &k) const;
       void Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                       const double &k) const;
+                       const real_t &k) const;
 
       virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
       virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -989,20 +988,20 @@ namespace quda {
     DiracMobiusPC& operator=(const DiracMobiusPC &dirac);
 
     void M5inv(ColorSpinorField &out, const ColorSpinorField &in) const;
-    void M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const double &k) const;
+    void M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const real_t &k) const;
 
     void Dslash4M5invM5pre(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     void Dslash4M5preM5inv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     void Dslash4M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                          const ColorSpinorField &x, const double &a) const;
+                          const ColorSpinorField &x, const real_t &a) const;
     void Dslash4M5preXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                          const ColorSpinorField &x, const double &a) const;
+                          const ColorSpinorField &x, const real_t &a) const;
     void Dslash4XpayM5mob(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                          const ColorSpinorField &x, const double &a) const;
+                          const ColorSpinorField &x, const real_t &a) const;
     void Dslash4M5preXpayM5mob(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                               const ColorSpinorField &x, const double &a) const;
+                               const ColorSpinorField &x, const real_t &a) const;
     void Dslash4M5invXpayM5inv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                               const ColorSpinorField &x, const double &a, ColorSpinorField &y) const;
+                               const ColorSpinorField &x, const real_t &a, ColorSpinorField &y) const;
 
     void MdagMLocal(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1023,16 +1022,16 @@ namespace quda {
 
   protected:
     // The EOFA parameters
-    double m5inv_fac = 0.;
-    double sherman_morrison_fac = 0.;
-    double eofa_shift;
+    real_t m5inv_fac = 0.;
+    real_t sherman_morrison_fac = 0.;
+    real_t eofa_shift;
     int eofa_pm;
-    double mq1;
-    double mq2;
-    double mq3;
-    double eofa_u[QUDA_MAX_DWF_LS];
-    double eofa_x[QUDA_MAX_DWF_LS];
-    double eofa_y[QUDA_MAX_DWF_LS];
+    real_t mq1;
+    real_t mq2;
+    real_t mq3;
+    real_t eofa_u[QUDA_MAX_DWF_LS];
+    real_t eofa_x[QUDA_MAX_DWF_LS];
+    real_t eofa_y[QUDA_MAX_DWF_LS];
 
     /**
       @brief Check whether the input and output are valid 5D fields, and we require that they
@@ -1044,7 +1043,7 @@ namespace quda {
     DiracMobiusEofa(const DiracParam &param);
 
     void m5_eofa(ColorSpinorField &out, const ColorSpinorField &in) const;
-    void m5_eofa_xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double a = -1.) const;
+    void m5_eofa_xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t a = -1.) const;
 
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -1065,7 +1064,7 @@ namespace quda {
 
     void m5inv_eofa(ColorSpinorField &out, const ColorSpinorField &in) const;
     void m5inv_eofa_xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                         double a = -1.) const;
+                         real_t a = -1.) const;
 
     void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -1086,12 +1085,12 @@ namespace quda {
   class DiracTwistedMass : public DiracWilson {
 
   protected:
-      mutable double mu;
-      mutable double epsilon;
+      mutable real_t mu;
+      mutable real_t epsilon;
       void twistedApply(ColorSpinorField &out, const ColorSpinorField &in, const QudaTwistGamma5Type twistType) const;
       virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity) const;
       virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity,
-          const ColorSpinorField &x, const double &k) const;
+          const ColorSpinorField &x, const real_t &k) const;
 
   public:
     DiracTwistedMass(const DiracTwistedMass &dirac);
@@ -1112,7 +1111,7 @@ namespace quda {
 
     virtual QudaDiracType getDiracType() const { return QUDA_TWISTED_MASS_DIRAC; }
 
-    double Mu() const { return mu; }
+    real_t Mu() const { return mu; }
 
     /**
      * @brief Create the coarse twisted-mass operator
@@ -1134,8 +1133,8 @@ namespace quda {
      * @param mu_factor multiplicative factor for the mu parameter
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for twisted mass
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor = 0., bool allow_trunation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor = 0., bool allow_trunation = false) const;
   };
 
   // Even-odd preconditioned twisted mass
@@ -1152,7 +1151,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const;
+                            const ColorSpinorField &x, const real_t &k) const;
     void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1177,17 +1176,17 @@ namespace quda {
      * @param mu_factor multiplicative factor for the mu parameter
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for twisted mass
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
   };
 
   // Full twisted mass with a clover term
   class DiracTwistedClover : public DiracWilson {
 
   protected:
-    double mu;
-    double epsilon;
-    double tm_rho;
+    real_t mu;
+    real_t epsilon;
+    real_t tm_rho;
     CloverField *clover;
     void checkParitySpinor(const ColorSpinorField &, const ColorSpinorField &) const;
     void twistedCloverApply(ColorSpinorField &out, const ColorSpinorField &in, const QudaTwistGamma5Type twistType,
@@ -1203,7 +1202,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-        const ColorSpinorField &x, const double &k) const;
+        const ColorSpinorField &x, const real_t &k) const;
 
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
@@ -1216,7 +1215,7 @@ namespace quda {
 
     virtual QudaDiracType getDiracType() const { return QUDA_TWISTED_CLOVER_DIRAC; }
 
-    double Mu() const { return mu; }
+    real_t Mu() const { return mu; }
 
     /**
      *  @brief Update the internal gauge, fat gauge, long gauge, clover field pointer as appropriate.
@@ -1253,8 +1252,8 @@ namespace quda {
      * @param mu_factor multiplicative factor for the mu parameter
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for twisted clover
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -1281,19 +1280,19 @@ namespace quda {
     void TwistCloverInv(ColorSpinorField &out, const ColorSpinorField &in, const int parity) const;
 
     /**
-       @brief Convenience wrapper for single/doublet
+       @brief Convenience wrapper for single/real_tt
      */
     void WilsonDslash(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity) const;
 
     /**
-       @brief Convenience wrapper for single/doublet
+       @brief Convenience wrapper for single/real_tt
      */
     void WilsonDslashXpay(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity,
-                          const ColorSpinorField &x, double k) const;
+                          const ColorSpinorField &x, real_t k) const;
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-        const ColorSpinorField &x, const double &k) const;
+        const ColorSpinorField &x, const real_t &k) const;
     void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1320,8 +1319,8 @@ namespace quda {
      * @param mu_factor multiplicative factor for the mu parameter
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for twisted clover
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -1348,7 +1347,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const;
+                            const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1388,8 +1387,8 @@ namespace quda {
      * @param mu_factor Mu scaling factor for the coarse operator (ignored for staggered)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for staggered
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
      * @brief Create two-link staggered quark smearing operator
@@ -1401,7 +1400,7 @@ namespace quda {
      * @param[in] t0 time-slice index
      * @param[in] parity Parity flag
      */
-    void SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const double a, const double b, const int t0, const QudaParity parity) const;
+    void SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const real_t a, const real_t b, const int t0, const QudaParity parity) const;
   };
 
   // Even-odd preconditioned staggered
@@ -1449,8 +1448,8 @@ namespace quda {
      * @param mu_factor Mu scaling factor for the coarse operator (ignored for staggered)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for staggered
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
   };
 
   // Kahler-Dirac preconditioned staggered
@@ -1472,7 +1471,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const;
+                            const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1522,8 +1521,8 @@ namespace quda {
      * @param mu_factor Mu scaling factor for the coarse operator (ignored for staggered)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for staggered
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu = 0.,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu = 0.,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -1552,7 +1551,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const;
+                            const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1616,8 +1615,8 @@ namespace quda {
      * @param mu_factor Mu scaling factor for the coarse operator (ignored for staggered)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, dropping long links here
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor, bool allow_truncation) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor, bool allow_truncation) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -1638,7 +1637,7 @@ namespace quda {
      * @param[in] t0 time-slice index
      * @param[in] parity Parity flag
      */   
-    void SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const double a, const double b, const int t0, const QudaParity parity) const;
+    void SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const real_t a, const real_t b, const int t0, const QudaParity parity) const;
   };
 
   // Even-odd preconditioned staggered
@@ -1686,8 +1685,8 @@ namespace quda {
      * @param mu_factor Mu scaling factor for the coarse operator (ignored for staggered)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, dropping long links here
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor, bool allow_truncation) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor, bool allow_truncation) const;
   };
 
   // Kahler-Dirac preconditioned staggered
@@ -1708,7 +1707,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const;
+                            const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -1758,8 +1757,8 @@ namespace quda {
      * @param mu_factor Mu scaling factor for the coarse operator (ignored for staggered)
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, dropping long for asqtad
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor, bool allow_truncation) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor, bool allow_truncation) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -1780,9 +1779,9 @@ namespace quda {
   class DiracCoarse : public Dirac {
 
   protected:
-    double mass;
-    double mu;
-    double mu_factor;
+    real_t mass;
+    real_t mu;
+    real_t mu_factor;
     const Transfer *transfer; /** restrictor / prolongator defined here */
     const Dirac *dirac; /** Parent Dirac operator */
     const bool need_bidirectional; /** Whether or not to force a bi-directional build */
@@ -1839,9 +1838,9 @@ namespace quda {
     void createYhat(bool gpu = true) const;
 
   public:
-    double Mass() const { return mass; }
-    double Mu() const { return mu; }
-    double MuFactor() const { return mu_factor; }
+    real_t Mass() const { return mass; }
+    real_t Mu() const { return mu; }
+    real_t MuFactor() const { return mu_factor; }
     bool AllowTruncation() const { return allow_truncation; }
 
     /**
@@ -1915,10 +1914,10 @@ namespace quda {
        @param[in] k scalar multiplier
      */
     virtual void DslashXpay(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &in,
-                            QudaParity parity, cvector_ref<const ColorSpinorField> &x, double k) const;
+                            QudaParity parity, cvector_ref<const ColorSpinorField> &x, real_t k) const;
 
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                            const ColorSpinorField &x, const double &k) const
+                            const ColorSpinorField &x, const real_t &k) const
     {
       DslashXpay(cvector_ref<ColorSpinorField> {out}, cvector_ref<const ColorSpinorField> {in}, parity,
                  cvector_ref<const ColorSpinorField> {x}, k);
@@ -1973,8 +1972,8 @@ namespace quda {
      * @param mu_factor multiplicative factor for the mu parameter
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for coarse op
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
      * @brief Create the precondtioned coarse operator
@@ -2062,10 +2061,10 @@ namespace quda {
        @param[in] k scalar multiplier
      */
     void DslashXpay(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &in, QudaParity parity,
-                    cvector_ref<const ColorSpinorField> &x, double k) const;
+                    cvector_ref<const ColorSpinorField> &x, real_t k) const;
 
     void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                    const ColorSpinorField &x, const double &k) const
+                    const ColorSpinorField &x, const real_t &k) const
     {
       DslashXpay(cvector_ref<ColorSpinorField> {out}, cvector_ref<const ColorSpinorField> {in}, parity,
                  cvector_ref<const ColorSpinorField> {x}, k);
@@ -2116,8 +2115,8 @@ namespace quda {
      * @param mu_factor multiplicative factor for the mu parameter
      * @param allow_truncation [in] whether or not we let coarsening drop improvements, none available for coarse op
      */
-    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double mass, double mu,
-                        double mu_factor = 0., bool allow_truncation = false) const;
+    void createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t mass, real_t mu,
+                        real_t mu_factor = 0., bool allow_truncation = false) const;
 
     /**
       @brief If managed memory and prefetch is enabled, prefetch
@@ -2146,7 +2145,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
-			    const QudaParity parity, const ColorSpinorField &x, const double &k) const;
+			    const QudaParity parity, const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -2204,7 +2203,7 @@ namespace quda {
 
     virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
     virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
-			    const QudaParity parity, const ColorSpinorField &x, const double &k) const;
+			    const QudaParity parity, const ColorSpinorField &x, const real_t &k) const;
     virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
     virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
 
@@ -2301,7 +2300,7 @@ namespace quda {
     const Dirac *Expose() const { return dirac; }
 
     //! Shift term added onto operator (M/M^dag M/M M^dag + shift)
-    double shift;
+    real_t shift;
   };
 
   class DiracM : public DiracMatrix
diff --git a/include/dslash_quda.h b/include/dslash_quda.h
index ea12741be0..f78c56a9b6 100644
--- a/include/dslash_quda.h
+++ b/include/dslash_quda.h
@@ -81,7 +81,7 @@ namespace quda
      @param[in] comm_override Override for which dimensions are partitioned
      @param[in] profile The TimeProfile used for profiling the dslash
   */
-  void ApplyWilson(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double kappa,
+  void ApplyWilson(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t kappa,
                    const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
@@ -107,7 +107,7 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
   void ApplyWilsonClover(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-      double kappa, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
+      real_t kappa, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
        @brief Driver for applying the Wilson-clover stencil
@@ -133,7 +133,7 @@ namespace quda
        @param[in] profile The TimeProfile used for profiling the dslash
     */
   void ApplyWilsonCloverHasenbuschTwist(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                        const CloverField &A, double kappa, double mu, const ColorSpinorField &x,
+                                        const CloverField &A, real_t kappa, real_t mu, const ColorSpinorField &x,
                                         int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
@@ -174,7 +174,7 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
   void ApplyWilsonCloverPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-      const CloverField &A, double kappa, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+      const CloverField &A, real_t kappa, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
       TimeProfile &profile);
 
   /**
@@ -223,7 +223,7 @@ namespace quda
         @param[in] profile The TimeProfile used for profiling the dslash
      */
   void ApplyWilsonCloverHasenbuschTwistPCClovInv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                                 const CloverField &A, double kappa, double mu,
+                                                 const CloverField &A, real_t kappa, real_t mu,
                                                  const ColorSpinorField &x, int parity, bool dagger,
                                                  const int *comm_override, TimeProfile &profile);
 
@@ -251,12 +251,12 @@ namespace quda
         @param[in] profile The TimeProfile used for profiling the dslash
      */
   void ApplyWilsonCloverHasenbuschTwistPCNoClovInv(ColorSpinorField &out, const ColorSpinorField &in,
-                                                   const GaugeField &U, const CloverField &A, double kappa, double mu,
+                                                   const GaugeField &U, const CloverField &A, real_t kappa, real_t mu,
                                                    const ColorSpinorField &x, int parity, bool dagger,
                                                    const int *comm_override, TimeProfile &profile);
 
   // old
-  void ApplyTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
+  void ApplyTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
                         const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                         TimeProfile &profile);
 
@@ -296,8 +296,8 @@ namespace quda
      @param[in] comm_override Override for which dimensions are partitioned
      @param[in] profile The TimeProfile used for profiling the dslash
   */
-  void ApplyTwistedMassPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-      double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
+  void ApplyTwistedMassPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+      real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
       const int *comm_override, TimeProfile &profile);
 
   /**
@@ -327,8 +327,8 @@ namespace quda
      @param[in] comm_override Override for which dimensions are partitioned
      @param[in] profile The TimeProfile used for profiling the dslash
   */
-  void ApplyNdegTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
-      double c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
+  void ApplyNdegTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
+      real_t c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
      @brief Driver for applying the preconditioned non-degenerate
@@ -377,7 +377,7 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
   void ApplyNdegTwistedMassPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-      double a, double b, double c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
+      real_t a, real_t b, real_t c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
       const int *comm_override, TimeProfile &profile);
 
   /**
@@ -404,7 +404,7 @@ namespace quda
        @param[in] profile The TimeProfile used for profiling the dslash
     */
   void ApplyTwistedClover(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &C,
-      double a, double b, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+      real_t a, real_t b, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
       TimeProfile &profile);
 
   /**
@@ -445,7 +445,7 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
   void ApplyTwistedCloverPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-      const CloverField &C, double a, double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
+      const CloverField &C, real_t a, real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
       const int *comm_override, TimeProfile &profile);
 
   /**
@@ -477,7 +477,7 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
   void ApplyNdegTwistedClover(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                              const CloverField &C, double a, double b, double c, const ColorSpinorField &x, int parity,
+                              const CloverField &C, real_t a, real_t b, real_t c, const ColorSpinorField &x, int parity,
                               bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
@@ -519,7 +519,7 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
   void ApplyNdegTwistedCloverPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                            const CloverField &C, double a, double b, double c, bool xpay,
+                                            const CloverField &C, real_t a, real_t b, real_t c, bool xpay,
                                             const ColorSpinorField &x, int parity, bool dagger,
                                             const int *comm_override, TimeProfile &profile);
 
@@ -547,7 +547,7 @@ namespace quda
      @param[in] comm_override Override for which dimensions are partitioned
      @param[in] profile The TimeProfile used for profiling the dslash
   */
-  void ApplyDomainWall5D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_f,
+  void ApplyDomainWall5D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_f,
       const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
@@ -576,43 +576,43 @@ namespace quda
      @param[in] profile The TimeProfile used for profiling the dslash
   */
 
-  void ApplyDomainWall4D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_5,
-                         const Complex *b_5, const Complex *c_5, const ColorSpinorField &x, int parity, bool dagger,
+  void ApplyDomainWall4D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_5,
+                         const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x, int parity, bool dagger,
                          const int *comm_override, TimeProfile &profile);
 
-  void ApplyDomainWall4DM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                              double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                              real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                               TimeProfile &profile);
 
-  void ApplyDomainWall4DM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                              double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                              real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                               TimeProfile &profile);
 
-  void ApplyDomainWall4DM5invM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5invM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile);
 
-  void ApplyDomainWall4DM5preM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5preM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile);
 
-  void ApplyDomainWall4DM5invM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5invM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile);
 
-  void ApplyDomainWall4DM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                              double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                              real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                               TimeProfile &profile);
 
-  void ApplyDomainWall4DM5preM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5preM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile);
   /**
      @brief Apply either the domain-wall / mobius Dslash5 operator or
@@ -629,16 +629,16 @@ namespace quda
      @param[in] dagger Whether this is for the dagger operator
      @param[in] type Type of dslash we are applying
   */
-  void ApplyDslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double m_f,
-                    double m_5, const Complex *b_5, const Complex *c_5, double a, bool dagger, Dslash5Type type);
+  void ApplyDslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t m_f,
+                    real_t m_5, const complex_t *b_5, const complex_t *c_5, real_t a, bool dagger, Dslash5Type type);
 
   // The EOFA stuff
   namespace mobius_eofa
   {
-    void apply_dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double m_f,
-                       double m_5, const Complex *b_5, const Complex *c_5, double a, int eofa_pm, double inv,
-                       double kappa, const double *eofa_u, const double *eofa_x, const double *eofa_y,
-                       double sherman_morrison, bool dagger, Dslash5Type type);
+    void apply_dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t m_f,
+                       real_t m_5, const complex_t *b_5, const complex_t *c_5, real_t a, int eofa_pm, real_t inv,
+                       real_t kappa, const real_t *eofa_u, const real_t *eofa_x, const real_t *eofa_y,
+                       real_t sherman_morrison, bool dagger, Dslash5Type type);
   }
 
   /**
@@ -660,7 +660,7 @@ namespace quda
      @param[in] b Scale factor applied to aux field
      @param[in] x Vector field we accumulate onto to
   */
-  void ApplyLaplace(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir, double a, double b,
+  void ApplyLaplace(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir, real_t a, real_t b,
                     const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
@@ -707,7 +707,7 @@ namespace quda
      @param[in] dagger Whether we are applying the dagger or not
      @param[in] improved whether to apply the standard-staggered (false) or asqtad (true) operator
   */
-  void ApplyStaggered(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
+  void ApplyStaggered(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
                       const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile);
 
   /**
@@ -723,7 +723,7 @@ namespace quda
      @param[in] improved whether to apply the standard-staggered (false) or asqtad (true) operator
   */
   void ApplyImprovedStaggered(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                              const GaugeField &L, double a, const ColorSpinorField &x, int parity, bool dagger,
+                              const GaugeField &L, real_t a, const ColorSpinorField &x, int parity, bool dagger,
                               const int *comm_override, TimeProfile &profile);
                               
   /**
@@ -763,8 +763,8 @@ namespace quda
      @param[in] dagger Whether we are applying the dagger or not
      @param[in] twist The type of kernel we are doing
   */
-  void ApplyTwistGamma(ColorSpinorField &out, const ColorSpinorField &in, int d, double kappa, double mu,
-		       double epsilon, int dagger, QudaTwistGamma5Type type);
+  void ApplyTwistGamma(ColorSpinorField &out, const ColorSpinorField &in, int d, real_t kappa, real_t mu,
+		       real_t epsilon, int dagger, QudaTwistGamma5Type type);
 
   /**
      @brief Apply twisted clover-matrix field to a color-spinor field
@@ -781,7 +781,7 @@ namespace quda
        else if (twist == QUDA_TWIST_GAMMA5_INVERSE) apply (Clover + i*a*gamma_5)/(Clover^2 + a^2) to the input spinor
   */
   void ApplyTwistClover(ColorSpinorField &out, const ColorSpinorField &in, const CloverField &clover,
-			double kappa, double mu, double epsilon, int parity, int dagger, QudaTwistGamma5Type twist);
+			real_t kappa, real_t mu, real_t epsilon, int parity, int dagger, QudaTwistGamma5Type twist);
 
   /**
      @brief Dslash face packing routine
@@ -798,7 +798,7 @@ namespace quda
      @param[in] stream Which stream are we executing in
   */
   void PackGhost(void *ghost[2 * QUDA_MAX_DIM], const ColorSpinorField &field, MemoryLocation location, int nFace,
-                 bool dagger, int parity, bool spin_project, double a, double b, double c, int shmem,
+                 bool dagger, int parity, bool spin_project, real_t a, real_t b, real_t c, int shmem,
                  const qudaStream_t &stream);
 
   /**
diff --git a/include/eigensolve_quda.h b/include/eigensolve_quda.h
index 06472f069b..f615aa8b11 100644
--- a/include/eigensolve_quda.h
+++ b/include/eigensolve_quda.h
@@ -28,7 +28,7 @@ namespace quda
     int n_kr;         /** Size of Krylov space after extension */
     int n_conv;       /** Number of converged eigenvalues requested */
     int n_ev_deflate; /** Number of converged eigenvalues to use in deflation */
-    double tol;       /** Tolerance on eigenvalues */
+    real_t tol;       /** Tolerance on eigenvalues */
     bool reverse;     /** True if using polynomial acceleration */
     char spectrum[3]; /** Part of the spectrum to be computed */
     bool compute_svd; /** Compute the SVD if requested **/
@@ -51,7 +51,7 @@ namespace quda
     int num_locked;
     int num_keep;
 
-    std::vector<double> residua;
+    std::vector<real_t> residua;
 
     // Device side vector workspace
     std::vector<ColorSpinorField> r;
@@ -82,7 +82,7 @@ namespace quda
        @param kSpace The converged eigenvectors
        @param evals The converged eigenvalues
      */
-    virtual void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals) = 0;
+    virtual void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals) = 0;
 
     /**
        @brief Creates the eigensolver using the parameters given and the matrix.
@@ -110,7 +110,7 @@ namespace quda
        @param[in] kSpace The Krylov space vectors
        @param[in] evals The eigenvalue array
     */
-    void prepareKrylovSpace(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals);
+    void prepareKrylovSpace(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals);
 
     /**
        @brief Set the epsilon parameter
@@ -135,7 +135,7 @@ namespace quda
        @param[in] kSpace The Krylov space vectors
        @param[in] evals The eigenvalue array
     */
-    void cleanUpEigensolver(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals);
+    void cleanUpEigensolver(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals);
 
     /**
        @brief Promoted the specified matVec operation:
@@ -151,7 +151,7 @@ namespace quda
        @param[in] out Output spinor
        @param[in] in Input spinor
     */
-    double estimateChebyOpMax(ColorSpinorField &out, ColorSpinorField &in);
+    real_t estimateChebyOpMax(ColorSpinorField &out, ColorSpinorField &in);
 
     /**
        @brief Orthogonalise input vectors r against
@@ -240,7 +240,7 @@ namespace quda
        @param[in] accumulate Whether to preserve the sol vector content prior to accumulating
     */
     void deflate(cvector_ref<ColorSpinorField> &sol, cvector_ref<const ColorSpinorField> &src,
-                 cvector_ref<const ColorSpinorField> &evecs, const std::vector<Complex> &evals,
+                 cvector_ref<const ColorSpinorField> &evecs, const std::vector<complex_t> &evals,
                  bool accumulate = false) const;
 
     /**
@@ -253,7 +253,7 @@ namespace quda
        @param[in] accumulate Whether to preserve the sol vector content prior to accumulating
     */
     void deflateSVD(cvector_ref<ColorSpinorField> &sol, cvector_ref<const ColorSpinorField> &vec,
-                    cvector_ref<const ColorSpinorField> &evecs, const std::vector<Complex> &evals,
+                    cvector_ref<const ColorSpinorField> &evecs, const std::vector<complex_t> &evals,
                     bool accumulate = false) const;
 
     /**
@@ -261,7 +261,7 @@ namespace quda
        @param[in] evecs Computed eigenvectors of NormOp
        @param[in] evals Computed eigenvalues of NormOp
     */
-    void computeSVD(std::vector<ColorSpinorField> &evecs, std::vector<Complex> &evals);
+    void computeSVD(std::vector<ColorSpinorField> &evecs, std::vector<complex_t> &evals);
 
     /**
        @brief Compute eigenvalues and their residiua
@@ -270,8 +270,7 @@ namespace quda
        @param[in] evals The eigenvalues
        @param[in] size The number of eigenvalues to compute
     */
-    void computeEvals(std::vector<ColorSpinorField> &evecs, std::vector<Complex> &evals,
-                      int size);
+    void computeEvals(std::vector<ColorSpinorField> &evecs, std::vector<complex_t> &evals, int size);
 
     /**
        @brief Compute eigenvalues and their residiua.  This variant compute the number of converged eigenvalues.
@@ -279,7 +278,7 @@ namespace quda
        @param[in] evecs The eigenvectors
        @param[in] evals The eigenvalues
     */
-    void computeEvals(std::vector<ColorSpinorField> &evecs, std::vector<Complex> &evals)
+    void computeEvals(std::vector<ColorSpinorField> &evecs, std::vector<complex_t> &evals)
     {
       computeEvals(evecs, evals, n_conv);
     }
@@ -290,7 +289,7 @@ namespace quda
        @param[in] eig_vecs The eigenvectors to save
        @param[in] file The filename to save
     */
-    void loadFromFile(std::vector<ColorSpinorField> &eig_vecs, std::vector<Complex> &evals);
+    void loadFromFile(std::vector<ColorSpinorField> &eig_vecs, std::vector<complex_t> &evals);
 
     /**
        @brief Sort array the first n elements of x according to spec_type, y comes along for the ride
@@ -299,7 +298,7 @@ namespace quda
        @param[in] x The array to sort
        @param[in] y An array whose elements will be permuted in tandem with x
     */
-    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<Complex> &x, std::vector<Complex> &y);
+    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<complex_t> &x, std::vector<complex_t> &y);
 
     /**
        @brief Sort array the first n elements of x according to spec_type, y comes along for the ride
@@ -309,7 +308,7 @@ namespace quda
        @param[in] x The array to sort
        @param[in] y An array whose elements will be permuted in tandem with x
     */
-    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<double> &x, std::vector<Complex> &y);
+    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<real_t> &x, std::vector<complex_t> &y);
 
     /**
        @brief Sort array the first n elements of x according to spec_type, y comes along for the ride
@@ -319,7 +318,7 @@ namespace quda
        @param[in] x The array to sort
        @param[in] y An array whose elements will be permuted in tandem with x
     */
-    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<Complex> &x, std::vector<double> &y);
+    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<complex_t> &x, std::vector<real_t> &y);
 
     /**
        @brief Sort array the first n elements of x according to spec_type, y comes along for the ride
@@ -330,7 +329,7 @@ namespace quda
        @param[in] x The array to sort
        @param[in] y An array whose elements will be permuted in tandem with x
     */
-    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<double> &x, std::vector<double> &y);
+    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<real_t> &x, std::vector<real_t> &y);
 
     /**
        @brief Sort array the first n elements of x according to spec_type, y comes along for the ride
@@ -341,7 +340,7 @@ namespace quda
        @param[in] x The array to sort
        @param[in] y An array whose elements will be permuted in tandem with x
     */
-    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<Complex> &x, std::vector<int> &y);
+    void sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<complex_t> &x, std::vector<int> &y);
   };
 
   /**
@@ -365,18 +364,18 @@ namespace quda
     virtual bool hermitian() { return true; } /** TRLM is only for Hermitian systems */
 
     // Variable size matrix
-    std::vector<double> ritz_mat;
+    std::vector<real_t> ritz_mat;
 
     // Tridiagonal/Arrow matrix, fixed size.
-    std::vector<double> alpha;
-    std::vector<double> beta;
+    std::vector<real_t> alpha;
+    std::vector<real_t> beta;
 
     /**
        @brief Compute eigenpairs
        @param[in] kSpace Krylov vector space
        @param[in] evals Computed eigenvalues
     */
-    void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals);
+    void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals);
 
     /**
        @brief Lanczos step: extends the Krylov space.
@@ -421,14 +420,14 @@ namespace quda
     virtual bool hermitian() { return true; } /** (BLOCK)TRLM is only for Hermitian systems */
 
     // Variable size matrix
-    std::vector<Complex> block_ritz_mat;
+    std::vector<complex_t> block_ritz_mat;
 
     /** Block Tridiagonal/Arrow matrix, fixed size. */
-    std::vector<Complex> block_alpha;
-    std::vector<Complex> block_beta;
+    std::vector<complex_t> block_alpha;
+    std::vector<complex_t> block_beta;
 
     /** Temp storage used in blockLanczosStep, fixed size. */
-    std::vector<Complex> jth_block;
+    std::vector<complex_t> jth_block;
 
     /** Size of blocks of data in alpha/beta */
     int block_data_length;
@@ -438,7 +437,7 @@ namespace quda
        @param[in] kSpace Krylov vector space
        @param[in] evals Computed eigenvalues
     */
-    void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals);
+    void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals);
 
     /**
        @brief block lanczos step: extends the Krylov space in block step
@@ -474,9 +473,9 @@ namespace quda
   {
 
   public:
-    std::vector<std::vector<Complex>> upperHess;
-    std::vector<std::vector<Complex>> Qmat;
-    std::vector<std::vector<Complex>> Rmat;
+    std::vector<std::vector<complex_t>> upperHess;
+    std::vector<std::vector<complex_t>> Qmat;
+    std::vector<std::vector<complex_t>> Rmat;
 
     /**
        @brief Constructor for Thick Restarted Eigensolver class
@@ -496,7 +495,7 @@ namespace quda
        @param[in] kSpace Krylov vector space
        @param[in] evals Computed eigenvalues
     */
-    void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals);
+    void operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals);
 
     /**
        @brief Arnoldi step: extends the Krylov space by one vector
@@ -505,14 +504,14 @@ namespace quda
        @param[in] beta Norm of residual vector
        @param[in] j Index of vector being computed
     */
-    void arnoldiStep(std::vector<ColorSpinorField> &v, std::vector<ColorSpinorField> &r, double &beta, int j);
+    void arnoldiStep(std::vector<ColorSpinorField> &v, std::vector<ColorSpinorField> &r, real_t &beta, int j);
 
     /**
        @brief Get the eigendecomposition from the upper Hessenberg matrix via QR
-       @param[in] evals Complex eigenvalues
+       @param[in] evals complex_t eigenvalues
        @param[in] beta Norm of residual (used to compute errors on eigenvalues)
     */
-    void eigensolveFromUpperHess(std::vector<Complex> &evals, const double beta);
+    void eigensolveFromUpperHess(std::vector<complex_t> &evals, const real_t beta);
 
     /**
        @brief Rotate the Krylov space
@@ -526,14 +525,14 @@ namespace quda
        @param[in] evals The shifts to apply
        @param[in] num_shifts The number of shifts to apply
     */
-    void qrShifts(const std::vector<Complex> evals, const int num_shifts);
+    void qrShifts(const std::vector<complex_t> evals, const int num_shifts);
 
     /**
        @brief Apply One step of the the QR algorithm
        @param[in] Q The Q matrix
        @param[in] R The R matrix
     */
-    void qrIteration(std::vector<std::vector<Complex>> &Q, std::vector<std::vector<Complex>> &R);
+    void qrIteration(std::vector<std::vector<complex_t>> &Q, std::vector<std::vector<complex_t>> &R);
 
     /**
        @brief Reorder the Krylov space and eigenvalues
@@ -542,7 +541,7 @@ namespace quda
        @param[in] spec_type The spectrum type (Largest/Smallest)(Modulus/Imaginary/Real) that
        determines the sorting condition
     */
-    void reorder(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals,
+    void reorder(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals,
                  const QudaEigSpectrumType spec_type);
   };
 
@@ -561,7 +560,7 @@ namespace quda
      @param[in] eig_param Parameter structure for all QUDA eigensolvers
      @param[in,out] profile TimeProfile instance used for profiling
   */
-  void arpack_solve(std::vector<ColorSpinorField> &h_evecs, std::vector<Complex> &h_evals, const DiracMatrix &mat,
+  void arpack_solve(std::vector<ColorSpinorField> &h_evecs, std::vector<complex_t> &h_evals, const DiracMatrix &mat,
                     QudaEigParam *eig_param, TimeProfile &profile);
 
 } // namespace quda
diff --git a/include/float_vector.h b/include/float_vector.h
index 201d803c95..9bc39d021d 100644
--- a/include/float_vector.h
+++ b/include/float_vector.h
@@ -12,9 +12,19 @@
 #include <array.h>
 #include <limits>
 #include <type_traits>
+#include "dbldbl.h"
+#include "reproducible_floating_accumulator.hpp"
 
 namespace quda {
 
+#if defined(QUDA_REDUCTION_ALGORITHM_NAIVE)
+  using device_reduce_t = reduction_t;
+#elif defined(QUDA_REDUCTION_ALGORITHM_KAHAN)
+  using device_reduce_t = kahan_t<reduction_t>;
+#elif defined(QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE)
+  using device_reduce_t = rfa_t<reduction_t>;
+#endif
+
   __host__ __device__ inline double2 operator+(const double2 &x, const double2 &y)
   {
     return make_double2(x.x + y.x, x.y + y.y);
@@ -35,6 +45,15 @@ namespace quda {
     return make_float2(x.x + y.x, x.y + y.y);
   }
 
+#ifdef QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE
+  __host__ __device__ inline device_reduce_t operator+(const device_reduce_t &x, const device_reduce_t &y)
+  {
+    device_reduce_t z = x;
+    z.operator+=(y);
+    return z;
+  }
+#endif
+
   template <typename T, int n>
   __device__ __host__ inline array<T, n> operator+(const array<T, n> &a, const array<T, n> &b)
   {
@@ -44,80 +63,25 @@ namespace quda {
     return c;
   }
 
-  template <typename T> constexpr std::enable_if_t<std::is_arithmetic_v<T>, T> zero() { return static_cast<T>(0); }
-  template <typename T> constexpr std::enable_if_t<std::is_same_v<T, complex<typename T::value_type>>, T> zero()
-  {
-    return static_cast<T>(0);
-  }
-
-  template <typename T, typename U> using specialize = std::enable_if_t<std::is_same_v<T, U>, U>;
-
-  template <typename T> constexpr specialize<T, double2> zero() { return double2 {0.0, 0.0}; }
-  template <typename T> constexpr specialize<T, double3> zero() { return double3 {0.0, 0.0, 0.0}; }
-  template <typename T> constexpr specialize<T, double4> zero() { return double4 {0.0, 0.0, 0.0, 0.0}; }
-
-  template <typename T> constexpr specialize<T, float2> zero() { return float2 {0.0f, 0.0f}; }
-  template <typename T> constexpr specialize<T, float3> zero() { return float3 {0.0f, 0.0f, 0.0f}; }
-  template <typename T> constexpr specialize<T, float4> zero() { return float4 {0.0f, 0.0f, 0.0f, 0.0f}; }
-
-#ifdef QUAD_SUM
-  template <typename T> __device__ __host__ inline specialize<T, doubledouble> zero() { return doubledouble(); }
-  template <typename T> __device__ __host__ inline specialize<T, doubledouble2> zero() { return doubledouble2(); }
-  template <typename T> __device__ __host__ inline specialize<T, doubledouble3> zero() { return doubledouble3(); }
-#endif
-
-  template <typename T, int n> __device__ __host__ inline array<T, n> zero()
-  {
-    array<T, n> v;
-#pragma unroll
-    for (int i = 0; i < n; i++) v[i] = zero<T>();
-    return v;
-  }
-
-  // array of arithmetic types specialization
-  template <typename T>
-  __device__ __host__ inline std::enable_if_t<
-    std::is_same_v<T, array<typename T::value_type, T::N>> && std::is_arithmetic_v<typename T::value_type>, T>
-  zero()
-  {
-    return zero<typename T::value_type, T::N>();
-  }
-
-  // array of array specialization
-  template <typename T>
-  __device__ __host__ inline std::enable_if_t<
-    std::is_same_v<T, array<array<typename T::value_type::value_type, T::value_type::N>, T::N>>, T>
-  zero()
-  {
-    T v;
-#pragma unroll
-    for (int i = 0; i < v.size(); i++) v[i] = zero<typename T::value_type>();
-    return v;
-  }
-
-  // array of complex specialization
-  template <typename T>
-  __device__
-    __host__ inline std::enable_if_t<std::is_same_v<T, array<complex<typename T::value_type::value_type>, T::N>>, T>
-    zero()
-  {
-    T v;
-#pragma unroll
-    for (int i = 0; i < v.size(); i++) v[i] = zero<typename T::value_type>();
-    return v;
-  }
-
   /**
      Container used when we want to track the reference value when
      computing an infinity norm
    */
   template <typename T> struct deviation_t {
+    using value_type = T;
+
     T diff;
     T ref;
+
+    template <typename U> constexpr deviation_t<T> &operator=(const deviation_t<U> &other)
+    {
+      diff = T(other.diff);
+      ref = T(other.ref);
+      return *this;
+    }
   };
 
-  template <typename T> constexpr specialize<T, deviation_t<double>> zero() { return {0.0, 0.0}; }
-  template <typename T> constexpr specialize<T, deviation_t<float>> zero() { return {0.0f, 0.0f}; }
+  template <class T> struct get_scalar<deviation_t<T>> { using type = typename get_scalar<T>::type; };
 
   template <typename T> __host__ __device__ inline bool operator>(const deviation_t<T> &a, const deviation_t<T> &b)
   {
@@ -128,6 +92,10 @@ namespace quda {
     static constexpr std::enable_if_t<std::is_arithmetic_v<T>, T> value() { return std::numeric_limits<T>::lowest(); }
   };
 
+  template <> struct low<doubledouble> {
+    static constexpr doubledouble value() { return std::numeric_limits<double>::lowest(); }
+  };
+
   template <typename T, int N> struct low<array<T, N>> {
     static inline __host__ __device__ array<T, N> value()
     {
@@ -146,6 +114,10 @@ namespace quda {
     static constexpr std::enable_if_t<std::is_arithmetic_v<T>, T> value() { return std::numeric_limits<T>::max(); }
   };
 
+  template <> struct high<doubledouble> {
+    static constexpr doubledouble value() { return std::numeric_limits<double>::max(); }
+  };
+
   template <typename T> struct RealType {
   };
   template <> struct RealType<double> {
diff --git a/include/gauge_field.h b/include/gauge_field.h
index bf75bc6bfa..700466df70 100644
--- a/include/gauge_field.h
+++ b/include/gauge_field.h
@@ -46,8 +46,8 @@ namespace quda {
     QudaTboundary t_boundary = QUDA_INVALID_T_BOUNDARY;
     QudaReconstructType reconstruct = QUDA_RECONSTRUCT_NO;
 
-    double anisotropy = 1.0;
-    double tadpole = 1.0;
+    real_t anisotropy = 1.0;
+    real_t tadpole = 1.0;
     GaugeField *field = nullptr; // pointer to a pre-allocated field
     void *gauge = nullptr;       // used when we use a reference to an external field
 
@@ -67,7 +67,7 @@ namespace quda {
     bool staggeredPhaseApplied = false;
 
     /** Imaginary chemical potential */
-    double i_mu = 0.0;
+    real_t i_mu = 0.0;
 
     /** Offset into MILC site struct to the desired matrix field (only if gauge_order=MILC_SITE_GAUGE_ORDER) */
     size_t site_offset = 0;
@@ -188,9 +188,9 @@ namespace quda {
     QudaLinkType link_type = QUDA_INVALID_LINKS;
     QudaTboundary t_boundary = QUDA_INVALID_T_BOUNDARY;
 
-    double anisotropy = 0.0;
-    double tadpole = 0.0;
-    double fat_link_max = 0.0;
+    real_t anisotropy = 0.0;
+    real_t tadpole = 0.0;
+    real_t fat_link_max = 0.0;
 
     mutable array<quda_ptr, 2 *QUDA_MAX_DIM> ghost
       = {}; // stores the ghost zone of the gauge field (non-native fields only)
@@ -210,7 +210,7 @@ namespace quda {
     /**
        Imaginary chemical potential
     */
-    double i_mu = 0.0;
+    real_t i_mu = 0.0;
 
     /**
        Offset into MILC site struct to the desired matrix field (only if gauge_order=MILC_SITE_GAUGE_ORDER)
@@ -351,8 +351,8 @@ namespace quda {
     int Ncolor() const { return nColor; }
     QudaReconstructType Reconstruct() const { return reconstruct; }
     QudaGaugeFieldOrder Order() const { return order; }
-    double Anisotropy() const { return anisotropy; }
-    double Tadpole() const { return tadpole; }
+    real_t Anisotropy() const { return anisotropy; }
+    real_t Tadpole() const { return tadpole; }
     QudaTboundary TBoundary() const { return t_boundary; }
     QudaLinkType LinkType() const { return link_type; }
     QudaGaugeFixed GaugeFixed() const { return fixed; }
@@ -382,9 +382,9 @@ namespace quda {
     /**
        Return the imaginary chemical potential applied to this field
     */
-    double iMu() const { return i_mu; }
+    real_t iMu() const { return i_mu; }
 
-    const double& LinkMax() const { return fat_link_max; }
+    const real_t& LinkMax() const { return fat_link_max; }
     int Nface() const { return nFace; }
 
     /**
@@ -518,28 +518,28 @@ namespace quda {
        @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
        @return L1 norm
      */
-    double norm1(int dim = -1, bool fixed = false) const;
+    real_t norm1(int dim = -1, bool fixed = false) const;
 
     /**
        @brief Compute the L2 norm squared of the field
        @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
        @return L2 norm squared
      */
-    double norm2(int dim = -1, bool fixed = false) const;
+    real_t norm2(int dim = -1, bool fixed = false) const;
 
     /**
        @brief Compute the absolute maximum of the field (Linfinity norm)
        @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
        @return Absolute maximum value
      */
-    double abs_max(int dim = -1, bool fixed = false) const;
+    real_t abs_max(int dim = -1, bool fixed = false) const;
 
     /**
        @brief Compute the absolute minimum of the field
        @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
        @return Absolute minimum value
      */
-    double abs_min(int dim = -1, bool fixed = false) const;
+    real_t abs_min(int dim = -1, bool fixed = false) const;
 
     /**
        Compute checksum of this gauge field: this uses a XOR-based checksum method
@@ -608,7 +608,7 @@ namespace quda {
      @param u The gauge field that we want the norm of
      @return The L1 norm of the gauge field
   */
-  double norm1(const GaugeField &u);
+  real_t norm1(const GaugeField &u);
 
   /**
      @brief This is a debugging function, where we cast a gauge field
@@ -616,14 +616,14 @@ namespace quda {
      @param u The gauge field that we want the norm of
      @return The L2 norm squared of the gauge field
   */
-  double norm2(const GaugeField &u);
+  real_t norm2(const GaugeField &u);
 
   /**
      @brief Scale the gauge field by the scalar a.
      @param[in] a scalar multiplier
      @param[in] u The gauge field we want to multiply
    */
-  void ax(const double &a, GaugeField &u);
+  void ax(const real_t &a, GaugeField &u);
 
   /**
      This function is used for  extracting the gauge ghost zone from a
diff --git a/include/gauge_field_order.h b/include/gauge_field_order.h
index 17eb70b42c..8454f60ba3 100644
--- a/include/gauge_field_order.h
+++ b/include/gauge_field_order.h
@@ -377,7 +377,7 @@ namespace quda {
       {
         for (int d = 0; d < U.Geometry(); d++)
           u[d] = gauge_ ? static_cast<complex<storeFloat> **>(gauge_)[d] : U.data<complex<storeFloat> *>(d);
-        resetScale(U.Scale());
+        resetScale(double(U.Scale()));
       }
 
       void resetScale(Float max)
@@ -418,7 +418,7 @@ namespace quda {
          in transform_reduce
        */
       template <typename reducer, typename helper>
-      __host__ double transform_reduce(QudaFieldLocation location, int dim, helper h) const
+      auto transform_reduce(QudaFieldLocation location, int dim, helper h) const
       {
         if (dim >= geometry) errorQuda("Request dimension %d exceeds dimensionality of the field %d", dim, geometry);
         int lower = (dim == -1) ? 0 : dim;
@@ -457,7 +457,7 @@ namespace quda {
           ghostOffset[d+4] = U.Nface()*U.SurfaceCB(d)*U.Ncolor()*U.Ncolor();
         }
 
-	resetScale(U.Scale());
+	resetScale(double(U.Scale()));
       }
 
       void resetScale(Float max)
@@ -492,7 +492,7 @@ namespace quda {
         scale(static_cast<Float>(1.0)),
         scale_inv(static_cast<Float>(1.0))
       {
-        resetScale(U.Scale());
+        resetScale(double(U.Scale()));
       }
 
       void resetScale(Float max)
@@ -537,12 +537,11 @@ namespace quda {
          in transform_reduce
        */
       template <typename reducer, typename helper>
-      __host__ double transform_reduce(QudaFieldLocation location, int dim, helper h) const
+      auto transform_reduce(QudaFieldLocation location, int dim, helper h) const
       {
         if (dim >= geometry) errorQuda("Request dimension %d exceeds dimensionality of the field %d", dim, geometry);
         auto count = (dim == -1 ? geometry : 1) * volumeCB * nColor * nColor; // items per parity
-        auto init = reducer::init();
-        std::vector<decltype(init)> result = {init, init};
+        std::vector<typename reducer::reduce_t> result = {reducer::init(), reducer::init()};
         std::vector<decltype(u)> v
           = {u + 0 * volumeCB * geometry * nColor * nColor, u + 1 * volumeCB * geometry * nColor * nColor};
         if (dim == -1) {
@@ -578,7 +577,7 @@ namespace quda {
           ghostOffset[d+4] = U.Nface()*U.SurfaceCB(d)*U.Ncolor()*U.Ncolor();
         }
 
-	resetScale(U.Scale());
+	resetScale(double(U.Scale()));
       }
 
       void resetScale(Float max)
@@ -631,7 +630,7 @@ namespace quda {
         scale(static_cast<Float>(1.0)),
         scale_inv(static_cast<Float>(1.0))
       {
-	resetScale(U.Scale());
+	resetScale(double(U.Scale()));
       }
 
       void resetScale(Float max)
@@ -673,13 +672,12 @@ namespace quda {
          in transform_reduce
        */
       template <typename reducer, typename helper>
-      __host__ double transform_reduce(QudaFieldLocation location, int dim, helper h) const
+      auto transform_reduce(QudaFieldLocation location, int dim, helper h) const
       {
         if (dim >= geometry) errorQuda("Requested dimension %d exceeds dimensionality of the field %d", dim, geometry);
         auto start = (dim == -1) ? 0 : dim;
         auto count = (dim == -1 ? geometry : 1) * stride * nColor * nColor;
-        auto init = reducer::init();
-        std::vector<decltype(init)> result = {init, init};
+        std::vector<typename reducer::reduce_t> result = {reducer::init(), reducer::init()};
         std::vector<decltype(u)> v = {u + 0 * offset_cb + start * count, u + 1 * offset_cb + start * count};
         ::quda::transform_reduce<reducer>(location, result, v, count, h);
         return reducer::apply(result[0], result[1]);
@@ -708,7 +706,7 @@ namespace quda {
           ghost[d+4] = !native_ghost && U.Geometry() == QUDA_COARSE_GEOMETRY? static_cast<complex<storeFloat>*>(ghost_[d+4]) : nullptr;
           ghostVolumeCB[d+4] = U.Nface()*U.SurfaceCB(d);
         }
-        resetScale(U.Scale());
+        resetScale(double(U.Scale()));
       }
 
       void resetScale(Float max)
@@ -892,10 +890,10 @@ namespace quda {
 	 * @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
 	 * @return L1 norm
 	 */
-	__host__ double norm1(int dim=-1, bool global=true) const {
+	__host__ real_t norm1(int dim=-1, bool global=true) const {
           commGlobalReductionPush(global);
-          double nrm1 = accessor.template transform_reduce<plus<double>>(location, dim,
-                                                                         abs_<double, storeFloat>(accessor.scale_inv));
+          real_t nrm1 = real_t(accessor.template transform_reduce<plus<device_reduce_t>>
+                               (location, dim, abs_<double, storeFloat>(accessor.scale_inv)));
           commGlobalReductionPop();
           return nrm1;
         }
@@ -905,11 +903,11 @@ namespace quda {
          * @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
          * @return L2 norm squared
          */
-        __host__ double norm2(int dim = -1, bool global = true) const
+        __host__ real_t norm2(int dim = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double nrm2 = accessor.template transform_reduce<plus<double>>(
-            location, dim, square_<double, storeFloat>(accessor.scale_inv));
+          real_t nrm2 = real_t(accessor.template transform_reduce<plus<device_reduce_t>>
+                               (location, dim, square_<double, storeFloat>(accessor.scale_inv)));
           commGlobalReductionPop();
           return nrm2;
         }
@@ -919,11 +917,11 @@ namespace quda {
          * @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
          * @return Linfinity norm
          */
-        __host__ double abs_max(int dim = -1, bool global = true) const
+        __host__ real_t abs_max(int dim = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double absmax = accessor.template transform_reduce<maximum<Float>>(
-            location, dim, abs_max_<Float, storeFloat>(accessor.scale_inv));
+          real_t absmax = real_t(accessor.template transform_reduce<maximum<Float>>
+                                 (location, dim, abs_max_<Float, storeFloat>(accessor.scale_inv)));
           commGlobalReductionPop();
           return absmax;
         }
@@ -933,10 +931,10 @@ namespace quda {
          * @param[in] dim Which dimension we are taking the norm of (dim=-1 mean all dimensions)
          * @return Minimum norm
          */
-        __host__ double abs_min(int dim = -1, bool global = true) const
+        __host__ real_t abs_min(int dim = -1, bool global = true) const
         {
           commGlobalReductionPush(global);
-          double absmin = accessor.template transform_reduce<minimum<Float>>(
+          real_t absmin = accessor.template transform_reduce<minimum<Float>>(
             location, dim, abs_min_<Float, storeFloat>(accessor.scale_inv));
           commGlobalReductionPop();
           return absmin;
@@ -1270,7 +1268,7 @@ namespace quda {
 
         // scale factor is set when using recon-9
         Reconstruct(const GaugeField &u, real scale = 1.0) :
-          anisotropy(u.Anisotropy() * scale, 1.0 / (u.Anisotropy() * scale)),
+          anisotropy(Float(u.Anisotropy() * scale), Float(1.0 / (u.Anisotropy() * scale))),
           tBoundary(static_cast<real>(u.TBoundary()) * scale, 1.0 / (static_cast<real>(u.TBoundary()) * scale)),
           firstTimeSliceBound(u.VolumeCB()),
           lastTimeSliceBound((u.X()[3] - 1) * u.X()[0] * u.X()[1] * u.X()[2] / 2),
@@ -2201,7 +2199,7 @@ namespace quda {
         LegacyOrder<Float, length>(u, ghost_),
         gauge(gauge_ ? gauge_ : u.data<Float *>()),
         volumeCB(u.VolumeCB()),
-        scale(u.Scale()),
+        scale(real(u.Scale())),
         scale_inv(1.0 / scale)
       {
         if constexpr (length != 18) errorQuda("Gauge length %d not supported", length);
diff --git a/include/gauge_path_helper.cuh b/include/gauge_path_helper.cuh
index 0281848609..af268bd69c 100644
--- a/include/gauge_path_helper.cuh
+++ b/include/gauge_path_helper.cuh
@@ -18,7 +18,7 @@ namespace quda {
     int *buffer;
     int count;
 
-    paths(std::vector<int**>& input_path, std::vector<int>& length_h, std::vector<double>& path_coeff_h, int num_paths, int max_length) :
+    paths(std::vector<int**>& input_path, std::vector<int>& length_h, std::vector<real_t>& path_coeff_h, int num_paths, int max_length) :
       num_paths(num_paths),
       max_length(max_length),
       count(0)
@@ -52,8 +52,9 @@ namespace quda {
       // length array
       memcpy(path_h + dim * num_paths * max_length, length_h.data(), num_paths*sizeof(int));
 
-      // path_coeff array
-      memcpy(path_h + dim * num_paths * max_length + num_paths + pad, path_coeff_h.data(), num_paths*sizeof(double));
+      // path_coeff array (copy and convert if needed)
+      double *path_coeff_ = reinterpret_cast<double*>(path_h + dim * num_paths * max_length + num_paths + pad);
+      for (auto i = 0; i < num_paths; i++) path_coeff_[i] = double(path_coeff_h[i]);
 
       qudaMemcpy(buffer, path_h, bytes, qudaMemcpyHostToDevice);
       host_free(path_h);
diff --git a/include/gauge_path_quda.h b/include/gauge_path_quda.h
index db398c11a5..7b53af9acd 100644
--- a/include/gauge_path_quda.h
+++ b/include/gauge_path_quda.h
@@ -14,8 +14,8 @@ namespace quda
      @param[in] num_paths Numer of paths
      @param[in] max_length Maximum length of each path
    */
-  void gaugeForce(GaugeField &mom, const GaugeField &u, double coeff, std::vector<int **> &input_path,
-                  std::vector<int> &length, std::vector<double> &path_coeff, int num_paths, int max_length);
+  void gaugeForce(GaugeField &mom, const GaugeField &u, real_t coeff, std::vector<int **> &input_path,
+                  std::vector<int> &length, std::vector<real_t> &path_coeff, int num_paths, int max_length);
 
   /**
      @brief Compute the product of gauge-links along the given path
@@ -28,8 +28,8 @@ namespace quda
      @param[in] num_paths Numer of paths
      @param[in] max_length Maximum length of each path
    */
-  void gaugePath(GaugeField &out, const GaugeField &u, double coeff, std::vector<int **> &input_path,
-                 std::vector<int> &length, std::vector<double> &path_coeff, int num_paths, int max_length);
+  void gaugePath(GaugeField &out, const GaugeField &u, real_t coeff, std::vector<int **> &input_path,
+                 std::vector<int> &length, std::vector<real_t> &path_coeff, int num_paths, int max_length);
 
   /**
      @brief Compute the trace of an arbitrary set of gauge loops
@@ -42,8 +42,8 @@ namespace quda
      @param[in] num_paths Numer of paths
      @param[in] path_max_length Maximum length of each path
    */
-  void gaugeLoopTrace(const GaugeField &u, std::vector<Complex> &loop_traces, double factor,
-                      std::vector<int **> &input_path, std::vector<int> &length, std::vector<double> &path_coeff_h,
+  void gaugeLoopTrace(const GaugeField &u, std::vector<complex_t> &loop_traces, real_t factor,
+                      std::vector<int **> &input_path, std::vector<int> &length, std::vector<real_t> &path_coeff_h,
                       int num_paths, int path_max_length);
 
 } // namespace quda
diff --git a/include/gauge_tools.h b/include/gauge_tools.h
index 9b7d68db37..349d0f6b7e 100644
--- a/include/gauge_tools.h
+++ b/include/gauge_tools.h
@@ -21,7 +21,7 @@ namespace quda
    * @param tol Tolerance to which the iterative algorithm works
    * @param fails Number of link failures (device pointer)
    */
-  void projectSU3(GaugeField &U, double tol, int *fails);
+  void projectSU3(GaugeField &U, real_t tol, int *fails);
 
   /**
      @brief Compute the plaquette of the gauge field
@@ -31,7 +31,7 @@ namespace quda
      temporal plaquette) site averages normalized such that each
      plaquette is in the range [0,1]
    */
-  double3 plaquette(const GaugeField &U);
+  array<real_t, 3> plaquette(const GaugeField &U);
 
   /**
      @brief Generate Gaussian distributed su(N) or SU(N) fields.  If U
@@ -47,7 +47,7 @@ namespace quda
      @param[in] rngstate random states
      @param[in] sigma Width of Gaussian distrubution
   */
-  void gaugeGauss(GaugeField &U, RNG &rngstate, double epsilon);
+  void gaugeGauss(GaugeField &U, RNG &rngstate, real_t epsilon);
 
   /**
      @brief Generate Gaussian distributed su(N) or SU(N) fields.  If U
@@ -63,7 +63,7 @@ namespace quda
      @param[in] seed The seed used for the RNG
      @param[in] sigma Wdith of the Gaussian distribution
   */
-  void gaugeGauss(GaugeField &U, unsigned long long seed, double epsilon);
+  void gaugeGauss(GaugeField &U, unsigned long long seed, real_t epsilon);
 
   /**
      @brief Generate a random noise gauge field.  This variant allows
@@ -96,7 +96,7 @@ namespace quda
      @param[in] dataOr Input gauge field
      @param[in] alpha smearing parameter
   */
-  void APEStep(GaugeField &dataDs, GaugeField &dataOr, double alpha);
+  void APEStep(GaugeField &dataDs, GaugeField &dataOr, real_t alpha);
 
   /**
      @brief Apply STOUT smearing to the gauge field
@@ -105,7 +105,7 @@ namespace quda
      @param[in] dataOr Input gauge field
      @param[in] rho smearing parameter
   */
-  void STOUTStep(GaugeField &dataDs, GaugeField &dataOr, double rho);
+  void STOUTStep(GaugeField &dataDs, GaugeField &dataOr, real_t rho);
 
   /**
      @brief Apply Over Improved STOUT smearing to the gauge field
@@ -115,7 +115,7 @@ namespace quda
      @param[in] rho smearing parameter
      @param[in] epsilon smearing parameter
   */
-  void OvrImpSTOUTStep(GaugeField &dataDs, GaugeField &dataOr, double rho, double epsilon);
+  void OvrImpSTOUTStep(GaugeField &dataDs, GaugeField &dataOr, real_t rho, real_t epsilon);
 
   /**
      @brief Apply Wilson Flow steps W1, W2, Vt to the gauge field.
@@ -129,7 +129,7 @@ namespace quda
      @param[in] epsilon Step size
      @param[in] smear_type Wilson (1x1) or Symanzik improved (2x1) staples, else error
   */
-  void WFlowStep(GaugeField &out, GaugeField &temp, GaugeField &in, double epsilon, QudaGaugeSmearType smear_type);
+  void WFlowStep(GaugeField &out, GaugeField &temp, GaugeField &in, real_t epsilon, QudaGaugeSmearType smear_type);
 
   /**
    * @brief Gauge fixing with overrelaxation with support for single and multi GPU.
@@ -145,7 +145,7 @@ namespace quda
    * @param[in] stopWtheta, 0 for MILC criterion and 1 to use the theta value
    */
   void gaugeFixingOVR(GaugeField &data, const int gauge_dir, const int Nsteps, const int verbose_interval,
-                      const double relax_boost, const double tolerance, const int reunit_interval, const int stopWtheta);
+                      const real_t relax_boost, const real_t tolerance, const int reunit_interval, const int stopWtheta);
 
   /**
    * @brief Gauge fixing with Steepest descent method with FFTs with support for single GPU only.
@@ -161,7 +161,7 @@ namespace quda
    * @param[in] stopWtheta, 0 for MILC criterion and 1 to use the theta value
    */
   void gaugeFixingFFT(GaugeField &data, const int gauge_dir, const int Nsteps, const int verbose_interval,
-                      const double alpha, const int autotune, const double tolerance, const int stopWtheta);
+                      const real_t alpha, const int autotune, const real_t tolerance, const int stopWtheta);
 
   /**
      @brief Compute the Fmunu tensor
@@ -173,22 +173,22 @@ namespace quda
   /**
      @brief Compute the topological charge and field energy
      @param[out] energy The total, spatial, and temporal field energy
-     @param[out] qcharge The total topological charge
      @param[in] Fmunu The Fmunu tensor, usually calculated from a
      smeared configuration
+     @return The total topological charge
    */
-  void computeQCharge(double energy[3], double &qcharge, const GaugeField &Fmunu);
+  real_t computeQCharge(array<real_t, 3> &energy, const GaugeField &Fmunu);
 
   /**
      @brief Compute the topological charge, field energy and the
      topological charge density per lattice site
      @param[out] energy The total, spatial, and temporal field energy
-     @param[out] qcharge The total topological charge
      @param[out] qdensity The topological charge at each lattice site
      @param[in] Fmunu The Fmunu tensor, usually calculated from a
      smeared configuration
+     @return The total topological charge
   */
-  void computeQChargeDensity(double energy[3], double &qcharge, void *qdensity, const GaugeField &Fmunu);
+  real_t computeQChargeDensity(array<real_t, 3> &energy, void *qdensity, const GaugeField &Fmunu);
 
   /**
    * @brief Compute the trace of the Polyakov loop in a given dimension
@@ -197,6 +197,6 @@ namespace quda
    * @param[in] dir The direction to compute the Polyakov loop in
    * @param[in] profile TimeProfile instance used for profiling.
    */
-  void gaugePolyakovLoop(double ploop[2], const GaugeField &u, int dir, TimeProfile &profile);
+  array<real_t, 2> gaugePolyakovLoop(const GaugeField &u, int dir, TimeProfile &profile);
 
 } // namespace quda
diff --git a/include/invert_quda.h b/include/invert_quda.h
index 35a21ce31c..d7aec4775b 100644
--- a/include/invert_quda.h
+++ b/include/invert_quda.h
@@ -64,7 +64,7 @@ namespace quda {
     QudaComputeNullVector compute_null_vector;
 
     /**< Reliable update tolerance */
-    double delta;
+    real_t delta;
 
     /**< Whether to user alternative reliable updates (CG only at the moment) */
     bool use_alternative_reliable;
@@ -109,13 +109,13 @@ namespace quda {
     int pipeline;
 
     /**< Solver tolerance in the L2 residual norm */
-    double tol;
+    real_t tol;
 
     /**< Solver tolerance in the L2 residual norm */
-    double tol_restart;
+    real_t tol_restart;
 
     /**< Solver tolerance in the heavy quark residual norm */
-    double tol_hq;
+    real_t tol_hq;
 
     /**< Whether to compute the true residual post solve */
     bool compute_true_res;
@@ -124,10 +124,10 @@ namespace quda {
     bool sloppy_converge;
 
     /**< Actual L2 residual norm achieved in solver */
-    double true_res;
+    real_t true_res;
 
     /**< Actual heavy quark residual norm achieved in solver */
-    double true_res_hq;
+    real_t true_res_hq;
 
     /**< Maximum number of iterations in the linear solver */
     int maxiter;
@@ -166,22 +166,22 @@ namespace quda {
     int num_offset;
 
     /** Offsets for multi-shift solver */
-    double offset[QUDA_MAX_MULTI_SHIFT];
+    real_t offset[QUDA_MAX_MULTI_SHIFT];
 
     /** Solver tolerance for each offset */
-    double tol_offset[QUDA_MAX_MULTI_SHIFT];
+    real_t tol_offset[QUDA_MAX_MULTI_SHIFT];
 
     /** Solver tolerance for each shift when refinement is applied using the heavy-quark residual */
-    double tol_hq_offset[QUDA_MAX_MULTI_SHIFT];
+    real_t tol_hq_offset[QUDA_MAX_MULTI_SHIFT];
 
     /** Actual L2 residual norm achieved in solver for each offset */
-    double true_res_offset[QUDA_MAX_MULTI_SHIFT];
+    real_t true_res_offset[QUDA_MAX_MULTI_SHIFT];
 
     /** Iterated L2 residual norm achieved in multi shift solver for each offset */
-    double iter_res_offset[QUDA_MAX_MULTI_SHIFT];
+    real_t iter_res_offset[QUDA_MAX_MULTI_SHIFT];
 
     /** Actual heavy quark residual norm achieved in solver for each offset */
-    double true_res_hq_offset[QUDA_MAX_MULTI_SHIFT];
+    real_t true_res_hq_offset[QUDA_MAX_MULTI_SHIFT];
 
     /** Number of steps in s-step algorithms */
     int Nsteps;
@@ -193,31 +193,31 @@ namespace quda {
     int precondition_cycle;
 
     /** Tolerance in the inner solver */
-    double tol_precondition;
+    real_t tol_precondition;
 
     /** Maximum number of iterations allowed in the inner solver */
     int maxiter_precondition;
 
     /** Relaxation parameter used in GCR-DD (default = 1.0) */
-    double omega;
+    real_t omega;
 
     /** Basis for CA algorithms */
     QudaCABasis ca_basis;
 
     /** Minimum eigenvalue for Chebyshev CA basis */
-    double ca_lambda_min;
+    real_t ca_lambda_min;
 
     /** Maximum eigenvalue for Chebyshev CA basis */
-    double ca_lambda_max; // -1 -> power iter generate
+    real_t ca_lambda_max; // -1 -> power iter generate
 
     /** Basis for CA algorithms in a preconditioner */
     QudaCABasis ca_basis_precondition;
 
     /** Minimum eigenvalue for Chebyshev CA basis in a preconditioner */
-    double ca_lambda_min_precondition;
+    real_t ca_lambda_min_precondition;
 
     /** Maximum eigenvalue for Chebyshev CA basis in a preconditioner */
-    double ca_lambda_max_precondition; // -1 -> power iter generate
+    real_t ca_lambda_max_precondition; // -1 -> power iter generate
 
     /** Whether to use additive or multiplicative Schwarz preconditioning */
     QudaSchwarzType schwarz_type;
@@ -242,8 +242,8 @@ namespace quda {
 
     int     eigcg_max_restarts;
     int     max_restart_num;
-    double  inc_tol;
-    double  eigenval_tol;
+    real_t  inc_tol;
+    real_t  eigenval_tol;
 
     QudaVerbosity verbosity_precondition; //! verbosity to use for preconditioner
 
@@ -463,31 +463,31 @@ namespace quda {
        @param param the QudaInvertParam to be updated
      */
     void updateInvertParam(QudaInvertParam &param, int offset=-1) {
-      param.true_res = true_res;
-      param.true_res_hq = true_res_hq;
+      param.true_res = double(true_res);
+      param.true_res_hq = double(true_res_hq);
       param.iter += iter;
       comm_allreduce_sum(gflops);
       param.gflops += gflops;
       param.secs += secs;
       if (offset >= 0) {
-	param.true_res_offset[offset] = true_res_offset[offset];
-        param.iter_res_offset[offset] = iter_res_offset[offset];
-	param.true_res_hq_offset[offset] = true_res_hq_offset[offset];
+	param.true_res_offset[offset] = double(true_res_offset[offset]);
+        param.iter_res_offset[offset] = double(iter_res_offset[offset]);
+	param.true_res_hq_offset[offset] = double(true_res_hq_offset[offset]);
       } else {
 	for (int i=0; i<num_offset; i++) {
-	  param.true_res_offset[i] = true_res_offset[i];
-          param.iter_res_offset[i] = iter_res_offset[i];
-	  param.true_res_hq_offset[i] = true_res_hq_offset[i];
+	  param.true_res_offset[i] = double(true_res_offset[i]);
+          param.iter_res_offset[i] = double(iter_res_offset[i]);
+	  param.true_res_hq_offset[i] = double(true_res_hq_offset[i]);
 	}
       }
       //for incremental eigCG:
       param.rhs_idx = rhs_idx;
 
-      param.ca_lambda_min = ca_lambda_min;
-      param.ca_lambda_max = ca_lambda_max;
+      param.ca_lambda_min = double(ca_lambda_min);
+      param.ca_lambda_max = double(ca_lambda_max);
 
-      param.ca_lambda_min_precondition = ca_lambda_min_precondition;
-      param.ca_lambda_max_precondition = ca_lambda_max_precondition;
+      param.ca_lambda_min_precondition = double(ca_lambda_min_precondition);
+      param.ca_lambda_max_precondition = double(ca_lambda_max_precondition);
 
       if (deflate) *static_cast<QudaEigParam *>(param.eig_param) = eig_param;
     }
@@ -515,7 +515,7 @@ namespace quda {
     bool deflate_compute;   /** If true, instruct the solver to create a deflation space. */
     bool recompute_evals;   /** If true, instruct the solver to recompute evals from an existing deflation space. */
     std::vector<ColorSpinorField> evecs; /** Holds the eigenvectors. */
-    std::vector<Complex> evals;          /** Holds the eigenvalues. */
+    std::vector<complex_t> evals;        /** Holds the eigenvalues. */
 
     bool mixed() { return param.precision != param.precision_sloppy; }
 
@@ -553,12 +553,12 @@ namespace quda {
       @brief a virtual method that performs the inversion and collect some vectors.
         The default here is a no-op and should not be called.
      */
-    virtual void solve_and_collect(ColorSpinorField &, ColorSpinorField &, cvector_ref<ColorSpinorField> &, int, double)
+    virtual void solve_and_collect(ColorSpinorField &, ColorSpinorField &, cvector_ref<ColorSpinorField> &, int, real_t)
     {
       errorQuda("NOT implemented.");
     }
 
-    void set_tol(double tol) { param.tol = tol; }
+    void set_tol(real_t tol) { param.tol = tol; }
     void set_maxiter(int maxiter) { param.maxiter = maxiter; }
 
     const DiracMatrix &M() { return mat; }
@@ -636,7 +636,7 @@ namespace quda {
        @param[in] residual_type The type of residual we want to solve for
        @return L2 stopping condition
     */
-    static double stopping(double tol, double b2, QudaResidualType residual_type);
+    static real_t stopping(real_t tol, real_t b2, QudaResidualType residual_type);
 
     /**
        @briefTest for solver convergence
@@ -646,7 +646,7 @@ namespace quda {
        @param[in] hq_tol Solver heavy-quark tolerance
        @return Whether converged
      */
-    bool convergence(double r2, double hq2, double r2_tol, double hq_tol);
+    bool convergence(real_t r2, real_t hq2, real_t r2_tol, real_t hq_tol);
 
     /**
        @brief Test for HQ solver convergence -- ignore L2 residual
@@ -656,7 +656,7 @@ namespace quda {
        @param[in[ hq_tol Solver heavy-quark tolerance
        @return Whether converged
      */
-    bool convergenceHQ(double r2, double hq2, double r2_tol, double hq_tol);
+    bool convergenceHQ(real_t r2, real_t hq2, real_t r2_tol, real_t hq_tol);
 
     /**
        @brief Test for L2 solver convergence -- ignore HQ residual
@@ -665,7 +665,7 @@ namespace quda {
        @param[in] r2_tol Solver L2 tolerance
        @param[in] hq_tol Solver heavy-quark tolerance
      */
-    bool convergenceL2(double r2, double hq2, double r2_tol, double hq_tol);
+    bool convergenceL2(real_t r2, real_t hq2, real_t r2_tol, real_t hq_tol);
 
     /**
        @brief Prints out the running statistics of the solver
@@ -675,7 +675,7 @@ namespace quda {
        @param[in] r2 L2 norm squared of the residual
        @param[in] hq2 Heavy quark residual
      */
-    void PrintStats(const char *name, int k, double r2, double b2, double hq2);
+    void PrintStats(const char *name, int k, real_t r2, real_t b2, real_t hq2);
 
     /**
        @brief Prints out the summary of the solver convergence
@@ -688,7 +688,7 @@ namespace quda {
        @param[in] r2_tol Solver L2 tolerance
        @param[in] hq_tol Solver heavy-quark tolerance
     */
-    void PrintSummary(const char *name, int k, double r2, double b2, double r2_tol, double hq_tol);
+    void PrintSummary(const char *name, int k, real_t r2, real_t b2, real_t r2_tol, real_t hq_tol);
 
     /**
        @brief Returns the epsilon tolerance for a given precision, by default returns
@@ -767,7 +767,7 @@ namespace quda {
        @return Norm of final power iteration result
     */
     template <typename... Args>
-    static double performPowerIterations(const DiracMatrix &diracm, const ColorSpinorField &start,
+    static real_t performPowerIterations(const DiracMatrix &diracm, const ColorSpinorField &start,
                                          ColorSpinorField &tempvec1, ColorSpinorField &tempvec2, int niter,
                                          int normalize_freq, Args &&...args);
 
@@ -784,8 +784,8 @@ namespace quda {
     */
     template <typename... Args>
     static void computeCAKrylovSpace(const DiracMatrix &diracm, std::vector<ColorSpinorField> &Ap,
-                                     std::vector<ColorSpinorField> &p, int n_krylov, QudaCABasis basis, double m_map,
-                                     double b_map, Args &&...args);
+                                     std::vector<ColorSpinorField> &p, int n_krylov, QudaCABasis basis, real_t m_map,
+                                     real_t b_map, Args &&...args);
 
     /**
      * @brief Return flops
@@ -823,7 +823,7 @@ namespace quda {
      * @param p_init Initial-search direction.
      * @param r2_old_init [description]
      */
-    void operator()(ColorSpinorField &out, ColorSpinorField &in, ColorSpinorField *p_init, double r2_old_init);
+    void operator()(ColorSpinorField &out, ColorSpinorField &in, ColorSpinorField *p_init, real_t r2_old_init);
 
     void blocksolve(ColorSpinorField &out, ColorSpinorField &in) override;
 
@@ -1055,7 +1055,7 @@ namespace quda {
        @param collect_tol maxiter tolerance start from which the r vectors are to be collected
     */
     virtual void solve_and_collect(ColorSpinorField &out, ColorSpinorField &in, cvector_ref<ColorSpinorField> &v_r,
-                                   int collect_miniter, double collect_tol) override;
+                                   int collect_miniter, real_t collect_tol) override;
 
     virtual bool hermitian() const override { return true; } /** PCG is only Hermitian system */
 
@@ -1099,10 +1099,10 @@ namespace quda {
     int pipeline; // pipelining factor for legacyGramSchmidt
 
     // Various coefficients and params needed on each iteration.
-    Complex rho0, rho1, alpha, omega, beta;           // Various coefficients for the BiCG part of BiCGstab-L.
-    std::vector<Complex> gamma, gamma_prime, gamma_prime_prime; // Parameters for MR part of BiCGstab-L. (L+1) length.
-    std::vector<Complex> tau; // Parameters for MR part of BiCGstab-L. Tech. modified Gram-Schmidt coeffs. (L+1)x(L+1) length.
-    std::vector<double> sigma; // Parameters for MR part of BiCGstab-L. Tech. the normalization part of Gram-Scmidt. (L+1) length.
+    complex_t rho0, rho1, alpha, omega, beta;           // Various coefficients for the BiCG part of BiCGstab-L.
+    std::vector<complex_t> gamma, gamma_prime, gamma_prime_prime; // Parameters for MR part of BiCGstab-L. (L+1) length.
+    std::vector<complex_t> tau; // Parameters for MR part of BiCGstab-L. Tech. modified Gram-Schmidt coeffs. (L+1)x(L+1) length.
+    std::vector<real_t> sigma; // Parameters for MR part of BiCGstab-L. Tech. the normalization part of Gram-Scmidt. (L+1) length.
 
     ColorSpinorField r_full; //! Full precision residual.
     ColorSpinorField y;      //! Full precision temporary.
@@ -1125,7 +1125,7 @@ namespace quda {
     /**
      @brief Internal routine for reliable updates. Made to not conflict with BiCGstab's implementation.
      */
-    int reliable(double &rNorm, double &maxrx, double &maxrr, const double &r2, const double &delta);
+    int reliable(real_t &rNorm, real_t &maxrx, real_t &maxrr, const real_t &r2, const real_t &delta);
 
     /**
      * @brief Internal routine for performing the MR part of BiCGstab-L
@@ -1203,9 +1203,9 @@ namespace quda {
      */
     int n_krylov;
 
-    std::vector<Complex> alpha;
-    std::vector<Complex> beta;
-    std::vector<double> gamma;
+    std::vector<complex_t> alpha;
+    std::vector<complex_t> beta;
+    std::vector<real_t> gamma;
 
     /**
        Solver uses lazy allocation: this flag to determine whether we have allocated.
@@ -1218,13 +1218,13 @@ namespace quda {
     std::vector<ColorSpinorField> p;  // GCR direction vectors
     std::vector<ColorSpinorField> Ap; // mat * direction vectors
 
-    void computeBeta(std::vector<Complex> &beta, std::vector<ColorSpinorField> &Ap, int i, int N, int k);
-    void updateAp(std::vector<Complex> &beta, std::vector<ColorSpinorField> &Ap, int begin, int size, int k);
-    void orthoDir(std::vector<Complex> &beta, std::vector<ColorSpinorField> &Ap, int k, int pipeline);
-    void backSubs(const std::vector<Complex> &alpha, const std::vector<Complex> &beta, const std::vector<double> &gamma,
-                  std::vector<Complex> &delta, int n);
-    void updateSolution(ColorSpinorField &x, const std::vector<Complex> &alpha, const std::vector<Complex> &beta,
-                        std::vector<double> &gamma, int k, std::vector<ColorSpinorField> &p);
+    void computeBeta(std::vector<complex_t> &beta, std::vector<ColorSpinorField> &Ap, int i, int N, int k);
+    void updateAp(std::vector<complex_t> &beta, std::vector<ColorSpinorField> &Ap, int begin, int size, int k);
+    void orthoDir(std::vector<complex_t> &beta, std::vector<ColorSpinorField> &Ap, int k, int pipeline);
+    void backSubs(const std::vector<complex_t> &alpha, const std::vector<complex_t> &beta, const std::vector<real_t> &gamma,
+                  std::vector<complex_t> &delta, int n);
+    void updateSolution(ColorSpinorField &x, const std::vector<complex_t> &alpha, const std::vector<complex_t> &beta,
+                        std::vector<real_t> &gamma, int k, std::vector<ColorSpinorField> &p);
 
     /**
        @brief Initiate the fields needed by the solver
@@ -1298,10 +1298,10 @@ namespace quda {
     bool lambda_init;
     QudaCABasis basis;
 
-    std::vector<double> Q_AQandg; // Fused inner product matrix
-    std::vector<double> Q_AS;     // inner product matrix
-    std::vector<double> alpha;    // QAQ^{-1} g
-    std::vector<double> beta;     // QAQ^{-1} QpolyS
+    std::vector<real_t> Q_AQandg; // Fused inner product matrix
+    std::vector<real_t> Q_AS;     // inner product matrix
+    std::vector<real_t> alpha;    // QAQ^{-1} g
+    std::vector<real_t> beta;     // QAQ^{-1} QpolyS
 
     ColorSpinorField r;
 
@@ -1335,7 +1335,7 @@ namespace quda {
     /**
        @ brief Check if it's time for a reliable update
     */
-    int reliable(double &rNorm,  double &maxrr, int &rUpdate, const double &r2, const double &delta);
+    int reliable(real_t &rNorm,  real_t &maxrr, int &rUpdate, const real_t &r2, const real_t &delta);
 
   public:
     CACG(const DiracMatrix &mat, const DiracMatrix &matSloppy, const DiracMatrix &matPrecon, const DiracMatrix &matEig,
@@ -1438,7 +1438,7 @@ namespace quda {
     bool lambda_init;  // whether or not lambda_max has been initialized
     QudaCABasis basis; // CA basis
 
-    std::vector<Complex> alpha; // Solution coefficient vectors
+    std::vector<complex_t> alpha; // Solution coefficient vectors
 
     ColorSpinorField r;
 
@@ -1459,7 +1459,7 @@ namespace quda {
        @param[in] q Search direction vectors with the operator applied
        @param[in] b Source vector against which we are solving
     */
-    void solve(std::vector<Complex> &psi, std::vector<ColorSpinorField> &q, ColorSpinorField &b);
+    void solve(std::vector<complex_t> &psi, std::vector<ColorSpinorField> &q, ColorSpinorField &b);
 
   public:
     CAGCR(const DiracMatrix &mat, const DiracMatrix &matSloppy, const DiracMatrix &matPrecon, const DiracMatrix &matEig,
@@ -1571,7 +1571,7 @@ namespace quda {
     }
 
     virtual void operator()(std::vector<ColorSpinorField> &out, ColorSpinorField &in) = 0;
-    bool convergence(const std::vector<double> &r2, const std::vector<double> &r2_tol, int n) const;
+    bool convergence(const std::vector<real_t> &r2, const std::vector<real_t> &r2_tol, int n) const;
   };
 
   /**
@@ -1603,7 +1603,7 @@ namespace quda {
      * @param r2_old_array pointer to last values of r2_old for old shifts. Needs to be large enough to hold r2_old for all shifts.
      */
     void operator()(std::vector<ColorSpinorField> &x, ColorSpinorField &b, std::vector<ColorSpinorField> &p,
-                    std::vector<double> &r2_old_array);
+                    std::vector<real_t> &r2_old_array);
 
     /**
      * @brief Run multi-shift and return Krylov-space at the end of the solve in p and r2_old_arry.
@@ -1613,7 +1613,7 @@ namespace quda {
      */
     void operator()(std::vector<ColorSpinorField> &out, ColorSpinorField &in)
     {
-      std::vector<double> r2_old(out.size());
+      std::vector<real_t> r2_old(out.size());
       std::vector<ColorSpinorField> p;
 
       (*this)(out, in, p, r2_old);
@@ -1649,7 +1649,7 @@ namespace quda {
        @param[in] q Search direction vectors with the operator applied
        @param[in] hermitian Whether the linear system is Hermitian or not
     */
-    void solve(std::vector<Complex> &psi_, std::vector<ColorSpinorField> &p, std::vector<ColorSpinorField> &q,
+    void solve(std::vector<complex_t> &psi_, std::vector<ColorSpinorField> &p, std::vector<ColorSpinorField> &q,
                const ColorSpinorField &b, bool hermitian);
 
   public:
@@ -1712,8 +1712,8 @@ namespace quda {
    */
   void increment(ColorSpinorField &V, int n_ev);
 
-  void RestartVT(const double beta, const double rho);
-  void UpdateVm(ColorSpinorField &res, double beta, double sqrtr2);
+  void RestartVT(const real_t beta, const real_t rho);
+  void UpdateVm(ColorSpinorField &res, real_t beta, real_t sqrtr2);
   // EigCG solver:
   int eigCGsolve(ColorSpinorField &out, ColorSpinorField &in);
   // InitCG solver:
@@ -1762,7 +1762,7 @@ namespace quda {
     void operator()(ColorSpinorField &out, ColorSpinorField &in);
     //
     //GMRESDR method
-    void RunDeflatedCycles (ColorSpinorField *out, ColorSpinorField *in, const double tol_threshold);
+    void RunDeflatedCycles (ColorSpinorField *out, ColorSpinorField *in, const real_t tol_threshold);
     //
     int FlexArnoldiProcedure (const int start_idx, const bool do_givens);
 
@@ -1782,7 +1782,7 @@ namespace quda {
  struct deflation_space : public Object {
    bool svd;                            /** Whether this space is for an SVD deflaton */
    std::vector<ColorSpinorField> evecs; /** Container for the eigenvectors */
-   std::vector<Complex> evals;          /** The eigenvalues */
+   std::vector<complex_t> evals;          /** The eigenvalues */
  };
 
  /**
diff --git a/include/invert_x_update.h b/include/invert_x_update.h
index 4e79624871..58ae5510e6 100644
--- a/include/invert_x_update.h
+++ b/include/invert_x_update.h
@@ -15,7 +15,7 @@ namespace quda
     int _j;                            /**< the current index */
     int _next;                         /**< the next index */
     std::vector<ColorSpinorField> _ps; /**< the container for the p-vectors */
-    std::vector<double> _alphas;       /**< @param _alphas the alpha's */
+    std::vector<real_t> _alphas;       /**< @param _alphas the alpha's */
 
     XUpdateBatch() = default;
 
@@ -49,7 +49,7 @@ namespace quda
     */
     void accumulate_x(ColorSpinorField &x)
     {
-      blas::axpy<double>({_alphas.begin(), _alphas.begin() + _j + 1}, {_ps.begin(), _ps.begin() + _j + 1}, x);
+      blas::axpy<real_t>({_alphas.begin(), _alphas.begin() + _j + 1}, {_ps.begin(), _ps.begin() + _j + 1}, x);
     }
 
     /**
@@ -80,12 +80,12 @@ namespace quda
     /**
       @brief Get the current alpha
      */
-    double &get_current_alpha() { return _alphas[_j]; }
+    real_t &get_current_alpha() { return _alphas[_j]; }
 
     /**
       @brief Get the current alpha
      */
-    const double &get_current_alpha() const { return _alphas[_j]; }
+    const real_t &get_current_alpha() const { return _alphas[_j]; }
 
     /**
       @brief increase the counter by one (modulo _Np)
diff --git a/include/kernels/blas_core.cuh b/include/kernels/blas_core.cuh
index 96f0c2b5f1..c0ee41feca 100644
--- a/include/kernels/blas_core.cuh
+++ b/include/kernels/blas_core.cuh
@@ -99,7 +99,7 @@ namespace quda
       static constexpr memory_access<0, 0, 0, 0, 1> write{ };
       const real a;
       const real b;
-      axpbyz_(const real &a, const real &b, const real &) : a(a), b(b) { ; }
+      axpbyz_(const real_t &a, const real_t &b, const real_t &) : a(a), b(b) { ; }
       template <typename T> __device__ __host__ void operator()(T &x, T &y, T &, T &, T &v) const
       {
 #pragma unroll
@@ -115,7 +115,7 @@ namespace quda
       static constexpr memory_access<1, 0> read{ };
       static constexpr memory_access<0, 1> write{ };
       const real a;
-      axy_(const real &a, const real &, const real &) : a(a) { ; }
+      axy_(const real_t &a, const real_t &, const real_t &) : a(a) { ; }
       template <typename T> __device__ __host__ void operator()(T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
@@ -182,7 +182,7 @@ namespace quda
       const real a;
       const real b;
       const real c;
-      axpbypczw_(const real &a, const real &b, const real &c) : a(a), b(b), c(c) { ; }
+      axpbypczw_(const real_t &a, const real_t &b, const real_t &c) : a(a), b(b), c(c) { ; }
       template <typename T> __device__ __host__ void operator()(T &x, T &y, T &z, T &w, T &) const
       {
 #pragma unroll
@@ -202,7 +202,7 @@ namespace quda
       const real a;
       const real b;
       const real c;
-      axpyBzpcx_(const real &a, const real &b, const real &c) : a(a), b(b), c(c) { ; }
+      axpyBzpcx_(const real_t &a, const real_t &b, const real_t &c) : a(a), b(b), c(c) { ; }
       template <typename T> __device__ __host__ void operator()(T &x, T &y, T &z, T &, T &) const
       {
 #pragma unroll
@@ -222,7 +222,7 @@ namespace quda
       static constexpr memory_access<1, 1> write{ };
       const real a;
       const real b;
-      axpyZpbx_(const real &a, const real &b, const real &) : a(a), b(b) { ; }
+      axpyZpbx_(const real_t &a, const real_t &b, const real_t &) : a(a), b(b) { ; }
       template <typename T> __device__ __host__ void operator()(T &x, T &y, T &z, T &, T &) const
       {
 #pragma unroll
@@ -369,19 +369,19 @@ namespace quda
       static constexpr memory_access<1, 1, 1> read{ };
       static constexpr memory_access<1, 1> write{ };
       complex<real> a;
-      double3 *Ar3;
+      array<device_reduce_t, 3> *Ar3;
       bool init_;
-      caxpyxmazMR_(const real &a, const real &, const real &) :
-        a(a),
-        Ar3(static_cast<double3 *>(reducer::get_device_buffer())),
+      caxpyxmazMR_(const real_t &a, const real_t &, const real_t &) :
+        a(real(a)),
+        Ar3(static_cast<array<device_reduce_t, 3>*>(reducer::get_device_buffer())),
         init_(false)
       { ; }
 
       __device__ __host__ void init()
       {
         if (!init_) {
-          double3 result = *Ar3;
-          a = a.real() * complex<real>((real)result.x, (real)result.y) * ((real)1.0 / (real)result.z);
+          auto result = *Ar3;
+          a = a.real() * complex<real>((real)result[0], (real)result[1]) / (real)result[2];
           init_ = true;
         }
       }
@@ -409,7 +409,7 @@ namespace quda
       static constexpr memory_access<0, 1, 1, 1> write{ };
       const real a;
       const real b;
-      tripleCGUpdate_(const real &a, const real &b, const real &) : a(a), b(b) { ; }
+      tripleCGUpdate_(const real_t &a, const real_t &b, const real_t &) : a(a), b(b) { ; }
       template <typename T> __device__ __host__ void operator()(T &x, T &y, T &z, T &w, T &) const
       {
 #pragma unroll
diff --git a/include/kernels/clover_compute.cuh b/include/kernels/clover_compute.cuh
index 67f5560845..897af593fa 100644
--- a/include/kernels/clover_compute.cuh
+++ b/include/kernels/clover_compute.cuh
@@ -22,7 +22,7 @@ namespace quda {
     int X[4]; // grid dimensions
     real coeff;
     
-    CloverArg(CloverField &clover, const GaugeField &f, double coeff) :
+    CloverArg(CloverField &clover, const GaugeField &f, real_t coeff) :
       kernel_param(dim3(f.VolumeCB(), 2, 1)),
       clover(clover, 0),
       f(f),
diff --git a/include/kernels/clover_invert.cuh b/include/kernels/clover_invert.cuh
index 42292b7a83..c0dfb00946 100644
--- a/include/kernels/clover_invert.cuh
+++ b/include/kernels/clover_invert.cuh
@@ -7,7 +7,7 @@
 namespace quda
 {
 
-  template <typename store_t_, bool twist_> struct CloverInvertArg : public ReduceArg<array<double, 2>> {
+  template <typename store_t_, bool twist_> struct CloverInvertArg : public ReduceArg<array<device_reduce_t, 2>> {
     using store_t = store_t_;
     using real = typename mapper<store_t>::type;
     static constexpr bool twist = twist_;
diff --git a/include/kernels/clover_sigma_outer_product.cuh b/include/kernels/clover_sigma_outer_product.cuh
index 91d2de8ef5..039392b2ab 100644
--- a/include/kernels/clover_sigma_outer_product.cuh
+++ b/include/kernels/clover_sigma_outer_product.cuh
@@ -27,15 +27,15 @@ namespace quda
 
     CloverSigmaOprodArg(GaugeField &oprod, const std::vector<ColorSpinorField*> &inA,
                         const std::vector<ColorSpinorField*> &inB,
-                        const std::vector<std::vector<double>> &coeff_) :
+                        const std::vector<std::vector<real_t>> &coeff_) :
       kernel_param(dim3(oprod.VolumeCB(), 2, 6)),
       oprod(oprod),
       inA{*inA[0]},
       inB{*inB[0]}
     {
       for (int i = 0; i < nvector; i++) {
-        coeff[i][0] = coeff_[i][0];
-        coeff[i][1] = coeff_[i][1];
+        coeff[i][0] = real(coeff_[i][0]);
+        coeff[i][1] = real(coeff_[i][1]);
       }
     }
   };
diff --git a/include/kernels/coarse_op_kernel.cuh b/include/kernels/coarse_op_kernel.cuh
index b63bf7f435..df66698cca 100644
--- a/include/kernels/coarse_op_kernel.cuh
+++ b/include/kernels/coarse_op_kernel.cuh
@@ -164,7 +164,7 @@ namespace quda {
     CalculateYArg(coarseGauge &Y, coarseGauge &X,
       coarseGaugeAtomic &Y_atomic, coarseGaugeAtomic &X_atomic,
       fineSpinorUV &UV, fineSpinorAV &AV, const fineGauge &U, const fineGauge &L, const fineGauge &K, const fineSpinorV &V,
-      const fineClover &C, const fineClover &Cinv, const ColorSpinorField &v, double kappa, double mass, double mu, double mu_factor,
+      const fineClover &C, const fineClover &Cinv, const ColorSpinorField &v, real_t kappa, real_t mass, real_t mu, real_t mu_factor,
       const int *x_size_, const int *xc_size_, int spin_bs_,
       const int *fine_to_coarse, const int *coarse_to_fine, bool bidirectional)
       : Y(Y), X(X), Y_atomic(Y_atomic), X_atomic(X_atomic),
diff --git a/include/kernels/dslash_clover_helper.cuh b/include/kernels/dslash_clover_helper.cuh
index 00b61a9b3e..03685b9f62 100644
--- a/include/kernels/dslash_clover_helper.cuh
+++ b/include/kernels/dslash_clover_helper.cuh
@@ -43,7 +43,7 @@ namespace quda {
     QudaTwistGamma5Type twist;
 
     CloverArg(ColorSpinorField &out, const ColorSpinorField &in, const CloverField &clover,
-	      int parity, real kappa=0.0, real mu=0.0, real epsilon = 0.0,
+	      int parity, real_t kappa=0.0, real_t mu=0.0, real_t epsilon = 0.0,
 	      bool dagger = false, QudaTwistGamma5Type twist = QUDA_TWIST_GAMMA5_INVALID) :
       kernel_param(dim3(in.TwistFlavor() == QUDA_TWIST_NONDEG_DOUBLET ? in.VolumeCB()/2 : in.VolumeCB(),
                         in.TwistFlavor() == QUDA_TWIST_NONDEG_DOUBLET ? 2 : 1, in.SiteSubset())),
@@ -58,20 +58,20 @@ namespace quda {
       checkLocation(out, in, clover);
       if (in.TwistFlavor() == QUDA_TWIST_SINGLET) {
         if (twist == QUDA_TWIST_GAMMA5_DIRECT) {
-          a = 2.0 * kappa * mu;
+          a = real(2.0 * kappa * mu);
           b = 1.0;
         } else if (twist == QUDA_TWIST_GAMMA5_INVERSE) {
-          a = -2.0 * kappa * mu;
+          a = -real(2.0 * kappa * mu);
           b = 1.0 / (1.0 + a*a);
         }
         if (dagger) a *= -1.0;
       } else if (doublet) {
         if (twist == QUDA_TWIST_GAMMA5_DIRECT){
-          a = 2.0 * kappa * mu;
-          b = -2.0 * kappa * epsilon;
+          a = real(2.0 * kappa * mu);
+          b = -real(2.0 * kappa * epsilon);
         } else if (twist == QUDA_TWIST_GAMMA5_INVERSE) {
-          a = -2.0 * kappa * mu;
-          b = 2.0 * kappa * epsilon;
+          a = -real(2.0 * kappa * mu);
+          b = real(2.0 * kappa * epsilon);
         }
         if (dagger) a *= -1.0;
       }
diff --git a/include/kernels/dslash_domain_wall_4d.cuh b/include/kernels/dslash_domain_wall_4d.cuh
index 09a09a9f3e..f6f961a9d0 100644
--- a/include/kernels/dslash_domain_wall_4d.cuh
+++ b/include/kernels/dslash_domain_wall_4d.cuh
@@ -11,16 +11,16 @@ namespace quda
     int Ls;                             /** fifth dimension length */
     complex<real> a_5[QUDA_MAX_DWF_LS]; /** xpay scale factor for each 4-d subvolume */
 
-    DomainWall4DArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_5,
-                    const Complex *b_5, const Complex *c_5, bool xpay, const ColorSpinorField &x, int parity,
+    DomainWall4DArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_5,
+                    const complex_t *b_5, const complex_t *c_5, bool xpay, const ColorSpinorField &x, int parity,
                     bool dagger, const int *comm_override) :
-      WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? a : 0.0, x, parity, dagger, comm_override),
+      WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? a : real_t(0.0), x, parity, dagger, comm_override),
       Ls(in.X(4))
     {
       if (b_5 == nullptr || c_5 == nullptr)
-        for (int s = 0; s < Ls; s++) a_5[s] = a; // 4-d Shamir
+        for (int s = 0; s < Ls; s++) a_5[s] = real(a); // 4-d Shamir
       else
-        for (int s = 0; s < Ls; s++) a_5[s] = 0.5 * a / (b_5[s] * (m_5 + 4.0) + 1.0); // 4-d Mobius
+        for (int s = 0; s < Ls; s++) a_5[s] = complex<real>(real_t(0.5) * a / (b_5[s] * (m_5 + real_t(4.0)) + real_t(1.0))); // 4-d Mobius
     }
   };
 
diff --git a/include/kernels/dslash_domain_wall_4d_fused_m5.cuh b/include/kernels/dslash_domain_wall_4d_fused_m5.cuh
index dfcd519214..7e3614976c 100644
--- a/include/kernels/dslash_domain_wall_4d_fused_m5.cuh
+++ b/include/kernels/dslash_domain_wall_4d_fused_m5.cuh
@@ -40,16 +40,16 @@ namespace quda
 
     bool fuse_m5inv_m5pre;
 
-    DomainWall4DFusedM5Arg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_5,
-                           const Complex *b_5, const Complex *c_5, bool xpay, const ColorSpinorField &x,
-                           ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f) :
+    DomainWall4DFusedM5Arg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_5,
+                           const complex_t *b_5, const complex_t *c_5, bool xpay, const ColorSpinorField &x,
+                           ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f) :
       DomainWall4DArg(out, in, U, a, m_5, b_5, c_5, xpay, x, parity, dagger, comm_override),
       Dslash5Arg(out, in, x, m_f, m_5, b_5, c_5, a),
       y(y)
     {
       for (int s = 0; s < Ls; s++) {
-        auto kappa_b_s = 0.5 / (b_5[s] * (m_5 + 4.0) + 1.0);
-        a_5[s] = a * kappa_b_s * kappa_b_s;
+        auto kappa_b_s = real_t(0.5) / (b_5[s] * (real_t(m_5) + real_t(4.0)) + real_t(1.0));
+        a_5[s] = static_cast<complex<real>>(a * kappa_b_s * kappa_b_s);
       }; // 4-d Mobius
     }
   };
diff --git a/include/kernels/dslash_domain_wall_5d.cuh b/include/kernels/dslash_domain_wall_5d.cuh
index c9c344df3d..624e2e6360 100644
--- a/include/kernels/dslash_domain_wall_5d.cuh
+++ b/include/kernels/dslash_domain_wall_5d.cuh
@@ -14,7 +14,7 @@ namespace quda
     real a;   /** xpay scale factor */
     real m_f; /** fermion mass parameter */
 
-    DomainWall5DArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_f,
+    DomainWall5DArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_f,
                     bool xpay, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? a : 0.0, x, parity, dagger, comm_override),
       Ls(in.X(4)),
diff --git a/include/kernels/dslash_domain_wall_m5.cuh b/include/kernels/dslash_domain_wall_m5.cuh
index bab21d4c11..8c7b03a86c 100644
--- a/include/kernels/dslash_domain_wall_m5.cuh
+++ b/include/kernels/dslash_domain_wall_m5.cuh
@@ -110,25 +110,25 @@ namespace quda
 
     coeff_5<real> coeff; // constant buffer used for Mobius coefficients for CPU kernel
 
-    void compute_coeff_mobius_pre(const Complex *b_5, const Complex *c_5)
+    void compute_coeff_mobius_pre(const complex_t *b_5, const complex_t *c_5)
     {
       // out = (b + c * D5) * in
       for (int s = 0; s < Ls; s++) {
         coeff.beta[s] = b_5[s];
-        coeff.alpha[s] = 0.5 * c_5[s]; // 0.5 from gamma matrices
+        coeff.alpha[s] = 0.5 * complex<double>(c_5[s]); // 0.5 from gamma matrices
         // xpay
-        coeff.a[s] = 0.5 / (b_5[s] * (m_5 + 4.0) + 1.0);
+        coeff.a[s] = 0.5 / (complex<double>(b_5[s]) * (m_5 + 4.0) + 1.0);
         coeff.a[s] *= coeff.a[s] * static_cast<real>(a); // kappa_b * kappa_b * a
       }
     }
 
-    void compute_coeff_mobius(const Complex *b_5, const Complex *c_5)
+    void compute_coeff_mobius(const complex_t *b_5, const complex_t *c_5)
     {
       // out = (1 + kappa * D5) * in
       for (int s = 0; s < Ls; s++) {
-        coeff.kappa[s] = 0.5 * (c_5[s] * (m_5 + 4.0) - 1.0) / (b_5[s] * (m_5 + 4.0) + 1.0); // 0.5 from gamma matrices
+        coeff.kappa[s] = 0.5 * (complex<double>(c_5[s]) * (m_5 + 4.0) - 1.0) / (complex<double>(b_5[s]) * (m_5 + 4.0) + 1.0); // 0.5 from gamma matrices
         // axpy
-        coeff.a[s] = 0.5 / (b_5[s] * (m_5 + 4.0) + 1.0);
+        coeff.a[s] = 0.5 / (complex<double>(b_5[s]) * (m_5 + 4.0) + 1.0);
         coeff.a[s] *= coeff.a[s] * static_cast<real>(a); // kappa_b * kappa_b * a
       }
     }
@@ -139,33 +139,33 @@ namespace quda
       inv = 0.5 / (1.0 + std::pow(kappa, (int)Ls) * m_f);
     }
 
-    void compute_coeff_m5inv_mobius(const Complex *b_5, const Complex *c_5)
+    void compute_coeff_m5inv_mobius(const complex_t *b_5, const complex_t *c_5)
     {
       // out = (1 + kappa * D5)^-1 * in = M5inv * in
-      kappa = -(c_5[0].real() * (4.0 + m_5) - 1.0) / (b_5[0].real() * (4.0 + m_5) + 1.0); // kappa = kappa_b / kappa_c
+      kappa = -(double(c_5[0].real()) * (4.0 + m_5) - 1.0) / (double(b_5[0].real()) * (4.0 + m_5) + 1.0); // kappa = kappa_b / kappa_c
       inv = 0.5 / (1.0 + std::pow(kappa, (int)Ls) * m_f);                                 // 0.5 from gamma matrices
-      a *= pow(0.5 / (b_5[0].real() * (m_5 + 4.0) + 1.0), 2);                             // kappa_b * kappa_b * a
+      a *= pow(0.5 / (double(b_5[0].real()) * (m_5 + 4.0) + 1.0), 2);                             // kappa_b * kappa_b * a
     }
 
-    void compute_coeff_m5inv_zmobius(const Complex *b_5, const Complex *c_5)
+    void compute_coeff_m5inv_zmobius(const complex_t *b_5, const complex_t *c_5)
     {
       // out = (1 + kappa * D5)^-1 * in = M5inv * in
       // Similar to mobius convention, but variadic across 5th dim
       complex<real> k = 1.0;
       for (int s = 0; s < Ls; s++) {
-        coeff.kappa[s] = -(c_5[s] * (4.0 + m_5) - 1.0) / (b_5[s] * (4.0 + m_5) + 1.0);
+        coeff.kappa[s] = -(complex<double>(c_5[s]) * (4.0 + m_5) - 1.0) / (complex<double>(b_5[s]) * (4.0 + m_5) + 1.0);
         k *= coeff.kappa[s];
       }
       coeff.inv = static_cast<real>(0.5) / (static_cast<real>(1.0) + k * m_f);
 
       for (int s = 0; s < Ls; s++) { // axpy coefficients
-        coeff.a[s] = 0.5 / (b_5[s] * (m_5 + 4.0) + 1.0);
+        coeff.a[s] = 0.5 / (complex<double>(b_5[s]) * (m_5 + 4.0) + 1.0);
         coeff.a[s] *= coeff.a[s] * static_cast<real>(a);
       }
     }
 
-    Dslash5Arg(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double m_f, double m_5,
-               const Complex *b_5, const Complex *c_5, double a_) :
+    Dslash5Arg(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t m_f, real_t m_5,
+               const complex_t *b_5, const complex_t *c_5, real_t a_) :
       kernel_param(dim3(in.VolumeCB() / in.X(4), in.X(4), in.SiteSubset())),
       out(out),
       in(in),
diff --git a/include/kernels/dslash_gamma_helper.cuh b/include/kernels/dslash_gamma_helper.cuh
index 3b5e27492a..041cba0586 100644
--- a/include/kernels/dslash_gamma_helper.cuh
+++ b/include/kernels/dslash_gamma_helper.cuh
@@ -27,7 +27,7 @@ namespace quda {
     real c;               // flavor twist
 
     GammaArg(ColorSpinorField &out, const ColorSpinorField &in, int d,
-	     real kappa=0.0, real mu=0.0, real epsilon=0.0,
+	     real_t kappa=0.0, real_t mu=0.0, real_t epsilon=0.0,
 	     bool dagger=false, QudaTwistGamma5Type twist=QUDA_TWIST_GAMMA5_INVALID) :
       out(out), in(in), d(d), nParity(in.SiteSubset()),
       doublet(in.TwistFlavor() == QUDA_TWIST_NONDEG_DOUBLET),
@@ -41,24 +41,24 @@ namespace quda {
 
       if (in.TwistFlavor() == QUDA_TWIST_SINGLET) {
 	if (twist == QUDA_TWIST_GAMMA5_DIRECT) {
-          b = 2.0 * kappa * mu;
+          b = real(2.0 * kappa * mu);
           a = 1.0;
         } else if (twist == QUDA_TWIST_GAMMA5_INVERSE) {
-          b = -2.0 * kappa * mu;
+          b = -real(2.0 * kappa * mu);
           a = 1.0 / (1.0 + b * b);
         }
 	c = 0.0;
         if (dagger) b *= -1.0;
       } else if (doublet) {
         if (twist == QUDA_TWIST_GAMMA5_DIRECT) {
-          b = 2.0 * kappa * mu;
-          c = -2.0 * kappa * epsilon;
+          b = real(2.0 * kappa * mu);
+          c = -real(2.0 * kappa * epsilon);
           a = 1.0;
         } else if (twist == QUDA_TWIST_GAMMA5_INVERSE) {
-          b = -2.0 * kappa * mu;
-          c = 2.0 * kappa * epsilon;
+          b = -real(2.0 * kappa * mu);
+          c = real(2.0 * kappa * epsilon);
           a = 1.0 / (1.0 + b * b - c * c);
-          if (a <= 0) errorQuda("Invalid twisted mass parameters (kappa=%e, mu=%e, epsilon=%e)\n", kappa, mu, epsilon);
+          if (a <= 0) errorQuda("Invalid twisted mass parameters (kappa=%e, mu=%e, epsilon=%e)\n", double(kappa), double(mu), double(epsilon));
         }
         if (dagger) b *= -1.0;
       }
diff --git a/include/kernels/dslash_mdw_fused.cuh b/include/kernels/dslash_mdw_fused.cuh
index 67f98b30cc..be3b6e31e7 100644
--- a/include/kernels/dslash_mdw_fused.cuh
+++ b/include/kernels/dslash_mdw_fused.cuh
@@ -87,7 +87,7 @@ namespace quda {
       const bool comm[4];
 
       FusedDslashArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, ColorSpinorField &y,
-                     const ColorSpinorField &x, double m_f_, double m_5_, const Complex *b_5, const Complex *c_5,
+                     const ColorSpinorField &x, real_t m_f_, real_t m_5_, const complex_t *b_5, const complex_t *c_5,
                      int parity, int shift_[4], int halo_shift_[4]) :
         out(out),
         in(in),
@@ -116,8 +116,8 @@ namespace quda {
 
         if (b_5[0] != b_5[1] || b_5[0].imag() != 0) { errorQuda("zMobius is NOT supported yet.\n"); }
 
-        b = b_5[0].real();
-        c = c_5[0].real();
+        b = double(b_5[0].real());
+        c = double(c_5[0].real());
         kappa = -(c * (4. + m_5) - 1.) / (b * (4. + m_5) + 1.); // This is actually -kappa in my(Jiqun Tu) notes.
 
         if (kappa * kappa < 1e-6) { small_kappa = true; }
diff --git a/include/kernels/dslash_mobius_eofa.cuh b/include/kernels/dslash_mobius_eofa.cuh
index f5e0a5c8ac..fceca25c70 100644
--- a/include/kernels/dslash_mobius_eofa.cuh
+++ b/include/kernels/dslash_mobius_eofa.cuh
@@ -52,9 +52,9 @@ namespace quda
 
       eofa_coeff<real> coeff;
 
-      Dslash5Arg(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const double m_f_,
-                 const double m_5_, const Complex */*b_5_*/, const Complex */*c_5_*/, double a_, double inv_, double kappa_,
-                 const double *eofa_u, const double *eofa_x, const double *eofa_y, double sherman_morrison_) :
+      Dslash5Arg(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const real_t m_f_,
+                 const real_t m_5_, const complex_t */*b_5_*/, const complex_t */*c_5_*/, real_t a_, real_t inv_, real_t kappa_,
+                 const real_t *eofa_u, const real_t *eofa_x, const real_t *eofa_y, real_t sherman_morrison_) :
         kernel_param(dim3(in.VolumeCB() / in.X(4), in.X(4), in.SiteSubset())),
         out(out),
         in(in),
@@ -76,13 +76,13 @@ namespace quda
 
         switch (type) {
         case Dslash5Type::M5_EOFA:
-          for (int s = 0; s < Ls; s++) { coeff.u[s] = eofa_u[s]; }
+          for (int s = 0; s < Ls; s++) { coeff.u[s] = real(eofa_u[s]); }
           break;
         case Dslash5Type::M5INV_EOFA:
           for (int s = 0; s < Ls; s++) {
-            coeff.u[s] = eofa_u[s];
-            coeff.x[s] = eofa_x[s];
-            coeff.y[s] = eofa_y[s];
+            coeff.u[s] = real(eofa_u[s]);
+            coeff.x[s] = real(eofa_x[s]);
+            coeff.y[s] = real(eofa_y[s]);
           }
           break;
         default: errorQuda("Unexpected EOFA Dslash5Type %d", static_cast<int>(type));
diff --git a/include/kernels/dslash_ndeg_twisted_clover.cuh b/include/kernels/dslash_ndeg_twisted_clover.cuh
index 108f8c5e84..b052c90076 100644
--- a/include/kernels/dslash_ndeg_twisted_clover.cuh
+++ b/include/kernels/dslash_ndeg_twisted_clover.cuh
@@ -21,8 +21,8 @@ namespace quda
     real c; /** this is the flavor twist factor */
     
   NdegTwistedCloverArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                       const CloverField &A, double a, double b,
-                       double c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
+                       const CloverField &A, real_t a, real_t b,
+                       real_t c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a, x, parity, dagger, comm_override),
       A(A, false),
       a(a),
diff --git a/include/kernels/dslash_ndeg_twisted_clover_preconditioned.cuh b/include/kernels/dslash_ndeg_twisted_clover_preconditioned.cuh
index bdbff30817..6f970558ce 100644
--- a/include/kernels/dslash_ndeg_twisted_clover_preconditioned.cuh
+++ b/include/kernels/dslash_ndeg_twisted_clover_preconditioned.cuh
@@ -25,7 +25,7 @@ namespace quda
 
   NdegTwistedCloverPreconditionedArg(ColorSpinorField &out, const ColorSpinorField &in,
                                      const GaugeField &U, const CloverField &A,
-                                     double a, double b, double c, bool xpay,
+                                     real_t a, real_t b, real_t c, bool xpay,
                                      const ColorSpinorField &x, int parity, bool dagger,
                                      const int *comm_override) :
     WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? 1.0 : 0.0, x, parity, dagger, comm_override),
diff --git a/include/kernels/dslash_ndeg_twisted_mass.cuh b/include/kernels/dslash_ndeg_twisted_mass.cuh
index 2f88d5ee48..fd6ee8b3f6 100644
--- a/include/kernels/dslash_ndeg_twisted_mass.cuh
+++ b/include/kernels/dslash_ndeg_twisted_mass.cuh
@@ -12,8 +12,8 @@ namespace quda
     real b; /** this is the chiral twist factor */
     real c; /** this is the flavor twist factor */
 
-    NdegTwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
-                       double c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
+    NdegTwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
+                       real_t c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a, x, parity, dagger, comm_override),
       a(a),
       b(dagger ? -b : b), // if dagger flip the chiral twist
diff --git a/include/kernels/dslash_ndeg_twisted_mass_preconditioned.cuh b/include/kernels/dslash_ndeg_twisted_mass_preconditioned.cuh
index 98e72eb61a..16d052e895 100644
--- a/include/kernels/dslash_ndeg_twisted_mass_preconditioned.cuh
+++ b/include/kernels/dslash_ndeg_twisted_mass_preconditioned.cuh
@@ -18,8 +18,8 @@ namespace quda
     real b_inv;      /** inverse chiral twist factor - used to allow early xpay inclusion */
     real c_inv;      /** inverse flavor twist factor - used to allow early xpay inclusion */
 
-    NdegTwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
-                       double c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
+    NdegTwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
+                       real_t c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? 1.0 : 0.0, x, parity, dagger, comm_override),
       a(a),
       b(dagger ? -b : b), // if dagger flip the chiral twist
diff --git a/include/kernels/dslash_pack.cuh b/include/kernels/dslash_pack.cuh
index b4c22a4bb9..dfaf6ad81a 100644
--- a/include/kernels/dslash_pack.cuh
+++ b/include/kernels/dslash_pack.cuh
@@ -71,8 +71,8 @@ namespace quda
 #else
     static constexpr int shmem = 0;
 #endif
-    PackArg(void **ghost, const ColorSpinorField &in, int nFace, int parity, int work_items, double a, double b,
-            double c, unsigned int block, unsigned int grid,
+    PackArg(void **ghost, const ColorSpinorField &in, int nFace, int parity, int work_items, real_t a, real_t b,
+            real_t c, unsigned int block, unsigned int grid,
 #ifdef NVSHMEM_COMMS
             int shmem_) :
 #else
diff --git a/include/kernels/dslash_staggered.cuh b/include/kernels/dslash_staggered.cuh
index deb38455f8..a2fae64ef9 100644
--- a/include/kernels/dslash_staggered.cuh
+++ b/include/kernels/dslash_staggered.cuh
@@ -49,7 +49,7 @@ namespace quda
 
     const real dagger_scale;
 
-    StaggeredArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const GaugeField &L, double a,
+    StaggeredArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const GaugeField &L, real_t a,
                  const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       DslashArg<Float, nDim>(out, in, U, x, parity, dagger, a == 0.0 ? false : true, improved_ ? 3 : 1, spin_project,
                              comm_override),
diff --git a/include/kernels/dslash_twisted_clover_preconditioned.cuh b/include/kernels/dslash_twisted_clover_preconditioned.cuh
index bc46d106f4..9284c20426 100644
--- a/include/kernels/dslash_twisted_clover_preconditioned.cuh
+++ b/include/kernels/dslash_twisted_clover_preconditioned.cuh
@@ -22,7 +22,7 @@ namespace quda
     real b2;
 
     TwistedCloverArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-                     double a, double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
+                     real_t a, real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
                      const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? 1.0 : 0.0, x, parity, dagger, comm_override),
       A(A, false),
diff --git a/include/kernels/dslash_twisted_mass.cuh b/include/kernels/dslash_twisted_mass.cuh
index 85230c729d..b47a0fff43 100644
--- a/include/kernels/dslash_twisted_mass.cuh
+++ b/include/kernels/dslash_twisted_mass.cuh
@@ -11,7 +11,7 @@ namespace quda
     real a; /** xpay scale facotor */
     real b; /** this is the twist factor */
 
-    TwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
+    TwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
                    const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a, x, parity, dagger, comm_override),
       a(a),
diff --git a/include/kernels/dslash_twisted_mass_preconditioned.cuh b/include/kernels/dslash_twisted_mass_preconditioned.cuh
index 496e12276d..bf62192548 100644
--- a/include/kernels/dslash_twisted_mass_preconditioned.cuh
+++ b/include/kernels/dslash_twisted_mass_preconditioned.cuh
@@ -15,7 +15,7 @@ namespace quda
     real a_inv;      /** inverse scaling factor - used to allow early xpay inclusion */
     real b_inv;      /** inverse twist factor - used to allow early xpay inclusion */
 
-    TwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b, bool xpay,
+    TwistedMassArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b, bool xpay,
                    const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, xpay ? 1.0 : 0.0, x, parity, dagger, comm_override),
       a(a),
diff --git a/include/kernels/dslash_wilson.cuh b/include/kernels/dslash_wilson.cuh
index f87e8f9865..7720a21bda 100644
--- a/include/kernels/dslash_wilson.cuh
+++ b/include/kernels/dslash_wilson.cuh
@@ -36,9 +36,9 @@ namespace quda
     const G U;    /** the gauge field */
     const real a; /** xpay scale factor - can be -kappa or -kappa^2 */
 
-    WilsonArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
+    WilsonArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
               const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
-      DslashArg<Float, nDim>(out, in, U, x, parity, dagger, a != 0.0 ? true : false, 1, spin_project, comm_override),
+      DslashArg<Float, nDim>(out, in, U, x, parity, dagger, a != real_t(0.0) ? true : false, 1, spin_project, comm_override),
       out(out),
       in(in),
       in_pack(in),
diff --git a/include/kernels/dslash_wilson_clover.cuh b/include/kernels/dslash_wilson_clover.cuh
index ffc8b880e8..09036b0405 100644
--- a/include/kernels/dslash_wilson_clover.cuh
+++ b/include/kernels/dslash_wilson_clover.cuh
@@ -21,7 +21,7 @@ namespace quda
     const real b; /** chiral twist factor (twisted-clover only) */
 
     WilsonCloverArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-                    double a, double b, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
+                    real_t a, real_t b, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a, x, parity, dagger, comm_override),
       A(A, false),
       a(a),
diff --git a/include/kernels/dslash_wilson_clover_hasenbusch_twist.cuh b/include/kernels/dslash_wilson_clover_hasenbusch_twist.cuh
index e6923bf707..80946efbd1 100644
--- a/include/kernels/dslash_wilson_clover_hasenbusch_twist.cuh
+++ b/include/kernels/dslash_wilson_clover_hasenbusch_twist.cuh
@@ -20,7 +20,7 @@ namespace quda
     const real b; /** chiral twist factor (twisted-clover only) */
 
     WilsonCloverHasenbuschTwistArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                   const CloverField &A, double a, double b, const ColorSpinorField &x, int parity,
+                                   const CloverField &A, real_t a, real_t b, const ColorSpinorField &x, int parity,
                                    bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a, x, parity, dagger, comm_override),
       A(A, false),
diff --git a/include/kernels/dslash_wilson_clover_hasenbusch_twist_preconditioned.cuh b/include/kernels/dslash_wilson_clover_hasenbusch_twist_preconditioned.cuh
index b9a1599e94..66b4baa37b 100644
--- a/include/kernels/dslash_wilson_clover_hasenbusch_twist_preconditioned.cuh
+++ b/include/kernels/dslash_wilson_clover_hasenbusch_twist_preconditioned.cuh
@@ -22,7 +22,7 @@ namespace quda
     real b;
 
     WilsonCloverHasenbuschTwistPCArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                     const CloverField &A_, double a_, double b_, const ColorSpinorField &x, int parity,
+                                     const CloverField &A_, real_t a_, real_t b_, const ColorSpinorField &x, int parity,
                                      bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a_, x, parity, dagger, comm_override),
       A(A_, false),
diff --git a/include/kernels/dslash_wilson_clover_preconditioned.cuh b/include/kernels/dslash_wilson_clover_preconditioned.cuh
index 9adbc64343..ca73f5b2b3 100644
--- a/include/kernels/dslash_wilson_clover_preconditioned.cuh
+++ b/include/kernels/dslash_wilson_clover_preconditioned.cuh
@@ -20,7 +20,7 @@ namespace quda
     const real a; /** xpay scale factor */
 
     WilsonCloverArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-                    double a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
+                    real_t a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       WilsonArg<Float, nColor, nDim, reconstruct_>(out, in, U, a, x, parity, dagger, comm_override),
       A(A, dynamic_clover ? false : true), // if dynamic clover we don't want the inverse field
       a(a)
diff --git a/include/kernels/gauge_det_trace.cuh b/include/kernels/gauge_det_trace.cuh
index bc4fc5d5fa..d40f028a95 100644
--- a/include/kernels/gauge_det_trace.cuh
+++ b/include/kernels/gauge_det_trace.cuh
@@ -9,7 +9,7 @@ namespace quda {
   enum struct compute_type { determinant, trace };
 
   template <typename Float, int nColor_, QudaReconstructType recon_, compute_type type_>
-  struct KernelArg : public ReduceArg<array<double, 2>> {
+  struct KernelArg : public ReduceArg<array<device_reduce_t, 2>> {
     static constexpr int nColor = nColor_;
     static constexpr QudaReconstructType recon = recon_;
     static constexpr compute_type type = type_;
@@ -52,14 +52,15 @@ namespace quda {
         x[dr] += arg.border[dr];
         X[dr] += 2*arg.border[dr];
       }
+
+      complex<double> local = {};
 #pragma unroll
       for (int mu = 0; mu < 4; mu++) {
         Matrix<complex<typename Arg::real>, Arg::nColor> U = arg.u(mu, linkIndex(x, X), parity);
-        auto local = Arg::type == compute_type::determinant ? getDeterminant(U) : getTrace(U);
-        value = operator()(value, reduce_t{local.real(), local.imag()});
+        local += Arg::type == compute_type::determinant ? getDeterminant(U) : getTrace(U);
       }
 
-      return value;
+      return operator()(value, array<double, 2>{local.real(), local.imag()});
     }
   };
 
diff --git a/include/kernels/gauge_fix_fft.cuh b/include/kernels/gauge_fix_fft.cuh
index 06b0f89b0f..c0c86088ba 100644
--- a/include/kernels/gauge_fix_fft.cuh
+++ b/include/kernels/gauge_fix_fft.cuh
@@ -83,7 +83,7 @@ namespace quda {
     Float alpha;
     int volume;
 
-    GaugeFixArg(GaugeField &data, double alpha) :
+    GaugeFixArg(GaugeField &data, real_t alpha) :
       kernel_param(dim3(data.VolumeCB(), 2, 1)),
       data(data),
       alpha(static_cast<Float>(alpha)),
@@ -150,7 +150,7 @@ namespace quda {
    * @brief container to pass parameters for the gauge fixing quality kernel
    */
   template <typename store_t, QudaReconstructType recon_, int gauge_dir_>
-  struct GaugeFixQualityFFTArg : public ReduceArg<array<double, 2>> {
+  struct GaugeFixQualityFFTArg : public ReduceArg<array<device_reduce_t, 2>> {
     using real = typename mapper<store_t>::type;
     static constexpr QudaReconstructType recon = recon_;
     using Gauge = typename gauge_mapper<store_t, recon>::type;
@@ -159,7 +159,7 @@ namespace quda {
     int_fastdiv X[4];     // grid dimensions
     Gauge data;
     complex<real> *delta;
-    reduce_t result;
+    array<real_t, 2> result;
     int volume;
 
     GaugeFixQualityFFTArg(const GaugeField &data, complex<real> *delta) :
@@ -172,8 +172,8 @@ namespace quda {
       for (int dir = 0; dir < 4; dir++) X[dir] = data.X()[dir];
     }
 
-    double getAction() { return result[0]; }
-    double getTheta() { return result[1]; }
+    real_t getAction() { return result[0]; }
+    real_t getTheta() { return result[1]; }
   };
 
   template <typename Arg> struct FixQualityFFT : plus<typename Arg::reduce_t> {
@@ -189,7 +189,7 @@ namespace quda {
      */
     __device__ __host__ inline reduce_t operator()(reduce_t &value, int x_cb, int parity)
     {
-      reduce_t data{0, 0};
+      array<double, 2> data = {};
       using matrix = Matrix<complex<typename Arg::real>, 3>;
       int x[4];
       getCoords(x, x_cb, arg.X, parity);
@@ -227,7 +227,7 @@ namespace quda {
 
       //35
       //T=36*gauge_dir+65
-      return operator()(data, value);
+      return operator()(value, data);
     }
   };
 
diff --git a/include/kernels/gauge_fix_ovr.cuh b/include/kernels/gauge_fix_ovr.cuh
index 644d9c2463..a678d422ec 100644
--- a/include/kernels/gauge_fix_ovr.cuh
+++ b/include/kernels/gauge_fix_ovr.cuh
@@ -14,7 +14,7 @@ namespace quda {
    * @brief container to pass parameters for the gauge fixing quality kernel
    */
   template <typename store_t, QudaReconstructType recon_, int gauge_dir_>
-  struct GaugeFixQualityOVRArg : public ReduceArg<array<double, 2>> {
+  struct GaugeFixQualityOVRArg : public ReduceArg<array<device_reduce_t, 2>> {
     using real = typename mapper<store_t>::type;
     static constexpr QudaReconstructType recon = recon_;
     using Gauge = typename gauge_mapper<store_t, recon>::type;
@@ -23,7 +23,7 @@ namespace quda {
     int X[4]; // grid dimensions
     int border[4];
     Gauge data;
-    reduce_t result;
+    array<real_t, 2> result;
 
     GaugeFixQualityOVRArg(const GaugeField &data) :
       ReduceArg<reduce_t>(dim3(data.LocalVolumeCB(), 2, 1), 1, true), // reset = true
@@ -36,8 +36,8 @@ namespace quda {
       }
     }
 
-    double getAction(){ return result[0]; }
-    double getTheta(){ return result[1]; }
+    auto getAction(){ return result[0]; }
+    auto getTheta(){ return result[1]; }
   };
 
   template <typename Arg> struct FixQualityOVR : plus<typename Arg::reduce_t> {
@@ -53,7 +53,7 @@ namespace quda {
      */
     __device__ __host__ inline reduce_t operator()(reduce_t &value, int x_cb, int parity)
     {
-      reduce_t data{0, 0};
+      array<double, 2> data = {};
       using Link = Matrix<complex<typename Arg::real>, 3>;
 
       int X[4];
@@ -93,7 +93,7 @@ namespace quda {
       //35
       //T=36*gauge_dir+65
 
-      return operator()(data, value);
+      return operator()(value, data);
     }
   };
 
@@ -113,7 +113,7 @@ namespace quda {
     int border[4];
     int *borderpoints[2];
 
-    GaugeFixArg(const GaugeField &u, const double relax_boost, int parity, int *borderpoints[2], unsigned threads) :
+    GaugeFixArg(const GaugeField &u, const real_t relax_boost, int parity, int *borderpoints[2], unsigned threads) :
       kernel_param(dim3(threads, type < 3 ? 8 : 4, 1)),
       u(u),
       relax_boost(static_cast<real>(relax_boost)),
diff --git a/include/kernels/gauge_force.cuh b/include/kernels/gauge_force.cuh
index 3647efdcf8..d749513af9 100644
--- a/include/kernels/gauge_force.cuh
+++ b/include/kernels/gauge_force.cuh
@@ -29,7 +29,7 @@ namespace quda {
     real epsilon; // stepsize and any other overall scaling factor
     const paths<4> p;
 
-    GaugeForceArg(GaugeField &mom, const GaugeField &u, double epsilon, const paths<4> &p) :
+    GaugeForceArg(GaugeField &mom, const GaugeField &u, real_t epsilon, const paths<4> &p) :
       kernel_param(dim3(mom.VolumeCB(), 2, 4)),
       mom(mom),
       u(u),
diff --git a/include/kernels/gauge_loop_trace.cuh b/include/kernels/gauge_loop_trace.cuh
index 9c6b6cc3f8..35a17a6f53 100644
--- a/include/kernels/gauge_loop_trace.cuh
+++ b/include/kernels/gauge_loop_trace.cuh
@@ -18,9 +18,8 @@ namespace quda {
   constexpr unsigned int max_n_batch_block_loop_trace() { return 8; }
 
   template <typename store_t, int nColor_, QudaReconstructType recon_>
-  struct GaugeLoopTraceArg : public ReduceArg<array<double, 2>>  {
+  struct GaugeLoopTraceArg : public ReduceArg<array<device_reduce_t, 2>>  {
     using real = typename mapper<store_t>::type;
-    using reduce_t = array<double, 2>;
     static constexpr unsigned int max_n_batch_block = max_n_batch_block_loop_trace();
     static constexpr int nColor = nColor_;
     static constexpr QudaReconstructType recon = recon_;
@@ -30,7 +29,7 @@ namespace quda {
 
     const Gauge u;
 
-    const double factor; // overall scaling factor for all loops
+    const real factor; // overall scaling factor for all loops
     static constexpr int nParity = 2; // always true for gauge fields
     int X[4]; // the regular volume parameters
     int E[4]; // the extended volume parameters
@@ -38,7 +37,7 @@ namespace quda {
 
     const paths<1> p;
 
-    GaugeLoopTraceArg(const GaugeField &u, double factor, const paths<1> &p) :
+    GaugeLoopTraceArg(const GaugeField &u, real_t factor, const paths<1> &p) :
       ReduceArg<reduce_t>(dim3(u.LocalVolumeCB(), 2, p.num_paths), p.num_paths),
       u(u),
       factor(factor),
@@ -65,16 +64,14 @@ namespace quda {
     {
       using Link = typename Arg::Link;
 
-      reduce_t loop_trace{0, 0};
-
       int x[4] = {0, 0, 0, 0};
       getCoords(x, x_cb, arg.X, parity);
       for (int dr=0; dr<4; ++dr) x[dr] += arg.border[dr]; // extended grid coordinates
 
       thread_array<int, 4> dx{0};
 
-      double coeff_loop = arg.factor * arg.p.path_coeff[path_id];
-      if (coeff_loop == 0) return operator()(loop_trace, value);
+      auto coeff_loop = arg.factor * arg.p.path_coeff[path_id];
+      if (coeff_loop == 0) return value;
 
       const int* path = arg.p.input_path[0] + path_id * arg.p.max_length;
 
@@ -84,10 +81,8 @@ namespace quda {
       // compute trace
       auto trace = getTrace(link_prod);
 
-      loop_trace[0] = coeff_loop * trace.real();
-      loop_trace[1] = coeff_loop * trace.imag();
-
-      return operator()(loop_trace, value);
+      array<double, 2> loop_trace = {coeff_loop * trace.real(), coeff_loop * trace.imag()};
+      return operator()(value, loop_trace);
     }
   };
 
diff --git a/include/kernels/gauge_phase.cuh b/include/kernels/gauge_phase.cuh
index ef57369cb8..03c674e08d 100644
--- a/include/kernels/gauge_phase.cuh
+++ b/include/kernels/gauge_phase.cuh
@@ -29,8 +29,8 @@ namespace quda {
       // else we are applying them
       Float dir = u.StaggeredPhaseApplied() ? -1.0 : 1.0;
 
-      i_mu_phase = complex<Float>( cos(M_PI * u.iMu() / (u.X()[3]*comm_dim(3)) ),
-				   dir * sin(M_PI * u.iMu() / (u.X()[3]*comm_dim(3))) );
+      i_mu_phase = complex( cos(M_PI * double(u.iMu()) / (u.X()[3]*comm_dim(3)) ),
+                            dir * sin(M_PI * double(u.iMu()) / (u.X()[3]*comm_dim(3))) );
 
       for (int d=0; d<4; d++) X[d] = u.X()[d];
 
diff --git a/include/kernels/gauge_plaq.cuh b/include/kernels/gauge_plaq.cuh
index 563d674000..0454817f9f 100644
--- a/include/kernels/gauge_plaq.cuh
+++ b/include/kernels/gauge_plaq.cuh
@@ -9,7 +9,7 @@
 namespace quda {
 
   template <typename Float_, int nColor_, QudaReconstructType recon_>
-  struct GaugePlaqArg : public ReduceArg<array<double, 2>> {
+  struct GaugePlaqArg : public ReduceArg<array<device_reduce_t, 2>> {
     using Float = Float_;
     static constexpr int nColor = nColor_;
     static_assert(nColor == 3, "Only nColor=3 enabled at this time");
@@ -62,7 +62,7 @@ namespace quda {
     // return the plaquette at site (x_cb, parity)
     __device__ __host__ inline reduce_t operator()(reduce_t &value, int x_cb, int parity)
     {
-      reduce_t plaq{0, 0};
+      array<double, 2> plaq {};
 
       int x[4];
       getCoords(x, x_cb, arg.X, parity);
@@ -79,7 +79,7 @@ namespace quda {
         plaq[1] += plaquette(arg, x, parity, mu, 3);
       }
 
-      return operator()(plaq, value);
+      return operator()(value, plaq);
     }
 
   };
diff --git a/include/kernels/gauge_polyakov_loop.cuh b/include/kernels/gauge_polyakov_loop.cuh
index 5ea4bc5219..06e6505526 100644
--- a/include/kernels/gauge_polyakov_loop.cuh
+++ b/include/kernels/gauge_polyakov_loop.cuh
@@ -166,7 +166,7 @@ namespace quda {
   };
 
   template <typename store_t, int nColor_, QudaReconstructType recon_>
-  struct GaugePolyakovLoopTraceArg : public ReduceArg<array<double, 2>> {
+  struct GaugePolyakovLoopTraceArg : public ReduceArg<array<device_reduce_t, 2>> {
     using real = typename mapper<store_t>::type;
     static constexpr int nColor = nColor_;
     static_assert(nColor == 3, "Only nColor=3 enabled at this time");
@@ -212,7 +212,7 @@ namespace quda {
       using HighPrecLink = typename Arg::HighPrecLink;
 
       HighPrecLink polyloop;
-      reduce_t ploop{0, 0};
+      array<double, 2> ploop = {};
 
       int x[4];
       getCoords(x, x_cb, arg.X, parity);
@@ -235,7 +235,7 @@ namespace quda {
       ploop[0] = tr.real();
       ploop[1] = tr.imag();
 
-      return operator()(ploop, value);
+      return operator()(value, ploop);
     }
 
   };
diff --git a/include/kernels/gauge_qcharge.cuh b/include/kernels/gauge_qcharge.cuh
index fadfd45321..638764c392 100644
--- a/include/kernels/gauge_qcharge.cuh
+++ b/include/kernels/gauge_qcharge.cuh
@@ -7,7 +7,7 @@ namespace quda
 {
 
   template <typename Float_, int nColor_, QudaReconstructType recon_, bool density_ = false> struct QChargeArg :
-    public ReduceArg<array<double, 3>>
+    public ReduceArg<array<device_reduce_t, 3>>
   {
     using Float = Float_;
     static constexpr int nColor = nColor_;
@@ -42,8 +42,8 @@ namespace quda
       constexpr real q_norm = static_cast<real>(-1.0 / (4*M_PI*M_PI));
       constexpr real n_inv = static_cast<real>(1.0 / Arg::nColor);
 
-      reduce_t E_local{0, 0, 0};
-      double &Q = E_local[2];
+      array<double, 3> E_local{0, 0, 0};
+      auto &Q = E_local[2];
 
       // Load the field-strength tensor from global memory
       //F0 = F[Y,X], F1 = F[Z,X], F2 = F[Z,Y],
diff --git a/include/kernels/gauge_random.cuh b/include/kernels/gauge_random.cuh
index 3c348d73b3..0e7b191d9d 100644
--- a/include/kernels/gauge_random.cuh
+++ b/include/kernels/gauge_random.cuh
@@ -23,7 +23,7 @@ namespace quda {
     RNGState *rng;
     real sigma; // where U = exp(sigma * H)
 
-    GaugeGaussArg(const GaugeField &U, RNGState *rng, double sigma) :
+    GaugeGaussArg(const GaugeField &U, RNGState *rng, real_t sigma) :
       kernel_param(dim3(U.LocalVolumeCB(), 2, 1)),
       U(U),
       rng(rng),
diff --git a/include/kernels/laplace.cuh b/include/kernels/laplace.cuh
index a029242210..21693985f4 100644
--- a/include/kernels/laplace.cuh
+++ b/include/kernels/laplace.cuh
@@ -38,7 +38,7 @@ namespace quda
     const real b; /** used by Wuppetal smearing kernel */
     int dir;      /** The direction from which to omit the derivative */
 
-    LaplaceArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir, double a, double b,
+    LaplaceArg(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir, real_t a, real_t b,
                const ColorSpinorField &x, int parity, bool dagger, const int *comm_override) :
       DslashArg<Float, nDim>(out, in, U, x, parity, dagger, a != 0.0 ? true : false, 1, false, comm_override),
       out(out),
diff --git a/include/kernels/momentum.cuh b/include/kernels/momentum.cuh
index 41f8bc929c..daa8d669de 100644
--- a/include/kernels/momentum.cuh
+++ b/include/kernels/momentum.cuh
@@ -7,14 +7,14 @@
 namespace quda {
 
   template <typename Float_, int nColor_, QudaReconstructType recon_>
-  struct MomActionArg : ReduceArg<double> {
+  struct MomActionArg : ReduceArg<device_reduce_t> {
     using Float = Float_;
     static constexpr int nColor = nColor_;
     static constexpr QudaReconstructType recon = recon_;
     const typename gauge_mapper<Float, recon>::type mom;
 
     MomActionArg(const GaugeField &mom) :
-      ReduceArg<double>(dim3(mom.VolumeCB(), 2, 1)),
+      ReduceArg<reduce_t>(dim3(mom.VolumeCB(), 2, 1)),
       mom(mom) { }
   };
 
@@ -56,7 +56,7 @@ namespace quda {
   };
 
   template<typename Float_, int nColor_, QudaReconstructType recon_>
-  struct UpdateMomArg : ReduceArg<array<double, 2>>
+  struct UpdateMomArg : ReduceArg<array<QUDA_REDUCTION_TYPE, 2>>
   {
     using Float = Float_;
     static constexpr int nColor = nColor_;
@@ -109,7 +109,7 @@ namespace quda {
         makeAntiHerm(f);
 
         // compute force norms
-        norm = operator()(reduce_t{f.L1(), f.L2()}, norm);
+        norm = operator()(norm, {f.L1(), f.L2()});
 
         m = m + arg.coeff * f;
 
diff --git a/include/kernels/multi_blas_core.cuh b/include/kernels/multi_blas_core.cuh
index 449e1de12b..94558fb7f6 100644
--- a/include/kernels/multi_blas_core.cuh
+++ b/include/kernels/multi_blas_core.cuh
@@ -89,8 +89,8 @@ namespace quda
           if (arg.f.read.Y) arg.Y[k].load(y, idx, parity);
           if (arg.f.read.W) arg.W[k].load(w, idx, parity);
         } else {
-          y = ::quda::zero<complex<typename Arg::real>, Arg::n/2>();
-          w = ::quda::zero<complex<typename Arg::real>, Arg::n/2>();
+          y = {};
+          w = {};
         }
 
 #pragma unroll
diff --git a/include/kernels/multi_reduce_core.cuh b/include/kernels/multi_reduce_core.cuh
index 9fcadd14c9..63dffc1f31 100644
--- a/include/kernels/multi_reduce_core.cuh
+++ b/include/kernels/multi_reduce_core.cuh
@@ -10,6 +10,8 @@
 namespace quda
 {
 
+  using compute_t = double;
+
   namespace blas
   {
 
@@ -142,10 +144,10 @@ namespace quda
        Return the real dot product of x and y
     */
     template <typename reduce_t, typename T>
-    __device__ __host__ void dot_(reduce_t &sum, const complex<T> &a, const complex<T> &b)
+    __device__ __host__ auto dot_(const complex<T> &a, const complex<T> &b)
     {
-      sum += static_cast<reduce_t>(a.real()) * static_cast<reduce_t>(b.real());
-      sum += static_cast<reduce_t>(a.imag()) * static_cast<reduce_t>(b.imag());
+      auto d = reduce_t(a.real()) * reduce_t(b.real());
+      return fma(reduce_t(a.imag()), reduce_t(b.imag()), d);
     }
 
     template <typename reduce_t, typename real>
@@ -159,7 +161,7 @@ namespace quda
       template <typename T> __device__ __host__ inline void operator()(reduce_t &sum, T &x, T &y, T &, T &, int, int) const
       {
 #pragma unroll
-        for (int k=0; k < x.size(); k++) dot_<reduce_t, real>(sum, x[k], y[k]);
+        for (int k=0; k < x.size(); k++) sum = plus<reduce_t>::apply(sum, dot_<compute_t>(x[k], y[k]));
       }
 
       constexpr int flops() const { return 2; }   //! flops per element
@@ -169,13 +171,14 @@ namespace quda
        Returns complex-valued dot product of x and y
     */
     template <typename reduce_t, typename T>
-    __device__ __host__ void cdot_(reduce_t &sum, const complex<T> &a, const complex<T> &b)
+    __device__ __host__ auto cdot_(const complex<T> &a, const complex<T> &b)
     {
-      using scalar = typename reduce_t::value_type;
-      sum[0] += static_cast<scalar>(a.real()) * static_cast<scalar>(b.real());
-      sum[0] += static_cast<scalar>(a.imag()) * static_cast<scalar>(b.imag());
-      sum[1] += static_cast<scalar>(a.real()) * static_cast<scalar>(b.imag());
-      sum[1] -= static_cast<scalar>(a.imag()) * static_cast<scalar>(b.real());
+      using scalar_t = typename reduce_t::value_type;
+      auto r = scalar_t(a.real()) * scalar_t(b.real());
+      r = fma(scalar_t(a.imag()), scalar_t(b.imag()), r);
+      auto i = scalar_t(a.real()) * scalar_t(b.imag());
+      i = fma(-scalar_t(a.imag()) , scalar_t(b.real()), i);
+      return reduce_t{r, i};
     }
 
     template <typename real_reduce_t, typename real>
@@ -190,7 +193,7 @@ namespace quda
       template <typename T> __device__ __host__ inline void operator()(reduce_t &sum, T &x, T &y, T &, T &, int, int) const
       {
 #pragma unroll
-        for (int k=0; k < x.size(); k++) cdot_<reduce_t, real>(sum, x[k], y[k]);
+        for (int k=0; k < x.size(); k++) sum = plus<reduce_t>::apply(sum, cdot_<array<compute_t, 2>>(x[k], y[k]));
       }
 
       constexpr int flops() const { return 4; }   //! flops per element
@@ -209,7 +212,7 @@ namespace quda
       {
 #pragma unroll
         for (int k = 0; k < x.size(); k++) {
-          cdot_<reduce_t, real>(sum, x[k], y[k]);
+          sum = plus<reduce_t>::apply(sum, cdot_<reduce_t>(x[k], y[k]));
           if (i == j) w[k] = y[k];
         }
       }
diff --git a/include/kernels/reduce_core.cuh b/include/kernels/reduce_core.cuh
index 4597f0b8cd..fb73b79bb3 100644
--- a/include/kernels/reduce_core.cuh
+++ b/include/kernels/reduce_core.cuh
@@ -2,6 +2,7 @@
 
 #include <color_spinor_field_order.h>
 #include <blas_helper.cuh>
+#include "float_vector.h"
 #include <reduce_helper.h>
 #include <array.h>
 #include <reduction_kernel.h>
@@ -9,6 +10,8 @@
 namespace quda
 {
 
+  using compute_t = double;
+
   namespace blas
   {
 
@@ -104,7 +107,6 @@ namespace quda
     struct ReduceFunctor {
       static constexpr use_kernel_arg_p use_kernel_arg = use_kernel_arg_p::TRUE;
       using reduce_t = reduce_t_;
-      using reducer = plus<reduce_t>;
       static constexpr bool site_unroll = site_unroll_;
 
       //! pre-computation routine called before the "M-loop"
@@ -114,12 +116,13 @@ namespace quda
       __device__ __host__ void post(reduce_t &) const { ; }
     };
 
-    template <typename reduce_t, typename real>
-    struct Max : public ReduceFunctor<reduce_t> {
+    template <typename, typename real>
+    struct Max : public ReduceFunctor<compute_t> {
+      using reduce_t = compute_t;
       using reducer = maximum<reduce_t>;
       static constexpr memory_access<1> read{ };
       static constexpr memory_access<> write{ };
-      Max(const real &, const real &) { ; }
+      Max(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &max, T &x, T &, T &, T &, T &) const
       {
 #pragma unroll
@@ -131,18 +134,18 @@ namespace quda
       constexpr int flops() const { return 0; }   //! flops per element
     };
 
-    template <typename real_reduce_t, typename real>
-    struct MaxDeviation : public ReduceFunctor<deviation_t<real_reduce_t>> {
-      using reduce_t = deviation_t<real_reduce_t>;
+    template <typename, typename real>
+    struct MaxDeviation : public ReduceFunctor<deviation_t<compute_t>> {
+      using reduce_t = deviation_t<compute_t>;
       using reducer = maximum<reduce_t>;
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<> write{ };
-      MaxDeviation(const real &, const real &) { ; }
+      MaxDeviation(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &max, T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
-          complex<real_reduce_t> diff = {abs(x[i].real() - y[i].real()), abs(x[i].imag() - y[i].imag())};
+          complex<compute_t> diff = {abs(x[i].real() - y[i].real()), abs(x[i].imag() - y[i].imag())};
           if (diff.real() > max.diff ) {
             max.diff = diff.real();
             max.ref = abs(y[i].real());
@@ -159,20 +162,21 @@ namespace quda
     /**
        Return the L1 norm of x
     */
-    template <typename reduce_t, typename T> __device__ __host__ reduce_t norm1_(const complex<T> &a)
+    template <typename reduce_t, typename T> __device__ __host__ auto norm1_(const complex<T> &a)
     {
-      return static_cast<reduce_t>(sqrt(a.real() * a.real() + a.imag() * a.imag()));
+      return reduce_t(sqrt(a.real() * a.real() + a.imag() * a.imag()));
     }
 
     template <typename reduce_t, typename real>
     struct Norm1 : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1> read{ };
       static constexpr memory_access<> write{ };
-      Norm1(const real &, const real &) { ; }
+      Norm1(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &, T &, T &, T &) const
       {
 #pragma unroll
-        for (int i=0; i < x.size(); i++) sum += norm1_<reduce_t, real>(x[i]);
+        for (int i=0; i < x.size(); i++) sum = reducer::apply(sum, norm1_<compute_t, real>(x[i]));
       }
       constexpr int flops() const { return 2; }   //! flops per element
     };
@@ -180,21 +184,22 @@ namespace quda
     /**
        Return the L2 norm of x
     */
-    template <typename reduce_t, typename T> __device__ __host__ void norm2_(reduce_t &sum, const complex<T> &a)
+    template <typename reduce_t, typename T> __device__ __host__ auto norm2_(const complex<T> &a)
     {
-      sum += static_cast<reduce_t>(a.real()) * static_cast<reduce_t>(a.real());
-      sum += static_cast<reduce_t>(a.imag()) * static_cast<reduce_t>(a.imag());
+      auto n = reduce_t(a.real()) * reduce_t(a.real());
+      return fma(reduce_t(a.imag()), reduce_t(a.imag()), n);
     }
 
     template <typename reduce_t, typename real>
     struct Norm2 : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1> read{ };
       static constexpr memory_access<> write{ };
-      Norm2(const real &, const real &) { ; }
+      Norm2(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &, T &, T &, T &) const
       {
 #pragma unroll
-        for (int i = 0; i < x.size(); i++) norm2_<reduce_t, real>(sum, x[i]);
+        for (int i = 0; i < x.size(); i++) sum = reducer::apply(sum, norm2_<compute_t>(x[i]));
       }
       constexpr int flops() const { return 2; }   //! flops per element
     };
@@ -203,21 +208,22 @@ namespace quda
        Return the real dot product of x and y
     */
     template <typename reduce_t, typename T>
-    __device__ __host__ void dot_(reduce_t &sum, const complex<T> &a, const complex<T> &b)
+    __device__ __host__ auto dot_(const complex<T> &a, const complex<T> &b)
     {
-      sum += static_cast<reduce_t>(a.real()) * static_cast<reduce_t>(b.real());
-      sum += static_cast<reduce_t>(a.imag()) * static_cast<reduce_t>(b.imag());
+      auto d = reduce_t(a.real()) * reduce_t(b.real());
+      return fma(reduce_t(a.imag()), reduce_t(b.imag()), d);
     }
 
     template <typename reduce_t, typename real>
     struct Dot : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1,1> read{ };
       static constexpr memory_access<> write{ };
-      Dot(const real &, const real &) { ; }
+      Dot(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
-        for (int i = 0; i < x.size(); i++) dot_<reduce_t, real>(sum, x[i], y[i]);
+        for (int i = 0; i < x.size(); i++) sum = reducer::apply(sum, dot_<compute_t, real>(x[i], y[i]));
       }
       constexpr int flops() const { return 2; }   //! flops per element
     };
@@ -228,17 +234,18 @@ namespace quda
     */
     template <typename reduce_t, typename real>
     struct axpbyzNorm2 : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 0> read{ };
       static constexpr memory_access<0, 0, 1> write{ };
       const real a;
       const real b;
-      axpbyzNorm2(const real &a, const real &b) : a(a), b(b) { ; }
+      axpbyzNorm2(const real_t &a, const real_t &b) : a(a), b(b) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &z, T &, T &) const
       {
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
           z[i] = a * x[i] + b * y[i];
-          norm2_<reduce_t, real>(sum, z[i]);
+          sum = reducer::apply(sum, norm2_<compute_t>(z[i]));
         }
       }
       constexpr int flops() const { return 4; }   //! flops per element
@@ -250,16 +257,17 @@ namespace quda
     */
     template <typename reduce_t, typename real>
     struct AxpyReDot : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<0, 1> write{ };
       const real a;
-      AxpyReDot(const real &a, const real &) : a(a) { ; }
+      AxpyReDot(const real_t &a, const real_t &) : a(a) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
           y[i] += a * x[i];
-          dot_<reduce_t, real>(sum, x[i], y[i]);
+          sum = reducer::apply(sum, dot_<compute_t, real>(x[i], y[i]));
         }
       }
       constexpr int flops() const { return 4; }   //! flops per element
@@ -271,6 +279,7 @@ namespace quda
     */
     template <typename reduce_t, typename real>
     struct caxpyNorm2 : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<0, 1> write{ };
       const complex<real> a;
@@ -280,20 +289,21 @@ namespace quda
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
           y[i] = cmac(a, x[i], y[i]);
-          norm2_<reduce_t, real>(sum, y[i]);
+          sum = reducer::apply(sum, norm2_<compute_t>(y[i]));
         }
       }
       constexpr int flops() const { return 6; }   //! flops per element
     };
 
     /**
-       double cabxpyzAxNorm(float a, complex b, float *x, float *y, float *z){}
+       cabxpyzAxNorm(float a, complex b, float *x, float *y, float *z){}
        First performs the operation z[i] = y[i] + a*b*x[i]
        Second performs x[i] *= a
        Third returns the norm of x
     */
     template <typename reduce_t, typename real>
     struct cabxpyzaxnorm : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 0> read{ };
       static constexpr memory_access<1, 0, 1> write{ };
       const real a;
@@ -305,7 +315,7 @@ namespace quda
         for (int i = 0; i < x.size(); i++) {
           x[i] *= a;
           z[i] = cmac(b, x[i], y[i]);
-          norm2_<reduce_t, real>(sum, z[i]);
+          sum = reducer::apply(sum, norm2_<compute_t>(z[i]));
         }
       }
       constexpr int flops() const { return 10; }  //! flops per element
@@ -315,37 +325,42 @@ namespace quda
        Returns complex-valued dot product of x and y
     */
     template <typename reduce_t, typename T>
-    __device__ __host__ void cdot_(reduce_t &sum, const complex<T> &a, const complex<T> &b)
+    __device__ __host__ auto cdot_(const complex<T> &a, const complex<T> &b)
     {
       using scalar_t = typename reduce_t::value_type;
-      sum[0] += static_cast<scalar_t>(a.real()) * static_cast<scalar_t>(b.real());
-      sum[0] += static_cast<scalar_t>(a.imag()) * static_cast<scalar_t>(b.imag());
-      sum[1] += static_cast<scalar_t>(a.real()) * static_cast<scalar_t>(b.imag());
-      sum[1] -= static_cast<scalar_t>(a.imag()) * static_cast<scalar_t>(b.real());
+      auto r = scalar_t(a.real()) * scalar_t(b.real());
+      r = fma(scalar_t(a.imag()), scalar_t(b.imag()), r);
+      auto i = scalar_t(a.real()) * scalar_t(b.imag());
+      i = fma(-scalar_t(a.imag()) , scalar_t(b.real()), i);
+      return reduce_t{r, i};
     }
 
     template <typename real_reduce_t, typename real>
     struct Cdot : public ReduceFunctor<array<real_reduce_t, 2>> {
       using reduce_t = array<real_reduce_t, 2>;
+      using compute_t = array<compute_t, 2>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<> write{ };
-      Cdot(const complex<real> &, const complex<real> &) { ; }
+      Cdot(const complex_t &, const complex_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
-        for (int i = 0; i < x.size(); i++) cdot_<reduce_t, real>(sum, x[i], y[i]);
+        for (int i = 0; i < x.size(); i++) sum = reducer::apply(sum, cdot_<compute_t, real>(x[i], y[i]));
       }
       constexpr int flops() const { return 4; }   //! flops per element
     };
 
     /**
-       double caxpyDotzyCuda(float a, float *x, float *y, float *z, n){}
+       caxpyDotzyCuda(float a, float *x, float *y, float *z, n){}
        First performs the operation y[i] = a*x[i] + y[i]
        Second returns the dot product (z,y)
     */
     template <typename real_reduce_t, typename real>
     struct caxpydotzy : public ReduceFunctor<array<real_reduce_t, 2>> {
       using reduce_t = array<real_reduce_t, 2>;
+      using compute_t = array<compute_t, 2>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 1> read{ };
       static constexpr memory_access<0, 1> write{ };
       const complex<real> a;
@@ -355,7 +370,7 @@ namespace quda
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
           y[i] = cmac(a, x[i], y[i]);
-          cdot_<reduce_t, real>(sum, z[i], y[i]);
+          sum = reducer::apply(sum, cdot_<compute_t, real>(z[i], y[i]));
         }
       }
       constexpr int flops() const { return 8; }   //! flops per element
@@ -366,25 +381,27 @@ namespace quda
        Returns the norm of x
     */
     template <typename reduce_t, typename InputType>
-    __device__ __host__ void cdotNormAB_(reduce_t &sum, const InputType &a, const InputType &b)
+    __device__ __host__ reduce_t cdotNormAB_(const InputType &a, const InputType &b)
     {
       using real = typename InputType::value_type;
       using scalar = typename reduce_t::value_type;
-      cdot_<reduce_t, real>(sum, a, b);
-      norm2_<scalar, real>(sum[2], a);
-      norm2_<scalar, real>(sum[3], b);
+      auto cdot = cdot_<reduce_t, real>(a, b);
+      return {cdot[0], cdot[1], norm2_<scalar>(a), norm2_<scalar, real>(b)};
     }
 
     template <typename real_reduce_t, typename real>
     struct CdotNormAB : public ReduceFunctor<array<real_reduce_t, 4>> {
       using reduce_t = array<real_reduce_t, 4>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<> write{ };
-      CdotNormAB(const real &, const real &) { ; }
+      CdotNormAB(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
-        for (int i = 0; i < x.size(); i++) cdotNormAB_<reduce_t>(sum, x[i], y[i]);
+        for (int i = 0; i < x.size(); i++) {
+          sum = reducer::apply(sum, cdotNormAB_<array<compute_t, 4>>(x[i], y[i]));
+        }
       }
       constexpr int flops() const { return 8; }   //! flops per element
     };
@@ -394,12 +411,12 @@ namespace quda
        Returns the norm of y
     */
     template <typename reduce_t, typename InputType>
-    __device__ __host__ void cdotNormB_(reduce_t &sum, const InputType &a, const InputType &b)
+    __device__ __host__ reduce_t cdotNormB_(const InputType &a, const InputType &b)
     {
       using real = typename InputType::value_type;
       using scalar = typename reduce_t::value_type;
-      cdot_<reduce_t, real>(sum, a, b);
-      norm2_<scalar, real>(sum[2], b);
+      auto cdot = cdot_<reduce_t, real>(a, b);
+      return {cdot[0], cdot[1], norm2_<scalar>(b)};
     }
 
     /**
@@ -409,6 +426,7 @@ namespace quda
     template <typename real_reduce_t, typename real>
     struct caxpbypzYmbwcDotProductUYNormY_ : public ReduceFunctor<array<real_reduce_t, 3>> {
       using reduce_t = array<real_reduce_t, 3>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 1, 1, 1> read{ };
       static constexpr memory_access<0, 1, 1> write{ };
       const complex<real> a;
@@ -421,7 +439,7 @@ namespace quda
           y[i] = cmac(a, x[i], y[i]);
           y[i] = cmac(b, z[i], y[i]);
           z[i] = cmac(-b, w[i], z[i]);
-          cdotNormB_<reduce_t>(sum, v[i], z[i]);
+          sum = reducer::apply(sum, cdotNormB_<array<compute_t, 3>>(v[i], z[i]));
         }
       }
       constexpr int flops() const { return 18; }  //! flops per element
@@ -436,17 +454,17 @@ namespace quda
     template <typename real_reduce_t, typename real>
     struct axpyCGNorm2 : public ReduceFunctor<array<real_reduce_t, 2>> {
       using reduce_t = array<real_reduce_t, 2>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<0, 1> write{ };
       const real a;
-      axpyCGNorm2(const real &a, const real &) : a(a) { ; }
+      axpyCGNorm2(const real_t &a, const real_t &) : a(a) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &, T &, T &) const
       {
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
           auto y_new = y[i] + a * x[i];
-          norm2_<real_reduce_t, real>(sum[0], y_new);
-          dot_<real_reduce_t, real>(sum[1], y_new, y_new - y[i]);
+          sum = reducer::apply(sum, array<compute_t, 2>{norm2_<compute_t>(y_new), dot_<compute_t>(y_new, y_new - y[i])});
           y[i] = y_new;
         }
       }
@@ -470,30 +488,21 @@ namespace quda
 
       static constexpr memory_access<1, 1> read{ };
       static constexpr memory_access<> write{ };
-      reduce_t aux;
-      HeavyQuarkResidualNorm_(const real &, const real &) : aux {} { ; }
+      array<compute_t, 2> aux;
+      HeavyQuarkResidualNorm_(const real_t &, const real_t &) : aux {} { ; }
 
-      __device__ __host__ void pre()
-      {
-        aux[0] = 0;
-        aux[1] = 0;
-      }
+      __device__ __host__ void pre() { aux = {}; }
 
       template <typename T> __device__ __host__ void operator()(reduce_t &, T &x, T &y, T &, T &, T &)
       {
 #pragma unroll
-        for (int i = 0; i < x.size(); i++) {
-          norm2_<real_reduce_t, real>(aux[0], x[i]);
-          norm2_<real_reduce_t, real>(aux[1], y[i]);
-        }
+        for (int i = 0; i < x.size(); i++) aux = plus<array<compute_t, 2>>::apply(aux, {norm2_<compute_t>(x[i]), norm2_<compute_t>(y[i])});
       }
 
       //! sum the solution and residual norms, and compute the heavy-quark norm
       __device__ __host__ void post(reduce_t &sum)
       {
-        sum[0] += aux[0];
-        sum[1] += aux[1];
-        sum[2] += (aux[0] > 0.0) ? (aux[1] / aux[0]) : static_cast<real>(1.0);
+        sum = reducer::apply(sum, array<compute_t, 3>{aux[0], aux[1], (aux[0] > 0.0) ? (aux[1] / aux[0]) : compute_t(1.0)});
       }
 
       constexpr int flops() const { return 4; }   //! undercounts since it excludes the per-site division
@@ -517,87 +526,76 @@ namespace quda
 
       static constexpr memory_access<1, 1, 1> read{ };
       static constexpr memory_access<> write{ };
-      reduce_t aux;
-      xpyHeavyQuarkResidualNorm_(const real &, const real &) : aux {} { ; }
+      array<compute_t, 2> aux;
+      xpyHeavyQuarkResidualNorm_(const real_t &, const real_t &) : aux {} { ; }
 
-      __device__ __host__ void pre()
-      {
-        aux[0] = 0;
-        aux[1] = 0;
-      }
+      __device__ __host__ void pre() { aux = {}; }
 
       template <typename T> __device__ __host__ void operator()(reduce_t &, T &x, T &y, T &z, T &, T &)
       {
 #pragma unroll
-        for (int i = 0; i < x.size(); i++) {
-          norm2_<real_reduce_t, real>(aux[0], x[i] + y[i]);
-          norm2_<real_reduce_t, real>(aux[1], z[i]);
-        }
+        for (int i = 0; i < x.size(); i++) aux = plus<array<compute_t, 2>>::apply(aux, {norm2_<compute_t>(x[i] + y[i]), norm2_<compute_t>(z[i])});
       }
 
       //! sum the solution and residual norms, and compute the heavy-quark norm
       __device__ __host__ void post(reduce_t &sum)
       {
-        sum[0] += aux[0];
-        sum[1] += aux[1];
-        sum[2] += (aux[0] > 0.0) ? (aux[1] / aux[0]) : static_cast<real>(1.0);
+        sum = reducer::apply(sum, array<compute_t, 3>{aux[0], aux[1], (aux[0] > 0.0) ? (aux[1] / aux[0]) : compute_t(1.0)});
       }
 
       constexpr int flops() const { return 5; }
     };
 
     /**
-       double3 tripleCGReduction(V x, V y, V z){}
+       tripleCGReduction(V x, V y, V z){}
        First performs the operation norm2(x)
-       Second performs the operatio norm2(y)
+       Second performs the operation norm2(y)
        Third performs the operation dotPropduct(y,z)
     */
     template <typename real_reduce_t, typename real>
     struct tripleCGReduction_ : public ReduceFunctor<array<real_reduce_t, 3>> {
       using reduce_t = array<real_reduce_t, 3>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 1> read{ };
       static constexpr memory_access<> write{ };
-      tripleCGReduction_(const real &, const real &) { ; }
+      tripleCGReduction_(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &z, T &, T &) const
       {
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
-          norm2_<real_reduce_t, real>(sum[0], x[i]);
-          norm2_<real_reduce_t, real>(sum[1], y[i]);
-          dot_<real_reduce_t, real>(sum[2], y[i], z[i]);
+          sum = reducer::apply(sum, array<compute_t, 3>{norm2_<compute_t>(x[i]), norm2_<compute_t>(y[i]), dot_<compute_t>(y[i], z[i])});
         }
       }
       constexpr int flops() const { return 6; }   //! flops per element
     };
 
     /**
-       double4 quadrupleCGReduction(V x, V y, V z){}
+       quadrupleCGReduction(V x, V y, V z){}
        First performs the operation norm2(x)
-       Second performs the operatio norm2(y)
+       Second performs the operation norm2(y)
        Third performs the operation dotPropduct(y,z)
        Fourth performs the operation norm(z)
     */
     template <typename real_reduce_t, typename real>
     struct quadrupleCGReduction_ : public ReduceFunctor<array<real_reduce_t, 4>> {
       using reduce_t = array<real_reduce_t, 4>;
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 1, 1> read{ };
       static constexpr memory_access<> write{ };
-      quadrupleCGReduction_(const real &, const real &) { ; }
+      quadrupleCGReduction_(const real_t &, const real_t &) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &z, T &w, T &) const
       {
 #pragma unroll
         for (int i = 0; i < x.size(); i++) {
-          norm2_<real_reduce_t, real>(sum[0], x[i]);
-          norm2_<real_reduce_t, real>(sum[1], y[i]);
-          dot_<real_reduce_t, real>(sum[2], y[i], z[i]);
-          norm2_<real_reduce_t, real>(sum[3], w[i]);
+          sum = reducer::apply(sum, array<compute_t, 4>{norm2_<compute_t>(x[i]), norm2_<compute_t>(y[i]),
+                                                        dot_<compute_t>(y[i], z[i]), norm2_<compute_t>(w[i])});
         }
       }
       constexpr int flops() const { return 8; }   //! flops per element
     };
 
     /**
-       double quadrupleCG3InitNorm(d a, d b, V x, V y, V z, V w, V v){}
+       quadrupleCG3InitNorm(d a, d b, V x, V y, V z, V w, V v){}
         z = x;
         w = y;
         x += a*y;
@@ -606,10 +604,11 @@ namespace quda
     */
     template <typename reduce_t, typename real>
     struct quadrupleCG3InitNorm_ : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 0, 0, 1> read{ };
       static constexpr memory_access<1, 1, 1, 1> write{ };
       const real a;
-      quadrupleCG3InitNorm_(const real &a, const real &) : a(a) { ; }
+      quadrupleCG3InitNorm_(const real_t &a, const real_t &) : a(a) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &z, T &w, T &v) const
       {
 #pragma unroll
@@ -618,14 +617,14 @@ namespace quda
           w[i] = y[i];
           x[i] += a * y[i];
           y[i] -= a * v[i];
-          norm2_<reduce_t, real>(sum, y[i]);
+          sum = reducer::apply(sum, norm2_<compute_t, real>(y[i]));
         }
       }
       constexpr int flops() const { return 6; }   //! flops per element check if it's right
     };
 
     /**
-       double quadrupleCG3UpdateNorm(d gamma, d rho, V x, V y, V z, V w, V v){}
+       quadrupleCG3UpdateNorm(d gamma, d rho, V x, V y, V z, V w, V v){}
         tmpx = x;
         tmpy = y;
         x = b*(x + a*y) + (1-b)*z;
@@ -636,11 +635,12 @@ namespace quda
     */
     template <typename reduce_t, typename real>
     struct quadrupleCG3UpdateNorm_ : public ReduceFunctor<reduce_t> {
+      using reducer = plus<reduce_t>;
       static constexpr memory_access<1, 1, 1, 1, 1> read{ };
       static constexpr memory_access<1, 1, 1, 1> write{ };
       const real a;
       const real b;
-      quadrupleCG3UpdateNorm_(const real &a, const real &b) : a(a), b(b) { ; }
+      quadrupleCG3UpdateNorm_(const real_t &a, const real_t &b) : a(a), b(b) { ; }
       template <typename T> __device__ __host__ void operator()(reduce_t &sum, T &x, T &y, T &z, T &w, T &v) const
       {
 #pragma unroll
@@ -651,7 +651,7 @@ namespace quda
           y[i] = b * (y[i] - a * v[i]) + ((real)1.0 - b) * w[i];
           z[i] = tmpx;
           w[i] = tmpy;
-          norm2_<reduce_t, real>(sum, y[i]);
+          sum = reducer::apply(sum, norm2_<compute_t, real>(y[i]));
         }
       }
       constexpr int flops() const { return 16; }  //! flops per element check if it's right
diff --git a/include/kernels/staggered_coarse_op_kernel.cuh b/include/kernels/staggered_coarse_op_kernel.cuh
index 7fe913bfdf..1786a23f09 100644
--- a/include/kernels/staggered_coarse_op_kernel.cuh
+++ b/include/kernels/staggered_coarse_op_kernel.cuh
@@ -34,7 +34,7 @@ namespace quda {
     const int coarseVolumeCB; /** Coarse grid volume */
     real two_mass;            /** Two times the staggered mass value */
 
-    CalculateStaggeredYArg(GaugeField &Y, GaugeField &X, const GaugeField &U, double mass) :
+    CalculateStaggeredYArg(GaugeField &Y, GaugeField &X, const GaugeField &U, real_t mass) :
       kernel_param(dim3(U.VolumeCB(), fineColor * fineColor, 2)),
       Y(Y),
       X(X),
diff --git a/include/kernels/staggered_kd_reorder_xinv_kernel.cuh b/include/kernels/staggered_kd_reorder_xinv_kernel.cuh
index e8c7dd9d65..727306ef0d 100644
--- a/include/kernels/staggered_kd_reorder_xinv_kernel.cuh
+++ b/include/kernels/staggered_kd_reorder_xinv_kernel.cuh
@@ -41,7 +41,7 @@ namespace quda {
 
     static constexpr int coarse_color = coarseColor;
 
-    CalculateStaggeredGeometryReorderArg(GaugeField& fineXinv, const GaugeField& coarseXinv, const double scale) :
+    CalculateStaggeredGeometryReorderArg(GaugeField& fineXinv, const GaugeField& coarseXinv, const real_t scale) :
       kernel_param(dim3(fineXinv.VolumeCB(), kdBlockSize, 2)),
       fineXinv(fineXinv),
       coarseXinv(coarseXinv),
diff --git a/include/kernels/transform_reduce.cuh b/include/kernels/transform_reduce.cuh
index af9df8d54a..f6fa6967b5 100644
--- a/include/kernels/transform_reduce.cuh
+++ b/include/kernels/transform_reduce.cuh
@@ -47,7 +47,7 @@ namespace quda {
       auto k = arg.m(i);
       auto v = arg.v[j];
       auto t = arg.h(v[k]);
-      return operator()(t, value);
+      return operator()(value, t);
     }
   };
 
diff --git a/include/lattice_field.h b/include/lattice_field.h
index e7c43b7d69..e745393366 100644
--- a/include/lattice_field.h
+++ b/include/lattice_field.h
@@ -81,7 +81,7 @@ namespace quda {
     lat_dim_t r = {};
 
     /** For fixed-point fields that need a global scaling factor */
-    double scale = 1.0;
+    real_t scale = 1.0;
 
     /**
        @brief Default constructor for LatticeFieldParam
@@ -217,7 +217,7 @@ namespace quda {
     mutable bool ghost_precision_reset = false;
 
     /** For fixed-point fields that need a global scaling factor */
-    double scale = 0.0;
+    real_t scale = 0.0;
 
     /** Whether the field is full or single parity */
     QudaSiteSubset siteSubset = QUDA_INVALID_SITE_SUBSET;
@@ -666,13 +666,13 @@ namespace quda {
     /**
        @return The global scaling factor for a fixed-point field
     */
-    double Scale() const { return scale; }
+    real_t Scale() const { return scale; }
 
     /**
        @brief Set the scale factor for a fixed-point field
        @param[in] scale_ The new scale factor
     */
-    void Scale(double scale_) { scale = scale_; }
+    void Scale(real_t scale_) { scale = scale_; }
 
     /**
        @return Field subset type
diff --git a/include/madwf_ml.h b/include/madwf_ml.h
index c017229311..8b812564ce 100644
--- a/include/madwf_ml.h
+++ b/include/madwf_ml.h
@@ -82,7 +82,7 @@ namespace quda
 
     MadwfParam param;
 
-    double mu;
+    real_t mu;
 
     ColorSpinorField forward_tmp;
     ColorSpinorField backward_tmp;
@@ -106,7 +106,7 @@ namespace quda
       @param[out] out the output vector
       @param[in] in the input vector
     */
-    double cost(const DiracMatrix &ref, Solver &base, ColorSpinorField &out, const ColorSpinorField &in);
+    real_t cost(const DiracMatrix &ref, Solver &base, ColorSpinorField &out, const ColorSpinorField &in);
 
     /**
       @brief Save the current parameter to disk
diff --git a/include/madwf_param.h b/include/madwf_param.h
index 5046ee6a67..4339e70dd8 100644
--- a/include/madwf_param.h
+++ b/include/madwf_param.h
@@ -8,7 +8,7 @@ namespace quda
   struct MadwfParam {
 
     /** The diagonal constant to suppress the low modes when performing 5D transfer */
-    double madwf_diagonal_suppressor;
+    real_t madwf_diagonal_suppressor;
 
     /** The target MADWF Ls to be used in the accelerator */
     int madwf_ls;
@@ -17,7 +17,7 @@ namespace quda
     int madwf_null_miniter;
 
     /** The maximum tolerance after which to generate the null vectors for MADWF */
-    double madwf_null_tol;
+    real_t madwf_null_tol;
 
     /** The maximum number of iterations for the training iterations */
     int madwf_train_maxiter;
diff --git a/include/multigrid.h b/include/multigrid.h
index 82a46998c4..84dd2b2e99 100644
--- a/include/multigrid.h
+++ b/include/multigrid.h
@@ -121,7 +121,7 @@ namespace quda {
     int nu_post;
 
     /** Tolerance to use for the solver / smoother (if applicable) */
-    double smoother_tol;
+    real_t smoother_tol;
 
     /** Multigrid cycle type */
     QudaMultigridCycleType cycle_type;
@@ -399,7 +399,7 @@ namespace quda {
      */
     void resetStaggeredKD(GaugeField *gauge_in, GaugeField *fat_gauge_in, GaugeField *long_gauge_in,
                           GaugeField *gauge_sloppy_in, GaugeField *fat_gauge_sloppy_in,
-                          GaugeField *long_gauge_sloppy_in, double mass);
+                          GaugeField *long_gauge_sloppy_in, real_t mass);
 
     /**
        @brief Dump the null-space vectors to disk.  Will recurse dumping all levels.
@@ -526,7 +526,7 @@ namespace quda {
      @param[in] halo_precision What precision to use for the halos (if QUDA_INVALID_PRECISION, use field precision)
    */
   void ApplyCoarse(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
-                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, double kappa,
+                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, real_t kappa,
                    int parity = QUDA_INVALID_PARITY, bool dslash = true, bool clover = true, bool dagger = false,
                    const int *commDim = 0, QudaPrecision halo_precision = QUDA_INVALID_PRECISION, bool use_mma = false);
 
@@ -551,7 +551,7 @@ namespace quda {
    */
   template <bool dagger, int coarseColor>
   void ApplyCoarse(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
-                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, double kappa,
+                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, real_t kappa,
                    int parity, bool dslash, bool clover, const int *commDim, QudaPrecision halo_precision);
 
   /**
@@ -595,7 +595,7 @@ namespace quda {
      even-odd preconditioned and we coarsen the full operator.
    */
   void CoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge, const CloverField *clover,
-                double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc);
+                real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc);
 
   /**
      @brief Coarse operator construction from a fine-grid operator
@@ -617,7 +617,7 @@ namespace quda {
    */
   template <int fineColor, int coarseColor>
   void CoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge, const CloverField *clover,
-                double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc);
+                real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc);
 
   /**
      @brief Coarse operator construction from a fine-grid operator (Staggered)
@@ -635,12 +635,12 @@ namespace quda {
      For staggered, should always be QUDA_MATPC_INVALID.
    */
   void StaggeredCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                         const GaugeField &longGauge, const GaugeField &XinvKD, double mass, bool allow_truncation,
+                         const GaugeField &longGauge, const GaugeField &XinvKD, real_t mass, bool allow_truncation,
                          QudaDiracType dirac, QudaMatPCType matpc);
 
   template <int fineColor, int coarseColor>
   void StaggeredCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                         const GaugeField &longGauge, const GaugeField &XinvKD, double mass, bool allow_truncation,
+                         const GaugeField &longGauge, const GaugeField &XinvKD, real_t mass, bool allow_truncation,
                          QudaDiracType dirac, QudaMatPCType matpc);
 
   /**
@@ -665,7 +665,7 @@ namespace quda {
      @param use_mma[in] Whether or not use MMA (tensor core) to do the calculation, default to false
    */
   void CoarseCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge, const GaugeField &clover,
-                      const GaugeField &cloverInv, double kappa, double mass, double mu, double mu_factor,
+                      const GaugeField &cloverInv, real_t kappa, real_t mass, real_t mu, real_t mu_factor,
                       QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional, bool use_mma = false);
 
   /**
@@ -695,8 +695,8 @@ namespace quda {
    */
   template <int fineColor, int coarseColor, bool mma>
   void CoarseCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                      const GaugeField &clover, const GaugeField &cloverInv, double kappa, double mass, double mu,
-                      double mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional);
+                      const GaugeField &clover, const GaugeField &cloverInv, real_t kappa, real_t mass, real_t mu,
+                      real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional);
 
   /**
      @brief Calculate preconditioned coarse links and coarse clover inverse field
diff --git a/include/pgauge_monte.h b/include/pgauge_monte.h
index 33decf4cf0..b9cfabdcd7 100644
--- a/include/pgauge_monte.h
+++ b/include/pgauge_monte.h
@@ -14,7 +14,7 @@ namespace quda {
    * @param[in] nhb number of heatbath steps
    * @param[in] nover number of overrelaxation steps
    */
-  void Monte(GaugeField &data, RNG &rngstate, double Beta, int nhb, int nover);
+  void Monte(GaugeField &data, RNG &rngstate, real_t Beta, int nhb, int nover);
 
   /**
    * @brief Perform a cold start to the gauge field, identity SU(3)
@@ -56,15 +56,15 @@ namespace quda {
    * @brief Calculate the Determinant
    *
    * @param[in] data Gauge field
-   * @returns double2 complex Determinant value
+   * @returns complex Determinant value
    */
-  double2 getLinkDeterminant(GaugeField &data);
+  complex_t getLinkDeterminant(GaugeField &data);
 
   /**
    * @brief Calculate the Trace
    *
    * @param[in] data Gauge field
-   * @returns double2 complex trace value
+   * @returns complex trace value
    */
-  double2 getLinkTrace(GaugeField &data);
+  complex_t getLinkTrace(GaugeField &data);
 }
diff --git a/include/polynomial.h b/include/polynomial.h
index aa51d372ed..4b4ea87cb8 100644
--- a/include/polynomial.h
+++ b/include/polynomial.h
@@ -9,68 +9,68 @@
 namespace quda
 {
 
-  inline std::vector<double> quadratic_formula(std::array<double, 3> coeff)
+  inline std::vector<real_t> quadratic_formula(std::array<real_t, 3> coeff)
   {
 
-    std::vector<double> z;
+    std::vector<real_t> z;
     z.reserve(2);
 
-    double &a = coeff[0];
-    double &b = coeff[1];
-    double &c = coeff[2];
+    real_t &a = coeff[0];
+    real_t &b = coeff[1];
+    real_t &c = coeff[2];
 
     // a x^2 + b x + c = 0
     if (a == 0) {
       // actually a linear equation
       if (b != 0) { z.push_back(-c / b); }
     } else {
-      double delta = b * b - 4.0 * a * c;
+      real_t delta = b * b - 4.0 * a * c;
       if (delta >= 0) {
-        z.push_back((-b + std::sqrt(delta)) / (2.0 * a));
-        z.push_back((-b - std::sqrt(delta)) / (2.0 * a));
+        z.push_back((-b + sqrt(delta)) / (2.0 * a));
+        z.push_back((-b - sqrt(delta)) / (2.0 * a));
       }
     }
 
     return z;
   }
 
-  inline std::vector<double> cubic_formula(std::array<double, 4> coeff)
+  inline std::vector<real_t> cubic_formula(std::array<real_t, 4> coeff)
   {
 
-    std::vector<double> t;
+    std::vector<real_t> t;
     t.reserve(3);
 
     // a x^3 + b x^2 + c x + d = 0
-    double &a = coeff[0];
-    double &b = coeff[1];
-    double &c = coeff[2];
-    double &d = coeff[3];
+    real_t &a = coeff[0];
+    real_t &b = coeff[1];
+    real_t &c = coeff[2];
+    real_t &d = coeff[3];
 
     if (a == 0) {
       // actually a quadratic equation.
-      std::array<double, 3> quadratic_coeff = {coeff[1], coeff[2], coeff[3]};
+      std::array<real_t, 3> quadratic_coeff = {coeff[1], coeff[2], coeff[3]};
       auto quad = quadratic_formula(quadratic_coeff);
       for (size_t i = 0; i < quad.size(); i++) { t.push_back(quad[i]); }
       return t;
     }
 
-    double a2 = a * a;
-    double a3 = a * a * a;
+    real_t a2 = a * a;
+    real_t a3 = a * a * a;
 
-    double b2 = b * b;
-    double b3 = b * b * b;
+    real_t b2 = b * b;
+    real_t b3 = b * b * b;
 
-    double p = (3.0 * a * c - b2) / (3.0 * a2);
-    double q = (2.0 * b3 - 9.0 * a * b * c + 27.0 * a2 * d) / (27.0 * a3);
+    real_t p = (3.0 * a * c - b2) / (3.0 * a2);
+    real_t q = (2.0 * b3 - 9.0 * a * b * c + 27.0 * a2 * d) / (27.0 * a3);
 
     // Now solving t^3 + p t + q = 0
     if (p == 0) {
 
-      t.push_back(std::cbrt(-q));
+      t.push_back(std::cbrt(-double(q)));
 
     } else {
 
-      double delta = -4.0 * p * p * p - 27.0 * q * q;
+      real_t delta = -4.0 * p * p * p - 27.0 * q * q;
 
       if (delta == 0) {
 
@@ -80,18 +80,18 @@ namespace quda
 
       } else if (delta > 0) {
 
-        double theta = std::acos(1.5 * (q / p) * std::sqrt(-3.0 / p));
-        double tmp = 2.0 * std::sqrt(-p / 3.0);
+        double theta = std::acos(double(1.5 * (q / p) * sqrt(-3.0 / p)));
+        real_t tmp = 2.0 * sqrt(-p / 3.0);
         for (int k = 0; k < 3; k++) { t.push_back(tmp * std::cos((theta - 2.0 * M_PI * k) / 3.0)); }
 
       } else if (delta < 0) {
 
         if (p < 0) {
-          double theta = std::acosh(-1.5 * std::abs(q) / p * std::sqrt(-3.0 / p));
-          t.push_back(-2.0 * std::abs(q) / q * std::sqrt(-p / 3.0) * cosh(theta / 3.0));
+          double theta = std::acosh(-double(1.5 * abs(q) / p * sqrt(-3.0 / p)));
+          t.push_back(-2.0 * abs(q) / q * sqrt(-p / 3.0) * cosh(theta / 3.0));
         } else if (p > 0) {
-          double theta = std::asinh(+1.5 * q / p * std::sqrt(3.0 / p));
-          t.push_back(-2.0 * std::sqrt(p / 3.0) * sinh(theta / 3.0));
+          double theta = std::asinh(double(1.5 * q / p * sqrt(3.0 / p)));
+          t.push_back(-2.0 * sqrt(p / 3.0) * sinh(theta / 3.0));
         }
       }
     }
@@ -101,11 +101,11 @@ namespace quda
     return t;
   }
 
-  inline double poly4(std::array<double, 5> coeffs, double x)
+  inline real_t poly4(std::array<real_t, 5> coeffs, real_t x)
   {
-    double x2 = x * x;
-    double x3 = x * x2;
-    double x4 = x2 * x2;
+    real_t x2 = x * x;
+    real_t x3 = x * x2;
+    real_t x4 = x2 * x2;
     return x4 * coeffs[4] + x3 * coeffs[3] + x2 * coeffs[2] + x * coeffs[1] + coeffs[0];
   }
 
diff --git a/include/quda_define.h.in b/include/quda_define.h.in
index 850c3990df..2dbe1604f7 100644
--- a/include/quda_define.h.in
+++ b/include/quda_define.h.in
@@ -260,3 +260,10 @@ static_assert(QUDA_ORDER_FP_MG == 2 || QUDA_ORDER_FP_MG == 4 || QUDA_ORDER_FP_MG
 #if !defined(QUDA_TARGET_CUDA) && !defined(QUDA_TARGET_HIP) && !defined(QUDA_TARGET_SYCL)
 #error "No QUDA_TARGET selected"
 #endif
+
+#cmakedefine QUDA_SCALAR_TYPE @QUDA_SCALAR_TYPE@
+#cmakedefine QUDA_REDUCTION_TYPE @QUDA_REDUCTION_TYPE@
+
+#cmakedefine QUDA_REDUCTION_ALGORITHM_NAIVE @QUDA_REDUCTION_ALGORITHM_NAIVE@
+#cmakedefine QUDA_REDUCTION_ALGORITHM_KAHAN @QUDA_REDUCTION_ALGORITHM_KAHAN@
+#cmakedefine QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE @QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE@
diff --git a/include/quda_internal.h b/include/quda_internal.h
index dd8a6c8177..7fe85f6390 100644
--- a/include/quda_internal.h
+++ b/include/quda_internal.h
@@ -50,10 +50,24 @@
 #include <device.h>
 #include <array.h>
 #include "timer.h"
+#include "dbldbl.h"
 
 namespace quda {
 
-  using Complex = std::complex<double>;
+  /**
+     Scalar real variable type on the host
+  */
+  using real_t = QUDA_SCALAR_TYPE;
+
+  /**
+     Scalar complex variable type on the host
+  */
+  using complex_t = std::complex<real_t>;
+
+  /**
+     Underlying type to use for reductions
+  */
+  using reduction_t = QUDA_REDUCTION_TYPE;
 
   /**
      Array object type used to storing lattice dimensions
diff --git a/include/quda_matrix.h b/include/quda_matrix.h
index 823ee78b89..99ba8b308d 100644
--- a/include/quda_matrix.h
+++ b/include/quda_matrix.h
@@ -425,7 +425,9 @@ namespace quda {
     }
 
   template< template<typename,int> class Mat, class T, int N>
-    __device__ __host__ inline Mat<T,N> operator+(const Mat<T,N> & a, const Mat<T,N> & b)
+  __device__ __host__ inline
+  std::enable_if_t<std::is_same_v<Mat<T,N>, Matrix<T, N>> || std::is_same_v<Mat<T,N>, HMatrix<T, N>>, Mat<T, N>>
+  operator+(const Mat<T,N> & a, const Mat<T,N> & b)
     {
       Mat<T,N> result;
 #pragma unroll
@@ -435,7 +437,8 @@ namespace quda {
 
 
   template< template<typename,int> class Mat, class T, int N>
-    __device__ __host__ inline Mat<T,N> operator+=(Mat<T,N> & a, const Mat<T,N> & b)
+  std::enable_if_t<std::is_same_v<Mat<T,N>, Matrix<T, N>> || std::is_same_v<Mat<T,N>, HMatrix<T, N>>, Mat<T, N>>
+    __device__ __host__ inline operator+=(Mat<T,N> & a, const Mat<T,N> & b)
     {
 #pragma unroll
       for (int i = 0; i < a.size(); i++) a.data[i] += b.data[i];
@@ -443,7 +446,8 @@ namespace quda {
     }
 
   template< template<typename,int> class Mat, class T, int N>
-    __device__ __host__ inline Mat<T,N> operator+=(Mat<T,N> & a, const T & b)
+  std::enable_if_t<std::is_same_v<Mat<T,N>, Matrix<T, N>> || std::is_same_v<Mat<T,N>, HMatrix<T, N>>, Mat<T, N>>
+  __device__ __host__ inline operator+=(Mat<T,N> & a, const T & b)
     {
 #pragma unroll
       for (int i = 0; i < a.rows(); i++) a(i, i) += b;
@@ -451,7 +455,8 @@ namespace quda {
     }
 
   template< template<typename,int> class Mat, class T, int N>
-    __device__ __host__ inline Mat<T,N> operator-=(Mat<T,N> & a, const Mat<T,N> & b)
+  std::enable_if_t<std::is_same_v<Mat<T,N>, Matrix<T, N>> || std::is_same_v<Mat<T,N>, HMatrix<T, N>>, Mat<T, N>>
+  __device__ __host__ inline operator-=(Mat<T,N> & a, const Mat<T,N> & b)
     {
 #pragma unroll
       for (int i = 0; i < a.size(); i++) a.data[i] -= b.data[i];
diff --git a/include/reducer.h b/include/reducer.h
index 3c2f37f364..b510d30b33 100644
--- a/include/reducer.h
+++ b/include/reducer.h
@@ -3,8 +3,8 @@
 #include "complex_quda.h"
 #include "quda_constants.h"
 #include "quda_api.h"
-#include <math_helper.cuh>
-#include <float_vector.h>
+#include "math_helper.cuh"
+#include "float_vector.h"
 #include "comm_quda.h"
 #include "fast_intdiv.h"
 
@@ -23,12 +23,6 @@
 namespace quda
 {
 
-#ifdef QUAD_SUM
-  using device_reduce_t = doubledouble;
-#else
-  using device_reduce_t = double;
-#endif
-
   namespace reducer
   {
     /**
@@ -79,15 +73,77 @@ namespace quda
   /**
      plus reducer, used for conventional sum reductions
    */
-  template <typename T> struct plus {
+  template <typename T, class Enable = void> struct plus {
     static constexpr bool do_sum = true;
     using reduce_t = T;
     using reducer_t = plus<T>;
     template <typename U> static inline void comm_reduce(std::vector<U> &a) { comm_allreduce_sum(a); }
-    __device__ __host__ static inline T init() { return zero<T>(); }
+    __device__ __host__ static inline T init() { return T{}; }
     __device__ __host__ static inline T apply(T a, T b) { return a + b; }
     __device__ __host__ inline T operator()(T a, T b) const { return apply(a, b); }
+
+    template <class U>
+    __device__ __host__ static inline std::enable_if_t<std::is_same_v<U, array<typename U::value_type, U::N>>, T> apply(T a, const U &b)
+    {
+#pragma unroll
+      for (int i = 0; i < T::N; i++) a[i].operator+=(b[i]);
+      return a;
+    }
+    template <class U>
+    __device__ __host__ inline std::enable_if_t<std::is_same_v<U, array<typename U::value_type, U::N>>, T> operator()(T a, const U &b) const { return apply(a, b); }
+  };
+
+#ifdef QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE
+  /**
+     plus reducer, specialized for reproducible sum reductions
+   */
+  template <class T>
+  struct plus<T, std::enable_if_t<std::is_same_v<T, rfa_t<typename T::ftype>>>> {
+    static constexpr bool do_sum = true;
+    using reduce_t = T;
+    using reducer_t = plus<T>;
+    template <typename U> static inline void comm_reduce(std::vector<U> &a) { comm_allreduce_sum(a); }
+    __device__ __host__ static inline T init() { return reduce_t(); }
+    // rfa_t + rfa_t
+    // FIXME - should we use references here?
+    __device__ __host__ static inline T apply(T a, T b) { a.operator+=(b); return a; }
+    __device__ __host__ inline T operator()(T a, T b) const { return apply(a, b); }
+
+    __device__ __host__ static inline T apply(T a, typename T::ftype b) { a.operator+=(b); return a; }
+    __device__ __host__ inline T operator()(T a, typename T::ftype b) const { return apply(a, b); }
+  };
+
+  /**
+     plus reducer, specialized for arrays of reproducible sum reductions
+   */
+  template <class T>
+  struct plus<T, std::enable_if_t<std::is_same_v<T, array<rfa_t<typename T::value_type::ftype>, T::N>>>>
+  {
+    static constexpr bool do_sum = true;
+    using reduce_t = T;
+    using reducer_t = plus<T>;
+    template <typename U> static inline void comm_reduce(std::vector<U> &a) { comm_allreduce_sum(a); }
+    __device__ __host__ static inline T init() { return reduce_t{}; }
+    // rfa_t + rfa_t
+    // FIXME - should we use references here?
+    __device__ __host__ static inline T apply(T a, T b)
+    {
+#pragma unroll
+      for (int i = 0; i < T::N; i++) a[i].operator+=(b[i]);
+      return a;
+    }
+    __device__ __host__ inline T operator()(T a, T b) const { return apply(a, b); }
+
+    __device__ __host__ static inline T apply(T a, const array<typename T::value_type::ftype, T::N> &b)
+    {
+#pragma unroll
+      for (int i = 0; i < T::N; i++) a[i].operator+=(b[i]);
+      return a;
+    }
+
+    __device__ __host__ inline T operator()(T a, const array<typename T::value_type::ftype, T::N> &b) const { return apply(a, b); }
   };
+#endif
 
   /**
      maximum reducer, used for max reductions
diff --git a/include/register_traits.h b/include/register_traits.h
index ecb618b9f5..1e255d1413 100644
--- a/include/register_traits.h
+++ b/include/register_traits.h
@@ -180,7 +180,7 @@ namespace quda {
     static const int value = 1;
   };
 
-  template <> struct vec_length<Complex> {
+  template <> struct vec_length<complex_t> {
     static const int value = 2;
   };
   template <> struct vec_length<complex<double>> {
@@ -319,6 +319,19 @@ namespace quda {
     typedef char8 type;
   };
 
+  // demote vector type to underlying scalar type
+  template <class T> struct get_scalar;
+  template <> struct get_scalar<float> { using type = float; };
+  template <> struct get_scalar<double> { using type = double; };
+  template <> struct get_scalar<double2> { using type = double; };
+  template <> struct get_scalar<doubledouble> { using type = doubledouble; };
+  template <> struct get_scalar<doubledouble2> { using type = doubledouble; };
+  template <> struct get_scalar<complex<float>> { using type = float; };
+  template <> struct get_scalar<complex<double>> { using type = double; };
+  template <class T, int n> struct get_scalar<array<T, n>> { using type = typename get_scalar<T>::type; };
+
+  template <class T> using get_scalar_t = typename get_scalar<T>::type;
+
   template<bool large_alloc> struct AllocType { };
   template<> struct AllocType<true> { typedef size_t type; };
   template<> struct AllocType<false> { typedef int type; };
diff --git a/include/reliable_updates.h b/include/reliable_updates.h
index a1ddd9f122..7940e88bfb 100644
--- a/include/reliable_updates.h
+++ b/include/reliable_updates.h
@@ -34,44 +34,44 @@ namespace quda
 
     bool alternative_reliable;
 
-    double u;
-    double uhigh;
-    double Anorm;
-    double delta;
+    real_t u;
+    real_t uhigh;
+    real_t Anorm;
+    real_t delta;
 
     // this parameter determines how many consective reliable update
     // residual increases we tolerate before terminating the solver,
     // i.e., how long do we want to keep trying to converge
-    int maxResIncrease; //  check if we reached the limit of our tolerance
-    int maxResIncreaseTotal;
+    int maxResIncrease = 0; //  check if we reached the limit of our tolerance
+    int maxResIncreaseTotal = 0;
 
     bool use_heavy_quark_res;
 
-    int hqmaxresIncrease;
-    int hqmaxresRestartTotal; // this limits the number of heavy quark restarts we can do
+    int hqmaxresIncrease = 0;
+    int hqmaxresRestartTotal = 0; // this limits the number of heavy quark restarts we can do
   };
 
   struct ReliableUpdates {
 
     const ReliableUpdatesParams params;
 
-    const double deps;
-    static constexpr double dfac = 1.1;
-    double d_new = 0;
-    double d = 0;
-    double dinit = 0;
-    double xNorm = 0;
-    double xnorm = 0;
-    double pnorm = 0;
-    double ppnorm = 0;
-    double delta;
-    double beta = 0.0;
-
-    double rNorm;
-    double r0Norm;
-    double maxrx;
-    double maxrr;
-    double maxr_deflate; // The maximum residual since the last deflation
+    const real_t deps;
+    static constexpr real_t dfac = 1.1;
+    real_t d_new = 0;
+    real_t d = 0;
+    real_t dinit = 0;
+    real_t xNorm = 0;
+    real_t xnorm = 0;
+    real_t pnorm = 0;
+    real_t ppnorm = 0;
+    real_t delta;
+    real_t beta = 0.0;
+
+    real_t rNorm;
+    real_t r0Norm;
+    real_t maxrx;
+    real_t maxrr;
+    real_t maxr_deflate; // The maximum residual since the last deflation
 
     int resIncrease = 0;
     int resIncreaseTotal = 0;
@@ -90,7 +90,7 @@ namespace quda
       @param params the parameters
       @param r2 the residual norm squared
      */
-    ReliableUpdates(ReliableUpdatesParams params, double r2) :
+    ReliableUpdates(ReliableUpdatesParams params, real_t r2) :
       params(params),
       deps(sqrt(params.u)),
       delta(params.delta),
@@ -110,23 +110,23 @@ namespace quda
     /**
       @brief Update the norm squared for p (thus ppnorm)
      */
-    void update_ppnorm(double ppnorm_) { ppnorm = ppnorm_; }
+    void update_ppnorm(real_t ppnorm_) { ppnorm = ppnorm_; }
 
     /**
       @brief Update the norm for r (thus rNorm)
      */
-    void update_rNorm(double rNorm_) { rNorm = rNorm_; }
+    void update_rNorm(real_t rNorm_) { rNorm = rNorm_; }
 
     /**
       @brief Update maxr_deflate
      */
-    void update_maxr_deflate(double r2) { maxr_deflate = sqrt(r2); }
+    void update_maxr_deflate(real_t r2) { maxr_deflate = sqrt(r2); }
 
     /**
       @brief Evaluate whether a reliable update is needed
       @param r2_old the old residual norm squared
      */
-    void evaluate(double r2_old)
+    void evaluate(real_t r2_old)
     {
       if (params.alternative_reliable) {
         // alternative reliable updates
@@ -155,7 +155,7 @@ namespace quda
       @brief Accumulate the estimate for error - used when reliable update is not performed
       @param alpha the alpha that is used in CG to update the solution vector x, given p
      */
-    void accumulate_norm(double alpha)
+    void accumulate_norm(real_t alpha)
     {
       // accumulate norms
       if (params.alternative_reliable) {
@@ -164,7 +164,7 @@ namespace quda
         xnorm = sqrt(pnorm);
         d_new = d + params.u * rNorm + params.uhigh * params.Anorm * xnorm;
         if (steps_since_reliable == 0 && getVerbosity() >= QUDA_DEBUG_VERBOSE)
-          printfQuda("New dnew: %e (r %e , y %e)\n", d_new, params.u * rNorm, params.uhigh * params.Anorm * xnorm);
+          printfQuda("New dnew: %e (r %e , y %e)\n", double(d_new), double(params.u * rNorm), double(params.uhigh * params.Anorm * xnorm));
       }
       steps_since_reliable++;
     }
@@ -174,18 +174,18 @@ namespace quda
       @param r2 the residual norm squared
       @param y2 the solution vector norm squared
      */
-    void update_norm(double r2, ColorSpinorField &y)
+    void update_norm(real_t r2, ColorSpinorField &y)
     {
       // update_norms
       if (params.alternative_reliable) {
-        double y2 = blas::norm2(y);
+        real_t y2 = blas::norm2(y);
         dinit = params.uhigh * (sqrt(r2) + params.Anorm * sqrt(y2));
         d = d_new;
         xnorm = 0; // sqrt(norm2(x));
         pnorm = 0; // pnorm + alpha * sqrt(norm2(p));
         if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
-          printfQuda("New dinit: %e (r %e , y %e)\n", dinit, params.uhigh * sqrt(r2),
-                     params.uhigh * params.Anorm * sqrt(y2));
+          printfQuda("New dinit: %e (r %e , y %e)\n", double(dinit), double(params.uhigh * sqrt(r2)),
+                     double(params.uhigh * params.Anorm * sqrt(y2)));
         d_new = dinit;
       } else {
         rNorm = sqrt(r2);
@@ -201,20 +201,20 @@ namespace quda
       @param[in/out] L2breakdown whether or not L2 breakdown
       @param L2breakdown_eps L2 breakdown epsilon
      */
-    bool reliable_break(double r2, double stop, bool &L2breakdown, double L2breakdown_eps)
+    bool reliable_break(real_t r2, real_t stop, bool &L2breakdown, real_t L2breakdown_eps)
     {
       // break-out check if we have reached the limit of the precision
       if (sqrt(r2) > r0Norm && updateX and not L2breakdown) { // reuse r0Norm for this
         resIncrease++;
         resIncreaseTotal++;
         warningQuda("new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-                    sqrt(r2), r0Norm, resIncreaseTotal);
+                    double(sqrt(r2)), double(r0Norm), resIncreaseTotal);
 
         if ((params.use_heavy_quark_res and sqrt(r2) < L2breakdown_eps) or resIncrease > params.maxResIncrease
             or resIncreaseTotal > params.maxResIncreaseTotal or r2 < stop) {
           if (params.use_heavy_quark_res) {
             L2breakdown = true;
-            warningQuda("L2 breakdown %e, %e", sqrt(r2), L2breakdown_eps);
+            warningQuda("L2 breakdown %e, %e", double(sqrt(r2)), double(L2breakdown_eps));
           } else {
             if (resIncrease > params.maxResIncrease or resIncreaseTotal > params.maxResIncreaseTotal or r2 < stop) {
               warningQuda("solver exiting due to too many true residual norm increases");
@@ -235,7 +235,7 @@ namespace quda
       @param heavy_quark_res_old the old heavy quark residual
       @param[in/out] heavy_quark_restart whether should restart the heavy quark
      */
-    bool reliable_heavy_quark_break(bool L2breakdown, double heavy_quark_res, double heavy_quark_res_old,
+    bool reliable_heavy_quark_break(bool L2breakdown, real_t heavy_quark_res, real_t heavy_quark_res_old,
                                     bool &heavy_quark_restart)
     {
       if (params.use_heavy_quark_res and L2breakdown) {
@@ -248,7 +248,7 @@ namespace quda
         if (heavy_quark_res > heavy_quark_res_old) { // check if new hq residual is greater than previous
           hqresIncrease++;                           // count the number of consecutive increases
           warningQuda("CG: new reliable HQ residual norm %e is greater than previous reliable residual norm %e",
-                      heavy_quark_res, heavy_quark_res_old);
+                      double(heavy_quark_res), double(heavy_quark_res_old));
           // break out if we do not improve here anymore
           if (hqresIncrease > params.hqmaxresIncrease) {
             warningQuda("CG: solver exiting due to too many heavy quark residual norm increases (%i/%i)", hqresIncrease,
@@ -272,7 +272,7 @@ namespace quda
       @brief Reset the counters - after a reliable update has been performed
       @param r2 residual norm squared
     */
-    void reset(double r2)
+    void reset(real_t r2)
     {
       steps_since_reliable = 0;
       r0Norm = sqrt(r2);
diff --git a/include/staggered_kd_build_xinv.h b/include/staggered_kd_build_xinv.h
index 2bd1b4f600..dd5622b636 100644
--- a/include/staggered_kd_build_xinv.h
+++ b/include/staggered_kd_build_xinv.h
@@ -14,7 +14,7 @@ namespace quda
      @param mass [in] Mass of the original staggered operator w/out factor of 2 convention
      @param dagger_approximation[in] Whether or not to use the dagger approximation, using the dagger of X instead of Xinv
   */
-  void BuildStaggeredKahlerDiracInverse(GaugeField &Xinv, const GaugeField &gauge, const double mass,
+  void BuildStaggeredKahlerDiracInverse(GaugeField &Xinv, const GaugeField &gauge, const real_t mass,
                                         const bool dagger_approximation);
 
   /**
@@ -25,7 +25,7 @@ namespace quda
      @param msas [in] Mass of the original staggered operator w/out factor of 2 convention, needed for dagger approx
   */
   void ReorderStaggeredKahlerDiracInverse(GaugeField &xInvFineLayout, const GaugeField &xInvCoarseLayout,
-                                          const bool dagger_approximation, const double mass);
+                                          const bool dagger_approximation, const real_t mass);
 
   /**
      @brief Allocate and build the Kahler-Dirac inverse block for KD operators
@@ -34,7 +34,7 @@ namespace quda
      @param dagger_approximation[in] Whether or not to use the dagger approximation, using the dagger of X instead of Xinv
      @return constructed Xinv
   */
-  std::shared_ptr<GaugeField> AllocateAndBuildStaggeredKahlerDiracInverse(const GaugeField &gauge, const double mass,
+  std::shared_ptr<GaugeField> AllocateAndBuildStaggeredKahlerDiracInverse(const GaugeField &gauge, const real_t mass,
                                                                           const bool dagger_approximation);
 
 } // namespace quda
diff --git a/include/targets/cuda/block_reduce_helper.h b/include/targets/cuda/block_reduce_helper.h
index dd368b6d02..bdf3988694 100644
--- a/include/targets/cuda/block_reduce_helper.h
+++ b/include/targets/cuda/block_reduce_helper.h
@@ -11,7 +11,8 @@
  */
 
 // whether to use cooperative groups (or cub)
-#if !(_NVHPC_CUDA || (defined(__clang__) && defined(__CUDA__))) // neither nvc++ or clang-cuda yet support CG
+#if !(_NVHPC_CUDA || (defined(__clang__) && defined(__CUDA__))) && !defined(QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE) // neither nvc++ or clang-cuda yet support CG
+// FIXME add CG support for reproducible reductions (can't naively break up the operation)
 #define USE_CG
 #endif
 
@@ -44,37 +45,32 @@ namespace quda
    */
   template <typename T, typename Enable = void> struct atomic_type;
 
-  template <> struct atomic_type<device_reduce_t> {
-    using type = device_reduce_t;
+  template <> struct atomic_type<doubledouble> {
+    using type = double; // must break up 128-bit types into doubles
   };
 
-  template <> struct atomic_type<float> {
-    using type = float;
-  };
-
-  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, array<device_reduce_t, T::N>>>> {
-    using type = device_reduce_t;
+  template <> struct atomic_type<double> {
+    using type = double;
   };
 
-  template <typename T>
-  struct atomic_type<T, std::enable_if_t<std::is_same_v<T, array<array<device_reduce_t, T::value_type::N>, T::N>>>> {
-    using type = device_reduce_t;
+  template <> struct atomic_type<float> {
+    using type = float;
   };
 
-  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, array<complex<double>, T::N>>>> {
-    using type = double;
+  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, complex<typename T::value_type>>>> {
+    using type = typename atomic_type<typename T::value_type>::type;
   };
 
-  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, array<complex<float>, T::N>>>> {
-    using type = float;
+  template <typename T> struct atomic_type<T, std::enable_if_t<is_rfa<T>::value>> {
+    using type = typename T::ftype;
   };
 
-  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, deviation_t<float>>>> {
-    using type = float;
+  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, array<typename T::value_type, T::N>>>> {
+    using type = typename atomic_type<typename T::value_type>::type;
   };
 
-  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, deviation_t<double>>>> {
-    using type = double;
+  template <typename T> struct atomic_type<T, std::enable_if_t<std::is_same_v<T, deviation_t<typename T::value_type>>>> {
+    using type = typename atomic_type<typename T::value_type>::type;
   };
 
   // pre-declaration of warp_reduce that we wish to specialize
diff --git a/include/targets/cuda/math_helper.cuh b/include/targets/cuda/math_helper.cuh
index bdc333297a..cee198e2d0 100644
--- a/include/targets/cuda/math_helper.cuh
+++ b/include/targets/cuda/math_helper.cuh
@@ -3,7 +3,11 @@
 #include <cmath>
 #include <target_device.h>
 
-#if (CUDA_VERSION >= 11070) && !defined(_NVHPC_CUDA)
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA) || (defined(__clang__) && defined(__CUDA__))
+#define QUDA_CUDA_CC
+#endif
+
+#if (CUDA_VERSION >= 11070) && defined(QUDA_CUDA_CC) && !defined(_NVHPC_CUDA)
 #define BUILTIN_ASSUME(x) \
   bool p = x;             \
   __builtin_assume(p);
@@ -34,6 +38,7 @@ namespace quda {
     template <typename T> inline void operator()(const T& a, T *s, T *c) { ::sincos(a, s, c); }
   };
 
+#ifdef QUDA_CUDA_CC
   template <> struct sincos_impl<true> {
     template <typename T> __device__ inline void operator()(const T& a, T *s, T *c)
     {
@@ -41,6 +46,7 @@ namespace quda {
       sincos(a, s, c);
     }
   };
+#endif
 
   /**
    * @brief Combined sin and cos calculation in QUDA NAMESPACE
@@ -55,9 +61,11 @@ namespace quda {
     inline void operator()(const float& a, float *s, float *c) { ::sincosf(a, s, c); }
   };
 
+#ifdef QUDA_CUDA_CC
   template <> struct sincosf_impl<true> {
     __device__ inline void operator()(const float& a, float *s, float *c) { __sincosf(a, s, c); }
   };
+#endif
 
   /**
    * @brief Combined sin and cos calculation in QUDA NAMESPACE
@@ -75,10 +83,11 @@ namespace quda {
     template <typename T> inline void operator()(const T& a, T *s, T *c) { ::sincos(a * static_cast<T>(M_PI), s, c); }
   };
 
+#ifdef QUDA_CUDA_CC
   template <> struct sincospi_impl<true> {
     template <typename T> __device__ inline void operator()(const T& a, T *s, T *c) { sincospi(a, s, c); }
   };
-
+#endif
 
   /**
    * @brief Combined sinpi and cospi calculation in QUDA NAMESPACE
@@ -100,20 +109,25 @@ namespace quda {
   template<>
   inline __host__ __device__ void sincospi(const float& a, float *s, float *c) { quda::sincos(a * static_cast<float>(M_PI), s, c); }
 
+  template <bool is_device> struct sinpi_impl {
+    template <typename T> inline T operator()(T a) { return ::sin(a * static_cast<T>(M_PI)); }
+  };
+#ifdef QUDA_CUDA_CC
+  template <> struct sinpi_impl<true> { template <typename T> __device__ inline T operator()(T a) { return ::sinpi(a); } };
+#endif
 
   /**
    * @brief Sine pi calculation in QUDA NAMESPACE
    * @param a the angle
    * @return result of the sin(a * pi)
    */
-  template<typename T> inline __host__ __device__ T sinpi(T a) { return ::sinpi(a); }
+  template<typename T> inline __host__ __device__ T sinpi(T a) { return target::dispatch<sinpi_impl>(a); }
+
 
-#ifndef _NVHPC_CUDA
-  template <bool is_device> struct sinpif_impl { inline float operator()(float a) { return ::sinpif(a); } };
-#else
   template <bool is_device> struct sinpif_impl { inline float operator()(float a) { return ::sinf(a * static_cast<float>(M_PI)); } };
-#endif
+#ifdef QUDA_CUDA_CC
   template <> struct sinpif_impl<true> { __device__ inline float operator()(float a) { return __sinf(a * static_cast<float>(M_PI)); } };
+#endif
 
   /**
    * @brief Sine pi calculation in QUDA NAMESPACE.
@@ -124,20 +138,27 @@ namespace quda {
    */
   template<> inline __host__ __device__ float sinpi(float a) { return target::dispatch<sinpif_impl>(a); }
 
+  template <bool is_device> struct cospi_impl {
+    template <typename T> inline T operator()(T a) { return ::cos(a * static_cast<T>(M_PI)); }
+  };
+#ifdef QUDA_CUDA_CC
+  template <> struct cospi_impl<true> {
+    template <typename T> __device__ inline T operator()(T a) { return ::cospi(a); }
+  };
+#endif
 
   /**
    * @brief Cosine pi calculation in QUDA NAMESPACE
    * @param a the angle
    * @return result of the cos(a * pi)
    */
-  template<typename T> inline __host__ __device__ T cospi(T a) { return ::cospi(a); }
+  template<typename T> inline __host__ __device__ T cospi(T a) { return target::dispatch<cospi_impl>(a); }
+
 
-#ifndef _NVHPC_CUDA
-  template <bool is_device> struct cospif_impl { inline float operator()(float a) { return ::cospif(a); } };
-#else
   template <bool is_device> struct cospif_impl { inline float operator()(float a) { return ::cosf(a * static_cast<float>(M_PI)); } };
-#endif
+#ifdef QUDA_CUDA_CC
   template <> struct cospif_impl<true> { __device__ inline float operator()(float a) { return __cosf(a * static_cast<float>(M_PI)); } };
+#endif
 
   /**
    * @brief Cosine pi calculation in QUDA NAMESPACE.
@@ -153,9 +174,11 @@ namespace quda {
     template <typename T> inline T operator()(T a) { return static_cast<T>(1.0) / sqrt(a); }
   };
 
+#ifdef QUDA_CUDA_CC
   template <> struct rsqrt_impl<true> {
     template <typename T> __device__ inline T operator()(T a) { return ::rsqrt(a); }
   };
+#endif
 
   /**
    * @brief Reciprocal square root function (rsqrt)
@@ -169,6 +192,7 @@ namespace quda {
 
   template <bool is_device> struct fpow_impl { template <typename real> inline real operator()(real a, int b) { return std::pow(a, b); } };
 
+#ifdef QUDA_CUDA_CC
   template <> struct fpow_impl<true> {
     __device__ inline double operator()(double a, int b) { return ::pow(a, b); }
 
@@ -179,6 +203,7 @@ namespace quda {
       return b & 1 ? sign * power : power;
     }
   };
+#endif
 
   /*
     @brief Fast power function that works for negative "a" argument
@@ -189,11 +214,60 @@ namespace quda {
   template <typename real> __device__ __host__ inline real fpow(real a, int b) { return target::dispatch<fpow_impl>(a, b); }
 
   template <bool is_device> struct fdividef_impl { inline float operator()(float a, float b) { return a / b; } };
+#ifdef QUDA_CUDA_CC
   template <> struct fdividef_impl<true> { __device__ inline float operator()(float a, float b) { return __fdividef(a, b); } };
+#endif
 
   /**
      @brief Optimized division routine on the device
   */
   __device__ __host__ inline float fdividef(float a, float b) { return target::dispatch<fdividef_impl>(a, b); }
 
+
+  template <bool is_device> struct dmul_rn_impl {
+    inline double operator()(double a, double b) { return a * b; }
+  };
+#ifdef QUDA_CUDA_CC
+  template <> struct dmul_rn_impl<true> {
+    __device__ inline double operator()(double a, double b) { return ::__dmul_rn(a, b); }
+  };
+#endif
+
+  /**
+     @brief IEEE double precision multiplication
+  */
+  __device__ __host__ inline double dmul_rn(double a, double b) { return target::dispatch<dmul_rn_impl>(a, b); }
+
+
+  template <bool is_device> struct dadd_rn_impl {
+    inline double operator()(double a, double b) { return a + b; }
+  };
+#ifdef QUDA_CUDA_CC
+  template <> struct dadd_rn_impl<true> {
+    __device__ inline double operator()(double a, double b) { return ::__dadd_rn(a, b); }
+  };
+#endif
+
+  /**
+     @brief IEEE double precision addition
+  */
+  __device__ __host__ inline double dadd_rn(double a, double b) { return target::dispatch<dadd_rn_impl>(a, b); }
+
+
+  template <bool is_device> struct fma_rn_impl {
+    inline double operator()(double a, double b, double c) { return std::fma(a, b, c); }
+  };
+#ifdef QUDA_CUDA_CC
+  template <> struct fma_rn_impl<true> {
+    __device__ inline double operator()(double a, double b, double c) { return ::__fma_rn(a, b, c); }
+  };
+#endif
+
+  /**
+     @brief IEEE double precision fused multiply add
+  */
+  __device__ __host__ inline double fma_rn(double a, double b, double c) { return target::dispatch<fma_rn_impl>(a, b, c); }
+
 }
+
+#undef QUDA_CUDA_CC
diff --git a/include/targets/cuda/reduce_helper.h b/include/targets/cuda/reduce_helper.h
index 73fc0bfbc0..794999cdd3 100644
--- a/include/targets/cuda/reduce_helper.h
+++ b/include/targets/cuda/reduce_helper.h
@@ -85,6 +85,14 @@ namespace quda
       result_h = static_cast<decltype(result_h)>(reducer::get_host_buffer());
       count = reducer::get_count<count_t>();
 
+      if constexpr (is_rfa<get_scalar_t<T>>::value) {
+        static bool init = false;
+        if (!init) {
+          cudaMemcpyToSymbol(reproducible::bin_device_buffer, static_cast<void*>(&reducer::get_rfa_bins()),
+                             sizeof(reproducible::RFA_bins<reduction_t>), 0, cudaMemcpyHostToDevice);
+        }
+      }
+
       if (!commAsyncReduction()) {
         // initialize the result buffer so we can test for completion
         for (int i = 0; i < n_reduce * n_item; i++) {
@@ -120,33 +128,30 @@ namespace quda
        @param[out] result The reduction result is copied here
        @param[in] stream The stream on which we the reduction is being done
      */
-    template <typename host_t, typename device_t = host_t>
-    void complete(std::vector<host_t> &result, const qudaStream_t = device::get_default_stream())
+    auto complete(const qudaStream_t = device::get_default_stream())
     {
-      if (launch_error == QUDA_ERROR) return; // kernel launch failed so return
-      if (launch_error == QUDA_ERROR_UNINITIALIZED) errorQuda("No reduction kernel appears to have been launched");
+      std::vector<T> result(n_reduce);
       if (consumed) errorQuda("Cannot call complete more than once for each construction");
+      if (launch_error == QUDA_ERROR_UNINITIALIZED) errorQuda("No reduction kernel appears to have been launched");
+      if (launch_error != QUDA_ERROR) {
+        for (int i = 0; i < n_reduce * n_item; i++) {
+          while (result_h[i].load(cuda::std::memory_order_relaxed) == init_value<system_atomic_t>()) { }
+        }
 
-      for (int i = 0; i < n_reduce * n_item; i++) {
-        while (result_h[i].load(cuda::std::memory_order_relaxed) == init_value<system_atomic_t>()) { }
-      }
-
-      // copy back result element by element and convert if necessary to host reduce type
-      // unit size here may differ from system_atomic_t size, e.g., if doing double-double
-      const int n_element = n_reduce * sizeof(T) / sizeof(device_t);
-      if (result.size() != (unsigned)n_element)
-        errorQuda("result vector length %lu does not match n_reduce %d", result.size(), n_element);
-      for (int i = 0; i < n_element; i++) result[i] = reinterpret_cast<device_t *>(result_h)[i];
+        memcpy(reinterpret_cast<void*>(result.data()), reinterpret_cast<void*>(result_h), n_reduce * sizeof(T));
 
-      if (!reset) {
-        consumed = true;
-      } else {
-        // reset the atomic counter - this allows multiple calls to complete with ReduceArg construction
-        for (int i = 0; i < n_reduce * n_item; i++) {
-          result_h[i].store(init_value<system_atomic_t>(), cuda::std::memory_order_relaxed);
+        if (!reset) {
+          consumed = true;
+        } else {
+          // reset the atomic counter - this allows multiple calls to complete with ReduceArg construction
+          for (int i = 0; i < n_reduce * n_item; i++) {
+            result_h[i].store(init_value<system_atomic_t>(), cuda::std::memory_order_relaxed);
+          }
+          cuda::std::atomic_thread_fence(cuda::std::memory_order_release);
         }
-        cuda::std::atomic_thread_fence(cuda::std::memory_order_release);
       }
+
+      return result;
     }
   };
 
@@ -174,21 +179,32 @@ namespace quda
       constexpr bool coalesced_write = true;
 #endif
       if constexpr (coalesced_write) {
-        static_assert(n <= device::warp_size(), "reduction array is greater than warp size");
-        auto mask = __ballot_sync(0xffffffff, tid < n);
-        if (tid < n) {
+        if (tid < device::warp_size()) { // only first warp takes part in write
+
           atomic_t sum_tmp[n];
           memcpy(sum_tmp, &sum, sizeof(sum));
 
-          atomic_t s = sum_tmp[0];
+          constexpr auto m = (n + device::warp_size() - 1) / device::warp_size();
 #pragma unroll
-          for (int i = 1; i < n; i++) {
-            auto si = __shfl_sync(mask, sum_tmp[i], 0);
-            if (i == tid) s = si;
-          }
+          for (auto j = 0; j < m; j++) {
+
+            auto t = j * device::warp_size() + tid; // effective thread index
+            atomic_t s = sum_tmp[j * device::warp_size()];
+            auto mask = __ballot_sync(0xffffffff, t < n);
 
-          s = (s == init_value<atomic_t>()) ? terminate_value<atomic_t>() : s;
-          arg.result_d[n * idx + tid].store(s, cuda::std::memory_order_relaxed);
+            if (t < n) {
+#pragma unroll
+              for (auto i = 1; i < device::warp_size(); i++) {
+                if (j * device::warp_size() + i < n) {
+                  auto si = __shfl_sync(mask, sum_tmp[j * device::warp_size() + i], 0);
+                  if (i == tid) s = si; // j * device::warp_size() cancels out on both sides
+                }
+              }
+
+              s = (s == init_value<atomic_t>()) ? terminate_value<atomic_t>() : s;
+              arg.result_d[n * idx + t].store(s, cuda::std::memory_order_relaxed);
+            }
+          }
         }
       } else {
         // write out the final reduced value
diff --git a/include/targets/cuda/reduction_kernel.h b/include/targets/cuda/reduction_kernel.h
index b2d23e7897..274675b009 100644
--- a/include/targets/cuda/reduction_kernel.h
+++ b/include/targets/cuda/reduction_kernel.h
@@ -23,13 +23,12 @@ namespace quda
   template <template <typename> class Transformer, typename Arg, bool grid_stride = true>
   __forceinline__ __device__ void Reduction2D_impl(const Arg &arg)
   {
-    using reduce_t = typename Transformer<Arg>::reduce_t;
     Transformer<Arg> t(arg);
 
     auto idx = threadIdx.x + blockIdx.x * blockDim.x;
     auto j = threadIdx.y;
 
-    reduce_t value = t.init();
+    auto value = t.init();
 
     while (idx < arg.threads.x) {
       value = t(value, idx, j);
@@ -97,7 +96,6 @@ namespace quda
   template <template <typename> class Functor, typename Arg, bool grid_stride = true>
   __forceinline__ __device__ void MultiReduction_impl(const Arg &arg)
   {
-    using reduce_t = typename Functor<Arg>::reduce_t;
     Functor<Arg> t(arg);
 
     auto idx = threadIdx.x + blockIdx.x * blockDim.x;
@@ -106,7 +104,7 @@ namespace quda
 
     if (j >= arg.threads.z) return;
 
-    reduce_t value = t.init();
+    auto value = t.init();
 
     while (idx < arg.threads.x) {
       value = t(value, idx, k, j);
diff --git a/include/targets/cuda/reproducible_floating_accumulator.hpp b/include/targets/cuda/reproducible_floating_accumulator.hpp
new file mode 100644
index 0000000000..515c66e5a0
--- /dev/null
+++ b/include/targets/cuda/reproducible_floating_accumulator.hpp
@@ -0,0 +1,928 @@
+//Reproducible Floating Point Accumulations via Binned Floating Point
+//Adapted to C++ by Richard Barnes from ReproBLAS v2.1.0.
+//ReproBLAS by Peter Ahrens, Hong Diep Nguyen, and James Demmel.
+//
+//The code accomplishes several objectives:
+//
+//1. Reproducible summation, independent of summation order, assuming only a
+//   subset of the IEEE 754 Floating Point Standard
+//
+//2. Has accuracy at least as good as conventional summation, and tunable
+//
+//3. Handles overflow, underflow, and other exceptions reproducibly.
+//
+//4. Makes only one read-only pass over the summands.
+//
+//5. Requires only one parallel reduction.
+//
+//6. Uses minimal memory (6 doubles per accumulator with fold=3).
+//
+//7. Relatively easy to use
+
+#pragma once
+
+#include <algorithm>
+#include <climits>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+
+//#include "array.h"
+
+//#ifndef __CUDACC__
+//#define __host__
+//#define __device__
+//#define __forceinline__
+//#include <array>
+//using std::array;
+//using std::min;
+//using std::max;
+//#else
+#include <cuda/std/array>
+//using cuda::std::array;
+//using cuda::std::min;
+//using cuda::std::max;
+//#include "vector.hpp"
+//#endif
+
+// disable zero checks
+//#define DISABLE_ZERO
+
+// disable nan / infinity checks
+#define DISABLE_NANINF
+
+// jump table for indexing into data
+#define MAX_JUMP 5
+static_assert(MAX_JUMP <= 5, "MAX_JUMP greater than max");
+
+namespace quda {
+
+  namespace reproducible {
+
+template <class T> auto abs_max(const T&);
+
+template <> __host__ __device__ inline auto abs_max(const float4 &x) { return fmax( fmaxf(fabs(x.x), fabs(x.y)), fmax(fabs(x.z), fabs(x.w)) ); }
+
+template <> __host__ __device__ inline auto abs_max(const double2 &x) { return fmax(fabs(x.x), fabs(x.y)); }
+
+template <> __host__ __device__ inline auto abs_max(const float2 &x) { return fmax(fabs(x.x), fabs(x.y)); }
+
+template <class ftype> struct RFA_bins
+{
+  static constexpr auto BIN_WIDTH = std::is_same_v<ftype, double> ? 40 : 13;
+  static constexpr auto MIN_EXP = std::numeric_limits<ftype>::min_exponent;
+  static constexpr auto MAX_EXP = std::numeric_limits<ftype>::max_exponent;
+  static constexpr auto MANT_DIG = std::numeric_limits<ftype>::digits;
+  ///Binned floating-point maximum index
+  static constexpr auto MAXINDEX = ((MAX_EXP - MIN_EXP + MANT_DIG - 1) / BIN_WIDTH) - 1;
+  //The maximum floating-point fold supported by the library
+  static constexpr auto MAXFOLD = MAXINDEX + 1;
+
+  static_assert(std::is_same_v<ftype, double> || std::is_same_v<ftype, float>);
+  static_assert(MAXINDEX > 0);
+  ///The binned floating-point reference bins
+  ::cuda::std::array<ftype, MAXINDEX + MAXFOLD> bins = {};
+
+  constexpr ftype& operator[](int d) { return bins[d]; }
+
+  void initialize_bins() {
+    if constexpr (std::is_same_v<ftype, float>){
+      bins[0] = std::ldexp(0.75, MAX_EXP);
+    } else {
+      bins[0] = 2.0 * ldexp(0.75, MAX_EXP - 1);
+    }
+
+    for(int index = 1; index <= MAXINDEX; index++){
+      bins[index] = ldexp(0.75, MAX_EXP + MANT_DIG - BIN_WIDTH + 1 - index * BIN_WIDTH);
+    }
+    for(int index = MAXINDEX + 1; index < MAXINDEX + MAXFOLD; index++){
+      bins[index] = bins[index - 1];
+    }
+  }
+};
+
+template <> struct RFA_bins<doubledouble>
+{
+  static constexpr doubledouble dummy = {};
+  constexpr const doubledouble& operator[](int) const { return dummy; }
+};
+
+  }
+
+  namespace reducer {
+    reproducible::RFA_bins<reduction_t>& get_rfa_bins();
+  }
+
+  namespace reproducible {
+
+#ifdef __CUDACC__
+__constant__ static char bin_device_buffer[sizeof(RFA_bins<double>)];
+#endif
+
+///Class to hold a reproducible summation of the numbers passed to it
+///
+///@param ftype Floating-point data type; either `float` or `double
+///@param FOLD  The fold; use 3 as a default unless you understand it.
+template<
+  class ftype_,
+  int FOLD_ = 3,
+  typename std::enable_if_t<std::is_floating_point<ftype_>::value>* = nullptr
+>
+class alignas(2 * sizeof(ftype_)) ReproducibleFloatingAccumulator {
+public:
+  using ftype = ftype_;
+  static constexpr int FOLD = FOLD_;
+
+private:
+  array<ftype, 2*FOLD> data = {};
+
+  ///Floating-point precision bin width
+  static constexpr int BIN_WIDTH = std::is_same_v<ftype, double> ? 40 : 13;
+  static constexpr int MIN_EXP = std::numeric_limits<ftype>::min_exponent;
+  static constexpr int MAX_EXP = std::numeric_limits<ftype>::max_exponent;
+  static constexpr int MANT_DIG = std::numeric_limits<ftype>::digits;
+  ///Binned floating-point maximum index
+  static constexpr int MAXINDEX = ((MAX_EXP - MIN_EXP + MANT_DIG - 1) / BIN_WIDTH) - 1;
+  //The maximum floating-point fold supported by the library
+  static constexpr int MAXFOLD = MAXINDEX + 1;
+  ///Binned floating-point compression factor
+  ///This factor is used to scale down inputs before deposition into the bin of
+  ///highest index
+  static constexpr auto COMPRESSION = 1.0 / (1 << (MANT_DIG - BIN_WIDTH + 1));
+  ///Binned double precision expansion factor
+  ///This factor is used to scale up inputs after deposition into the bin of
+  ///highest index
+  static constexpr auto EXPANSION = 1.0 * (1 << (MANT_DIG - BIN_WIDTH + 1));
+  static constexpr auto EXP_BIAS = MAX_EXP - 2;
+  static constexpr auto EPSILON = std::numeric_limits<ftype>::epsilon();
+  ///Binned floating-point deposit endurance
+  ///The number of deposits that can be performed before a renorm is necessary.
+  ///Applies also to binned complex double precision.
+  static constexpr auto ENDURANCE = 1 << (MANT_DIG - BIN_WIDTH - 2);
+
+  //RFA_bins<ftype> &bins;
+
+  ///Return a binned floating-point reference bin
+  __host__ __device__ inline const ftype* binned_bins(const int x) const
+  {
+#ifdef __CUDA_ARCH__ // must be arch not CC here
+    return &reinterpret_cast<RFA_bins<ftype>&>(bin_device_buffer)[x];
+#else
+    return &reducer::get_rfa_bins()[x];
+#endif
+    //return &bins[x];
+  }
+
+  ///Get the bit representation of a float
+  __host__ __device__ static inline uint32_t& get_bits(float &x)       { return *reinterpret_cast<      uint32_t*>(&x);}
+  ///Get the bit representation of a double
+  __host__ __device__ static inline uint64_t& get_bits(double &x)      { return *reinterpret_cast<      uint64_t*>(&x);}
+  ///Get the bit representation of a const float
+  __host__ __device__ static inline uint32_t  get_bits(const float &x) { return *reinterpret_cast<const uint32_t*>(&x);}
+  ///Get the bit representation of a const double
+  __host__ __device__ static inline uint64_t  get_bits(const double &x){ return *reinterpret_cast<const uint64_t*>(&x);}
+
+  ///Return primary vector value const ref
+  __host__ __device__ __forceinline__ const ftype& primary(int i) const {
+    if constexpr (FOLD <= MAX_JUMP) {
+      switch (i) {
+      case 0: if constexpr (FOLD >= 1) return data[0];
+      case 1: if constexpr (FOLD >= 2) return data[1];
+      case 2: if constexpr (FOLD >= 3) return data[2];
+      case 3: if constexpr (FOLD >= 4) return data[3];
+      case 4: if constexpr (FOLD >= 5) return data[4];
+      default: return data[FOLD-1];
+      }
+    } else {
+      return data[i];
+    }
+  }
+
+  ///Return carry vector value const ref
+  __host__ __device__ __forceinline__ const ftype& carry(int i) const {
+    if constexpr (FOLD <= MAX_JUMP) {
+      switch (i) {
+      case 0: if constexpr (FOLD >= 1) return data[FOLD + 0];
+      case 1: if constexpr (FOLD >= 2) return data[FOLD + 1];
+      case 2: if constexpr (FOLD >= 3) return data[FOLD + 2];
+      case 3: if constexpr (FOLD >= 4) return data[FOLD + 3];
+      case 4: if constexpr (FOLD >= 5) return data[FOLD + 4];
+      default: return data[2 * FOLD - 1];
+      }
+    } else {
+      return data[FOLD + i];
+    }
+  }
+
+  ///Return primary vector value ref
+  __host__ __device__ __forceinline__ ftype& primary(int i) {
+    const auto &c = *this;
+    return const_cast<ftype &>(c.primary(i));
+  }
+
+  ///Return carry vector value ref
+  __host__ __device__ __forceinline__ ftype& carry(int i) {
+    const auto &c = *this;
+    return const_cast<ftype &>(c.carry(i));
+  }
+
+#ifdef DISABLE_ZERO
+  __host__ __device__ static inline constexpr bool ISZERO(const ftype) { return false; }
+#else
+  __host__ __device__ static inline constexpr bool ISZERO(const ftype x) { return x == 0.0 ; }
+#endif
+
+#ifdef DISABLE_NANINF
+  __host__ __device__ static inline constexpr int ISNANINF(const ftype) { return false; }
+#else
+  __host__ __device__ static inline constexpr int ISNANINF(const ftype x) {
+    const auto bits = get_bits(x);
+    return (bits & ((2ull * MAX_EXP - 1) << (MANT_DIG - 1))) == ((2ull * MAX_EXP - 1) << (MANT_DIG - 1));
+  }
+#endif
+
+  __host__ __device__ static inline constexpr int EXP(const ftype x) {
+    const auto bits = get_bits(x);
+    return (bits >> (MANT_DIG - 1)) & (2 * MAX_EXP - 1);
+  }
+
+  static constexpr auto maxindex() { return MAXINDEX; }
+
+  ///Get index of float-point precision
+  ///The index of a non-binned type is the smallest index a binned type would
+  ///need to have to sum it reproducibly. Higher indicies correspond to smaller
+  ///bins.
+  __host__ __device__ static inline constexpr int binned_dindex(const ftype x){
+    int exp = EXP(x);
+    if(exp == 0){
+      if(x == 0.0){
+        return MAXINDEX;
+      } else {
+        frexp(x, &exp);
+        return min((MAX_EXP - exp)/BIN_WIDTH, maxindex());
+      }
+    }
+    return ((MAX_EXP + EXP_BIAS) - exp)/BIN_WIDTH;
+  }
+
+  ///Get index of manually specified binned double precision
+  ///The index of a binned type is the bin that it corresponds to. Higher
+  ///indicies correspond to smaller bins.
+  __host__ __device__ inline int binned_index() const {
+    return ((MAX_EXP + MANT_DIG - BIN_WIDTH + 1 + EXP_BIAS) - EXP(primary(0)))/BIN_WIDTH;
+  }
+
+  ///Check if index of manually specified binned floating-point is 0
+  ///A quick check to determine if the index is 0
+  __host__ __device__ inline bool binned_index0() const {
+    return EXP(primary(0)) == MAX_EXP + EXP_BIAS;
+  }
+
+  ///Update manually specified binned fp with a scalar (X -> Y)
+  ///
+  ///This method updates the binned fp to an index suitable for adding numbers
+  ///with absolute value less than @p max_abs_val
+  ///
+  ///@param incpriY stride within Y's primary vector (use every incpriY'th element)
+  ///@param inccarY stride within Y's carry vector (use every inccarY'th element)
+  __host__ __device__ void binned_dmdupdate(const ftype max_abs_val, const int incpriY, const int inccarY) {
+    if (ISNANINF(primary(0))) return;
+
+    int X_index = binned_dindex(max_abs_val);
+    if( ISZERO(primary(0)) ){
+      const ftype *const bins = binned_bins(X_index);
+      for(int i = 0; i < FOLD; i++){
+        primary(i * incpriY) = bins[i];
+        carry(i * inccarY) = 0.0;
+      }
+    }else{
+      int shift = binned_index() - X_index;
+      if(shift > 0){
+#pragma unroll
+        for(int i = FOLD - 1; i >= 1; i--){
+          if (i < shift) break;
+          primary(i * incpriY) = primary((i - shift) * incpriY);
+          carry(i * inccarY) = carry((i - shift) * inccarY);
+        }
+        const ftype *const bins = binned_bins(X_index);
+#pragma unroll
+        for(int j = 0; j < FOLD; j++){
+          if (j >= shift) break;
+          primary(j * incpriY) = bins[j];
+          carry(j * inccarY) = 0.0;
+        }
+      }
+    }
+  }
+
+  ///Add scalar @p X to suitably binned manually specified binned fp (Y += X)
+  ///
+  ///Performs the operation Y += X on an binned type Y where the index of Y is
+  ///larger than the index of @p X
+  ///
+  ///@param incpriY stride within Y's primary vector (use every incpriY'th element)
+  __host__ __device__ void binned_dmddeposit(const ftype X, const int incpriY){
+    ftype M;
+    ftype x = X;
+
+    if(ISNANINF(x) || ISNANINF(primary(0))){
+      primary(0) += x;
+      return;
+    }
+
+    if(binned_index0()){
+      M = primary(0);
+      ftype qd = x * COMPRESSION;
+      auto& ql = get_bits(qd);
+      ql |= 1;
+      qd += M;
+      primary(0) = qd;
+      M -= qd;
+      M *= EXPANSION * 0.5;
+      x += M;
+      x += M;
+#pragma unroll
+      for (int i = 1; i < FOLD - 1; i++) {
+        M = primary(i * incpriY);
+        qd = x;
+        ql |= 1;
+        qd += M;
+        primary(i * incpriY) = qd;
+        M -= qd;
+        x += M;
+      }
+      qd = x;
+      ql |= 1;
+      primary((FOLD - 1) * incpriY) += qd;
+    } else {
+      ftype qd = x;
+      auto& ql = get_bits(qd);
+#pragma unroll
+      for (int i = 0; i < FOLD - 1; i++) {
+        M = primary(i * incpriY);
+        qd = x;
+        ql |= 1;
+        qd += M;
+        primary(i * incpriY) = qd;
+        M -= qd;
+        x += M;
+      }
+      qd = x;
+      ql |= 1;
+      primary((FOLD - 1) * incpriY) += qd;
+    }
+  }
+
+
+  ///Renormalize manually specified binned double precision
+  ///
+  ///Renormalization keeps the primary vector within the necessary bins by
+  ///shifting over to the carry vector
+  ///
+  ///@param incpriX stride within X's primary vector (use every incpriX'th element)
+  ///@param inccarX stride within X's carry vector (use every inccarX'th element)
+  __host__ __device__ inline void binned_dmrenorm(const int incpriX, const int inccarX) {
+    if (ISZERO(primary(0)) || ISNANINF(primary(0))) return;
+
+    for (int i = 0; i < FOLD; i++) {
+      auto tmp_renormd = primary(i * incpriX);
+      auto& tmp_renorml = get_bits(tmp_renormd);
+
+      carry(i * inccarX) += (int)((tmp_renorml >> (MANT_DIG - 3)) & 3) - 2;
+
+      tmp_renorml &= ~(1ull << (MANT_DIG - 3));
+      tmp_renorml |= 1ull << (MANT_DIG - 2);
+      primary(i * incpriX) = tmp_renormd;
+    }
+  }
+
+  ///Add scalar to manually specified binned fp (Y += X)
+  ///
+  ///Performs the operation Y += X on an binned type Y
+  ///
+  ///@param incpriY stride within Y's primary vector (use every incpriY'th element)
+  ///@param inccarY stride within Y's carry vector (use every inccarY'th element)
+  __host__ __device__ void binned_dmdadd(const ftype X, const int incpriY, const int inccarY){
+    binned_dmdupdate(X, incpriY, inccarY);
+    binned_dmddeposit(X, incpriY);
+    binned_dmrenorm(incpriY, inccarY);
+  }
+
+  ///Convert manually specified binned fp to native double-precision (X -> Y)
+  ///
+  ///@param incpriX stride within X's primary vector (use every incpriX'th element)
+  ///@param inccarX stride within X's carry vector (use every inccarX'th element)
+  __host__ __device__ double binned_conv_double(const int incpriX, const int inccarX) const {
+    int i = 0;
+
+    if (ISNANINF(primary(0))) return primary(0);
+    if (ISZERO(primary(0))) return 0.0;
+
+    double Y = 0.0;
+    double scale_down;
+    double scale_up;
+    int scaled;
+    const auto X_index = binned_index();
+    const auto *const bins = binned_bins(X_index);
+    if(X_index <= (3 * MANT_DIG)/BIN_WIDTH){
+      scale_down = ldexp(0.5, 1 - (2 * MANT_DIG - BIN_WIDTH));
+      scale_up = ldexp(0.5, 1 + (2 * MANT_DIG - BIN_WIDTH));
+      scaled = max(min(fold(), (3 * MANT_DIG)/BIN_WIDTH - X_index), 0);
+      if(X_index == 0){
+        Y += carry(0) * ((bins[0]/6.0) * scale_down * EXPANSION);
+        Y += carry(inccarX) * ((bins[1]/6.0) * scale_down);
+        Y += (primary(0) - bins[0]) * scale_down * EXPANSION;
+        i = 2;
+      }else{
+        Y += carry(0) * ((bins[0]/6.0) * scale_down);
+        i = 1;
+      }
+      for(; i < scaled; i++){
+        Y += carry(i * inccarX) * ((bins[i]/6.0) * scale_down);
+        Y += (primary((i - 1) * incpriX) - bins[i - 1]) * scale_down;
+      }
+      if(i == FOLD){
+        Y += (primary((FOLD - 1) * incpriX) - bins[FOLD - 1]) * scale_down;
+        return Y * scale_up;
+      }
+      if(std::isinf(Y * scale_up)){
+        return Y * scale_up;
+      }
+      Y *= scale_up;
+      for(; i < FOLD; i++){
+        Y += carry(i * inccarX) * (bins[i]/6.0);
+        Y += primary((i - 1) * incpriX) - bins[i - 1];
+      }
+      Y += primary((FOLD - 1) * incpriX) - bins[FOLD - 1];
+    }else{
+      Y += carry(0) * (bins[0]/6.0);
+      for(i = 1; i < FOLD; i++){
+        Y += carry(i * inccarX) * (bins[i]/6.0);
+        Y += (primary((i - 1) * incpriX) - bins[i - 1]);
+      }
+      Y += (primary((FOLD - 1) * incpriX) - bins[FOLD - 1]);
+    }
+    return Y;
+  }
+
+  ///Convert manually specified binned fp to native single-precision (X -> Y)
+  ///
+  ///@param incpriX stride within X's primary vector (use every incpriX'th element)
+  ///@param inccarX stride within X's carry vector (use every inccarX'th element)
+  __host__ __device__ float binned_conv_single(const int incpriX, const int inccarX) const {
+    int i = 0;
+    double Y = 0.0;
+
+    if (ISNANINF(primary(0))) return primary(0);
+    if (ISZERO(primary(0))) return 0.0;
+
+    //Note that the following order of summation is in order of decreasing
+    //exponent. The following code is specific to SBWIDTH=13, FLT_MANT_DIG=24, and
+    //the number of carries equal to 1.
+    const auto X_index = binned_index();
+    const auto *const bins = binned_bins(X_index);
+    if(X_index == 0){
+      Y += (double)carry(0) * (double)(bins[0]/6.0) * (double)EXPANSION;
+      Y += (double)carry(inccarX) * (double)(bins[1]/6.0);
+      Y += (double)(primary(0) - bins[0]) * (double)EXPANSION;
+      i = 2;
+    }else{
+      Y += (double)carry(0) * (double)(bins[0]/6.0);
+      i = 1;
+    }
+    for(; i < FOLD; i++){
+      Y += (double)carry(i * inccarX) * (double)(bins[i]/6.0);
+      Y += (double)(primary((i - 1) * incpriX) - bins[i - 1]);
+    }
+    Y += (double)(primary((FOLD - 1) * incpriX) - bins[FOLD - 1]);
+
+    return (float)Y;
+  }
+
+  ///Add two manually specified binned fp (Y += X)
+  ///Performs the operation Y += X
+  ///
+  ///@param other   Another binned fp of the same type
+  ///@param incpriX stride within X's primary vector (use every incpriX'th element)
+  ///@param inccarX stride within X's carry vector (use every inccarX'th element)
+  ///@param incpriY stride within Y's primary vector (use every incpriY'th element)
+  ///@param inccarY stride within Y's carry vector (use every inccarY'th element)
+  __host__ __device__ void binned_dmdmadd(const ReproducibleFloatingAccumulator &x, const int incpriX, const int inccarX, const int incpriY, const int inccarY) {
+    if (ISZERO(x.primary(0))) return;
+
+    if (ISZERO(primary(0))) {
+      for (int i = 0; i < FOLD; i++) {
+        primary(i*incpriY) = x.primary(i*incpriX);
+        carry(i*inccarY) = x.carry(i*inccarX);
+      }
+      return;
+    }
+
+    if (ISNANINF(x.primary(0)) || ISNANINF(primary(0))){
+      primary(0) += x.primary(0);
+      return;
+    }
+
+    const auto X_index = x.binned_index();
+    const auto Y_index = this->binned_index();
+    const auto shift = Y_index - X_index;
+    if(shift > 0){
+      const auto *const bins = binned_bins(Y_index);
+      //shift Y upwards and add X to Y
+#pragma unroll
+      for (int i = FOLD - 1; i >= 1; i--) {
+        if (i < shift) break;
+        primary(i*incpriY) = x.primary(i*incpriX) + (primary((i - shift)*incpriY) - bins[i - shift]);
+        carry(i*inccarY) = x.carry(i*inccarX) + carry((i - shift)*inccarY);
+      }
+#pragma unroll
+      for (int i = 0; i < FOLD; i++) {
+        if (i == shift) break;
+        primary(i*incpriY) = x.primary(i*incpriX);
+        carry(i*inccarY) = x.carry(i*inccarX);
+      }
+    } else if (shift < 0) {
+      const auto *const bins = binned_bins(X_index);
+      //shift X upwards and add X to Y
+#pragma unroll
+      for (int i = 0; i < FOLD; i++) {
+        if (i < -shift) continue;
+        primary(i*incpriY) += x.primary((i + shift)*incpriX) - bins[i + shift];
+        carry(i*inccarY) += x.carry((i + shift)*inccarX);
+      }
+    } else if (shift == 0) {
+      const auto *const bins = binned_bins(X_index);
+      // add X to Y
+#pragma unroll
+      for (int i = 0; i < FOLD; i++) {
+        primary(i*incpriY) += x.primary(i*incpriX) - bins[i];
+        carry(i*inccarY) += x.carry(i*inccarX);
+      }
+    }
+
+    binned_dmrenorm(incpriY, inccarY);
+  }
+
+  ///Add two manually specified binned fp (Y += X)
+  ///Performs the operation Y += X
+  __host__ __device__ void binned_dbdbadd(const ReproducibleFloatingAccumulator &other){
+    binned_dmdmadd(other, 1, 1, 1, 1);
+  }
+
+
+ public:
+  ReproducibleFloatingAccumulator() = default;
+  ReproducibleFloatingAccumulator(const ReproducibleFloatingAccumulator &) = default;
+  ReproducibleFloatingAccumulator(ReproducibleFloatingAccumulator &&) = default;
+  ///Sets this binned fp equal to another binned fp
+  ReproducibleFloatingAccumulator& operator=(const ReproducibleFloatingAccumulator &) = default;
+  ReproducibleFloatingAccumulator& operator=(ReproducibleFloatingAccumulator &&) = default;
+
+  ///Set the binned fp to zero
+  __host__ __device__ void zero() {
+    data = {0};
+  }
+
+  ///Return the fold of the binned fp
+  constexpr int fold() const { return FOLD; }
+
+  ///Return the endurance of the binned fp
+  constexpr int endurance() const { return ENDURANCE; }
+
+  ///Returns the number of reference bins. Used for judging memory usage.
+  constexpr size_t number_of_reference_bins() {
+    return array<ftype, MAXINDEX + MAXFOLD>::size();
+  }
+
+  ///Accumulate an arithmetic @p x into the binned fp.
+  ///NOTE: Casts @p x to the type of the binned fp
+  template <typename U, typename std::enable_if_t<std::is_arithmetic_v<U>>* = nullptr>
+  __host__ __device__ ReproducibleFloatingAccumulator& operator+=(const U x){
+    binned_dmdadd(static_cast<ftype>(x), 1, 1);
+    return *this;
+  }
+
+  ///Accumulate-subtract an arithmetic @p x into the binned fp.
+  ///NOTE: Casts @p x to the type of the binned fp
+  template <typename U, typename std::enable_if_t<std::is_arithmetic_v<U>>* = nullptr>
+  __host__ __device__ ReproducibleFloatingAccumulator& operator-=(const U x){
+    binned_dmdadd(-static_cast<ftype>(x), 1, 1);
+    return *this;
+  }
+
+  ///Accumulate a binned fp @p x into the binned fp.
+  __host__ __device__ ReproducibleFloatingAccumulator& operator+=(const ReproducibleFloatingAccumulator &other){
+    binned_dbdbadd(other);
+    return *this;
+  }
+
+  ///Accumulate-subtract a binned fp @p x into the binned fp.
+  ///NOTE: Makes a copy and performs arithmetic; slow.
+  __host__ __device__ ReproducibleFloatingAccumulator& operator-=(const ReproducibleFloatingAccumulator &other){
+    const auto temp = -other;
+    binned_dbdbadd(temp);
+  }
+
+  ///Determines if two binned fp are equal
+  __host__ __device__ bool operator==(const ReproducibleFloatingAccumulator &other) const {
+    return data==other.data;
+  }
+
+  ///Determines if two binned fp are not equal
+  __host__ __device__ bool operator!=(const ReproducibleFloatingAccumulator &other) const {
+    return !operator==(other);
+  }
+
+  ///Sets this binned fp equal to the arithmetic value @p x
+  ///NOTE: Casts @p x to the type of the binned fp
+  template <typename U, typename std::enable_if_t<std::is_arithmetic_v<U>>* = nullptr>
+  __host__ __device__ ReproducibleFloatingAccumulator& operator=(const U x){
+    zero();
+    binned_dmdadd(static_cast<ftype>(x), 1, 1);
+    return *this;
+  }
+
+  ///Returns the negative of this binned fp
+  ///NOTE: Makes a copy and performs arithmetic; slow.
+  __host__ __device__ ReproducibleFloatingAccumulator operator-() {
+    constexpr int incpriX = 1;
+    constexpr int inccarX = 1;
+    ReproducibleFloatingAccumulator temp = *this;
+    if(primary(0) != 0.0){
+      const auto *const bins = binned_bins(binned_index());
+      for (int i = 0; i < FOLD; i++) {
+        temp.primary(i * incpriX) = bins[i] - (primary(i * incpriX) - bins[i]);
+        temp.carry(i * inccarX) = -carry(i * inccarX);
+      }
+    }
+    return temp;
+  }
+
+  ///Convert this binned fp into its native floating-point representation
+  __host__ __device__ ftype conv() const {
+    if(std::is_same_v<ftype, float>){
+      return binned_conv_single(1, 1);
+    } else {
+      return binned_conv_double(1, 1);
+    }
+  }
+
+  __host__ __device__ inline explicit operator double() const { return double(conv()); }
+  __host__ __device__ inline explicit operator float() const { return float(conv()); }
+
+  ///@brief Get binned fp summation error bound
+  ///
+  ///This is a bound on the absolute error of a summation using binned types
+  ///
+  ///@param N           The number of single precision floating point summands
+  ///@param max_abs_val The summand of maximum absolute value
+  ///@param binned_sum  The value of the sum computed using binned types
+  ///@return            The absolute error bound
+  static constexpr ftype error_bound(
+    const uint64_t N, const ftype max_abs_val, const ftype binned_sum
+  ) {
+    const double X = std::abs(max_abs_val);
+    const double S = std::abs(binned_sum);
+    return static_cast<ftype>(max(X, ldexp(0.5, MIN_EXP - 1)) * ldexp(0.5, (1 - FOLD) * BIN_WIDTH + 1) * N + ((7.0 * EPSILON) / (1.0 - 6.0 * std::sqrt(static_cast<double>(EPSILON)) - 7.0 * EPSILON)) * S);
+  }
+
+  ///Add @p x to the binned fp
+  __host__ __device__ void add(const ftype x){
+    binned_dmdadd(x, 1, 1);
+  }
+
+  ///Add arithmetics in the range [first, last) to the binned fp
+  ///
+  ///@param first       Start of range
+  ///@param last        End of range
+  ///@param max_abs_val Maximum absolute value of any member of the range
+  template <typename InputIt>
+  __host__ __device__ void add(InputIt first, InputIt last, const ftype max_abs_val) {
+    binned_dmdupdate(std::abs(max_abs_val), 1, 1);
+    size_t count = 0;
+    size_t N = last - first;
+    for(;first!=last;first++,count++){
+      binned_dmddeposit(static_cast<ftype>(*first), 1);
+      // first conditional allows compiler to remove the call here when possible
+      if (N > ENDURANCE && count==ENDURANCE) {
+        binned_dmrenorm(1, 1);
+        count = 0;
+      }
+    }
+  }
+
+  ///Add arithmetics in the range [first, last) to the binned fp
+  ///
+  ///NOTE: A maximum absolute value is calculated, so two passes are made over
+  ///      the data
+  ///
+  ///@param first       Start of range
+  ///@param last        End of range
+  template <typename InputIt>
+  void add(InputIt first, InputIt last) {
+      const auto max_abs_val = *std::max_element(first, last, [](const auto &a, const auto &b){
+      return std::abs(a) < std::abs(b);
+    });
+    add(first, last, static_cast<ftype>(max_abs_val));
+  }
+
+  ///Add @p N elements starting at @p input to the binned fp: [input, input+N)
+  ///
+  ///@param input       Start of the range
+  ///@param N           Number of elements to add
+  ///@param max_abs_val Maximum absolute value of any member of the range
+  template <typename T, typename std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
+  __host__ __device__ void add(const T *input, const size_t N, const ftype max_abs_val) {
+    if (N==0) return;
+    add(input, input + N, max_abs_val);
+  }
+
+  ///Add @p N elements starting at @p input to the binned fp: [input, input+N)
+  ///
+  ///NOTE: A maximum absolute value is calculated, so two passes are made over
+  ///      the data
+  ///
+  ///@param input       Start of the range
+  ///@param N           Number of elements to add
+  template <typename T, typename std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
+  __host__ __device__ void add(const T *input, const size_t N) {
+    if (N==0) return;
+
+    T max_abs_val = input[0];
+    for(size_t i=0;i<N;i++){
+      max_abs_val = max(max_abs_val, std::abs(input[i]));
+    }
+    add(input, N, max_abs_val);
+  }
+
+#ifdef __CUDACC__
+  ///Accumulate a float4 @p x into the binned fp.
+  ///NOTE: Casts @p x to the type of the binned fp
+  __host__ __device__ ReproducibleFloatingAccumulator& operator+=(const float4 &x){
+    binned_dmdupdate(abs_max(x), 1, 1);
+    binned_dmddeposit(static_cast<ftype>(x.x), 1);
+    binned_dmddeposit(static_cast<ftype>(x.y), 1);
+    binned_dmddeposit(static_cast<ftype>(x.z), 1);
+    binned_dmddeposit(static_cast<ftype>(x.w), 1);
+    return *this;
+  }
+
+  ///Accumulate a double2 @p x into the binned fp.
+  ///NOTE: Casts @p x to the type of the binned fp
+  __host__ __device__ ReproducibleFloatingAccumulator& operator+=(const float2 &x){
+    binned_dmdupdate(abs_max(x), 1, 1);
+    binned_dmddeposit(static_cast<ftype>(x.x), 1);
+    binned_dmddeposit(static_cast<ftype>(x.y), 1);
+    return *this;
+  }
+
+  ///Accumulate a double2 @p x into the binned fp.
+  ///NOTE: Casts @p x to the type of the binned fp
+  __host__ __device__ ReproducibleFloatingAccumulator& operator+=(const double2 &x){
+    binned_dmdupdate(abs_max(x), 1, 1);
+    binned_dmddeposit(static_cast<ftype>(x.x), 1);
+    binned_dmddeposit(static_cast<ftype>(x.y), 1);
+    return *this;
+  }
+
+  __host__ __device__ void add(const float4 *input, const size_t N, float max_abs_val) {
+    if (N==0) return;
+    binned_dmdupdate(max_abs_val, 1, 1);
+
+    size_t count = 0;
+    for (size_t i = 0; i < N; i++) {
+      binned_dmddeposit(static_cast<ftype>(input[i].x), 1);
+      binned_dmddeposit(static_cast<ftype>(input[i].y), 1);
+      binned_dmddeposit(static_cast<ftype>(input[i].z), 1);
+      binned_dmddeposit(static_cast<ftype>(input[i].w), 1);
+
+      if (N > ENDURANCE && count==ENDURANCE) {
+        binned_dmrenorm(1, 1);
+        count = 0;
+      }
+    }
+  }
+
+  __host__ __device__ void add(const double2 *input, const size_t N, double max_abs_val) {
+    if (N==0) return;
+    binned_dmdupdate(max_abs_val, 1, 1);
+
+    size_t count = 0;
+    for (size_t i = 0; i < N; i++) {
+      binned_dmddeposit(static_cast<ftype>(input[i].x), 1);
+      binned_dmddeposit(static_cast<ftype>(input[i].y), 1);
+
+      if (N > ENDURANCE && count==ENDURANCE) {
+        binned_dmrenorm(1, 1);
+        count = 0;
+      }
+    }
+  }
+
+  __host__ __device__ void add(const float2 *input, const size_t N, double max_abs_val) {
+    if (N==0) return;
+    binned_dmdupdate(max_abs_val, 1, 1);
+
+    size_t count = 0;
+    for (size_t i = 0; i < N; i++) {
+      binned_dmddeposit(static_cast<ftype>(input[i].x), 1);
+      binned_dmddeposit(static_cast<ftype>(input[i].y), 1);
+
+      if (N > ENDURANCE && count==ENDURANCE) {
+        binned_dmrenorm(1, 1);
+        count = 0;
+      }
+    }
+  }
+
+  __host__ __device__ void add(const float4 *input, const size_t N) {
+    if (N==0) return;
+
+    auto max_abs_val = abs_max(input[0]);
+    for (size_t i = 1; i < N; i++) max_abs_val = fmax(max_abs_val, abs_max(input[i]));
+
+    add(input, N, max_abs_val);
+  }
+
+  __host__ __device__ void add(const double2 *input, const size_t N) {
+    if (N==0) return;
+
+    auto max_abs_val = abs_max(input[0]);
+    for (size_t i = 1; i < N; i++) max_abs_val = fmax(max_abs_val, abs_max(input[i]));
+
+    add(input, N, max_abs_val);
+  }
+
+  __host__ __device__ void add(const float2 *input, const size_t N) {
+    if (N==0) return;
+
+    auto max_abs_val = abs_max(input[0]);
+    for (size_t i = 1; i < N; i++) max_abs_val = fmax(max_abs_val, abs_max(input[i]));
+
+    add(input, N, max_abs_val);
+  }
+#endif
+
+  //////////////////////////////////////
+  //MANUAL OPERATIONS; USE WISELY
+  //////////////////////////////////////
+
+  ///Rebins for repeated accumulation of scalars with magnitude <= @p mav
+  ///
+  ///Once rebinned, `ENDURANCE` values <= @p mav can be added to the accumulator
+  ///with `unsafe_add` after which `renorm()` must be called. See the source of
+  ///`add()` for an example
+  template <typename T, typename std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
+  __host__ __device__ void set_max_abs_val(const T mav){
+    binned_dmdupdate(std::abs(mav), 1, 1);
+  }
+
+  ///Add @p x to the binned fp
+  ///
+  ///This is intended to be used after a call to `set_max_abs_val()`
+  __host__ __device__ void unsafe_add(const ftype x){
+    binned_dmddeposit(x, 1);
+  }
+
+  ///Renormalizes the binned fp
+  ///
+  ///This is intended to be used after a call to `set_max_abs_val()` and one or
+  ///more calls to `unsafe_add()`
+  __host__ __device__ void renorm() {
+    binned_dmrenorm(1, 1);
+  }
+};
+
+  }
+
+  template <class T> using rfa_t = reproducible::ReproducibleFloatingAccumulator<T>;
+
+  template <> struct get_scalar<rfa_t<double>> { using type = rfa_t<double>; };
+
+  template <class T, class Enable = void>
+  struct is_rfa {
+    static constexpr bool value = false;
+  };
+
+  template <class T>
+  struct is_rfa<T, typename std::enable_if_t<std::is_same_v<T, rfa_t<typename T::ftype>>>> {
+    static constexpr bool value = true;
+  };
+
+  template <class T> __host__ __device__ inline rfa_t<T> operator+(const rfa_t<T> &x, const rfa_t<T> &y)
+  {
+    rfa_t<T> z = x;
+    z.operator+=(y);
+    return z;
+  }
+
+  template <typename T, int n>
+  __device__ __host__ inline array<rfa_t<T>, n> operator+(const array<rfa_t<T>, n> &a, const array<rfa_t<T>, n> &b)
+  {
+    array<rfa_t<T>, n> c;
+#pragma unroll
+    for (int i = 0; i < n; i++) c[i] = a[i] + b[i];
+    return c;
+  }
+
+}
diff --git a/include/targets/generic/reduce_helper.h b/include/targets/generic/reduce_helper.h
index 6492687291..23e7e3554c 100644
--- a/include/targets/generic/reduce_helper.h
+++ b/include/targets/generic/reduce_helper.h
@@ -56,6 +56,14 @@ namespace quda
       result_h = static_cast<decltype(result_h)>(reducer::get_host_buffer());
       count = reducer::get_count<count_t>();
 
+      if constexpr (is_rfa<get_scalar_t<T>>::value) {
+        static bool init = false;
+        if (!init) {
+          cudaMemcpyToSymbol(reproducible::bin_device_buffer, static_cast<void*>(&reducer::get_rfa_bins()),
+                             sizeof(reproducible::RFA_bins<reduction_t>), 0, cudaMemcpyHostToDevice);
+        }
+      }
+
       if (commAsyncReduction()) result_d = partial;
     }
 
@@ -82,21 +90,17 @@ namespace quda
        @param[out] result The reduction result is copied here
        @param[in] stream The stream on which we the reduction is being done
      */
-    template <typename host_t, typename device_t = host_t>
-    void complete(std::vector<host_t> &result, const qudaStream_t stream = device::get_default_stream())
+    auto complete(const qudaStream_t stream = device::get_default_stream())
     {
-      if (launch_error == QUDA_ERROR) return; // kernel launch failed so return
+      std::vector<T> result(n_reduce);
       if (launch_error == QUDA_ERROR_UNINITIALIZED) errorQuda("No reduction kernel appears to have been launched");
-      auto event = reducer::get_event();
-      qudaEventRecord(event, stream);
-      while (!qudaEventQuery(event)) { }
-
-      // copy back result element by element and convert if necessary to host reduce type
-      // unit size here may differ from system_atomic_t size, e.g., if doing double-double
-      const int n_element = n_reduce * sizeof(T) / sizeof(device_t);
-      if (result.size() != (unsigned)n_element)
-        errorQuda("result vector length %lu does not match n_reduce %d", result.size(), n_element);
-      for (int i = 0; i < n_element; i++) result[i] = reinterpret_cast<device_t *>(result_h)[i];
+      if (launch_error != QUDA_ERROR) {
+        auto event = reducer::get_event();
+        qudaEventRecord(event, stream);
+        while (!qudaEventQuery(event)) { }
+        memcpy(result.data(), result_h, n_reduce * sizeof(T));
+      }
+      return result;
     }
   };
 
diff --git a/include/targets/generic/reduction_kernel_host.h b/include/targets/generic/reduction_kernel_host.h
index ebe5115988..1fddcbe1ce 100644
--- a/include/targets/generic/reduction_kernel_host.h
+++ b/include/targets/generic/reduction_kernel_host.h
@@ -10,10 +10,10 @@ namespace quda
     using reduce_t = typename Functor<Arg>::reduce_t;
     Functor<Arg> t(arg);
 
-    reduce_t value = t.init();
+    std::vector<reduce_t> value(1, t.init());
 
     for (int j = 0; j < static_cast<int>(arg.threads.y); j++) {
-      for (int i = 0; i < static_cast<int>(arg.threads.x); i++) { value = t(value, i, j); }
+      for (int i = 0; i < static_cast<int>(arg.threads.x); i++) { value[0] = t(value[0], i, j); }
     }
 
     return value;
@@ -24,10 +24,8 @@ namespace quda
     using reduce_t = typename Functor<Arg>::reduce_t;
     Functor<Arg> t(arg);
 
-    std::vector<reduce_t> value(arg.threads.z);
+    std::vector<reduce_t> value(arg.threads.z, t.init());
     for (int k = 0; k < static_cast<int>(arg.threads.z); k++) {
-      value[k] = t.init();
-
       for (int j = 0; j < static_cast<int>(arg.threads.y); j++) {
         for (int i = 0; i < static_cast<int>(arg.threads.x); i++) { value[j] = t(value[j], i, j, k); }
       }
diff --git a/include/tunable_reduction.h b/include/tunable_reduction.h
index d24904b2fd..ec66ba5cfa 100644
--- a/include/tunable_reduction.h
+++ b/include/tunable_reduction.h
@@ -57,6 +57,21 @@ namespace quda
      */
     virtual unsigned int maxBlockSize(const TuneParam &) const { return device::max_block_size(); }
 
+    template <typename T, typename U>
+    void copy(T &out, const U &in)
+    {
+      using out_t = typename T::value_type;
+      using in_t = typename U::value_type;
+
+      // copy back result element by element and convert if necessary to host reduce type
+      // unit size here may differ from system_atomic_t size, e.g., if doing double-double
+      const int n_element_in = in.size() * sizeof(in_t) / sizeof(get_scalar_t<in_t>);
+      const int n_element_out = out.size() * sizeof(out_t) / sizeof(get_scalar_t<out_t>);
+      if (n_element_in != n_element_out) errorQuda("output elements %d does not match input %d", n_element_out, n_element_in);
+      for (auto i = 0; i < n_element_in; i++) reinterpret_cast<get_scalar_t<out_t>*>(&out[0])[i] =
+                                                static_cast<get_scalar_t<out_t>>(reinterpret_cast<const get_scalar_t<in_t>*>(&in[0])[i]);
+    }
+
     /**
        @brief Launch reduction kernel on the device performing the
        reduction defined in the functor.  After the local computation
@@ -79,10 +94,11 @@ namespace quda
       arg.launch_error = TunableKernel::launch_device<Functor, grid_stride>(KERNEL(Reduction2D), tp, stream, arg);
 
       if (!commAsyncReduction()) {
-        std::vector<T> result_(1);
-        arg.complete(result_, stream);
+        auto result_ = arg.complete(stream);
         if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(result_);
-        result = result_[0];
+        std::vector<T> result_out(1);
+        copy(result_out, result_);
+        result = result_out[0];
       }
     }
 
@@ -100,9 +116,11 @@ namespace quda
     {
       if (arg.threads.y != block_size_y)
         errorQuda("Unexected y threads: received %d, expected %d", arg.threads.y, block_size_y);
+
+      auto result_host = Reduction2D_host<Functor, Arg>(arg);
+      if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(result_host);
       std::vector<T> result_(1);
-      result_[0] = Reduction2D_host<Functor, Arg>(arg);
-      if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(result_);
+      copy(result_, result_host);
       result = result_[0];
     }
 
@@ -228,8 +246,9 @@ namespace quda
       arg.launch_error = TunableKernel::launch_device<Functor, grid_stride>(KERNEL(MultiReduction), tp, stream, arg);
 
       if (!commAsyncReduction()) {
-        arg.complete(result, stream);
-        if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(result);
+        auto result_ = arg.complete(stream);
+        if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(result_);
+        copy(result, result_);
       }
     }
 
@@ -249,8 +268,8 @@ namespace quda
         errorQuda("n_batch_block_max = %u greater than maximum supported %u", n_batch_block_max, Arg::max_n_batch_block);
 
       auto value = MultiReduction_host<Functor, Arg>(arg);
-      for (int j = 0; j < (int)arg.threads.z; j++) result[j] = value[j];
-      if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(result);
+      if (!activeTuning() && commGlobalReduction()) Functor<Arg>::comm_reduce(value);
+      copy(result, value);
     }
 
     /**
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index c165214251..c98cb43f1a 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -509,6 +509,28 @@ if(QUDA_BACKWARDS)
   target_link_libraries(quda PUBLIC ${BACKWARD_LIBRARIES})
 endif()
 
+set(QUDA_SCALAR_TYPE
+    double
+    CACHE STRING "set the host scalar coefficient type (double, doubledouble, __float128)")
+set_property(CACHE QUDA_SCALAR_TYPE PROPERTY STRINGS double doubledouble __float128)
+
+set(QUDA_REDUCTION_TYPE
+    double
+    CACHE STRING "set the reduction computation type (double, doubledouble)")
+set_property(CACHE QUDA_REDUCTION_TYPE PROPERTY STRINGS double doubledouble)
+
+set(QUDA_REDUCTION_ALGORITHM
+    NAIVE
+    CACHE STRING "set the reduction algorithm (NAIVE, KAHAN, REPRODUCIBLE)")
+set_property(CACHE QUDA_REDUCTION_ALGORITHM PROPERTY STRINGS NAIVE KAHAN REPRODUCIBLE)
+if(${QUDA_REDUCTION_ALGORITHM} STREQUAL "NAIVE")
+  set(QUDA_REDUCTION_ALGORITHM_NAIVE 1)
+elseif(${QUDA_REDUCTION_ALGORITHM} STREQUAL "KAHAN")
+  set(QUDA_REDUCTION_ALGORITHM_KAHAN 1)
+elseif(${QUDA_REDUCTION_ALGORITHM} STREQUAL "REPRODUCIBLE")
+  set(QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE 1)
+endif()
+
 configure_file(../include/quda_define.h.in ../include/quda_define.h @ONLY)
 install(FILES "${CMAKE_BINARY_DIR}/include/quda_define.h" DESTINATION include/)
 
diff --git a/lib/blas_quda.cu b/lib/blas_quda.cu
index 4c8719f309..7639c7f530 100644
--- a/lib/blas_quda.cu
+++ b/lib/blas_quda.cu
@@ -55,6 +55,16 @@ namespace quda {
           strcat(aux, y.AuxString().c_str());
         }
 
+#ifdef QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE
+        {
+          static bool init = false;
+          if (!init) {
+            cudaMemcpyToSymbol(reproducible::bin_device_buffer, static_cast<void*>(&reducer::get_rfa_bins()),
+                               sizeof(reproducible::RFA_bins<reduction_t>), 0, cudaMemcpyHostToDevice);
+            init = true;
+          }
+        }
+#endif
         apply(device::get_default_stream());
 
         blas::bytes += bytes();
@@ -140,89 +150,89 @@ namespace quda {
       }
     };
 
-    void axpbyz(double a, const ColorSpinorField &x, double b, const ColorSpinorField &y, ColorSpinorField &z)
+    void axpbyz(real_t a, const ColorSpinorField &x, real_t b, const ColorSpinorField &y, ColorSpinorField &z)
     {
-      instantiate<axpbyz_, Blas, true>(a, b, 0.0, x, y, x, x, z);
+      instantiate<axpbyz_, Blas, true>(a, b, real_t(0.0), x, y, x, x, z);
     }
 
-    void axy(double a, const ColorSpinorField &x, ColorSpinorField &y)
+    void axy(real_t a, const ColorSpinorField &x, ColorSpinorField &y)
     {
-      instantiate<axy_, Blas, false>(a, 0.0, 0.0, x, y, y, y, y);
+      instantiate<axy_, Blas, false>(a, real_t(0.0), real_t(0.0), x, y, y, y, y);
     }
 
-    void caxpy(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y)
+    void caxpy(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y)
     {
-      instantiate<caxpy_, Blas, true>(a, Complex(0.0), Complex(0.0), x, y, x, x, y);
+      instantiate<caxpy_, Blas, true>(a, complex_t(0.0), complex_t(0.0), x, y, x, x, y);
     }
 
-    void caxpby(const Complex &a, const ColorSpinorField &x, const Complex &b, ColorSpinorField &y)
+    void caxpby(const complex_t &a, const ColorSpinorField &x, const complex_t &b, ColorSpinorField &y)
     {
-      instantiate<caxpby_, Blas, false>(a, b, Complex(0.0), x, y, x, x, y);
+      instantiate<caxpby_, Blas, false>(a, b, complex_t(0.0), x, y, x, x, y);
     }
 
-    void axpbypczw(double a, const ColorSpinorField &x, double b, const ColorSpinorField &y,
-                   double c, const ColorSpinorField &z, ColorSpinorField &w)
+    void axpbypczw(real_t a, const ColorSpinorField &x, real_t b, const ColorSpinorField &y,
+                   real_t c, const ColorSpinorField &z, ColorSpinorField &w)
     {
       instantiate<axpbypczw_, Blas, false>(a, b, c, x, y, z, w, y);
     }
 
-    void cxpaypbz(const ColorSpinorField &x, const Complex &a, const ColorSpinorField &y,
-                  const Complex &b, ColorSpinorField &z)
+    void cxpaypbz(const ColorSpinorField &x, const complex_t &a, const ColorSpinorField &y,
+                  const complex_t &b, ColorSpinorField &z)
     {
-      instantiate<cxpaypbz_, Blas, false>(a, b, Complex(0.0), x, y, z, x, y);
+      instantiate<cxpaypbz_, Blas, false>(a, b, complex_t(0.0), x, y, z, x, y);
     }
 
-    void axpyBzpcx(double a, ColorSpinorField& x, ColorSpinorField& y, double b, const ColorSpinorField& z, double c)
+    void axpyBzpcx(real_t a, ColorSpinorField& x, ColorSpinorField& y, real_t b, const ColorSpinorField& z, real_t c)
     {
       instantiate<axpyBzpcx_, Blas, true>(a, b, c, x, y, z, x, y);
     }
 
-    void axpyZpbx(double a, ColorSpinorField& x, ColorSpinorField& y, const ColorSpinorField& z, double b)
+    void axpyZpbx(real_t a, ColorSpinorField& x, ColorSpinorField& y, const ColorSpinorField& z, real_t b)
     {
-      instantiate<axpyZpbx_, Blas, true>(a, b, 0.0, x, y, z, x, y);
+      instantiate<axpyZpbx_, Blas, true>(a, b, real_t(0.0), x, y, z, x, y);
     }
 
-    void caxpyBzpx(const Complex &a, ColorSpinorField &x, ColorSpinorField &y,
-                   const Complex &b, const ColorSpinorField &z)
+    void caxpyBzpx(const complex_t &a, ColorSpinorField &x, ColorSpinorField &y,
+                   const complex_t &b, const ColorSpinorField &z)
     {
-      instantiate<caxpyBzpx_, Blas, true>(a, b, Complex(0.0), x, y, z, x, y);
+      instantiate<caxpyBzpx_, Blas, true>(a, b, complex_t(0.0), x, y, z, x, y);
     }
 
-    void caxpyBxpz(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y,
-                   const Complex &b, ColorSpinorField &z)
+    void caxpyBxpz(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y,
+                   const complex_t &b, ColorSpinorField &z)
     {
-      instantiate<caxpyBxpz_, Blas, true>(a, b, Complex(0.0), x, y, z, x, y);
+      instantiate<caxpyBxpz_, Blas, true>(a, b, complex_t(0.0), x, y, z, x, y);
     }
 
-    void caxpbypzYmbw(const Complex &a, const ColorSpinorField &x, const Complex &b,
+    void caxpbypzYmbw(const complex_t &a, const ColorSpinorField &x, const complex_t &b,
                       ColorSpinorField &y, ColorSpinorField &z, const ColorSpinorField &w)
     {
-      instantiate<caxpbypzYmbw_, Blas, false>(a, b, Complex(0.0), x, y, z, w, y);
+      instantiate<caxpbypzYmbw_, Blas, false>(a, b, complex_t(0.0), x, y, z, w, y);
     }
 
-    void cabxpyAx(double a, const Complex &b, ColorSpinorField &x, ColorSpinorField &y)
+    void cabxpyAx(real_t a, const complex_t &b, ColorSpinorField &x, ColorSpinorField &y)
     {
-      instantiate<cabxpyAx_, Blas, false>(Complex(a), b, Complex(0.0), x, y, x, x, y);
+      instantiate<cabxpyAx_, Blas, false>(complex_t(a), b, complex_t(0.0), x, y, x, x, y);
     }
 
-    void caxpyXmaz(const Complex &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z)
+    void caxpyXmaz(const complex_t &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z)
     {
-      instantiate<caxpyxmaz_, Blas, false>(a, Complex(0.0), Complex(0.0), x, y, z, x, y);
+      instantiate<caxpyxmaz_, Blas, false>(a, complex_t(0.0), complex_t(0.0), x, y, z, x, y);
     }
 
-    void caxpyXmazMR(const double &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z)
+    void caxpyXmazMR(const real_t &a, ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z)
     {
       if (!commAsyncReduction())
 	errorQuda("This kernel requires asynchronous reductions to be set");
       if (x.Location() == QUDA_CPU_FIELD_LOCATION)
 	errorQuda("This kernel cannot be run on CPU fields");
-      instantiate<caxpyxmazMR_, Blas, false>(a, 0.0, 0.0, x, y, z, y, y);
+      instantiate<caxpyxmazMR_, Blas, false>(a, real_t(0.0), real_t(0.0), x, y, z, y, y);
     }
 
-    void tripleCGUpdate(double a, double b, const ColorSpinorField &x, ColorSpinorField &y,
+    void tripleCGUpdate(real_t a, real_t b, const ColorSpinorField &x, ColorSpinorField &y,
                         ColorSpinorField &z, ColorSpinorField &w)
     {
-      instantiate<tripleCGUpdate_, Blas, true>(a, b, 0.0, x, y, z, w, y);
+      instantiate<tripleCGUpdate_, Blas, true>(a, b, real_t(0.0), x, y, z, w, y);
     }
 
   } // namespace blas
diff --git a/lib/clover_deriv_quda.cu b/lib/clover_deriv_quda.cu
index 34ef0b993b..4f228eed96 100644
--- a/lib/clover_deriv_quda.cu
+++ b/lib/clover_deriv_quda.cu
@@ -9,12 +9,12 @@ namespace quda {
     GaugeField &force;
     GaugeField &gauge;
     GaugeField &oprod;
-    double coeff;
+    real_t coeff;
     int parity;
     unsigned int minThreads() const { return gauge.LocalVolumeCB(); }
 
   public:
-    DerivativeClover(GaugeField &force, GaugeField &gauge, GaugeField &oprod, double coeff, int parity) :
+    DerivativeClover(GaugeField &force, GaugeField &gauge, GaugeField &oprod, real_t coeff, int parity) :
       TunableKernel3D(gauge, 2, 4),
       force(force),
       gauge(gauge),
@@ -42,7 +42,7 @@ namespace quda {
   };
 
   template<typename Float>
-  void cloverDerivative(GaugeField &force, GaugeField &gauge, GaugeField &oprod, double coeff, int parity)
+  void cloverDerivative(GaugeField &force, GaugeField &gauge, GaugeField &oprod, real_t coeff, int parity)
   {
     if (oprod.Reconstruct() != QUDA_RECONSTRUCT_NO) errorQuda("Force field does not support reconstruction");
     if (force.Order() != oprod.Order()) errorQuda("Force and Oprod orders must match");
@@ -64,7 +64,7 @@ namespace quda {
   }
 
 #if defined(GPU_CLOVER_DIRAC) && (QUDA_PRECISION & 8)
-  void cloverDerivative(GaugeField &force, GaugeField &gauge, GaugeField &oprod, double coeff, QudaParity parity)
+  void cloverDerivative(GaugeField &force, GaugeField &gauge, GaugeField &oprod, real_t coeff, QudaParity parity)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     assert(oprod.Geometry() == QUDA_TENSOR_GEOMETRY);
@@ -83,7 +83,7 @@ namespace quda {
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
   }
 #else
-  void cloverDerivative(GaugeField &, GaugeField &, GaugeField &, double, QudaParity)
+  void cloverDerivative(GaugeField &, GaugeField &, GaugeField &, real_t, QudaParity)
   {
 #ifdef GPU_CLOVER_DIRAC
     errorQuda("QUDA_PRECISION=%d does not enable double precision", QUDA_PRECISION);
diff --git a/lib/clover_field.cpp b/lib/clover_field.cpp
index 0d859c4fdc..056d496967 100644
--- a/lib/clover_field.cpp
+++ b/lib/clover_field.cpp
@@ -136,11 +136,6 @@ namespace quda {
 
   CloverField *CloverField::Create(const CloverFieldParam &param) { return new CloverField(param); }
 
-  void CloverField::setRho(double rho_)
-  {
-    rho = rho_;
-  }
-
   void CloverField::copy(const CloverField &src, bool is_inverse)
   {
     if (src.Location() == QUDA_CUDA_FIELD_LOCATION && location == QUDA_CPU_FIELD_LOCATION) {
@@ -304,12 +299,12 @@ namespace quda {
     output << "inverse = "   << param.inverse << std::endl;
     output << "clover = "    << param.clover << std::endl;
     output << "cloverInv = " << param.cloverInv << std::endl;
-    output << "csw = "       << param.csw << std::endl;
-    output << "coeff = " << param.coeff << std::endl;
+    output << "csw = "       << double(param.csw) << std::endl;
+    output << "coeff = " << double(param.coeff) << std::endl;
     output << "twist_flavor = " << param.twist_flavor << std::endl;
-    output << "mu2 = " << param.mu2 << std::endl;
-    output << "epsilon2 = " << param.epsilon2 << std::endl;
-    output << "rho = " << param.rho << std::endl;
+    output << "mu2 = " << double(param.mu2) << std::endl;
+    output << "epsilon2 = " << double(param.epsilon2) << std::endl;
+    output << "rho = " << double(param.rho) << std::endl;
     output << "order = " << param.order << std::endl;
     output << "create = " << param.create << std::endl;
     return output;  // for multiple << operators.
@@ -337,14 +332,14 @@ namespace quda {
   }
 
   // Return the L2 norm squared of the clover field
-  double norm2(const CloverField &a, bool inverse)
+  real_t norm2(const CloverField &a, bool inverse)
   {
     ColorSpinorField b(colorSpinorParam(a, inverse));
     return blas::norm2(b);
   }
 
   // Return the L1 norm of the clover field
-  double norm1(const CloverField &a, bool inverse)
+  real_t norm1(const CloverField &a, bool inverse)
   {
     ColorSpinorField b(colorSpinorParam(a, inverse));
     return blas::norm1(b);
diff --git a/lib/clover_invert.cu b/lib/clover_invert.cu
index 903ce4e76c..4f89f64e72 100644
--- a/lib/clover_invert.cu
+++ b/lib/clover_invert.cu
@@ -21,8 +21,8 @@ namespace quda {
              ",twist=true" : ",twist=false");
       apply(device::get_default_stream());
 
-      if (compute_tr_log && (std::isnan(clover.TrLog()[0]) || std::isnan(clover.TrLog()[1]))) {
-	printfQuda("clover.TrLog()[0]=%e, clover.TrLog()[1]=%e\n", clover.TrLog()[0], clover.TrLog()[1]);
+      if (compute_tr_log && (isnan(clover.TrLog()[0]) || isnan(clover.TrLog()[1]))) {
+	printfQuda("clover.TrLog()[0]=%e, clover.TrLog()[1]=%e\n", double(clover.TrLog()[0]), double(clover.TrLog()[1]));
 	errorQuda("Clover trlog has returned -nan, likey due to the clover matrix being singular.");
       }
     }
diff --git a/lib/clover_outer_product.cu b/lib/clover_outer_product.cu
index d579476714..cca831e892 100644
--- a/lib/clover_outer_product.cu
+++ b/lib/clover_outer_product.cu
@@ -25,7 +25,7 @@ namespace quda {
   public:
     CloverForce(const GaugeField &U, GaugeField &force, const ColorSpinorField& inA,
                 const ColorSpinorField& inB, const ColorSpinorField& inC, const ColorSpinorField& inD,
-                int parity, double coeff) :
+                int parity, real_t coeff) :
       TunableKernel1D(force),
       force(force),
       U(U),
@@ -134,7 +134,7 @@ namespace quda {
 
 #ifdef GPU_CLOVER_DIRAC
   void computeCloverForce(GaugeField &force, const GaugeField &U, std::vector<ColorSpinorField *> &x,
-                          std::vector<ColorSpinorField *> &p, std::vector<double> &coeff)
+                          std::vector<ColorSpinorField *> &p, std::vector<real_t> &coeff)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     checkNative(*x[0], *p[0], force, U);
@@ -164,7 +164,7 @@ namespace quda {
   }
 #else // GPU_CLOVER_DIRAC not defined
   void computeCloverForce(GaugeField &, const GaugeField &, std::vector<ColorSpinorField *> &,
-                          std::vector<ColorSpinorField *> &, std::vector<double> &)
+                          std::vector<ColorSpinorField *> &, std::vector<real_t> &)
   {
     errorQuda("Clover Dirac operator has not been built!");
   }
diff --git a/lib/clover_quda.cu b/lib/clover_quda.cu
index c000310f6b..975c667a59 100644
--- a/lib/clover_quda.cu
+++ b/lib/clover_quda.cu
@@ -15,7 +15,7 @@ namespace quda {
     unsigned int minThreads() const { return arg.threads.x; }
 
   public:
-    ComputeClover(CloverField &clover, const GaugeField& f, double coeff) :
+    ComputeClover(CloverField &clover, const GaugeField& f, real_t coeff) :
       TunableKernel2D(clover, 2),
       arg(clover, f, coeff),
       meta(f)
@@ -35,7 +35,7 @@ namespace quda {
   };
 
 #ifdef GPU_CLOVER_DIRAC
-  void computeClover(CloverField &clover, const GaugeField& f, double coeff)
+  void computeClover(CloverField &clover, const GaugeField& f, real_t coeff)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     if (clover.Precision() < QUDA_SINGLE_PRECISION) errorQuda("Cannot use fixed-point precision here");
@@ -44,7 +44,7 @@ namespace quda {
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
   }
 #else
-  void computeClover(CloverField &, const GaugeField &, double)
+  void computeClover(CloverField &, const GaugeField &, real_t)
   {
     errorQuda("Clover has not been built");
   }
diff --git a/lib/clover_sigma_outer_product.cu b/lib/clover_sigma_outer_product.cu
index 370ada813f..6c6fa579ce 100644
--- a/lib/clover_sigma_outer_product.cu
+++ b/lib/clover_sigma_outer_product.cu
@@ -16,13 +16,13 @@ namespace quda {
     GaugeField &oprod;
     const std::vector<ColorSpinorField*> &inA;
     const std::vector<ColorSpinorField*> &inB;
-    const std::vector<std::vector<double>> &coeff;
+    const std::vector<std::vector<real_t>> &coeff;
     unsigned int minThreads() const { return oprod.VolumeCB(); }
 
   public:
     CloverSigmaOprod(GaugeField &oprod, const std::vector<ColorSpinorField*> &inA,
                      const std::vector<ColorSpinorField*> &inB,
-                     const std::vector<std::vector<double>> &coeff) :
+                     const std::vector<std::vector<real_t>> &coeff) :
       TunableKernel3D(oprod, 2, 6),
       oprod(oprod),
       inA(inA),
@@ -59,14 +59,14 @@ namespace quda {
 
 #ifdef GPU_CLOVER_DIRAC
   void computeCloverSigmaOprod(GaugeField& oprod, std::vector<ColorSpinorField*> &x,
-			       std::vector<ColorSpinorField*> &p, std::vector<std::vector<double> > &coeff)
+			       std::vector<ColorSpinorField*> &p, std::vector<std::vector<real_t> > &coeff)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     if (x.size() > MAX_NVECTOR) {
       // divide and conquer
       std::vector<ColorSpinorField*> x0(x.begin(), x.begin()+x.size()/2);
       std::vector<ColorSpinorField*> p0(p.begin(), p.begin()+p.size()/2);
-      std::vector<std::vector<double> > coeff0(coeff.begin(), coeff.begin()+coeff.size()/2);
+      std::vector<std::vector<real_t> > coeff0(coeff.begin(), coeff.begin()+coeff.size()/2);
       for (unsigned int i=0; i<coeff0.size(); i++) {
 	coeff0[i].reserve(2); coeff0[i][0] = coeff[i][0]; coeff0[i][1] = coeff[i][1];
       }
@@ -74,7 +74,7 @@ namespace quda {
 
       std::vector<ColorSpinorField*> x1(x.begin()+x.size()/2, x.end());
       std::vector<ColorSpinorField*> p1(p.begin()+p.size()/2, p.end());
-      std::vector<std::vector<double> > coeff1(coeff.begin()+coeff.size()/2, coeff.end());
+      std::vector<std::vector<real_t> > coeff1(coeff.begin()+coeff.size()/2, coeff.end());
       for (unsigned int i=0; i<coeff1.size(); i++) {
 	coeff1[i].reserve(2); coeff1[i][0] = coeff[coeff.size()/2 + i][0]; coeff1[i][1] = coeff[coeff.size()/2 + i][1];
       }
@@ -88,7 +88,7 @@ namespace quda {
   }
 #else // GPU_CLOVER_DIRAC not defined
   void computeCloverSigmaOprod(GaugeField &, std::vector<ColorSpinorField*> &,
-			       std::vector<ColorSpinorField*> &, std::vector<std::vector<double> > &)
+			       std::vector<ColorSpinorField*> &, std::vector<std::vector<real_t> > &)
   {
     errorQuda("Clover Dirac operator has not been built!");
   }
diff --git a/lib/clover_trace_quda.cu b/lib/clover_trace_quda.cu
index cb0fc82131..d0b0c67361 100644
--- a/lib/clover_trace_quda.cu
+++ b/lib/clover_trace_quda.cu
@@ -14,7 +14,7 @@ namespace quda {
     unsigned int minThreads() const { return clover.VolumeCB(); }
 
   public:
-    CloverSigmaTrace(GaugeField& output, const CloverField& clover, double coeff) :
+    CloverSigmaTrace(GaugeField& output, const CloverField& clover, real_t coeff) :
       TunableKernel1D(output),
       output(output),
       clover(clover),
@@ -33,13 +33,13 @@ namespace quda {
   };
 
 #ifdef GPU_CLOVER_DIRAC
-  void computeCloverSigmaTrace(GaugeField& output, const CloverField& clover, double coeff)
+  void computeCloverSigmaTrace(GaugeField& output, const CloverField& clover, real_t coeff)
   {
     checkNative(output, clover);
     instantiate<CloverSigmaTrace>(output, clover, coeff);
   }
 #else
-  void computeCloverSigmaTrace(GaugeField&, const CloverField&, double)
+  void computeCloverSigmaTrace(GaugeField&, const CloverField&, real_t)
   {
     errorQuda("Clover has not been built");
   }
diff --git a/lib/coarse_op.cuh b/lib/coarse_op.cuh
index 40ac842c06..f4c86e5bc9 100644
--- a/lib/coarse_op.cuh
+++ b/lib/coarse_op.cuh
@@ -974,8 +974,8 @@ namespace quda {
   void calculateY(coarseGauge &Y, coarseGauge &X, coarseGaugeAtomic &Y_atomic, coarseGaugeAtomic &X_atomic, uvSpinor &UV,
                   avSpinor &AV, vSpinor &V, fineGauge &G, fineGauge &L, fineGauge &K, fineClover &C, fineClover &Cinv, GaugeField &Y_, GaugeField &X_,
                   GaugeField &Y_atomic_, GaugeField &X_atomic_, ColorSpinorField &uv, ColorSpinorField &av,
-                  const ColorSpinorField &v, double kappa, double mass, double mu,
-                  double mu_factor, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional,
+                  const ColorSpinorField &v, real_t kappa, real_t mass, real_t mu,
+                  real_t mu_factor, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional,
                   const int *fine_to_coarse, const int *coarse_to_fine)
   {
     // For coarsening un-preconditioned operators we use uni-directional
@@ -1087,12 +1087,12 @@ namespace quda {
 
       if (av.Precision() == QUDA_HALF_PRECISION) {
 	// this is just a trivial rescaling kernel, find the maximum
-	complex<Float> fp(1./(1.+arg.mu*arg.mu),-arg.mu/(1.+arg.mu*arg.mu));
-	complex<Float> fm(1./(1.+arg.mu*arg.mu),+arg.mu/(1.+arg.mu*arg.mu));
-	double max = std::max({abs(fp.real()), abs(fp.imag()), abs(fm.real()), abs(fm.imag())}) * v.Scale();
-	logQuda(QUDA_DEBUG_VERBOSE, "tm max %e\n", max);
-	av.Scale(max);
-	arg.AV.resetScale(max);
+	complex_t fp(1./(1.+arg.mu*arg.mu),-arg.mu/(1.+arg.mu*arg.mu));
+	complex_t fm(1./(1.+arg.mu*arg.mu),+arg.mu/(1.+arg.mu*arg.mu));
+	real_t max = std::max({abs(fp.real()), abs(fp.imag()), abs(fm.real()), abs(fm.imag())}) * v.Scale();
+	logQuda(QUDA_DEBUG_VERBOSE, "tm max %e\n", double(max));
+	av.Scale(double(max));
+	arg.AV.resetScale(double(max));
       }
 
       y.setComputeType(COMPUTE_TMAV);
@@ -1219,21 +1219,21 @@ namespace quda {
         }
 
         if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
-          printfQuda("Y2[%d] (atomic) = %e\n", 4+d, Y_atomic_.norm2((4+d) % arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint()));
+          printfQuda("Y2[%d] (atomic) = %e\n", 4+d, double(Y_atomic_.norm2((4+d) % arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint())));
 
         // now convert from atomic to application computation format if necessary for Y[d]
         if (coarseGaugeAtomic::fixedPoint() || coarseGauge::fixedPoint()) {
 
           if (coarseGauge::fixedPoint()) {
-            double y_max = Y_atomic_.abs_max((4+d) % arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint());
+            real_t y_max = Y_atomic_.abs_max((4+d) % arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint());
 
             if (!set_scale) {
-              Y_.Scale(1.1*y_max); // slightly oversize to avoid unnecessary rescaling
-              arg.Y.resetScale(Y_.Scale());
+              Y_.Scale(double(1.1*y_max)); // slightly oversize to avoid unnecessary rescaling
+              arg.Y.resetScale(double(Y_.Scale()));
               set_scale = true;
             } else if (y_max > Y_.Scale()) {
               // we have exceeded the maximum used before so we need to reset the maximum and rescale the elements
-              arg.rescale = Y_.Scale() / y_max; // how much we need to shrink the elements by
+              arg.rescale = double(Y_.Scale() / y_max); // how much we need to shrink the elements by
               y.setComputeType(COMPUTE_RESCALE);
 
               for (int d_=0; d_<d; d_++) {
@@ -1242,17 +1242,17 @@ namespace quda {
               }
 
               y.setDimension(d);
-              Y_.Scale(y_max);
-              arg.Y.resetScale(Y_.Scale());
+              Y_.Scale(double(y_max));
+              arg.Y.resetScale(double(Y_.Scale()));
             }
-            logQuda(QUDA_DEBUG_VERBOSE, "Y[%d] (atomic) max = %e Y[%d] scale = %e\n", 4+d, y_max, 4+d, Y_.Scale());
+            logQuda(QUDA_DEBUG_VERBOSE, "Y[%d] (atomic) max = %e Y[%d] scale = %e\n", 4+d, double(y_max), 4+d, double(Y_.Scale()));
           }
 
           y.setComputeType(COMPUTE_CONVERT);
           y.apply(device::get_default_stream());
         }
 
-        logQuda(QUDA_VERBOSE, "Y2[%d] = %e\n", 4+d, Y_.norm2( 4+d ));
+        logQuda(QUDA_VERBOSE, "Y2[%d] = %e\n", 4+d, double(Y_.norm2( 4+d )));
       }
     }
 
@@ -1321,21 +1321,21 @@ namespace quda {
       }
 
       if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
-        printfQuda("Y2[%d] (atomic) = %e\n", d, Y_atomic_.norm2(d%arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint()));
+        printfQuda("Y2[%d] (atomic) = %e\n", d, double(Y_atomic_.norm2(d%arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint())));
 
       // now convert from atomic to application computation format if necessary for Y[d]
       if (coarseGaugeAtomic::fixedPoint() || coarseGauge::fixedPoint() ) {
 
         if (coarseGauge::fixedPoint()) {
-          double y_max = Y_atomic_.abs_max(d % arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint());
+          real_t y_max = Y_atomic_.abs_max(d % arg.Y_atomic.geometry, coarseGaugeAtomic::fixedPoint());
 
           if (!set_scale) {
-            Y_.Scale(1.1*y_max); // slightly oversize to avoid unnecessary rescaling
-            arg.Y.resetScale(Y_.Scale());
+            Y_.Scale(double(1.1*y_max)); // slightly oversize to avoid unnecessary rescaling
+            arg.Y.resetScale(double(Y_.Scale()));
             set_scale = true;
           } else if (y_max > Y_.Scale()) {
             // we have exceeded the maximum used before so we need to reset the maximum and rescale the elements
-            arg.rescale = Y_.Scale() / y_max; // how much we need to shrink the elements by
+            arg.rescale = double(Y_.Scale() / y_max); // how much we need to shrink the elements by
             y.setComputeType(COMPUTE_RESCALE);
 
             // update all prior compute Y links
@@ -1354,20 +1354,20 @@ namespace quda {
             }
 
             y.setDimension(d);
-            Y_.Scale(y_max);
-            arg.Y.resetScale(Y_.Scale());
+            Y_.Scale(double(y_max));
+            arg.Y.resetScale(double(Y_.Scale()));
           }
-          logQuda(QUDA_DEBUG_VERBOSE, "Y[%d] (atomic) max = %e Y[%d] scale = %e\n", d, y_max, d, Y_.Scale());
+          logQuda(QUDA_DEBUG_VERBOSE, "Y[%d] (atomic) max = %e Y[%d] scale = %e\n", d, double(y_max), d, double(Y_.Scale()));
         }
 
         y.setComputeType(COMPUTE_CONVERT);
         y.apply(device::get_default_stream());
       }
 
-      logQuda(QUDA_VERBOSE, "Y2[%d] = %e\n", d, Y_.norm2( d ));
+      logQuda(QUDA_VERBOSE, "Y2[%d] = %e\n", d, double(Y_.norm2( d )));
     }
 
-    logQuda(QUDA_VERBOSE, "X2 = %e\n", X_atomic_.norm2(0, coarseGaugeAtomic::fixedPoint()));
+    logQuda(QUDA_VERBOSE, "X2 = %e\n", double(X_atomic_.norm2(0, coarseGaugeAtomic::fixedPoint())));
 
     // if not doing a preconditioned operator then we can trivially
     // construct the forward links from the backward links
@@ -1406,7 +1406,7 @@ namespace quda {
       y.setComputeType(COMPUTE_VUV); // compute X += VCV
       y.apply(device::get_default_stream());
       if (getVerbosity() >= QUDA_VERBOSE)
-        printfQuda("X2 (atomic) = %e\n", X_atomic_.norm2(0, coarseGaugeAtomic::fixedPoint()));
+        printfQuda("X2 (atomic) = %e\n", double(X_atomic_.norm2(0, coarseGaugeAtomic::fixedPoint())));
 
     } else if (dirac == QUDA_STAGGERED_DIRAC || dirac == QUDA_STAGGEREDPC_DIRAC || dirac == QUDA_ASQTAD_DIRAC || dirac == QUDA_ASQTADPC_DIRAC) {
       logQuda(QUDA_VERBOSE, "Summing staggered mass contribution to coarse clover\n");
@@ -1444,16 +1444,16 @@ namespace quda {
       y.setDirection(QUDA_BACKWARDS);
 
       if (coarseGauge::fixedPoint()) {
-        double x_max = X_atomic_.abs_max(0, coarseGaugeAtomic::fixedPoint());
+        real_t x_max = X_atomic_.abs_max(0, coarseGaugeAtomic::fixedPoint());
+        arg.X.resetScale(double(x_max));
         X_.Scale(x_max);
-        arg.X.resetScale(x_max);
       }
 
       y.setComputeType(COMPUTE_CONVERT);
       y.apply(device::get_default_stream());
     }
 
-    logQuda(QUDA_VERBOSE, "X2 = %e\n", X_.norm2(0));
+    logQuda(QUDA_VERBOSE, "X2 = %e\n", double(X_.norm2(0)));
 
     pool_device_free(arg.max_d);
     pool_pinned_free(arg.max_h);
diff --git a/lib/coarse_op.in.cpp b/lib/coarse_op.in.cpp
index e35a2b3dce..8ff36b0e59 100644
--- a/lib/coarse_op.in.cpp
+++ b/lib/coarse_op.in.cpp
@@ -8,7 +8,7 @@ namespace quda
 
   template <int fineColor, int coarseColor, int... N>
   void CoarseOp2(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge, const CloverField *clover,
-                 double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc,
+                 real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc,
                  IntList<coarseColor, N...>)
   {
     if (Y.Ncolor() / 2 == coarseColor) {
@@ -24,7 +24,7 @@ namespace quda
 
   template <int fineColor, int... N>
   void CoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge, const CloverField *clover,
-                double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc,
+                real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc,
                 IntList<fineColor, N...>)
   {
     if (gauge.Ncolor() == fineColor) {
@@ -42,7 +42,7 @@ namespace quda
   }
 
   void CoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge, const CloverField *clover,
-                double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
+                real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
   {
     if constexpr (is_enabled_multigrid()) {
       IntList<3> fineColors;
diff --git a/lib/coarse_op.in.cu b/lib/coarse_op.in.cu
index 259da32c98..6adceb640c 100644
--- a/lib/coarse_op.in.cu
+++ b/lib/coarse_op.in.cu
@@ -15,7 +15,7 @@ namespace quda {
   template <typename Float, typename vFloat, int fineColor, int coarseColor>
   void calculateY(GaugeField &Y, GaugeField &X, GaugeField &Yatomic, GaugeField &Xatomic,
                   ColorSpinorField &uv, ColorSpinorField &av, const Transfer &T,
-		  const GaugeField &g, const CloverField &c, double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
+		  const GaugeField &g, const CloverField &c, real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
   {
     QudaFieldLocation location = Y.Location();
     constexpr int fineSpin = 4;
@@ -111,7 +111,7 @@ namespace quda {
   template <int fineColor, int coarseColor>
   void calculateY(GaugeField &Y, GaugeField &X, GaugeField &Yatomic, GaugeField &Xatomic,
                   ColorSpinorField &uv, ColorSpinorField &av, const Transfer &T, const GaugeField &g,
-                  const CloverField &c, double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
+                  const CloverField &c, real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
   {
     if constexpr (is_enabled_multigrid()) {
       checkPrecision(Xatomic, Yatomic, g);
@@ -150,7 +150,7 @@ namespace quda {
   template <>
   void CoarseOp<fineColor, coarseColor>(GaugeField &Y, GaugeField &X, const Transfer &T,
                                         const GaugeField &gauge, const CloverField *clover,
-                                        double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
+                                        real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc)
   {
     QudaPrecision precision = Y.Precision();
     QudaFieldLocation location = checkLocation(Y, X);
diff --git a/lib/coarse_op_preconditioned.in.cu b/lib/coarse_op_preconditioned.in.cu
index 833b3f55ad..2814849001 100644
--- a/lib/coarse_op_preconditioned.in.cu
+++ b/lib/coarse_op_preconditioned.in.cu
@@ -226,7 +226,7 @@ namespace quda
         // XXX: This doesn't work for double precision since hard-coded to single precision
         using gCoarseInv = gauge::FieldOrder<float, N, 1, gOrder_milc, use_native_ghosts, float>;
 
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Xinv = %e\n", Xinv_aos->norm2(0));
+        logQuda(QUDA_VERBOSE, "Xinv = %e\n", double(Xinv_aos->norm2(0)));
 
         if (Yhat.Precision() == QUDA_HALF_PRECISION || Yhat.Precision() == QUDA_QUARTER_PRECISION) {
           CalculateYhat<location, Float, gPreconditionedCoarse, gCoarse, gCoarseInv, N, 4, 2, true, true>
@@ -249,7 +249,7 @@ namespace quda
         // use spin-ignorant accessor to make multiplication simpler
         using gCoarse = typename gauge::FieldOrder<Float, N, 1, gOrder, true, storeFloat>;
         using gPreconditionedCoarse = typename gauge::FieldOrder<Float, N, 1, gOrder, true, storeFloat>;
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Xinv = %e\n", Xinv.norm2(0));
+        logQuda(QUDA_VERBOSE, "Xinv = %e\n", double(Xinv.norm2(0)));
 
         if (Yhat.Precision() == QUDA_HALF_PRECISION || Yhat.Precision() == QUDA_QUARTER_PRECISION) {
           CalculateYhat<location, Float, gPreconditionedCoarse, gCoarse, gCoarse, N, 4, 2, true, false>
@@ -271,11 +271,9 @@ namespace quda
     // links and not overwrite the backwards ghost
     Yhat.exchangeGhost(QUDA_LINK_FORWARDS);
 
-    if (getVerbosity() >= QUDA_VERBOSE) {
-      for (int d = 0; d < 8; d++)
-        printfQuda("Yhat[%d] = %e (%e < %e x %e)\n", d, Yhat.norm2(d), Yhat.abs_max(d), Y.abs_max(d), Xinv.abs_max(0));
-    }
-
+    for (int d = 0; d < 8; d++)
+      logQuda(QUDA_VERBOSE, "Yhat[%d] = %e (%e < %e x %e)\n", d, double(Yhat.norm2(d)),
+              double(Yhat.abs_max(d)), double(Y.abs_max(d)), double(Xinv.abs_max(0)));
   }
 
   template <typename storeFloat, typename Float, int N>
diff --git a/lib/coarsecoarse_op.hpp b/lib/coarsecoarse_op.hpp
index f37dba8602..1950d62a70 100644
--- a/lib/coarsecoarse_op.hpp
+++ b/lib/coarsecoarse_op.hpp
@@ -16,7 +16,7 @@ namespace quda
   std::enable_if_t<!use_mma, void>
   calculateYcoarse(GaugeField &Y, GaugeField &X, GaugeField &Yatomic, GaugeField &Xatomic, ColorSpinorField &uv,
                    const Transfer &T, const GaugeField &g, const GaugeField &clover, const GaugeField &cloverInv,
-                   double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc,
+                   real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc,
                    bool need_bidirectional)
   {
     constexpr int fineSpin = 2;
@@ -106,8 +106,8 @@ namespace quda
   template <bool use_mma, typename Float, typename vFloat, int fineColor, int coarseColor>
   std::enable_if_t<use_mma, void> calculateYcoarse(GaugeField &Y, GaugeField &X, GaugeField &Yatomic, GaugeField &Xatomic,
                                                    ColorSpinorField &uv, const Transfer &T, const GaugeField &g,
-                                                   const GaugeField &clover, const GaugeField &cloverInv, double kappa,
-                                                   double mass, double mu, double mu_factor, QudaDiracType dirac,
+                                                   const GaugeField &clover, const GaugeField &cloverInv, real_t kappa,
+                                                   real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac,
                                                    QudaMatPCType matpc, bool need_bidirectional)
   {
     constexpr int fineSpin = 2;
@@ -167,7 +167,7 @@ namespace quda
   template <bool use_mma, int fineColor, int coarseColor>
   void calculateYcoarse(GaugeField &Y, GaugeField &X, GaugeField &Yatomic, GaugeField &Xatomic, ColorSpinorField &uv,
                         const Transfer &T, const GaugeField &g, const GaugeField &clover, const GaugeField &cloverInv,
-                        double kappa, double mass, double mu, double mu_factor, QudaDiracType dirac,
+                        real_t kappa, real_t mass, real_t mu, real_t mu_factor, QudaDiracType dirac,
                         QudaMatPCType matpc, bool need_bidirectional)
   {
     if constexpr (is_enabled_multigrid()) {
diff --git a/lib/coarsecoarse_op.in.cpp b/lib/coarsecoarse_op.in.cpp
index 4f504bd416..fccbc3eb0b 100644
--- a/lib/coarsecoarse_op.in.cpp
+++ b/lib/coarsecoarse_op.in.cpp
@@ -8,8 +8,8 @@ namespace quda
 
   template <int fineColor, int coarseColor, int... N>
   void CoarseCoarseOp2(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                       const GaugeField &clover, const GaugeField &cloverInv, double kappa, double mass, double mu,
-                       double mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional,
+                       const GaugeField &clover, const GaugeField &cloverInv, real_t kappa, real_t mass, real_t mu,
+                       real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional,
                        bool use_mma, IntList<coarseColor, N...>)
   {
     if (Y.Ncolor() / 2 == coarseColor) {
@@ -36,8 +36,8 @@ namespace quda
 
   template <int fineColor, int... N>
   void CoarseCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                      const GaugeField &clover, const GaugeField &cloverInv, double kappa, double mass, double mu,
-                      double mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional, bool use_mma,
+                      const GaugeField &clover, const GaugeField &cloverInv, real_t kappa, real_t mass, real_t mu,
+                      real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional, bool use_mma,
                       IntList<fineColor, N...>)
   {
     if (gauge.Ncolor() / T.Vectors().Nspin() == fineColor) {
@@ -57,8 +57,8 @@ namespace quda
   }
 
   void CoarseCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                      const GaugeField &clover, const GaugeField &cloverInv, double kappa, double mass, double mu,
-                      double mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional, bool use_mma)
+                      const GaugeField &clover, const GaugeField &cloverInv, real_t kappa, real_t mass, real_t mu,
+                      real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional, bool use_mma)
   {
     if constexpr (is_enabled_multigrid()) {
       // clang-format off
diff --git a/lib/coarsecoarse_op.in.cu b/lib/coarsecoarse_op.in.cu
index b10dc139f4..054560c22e 100644
--- a/lib/coarsecoarse_op.in.cu
+++ b/lib/coarsecoarse_op.in.cu
@@ -10,8 +10,8 @@ namespace quda {
   //N.B. Assumes Y, X have been allocated.
   template <>
   void CoarseCoarseOp<fineColor, coarseColor, use_mma>(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                                                       const GaugeField &clover, const GaugeField &cloverInv, double kappa, double mass, double mu,
-                                                       double mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional)
+                                                       const GaugeField &clover, const GaugeField &cloverInv, real_t kappa, real_t mass, real_t mu,
+                                                       real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional)
   {
     QudaFieldLocation location = checkLocation(X, Y, gauge, clover, cloverInv);
 
diff --git a/lib/coarsecoarse_op_mma.in.cu b/lib/coarsecoarse_op_mma.in.cu
index eee43a43ac..8234999795 100644
--- a/lib/coarsecoarse_op_mma.in.cu
+++ b/lib/coarsecoarse_op_mma.in.cu
@@ -8,8 +8,8 @@ namespace quda {
 
   template<>
   void CoarseCoarseOp<fineColor, coarseColor, use_mma>(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                                                       const GaugeField &clover, const GaugeField &cloverInv, double kappa, double mass,
-                                                       double mu, double mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional)
+                                                       const GaugeField &clover, const GaugeField &cloverInv, real_t kappa, real_t mass,
+                                                       real_t mu, real_t mu_factor, QudaDiracType dirac, QudaMatPCType matpc, bool need_bidirectional)
   {
     QudaFieldLocation location = checkLocation(X, Y, gauge, clover, cloverInv);
     if (location == QUDA_CPU_FIELD_LOCATION) errorQuda("use_mma = true does not go with QUDA_CPU_FIELD_LOCATION.");
diff --git a/lib/color_spinor_util.in.cu b/lib/color_spinor_util.in.cu
index c1471b262b..90607b982a 100644
--- a/lib/color_spinor_util.in.cu
+++ b/lib/color_spinor_util.in.cu
@@ -252,7 +252,7 @@ namespace quda {
         FieldOrderCB<oFloat,Ns,Nc,1,order> A(a);
 	FieldOrderCB<iFloat,Ns,Nc,1,order> B(b);
 
-        double rescale = 1.0 / A.abs_max(a);
+        auto rescale = 1.0 / A.abs_max(a);
 
         auto a_(a), b_(b);
         blas::ax(rescale, a_);
@@ -266,7 +266,7 @@ namespace quda {
         FieldOrderCB<oFloat,Ns,Nc,1,order> A(a);
 	FieldOrderCB<iFloat,Ns,Nc,1,order> B(b);
 
-        double rescale = 1.0 / A.abs_max(a);
+        auto rescale = 1.0 / A.abs_max(a);
 
         auto a_(a), b_(b);
         blas::ax(rescale, a_);
diff --git a/lib/communicator_qmp.cpp b/lib/communicator_qmp.cpp
index 1a4a2a7878..5e60e8ccb9 100644
--- a/lib/communicator_qmp.cpp
+++ b/lib/communicator_qmp.cpp
@@ -299,7 +299,8 @@ void Communicator::comm_wait(MsgHandle *mh) { QMP_CHECK(QMP_wait(mh->handle)); }
 
 int Communicator::comm_query(MsgHandle *mh) { return (QMP_is_complete(mh->handle) == QMP_TRUE); }
 
-void Communicator::comm_allreduce_sum_array(double *data, size_t size)
+template <>
+void Communicator::comm_allreduce_sum_array<double>(double *data, size_t size)
 {
   if (!comm_deterministic_reduce()) {
     QMP_CHECK(QMP_comm_sum_double_array(QMP_COMM_HANDLE, data, size));
@@ -314,7 +315,57 @@ void Communicator::comm_allreduce_sum_array(double *data, size_t size)
       for (size_t j = 0; j < size; j++) { recv_trans[j * n + i] = recv_buf[i * size + j]; }
     }
 
-    for (size_t i = 0; i < size; i++) { data[i] = deterministic_reduce(recv_trans.data() + i * n, n); }
+    for (size_t i = 0; i < size; i++) { data[i] = deterministic_sum_reduce(recv_trans.data() + i * n, n); }
+  }
+}
+
+template <>
+void Communicator::comm_allreduce_sum_array<doubledouble>(doubledouble *data, size_t size)
+{
+  // we need to break out of QMP for doubledouble
+  size_t n = comm_size();
+  std::vector<doubledouble> recv_buf(size * n);
+  MPI_CHECK(MPI_Allgather(data, size, MPI_DOUBLE_COMPLEX, recv_buf.data(), size, MPI_DOUBLE_COMPLEX, MPI_COMM_HANDLE));
+
+  std::vector<doubledouble> recv_trans(size * n);
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = 0; j < size; j++) { recv_trans[j * n + i] = recv_buf[i * size + j]; }
+  }
+
+  for (size_t i = 0; i < size; i++) { data[i] = deterministic_sum_reduce(recv_trans.data() + i * n, n); }
+}
+
+template <>
+void Communicator::comm_allreduce_sum_array<rfa_t<reduction_t>>(rfa_t<reduction_t> *data, size_t size)
+{
+  {
+    static bool init = false;
+    if (!init) {
+      reproducible::RFA_bins<reduction_t> bins;
+      bins.initialize_bins();
+            memcpy(reproducible::bin_host_buffer, &bins, sizeof(bins));
+            init = true;
+    }
+  }
+
+  // we need to break out of QMP for doubledouble
+  size_t n = comm_size();
+  std::vector<rfa_t<reduction_t>> recv_buf(size * n);
+  static_assert(sizeof(rfa_t<reduction_t>) % (2 * sizeof(double)) == 0);
+  auto gather_size = size * sizeof(rfa_t<reduction_t>) / (2 * sizeof(double));
+  MPI_CHECK(MPI_Allgather(data, gather_size, MPI_DOUBLE_COMPLEX,
+                          recv_buf.data(), gather_size, MPI_DOUBLE_COMPLEX, MPI_COMM_HANDLE));
+
+  std::vector<rfa_t<reduction_t>> recv_trans(size * n);
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = 0; j < size; j++) { recv_trans[j * n + i] = recv_buf[i * size + j]; }
+  }
+
+  for (size_t i = 0; i < size; i++) {
+    data[i] = 0.0;
+    for (size_t j = 0; j < n; j++) {
+      data[i] += recv_trans[i * n + j];
+    }
   }
 }
 
@@ -326,7 +377,14 @@ void Communicator::comm_allreduce_sum(size_t &a)
   QMP_CHECK(QMP_comm_sum_uint64_t(QMP_COMM_HANDLE, reinterpret_cast<uint64_t *>(&a)));
 }
 
-void Communicator::comm_allreduce_max_array(deviation_t<double> *data, size_t size)
+template <>
+void Communicator::comm_allreduce_max_array<rfa_t<reduction_t>>(rfa_t<reduction_t> *, size_t)
+{
+  errorQuda("This is a bug I need to fix - this function should not exist");
+}
+
+template <>
+void Communicator::comm_allreduce_max_array<deviation_t<double>>(deviation_t<double> *data, size_t size)
 {
   size_t n = comm_size();
   std::vector<deviation_t<double>> recv_buf(size * n);
@@ -343,12 +401,50 @@ void Communicator::comm_allreduce_max_array(deviation_t<double> *data, size_t si
   }
 }
 
-void Communicator::comm_allreduce_max_array(double *data, size_t size)
+template <>
+void Communicator::comm_allreduce_max_array<deviation_t<doubledouble>>(deviation_t<doubledouble> *data, size_t size)
+{
+  size_t n = comm_size();
+  std::vector<deviation_t<doubledouble>> recv_buf(size * n);
+  MPI_CHECK(MPI_Allgather(data, 2 * size, MPI_DOUBLE_COMPLEX, recv_buf.data(), 2 * size, MPI_DOUBLE_COMPLEX, MPI_COMM_HANDLE));
+
+  std::vector<deviation_t<doubledouble>> recv_trans(size * n);
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = 0; j < size; j++) { recv_trans[j * n + i] = recv_buf[i * size + j]; }
+  }
+
+  for (size_t i = 0; i < size; i++) {
+    data[i] = recv_trans[i * n];
+    for (size_t j = 1; j < n; j++) { data[i] = data[i] > recv_trans[i * n + j] ? data[i] : recv_trans[i * n + j]; }
+  }
+}
+
+template<>
+void Communicator::comm_allreduce_max_array<double>(double *data, size_t size)
 {
   for (size_t i = 0; i < size; i++) { QMP_CHECK(QMP_comm_max_double(QMP_COMM_HANDLE, data + i)); }
 }
 
-void Communicator::comm_allreduce_min_array(double *data, size_t size)
+template <>
+void Communicator::comm_allreduce_max_array<doubledouble>(doubledouble *data, size_t size)
+{
+  size_t n = comm_size();
+  std::vector<doubledouble> recv_buf(size * n);
+  MPI_CHECK(MPI_Allgather(data, size, MPI_DOUBLE_COMPLEX, recv_buf.data(), size, MPI_DOUBLE_COMPLEX, MPI_COMM_HANDLE));
+
+  std::vector<doubledouble> recv_trans(size * n);
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = 0; j < size; j++) { recv_trans[j * n + i] = recv_buf[i * size + j]; }
+  }
+
+  for (size_t i = 0; i < size; i++) {
+    data[i] = recv_trans[i * n];
+    for (size_t j = 1; j < n; j++) { data[i] = data[i] > recv_trans[i * n + j] ? data[i] : recv_trans[i * n + j]; }
+  }
+}
+
+template <>
+void Communicator::comm_allreduce_min_array<double>(double *data, size_t size)
 {
   for (size_t i = 0; i < size; i++) { QMP_CHECK(QMP_comm_min_double(QMP_COMM_HANDLE, data + i)); }
 }
diff --git a/lib/communicator_single.cpp b/lib/communicator_single.cpp
index 978fbcc069..0fe4b55680 100644
--- a/lib/communicator_single.cpp
+++ b/lib/communicator_single.cpp
@@ -81,15 +81,33 @@ namespace quda
 
   int Communicator::comm_query(MsgHandle *) { return 1; }
 
-  void Communicator::comm_allreduce_sum_array(double *, size_t) { }
+  template <>
+  void Communicator::comm_allreduce_sum_array<rfa_t<double>>(rfa_t<double> *, size_t) { }
 
   void Communicator::comm_allreduce_sum(size_t &) { }
 
-  void Communicator::comm_allreduce_max_array(deviation_t<double> *, size_t) { }
+  template <>
+  void Communicator::comm_allreduce_sum_array<double>(double *, size_t) { }
+  template <>
+  void Communicator::comm_allreduce_sum_array<doubledouble>(doubledouble *, size_t) { }
 
-  void Communicator::comm_allreduce_max_array(double *, size_t) { }
+  template <>
+  void Communicator::comm_allreduce_max_array<deviation_t<double>>(deviation_t<double> *, size_t) { }
 
-  void Communicator::comm_allreduce_min_array(double *, size_t) { }
+  template <>
+  void Communicator::comm_allreduce_max_array<deviation_t<doubledouble>>(deviation_t<doubledouble> *, size_t) { }
+
+  template<>
+  void Communicator::comm_allreduce_max_array<rfa_t<double>>(rfa_t<double> *, size_t) { }
+
+  template<>
+  void Communicator::comm_allreduce_max_array<double>(double *, size_t) { }
+
+  template <>
+  void Communicator::comm_allreduce_max_array<doubledouble>(doubledouble *, size_t) { }
+
+  template <>
+  void Communicator::comm_allreduce_min_array<double>(double *, size_t) { }
 
   void Communicator::comm_allreduce_int(int &) { }
 
diff --git a/lib/communicator_stack.cpp b/lib/communicator_stack.cpp
index fe9d1faaba..174552f388 100644
--- a/lib/communicator_stack.cpp
+++ b/lib/communicator_stack.cpp
@@ -179,51 +179,82 @@ namespace quda
 
 #undef CHECK_MH
 
-  void comm_allreduce_sum_array(double *data, size_t size)
+  template <typename T>
+  void comm_allreduce_sum_array(T *data, size_t size)
   {
     get_current_communicator().comm_allreduce_sum_array(data, size);
   }
 
+  template <> void comm_allreduce_sum<std::vector<rfa_t<double>>>(std::vector<rfa_t<double>> &a)
+  {
+    comm_allreduce_sum_array(a.data(), a.size());
+  }
+
   template <> void comm_allreduce_sum<std::vector<double>>(std::vector<double> &a)
   {
     comm_allreduce_sum_array(a.data(), a.size());
   }
 
-  template <> void comm_allreduce_sum<std::vector<double2>>(std::vector<double2> &a)
+  template <> void comm_allreduce_sum<std::vector<doubledouble>>(std::vector<doubledouble> &a)
   {
-    comm_allreduce_sum_array(reinterpret_cast<double *>(a.data()), 2 * a.size());
+    comm_allreduce_sum_array(a.data(), a.size());
   }
 
-  template <> void comm_allreduce_sum<std::vector<std::complex<double>>>(std::vector<std::complex<double>> &a)
+  template <> void comm_allreduce_sum<std::vector<complex_t>>(std::vector<complex_t> &a)
   {
-    comm_allreduce_sum_array(reinterpret_cast<double *>(a.data()), 2 * a.size());
+    comm_allreduce_sum_array(reinterpret_cast<real_t *>(a.data()), 2 * a.size());
   }
 
-  template <> void comm_allreduce_sum<std::vector<array<double, 2>>>(std::vector<array<double, 2>> &a)
+  template <> void comm_allreduce_sum<std::vector<array<device_reduce_t, 2>>>(std::vector<array<device_reduce_t, 2>> &a)
   {
-    comm_allreduce_sum_array(reinterpret_cast<double *>(a.data()), 2 * a.size());
+    comm_allreduce_sum_array(reinterpret_cast<device_reduce_t *>(a.data()), 2 * a.size());
   }
 
-  template <> void comm_allreduce_sum<std::vector<array<double, 3>>>(std::vector<array<double, 3>> &a)
+  template <> void comm_allreduce_sum<std::vector<array<device_reduce_t, 3>>>(std::vector<array<device_reduce_t, 3>> &a)
   {
-    comm_allreduce_sum_array(reinterpret_cast<double *>(a.data()), 3 * a.size());
+    comm_allreduce_sum_array(reinterpret_cast<device_reduce_t *>(a.data()), 3 * a.size());
   }
 
-  template <> void comm_allreduce_sum<std::vector<array<double, 4>>>(std::vector<array<double, 4>> &a)
+  template <> void comm_allreduce_sum<std::vector<array<device_reduce_t, 4>>>(std::vector<array<device_reduce_t, 4>> &a)
   {
-    comm_allreduce_sum_array(reinterpret_cast<double *>(a.data()), 4 * a.size());
+    comm_allreduce_sum_array(reinterpret_cast<device_reduce_t *>(a.data()), 4 * a.size());
   }
 
-  template <> void comm_allreduce_sum<double>(double &a) { comm_allreduce_sum_array(&a, 1); }
+  template <> void comm_allreduce_sum<rfa_t<double>>(rfa_t<double> &a)
+  {
+    get_current_communicator().comm_allreduce_sum_array(&a, 1);
+  }
 
-  template <> void comm_allreduce_sum<size_t>(size_t &a) { get_current_communicator().comm_allreduce_sum(a); }
+   template <> void comm_allreduce_sum<double>(double &a)
+  {
+    get_current_communicator().comm_allreduce_sum_array(&a, 1);
+  }
 
-  void comm_allreduce_max_array(double *data, size_t size)
+  template <> void comm_allreduce_sum<doubledouble>(doubledouble &a)
+  {
+    get_current_communicator().comm_allreduce_sum_array(&a, 1);
+  }
+
+  template <> void comm_allreduce_sum<size_t>(size_t &a)
+  {
+    get_current_communicator().comm_allreduce_sum(a);
+  }
+
+  template <typename T>
+  void comm_allreduce_max_array(T *data, size_t size)
   {
     get_current_communicator().comm_allreduce_max_array(data, size);
   }
 
-  template <> void comm_allreduce_max<double>(double &a) { comm_allreduce_max_array(&a, 1); }
+  template <> void comm_allreduce_max<doubledouble>(doubledouble &a)
+  {
+    comm_allreduce_max_array(&a, 1);
+  }
+
+  template <> void comm_allreduce_max<double>(double &a)
+  {
+    comm_allreduce_max_array(&a, 1);
+  }
 
   template <> void comm_allreduce_max<float>(float &a)
   {
@@ -232,11 +263,21 @@ namespace quda
     a = a_;
   }
 
+  template <> void comm_allreduce_max<std::vector<rfa_t<double>>>(std::vector<rfa_t<double>> &a)
+  {
+    comm_allreduce_max_array(a.data(), a.size());
+  }
+
   template <> void comm_allreduce_max<std::vector<double>>(std::vector<double> &a)
   {
     comm_allreduce_max_array(a.data(), a.size());
   }
 
+  template <> void comm_allreduce_max<std::vector<doubledouble>>(std::vector<doubledouble> &a)
+  {
+    comm_allreduce_max_array(a.data(), a.size());
+  }
+
   template <> void comm_allreduce_max<std::vector<float>>(std::vector<float> &a)
   {
     std::vector<double> a_(a.size());
@@ -245,12 +286,14 @@ namespace quda
     for (unsigned int i = 0; i < a.size(); i++) a[i] = a_[i];
   }
 
-  template <> void comm_allreduce_max<std::vector<array<double, 2>>>(std::vector<array<double, 2>> &a)
+  using comm_reduce_t = QUDA_REDUCTION_TYPE;
+
+  template <> void comm_allreduce_max<std::vector<array<comm_reduce_t, 2>>>(std::vector<array<comm_reduce_t, 2>> &a)
   {
-    comm_allreduce_max_array(reinterpret_cast<double *>(a.data()), 2 * a.size());
+    comm_allreduce_max_array(reinterpret_cast<comm_reduce_t *>(a.data()), 2 * a.size());
   }
 
-  template <> void comm_allreduce_max<deviation_t<double>>(deviation_t<double> &a)
+  template <> void comm_allreduce_max<deviation_t<comm_reduce_t>>(deviation_t<comm_reduce_t> &a)
   {
     get_current_communicator().comm_allreduce_max_array(&a, 1);
   }
@@ -260,6 +303,11 @@ namespace quda
     get_current_communicator().comm_allreduce_max_array(a.data(), a.size());
   }
 
+  template <> void comm_allreduce_max<std::vector<deviation_t<doubledouble>>>(std::vector<deviation_t<doubledouble>> &a)
+  {
+    get_current_communicator().comm_allreduce_max_array(a.data(), a.size());
+  }
+
   void comm_allreduce_min_array(double *data, size_t size)
   {
     get_current_communicator().comm_allreduce_min_array(data, size);
diff --git a/lib/deflation.cpp b/lib/deflation.cpp
index 9b6270db32..295a3a840a 100644
--- a/lib/deflation.cpp
+++ b/lib/deflation.cpp
@@ -9,9 +9,12 @@ namespace quda
 
   using namespace blas;
   using DynamicStride = Stride<Dynamic, Dynamic>;
+  using MatrixXc = Matrix<complex_t, Dynamic, Dynamic>;
+  using VectorXc = Matrix<complex_t, Dynamic, 1>;
+  using VectorX = Matrix<real_t, Dynamic, 1>;
 
-  static auto pinned_allocator = [] (size_t bytes ) { return static_cast<Complex*>(pool_pinned_malloc(bytes)); };
-  static auto pinned_deleter   = [] (Complex *hptr) { pool_pinned_free(hptr); };
+  static auto pinned_allocator = [] (size_t bytes ) { return static_cast<complex_t*>(pool_pinned_malloc(bytes)); };
+  static auto pinned_deleter   = [] (complex_t *hptr) { pool_pinned_free(hptr); };
 
   Deflation::Deflation(DeflationParam &param, TimeProfile &profile) :
     param(param),
@@ -83,13 +86,13 @@ namespace quda
     const int n_evs_to_print = param.cur_dim;
     if (n_evs_to_print == 0) errorQuda("Incorrect size of current deflation space");
 
-    std::unique_ptr<Complex, decltype(pinned_deleter) > projm( pinned_allocator(param.ld*param.cur_dim * sizeof(Complex)), pinned_deleter);
+    std::unique_ptr<complex_t, decltype(pinned_deleter) > projm( pinned_allocator(param.ld*param.cur_dim * sizeof(complex_t)), pinned_deleter);
 
 if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
-      Map<MatrixXcd, Unaligned, DynamicStride> projm_(param.matProj, param.cur_dim, param.cur_dim, DynamicStride(param.ld, 1));
-      Map<MatrixXcd, Unaligned, DynamicStride> evecs_(projm.get(), param.cur_dim, param.cur_dim, DynamicStride(param.ld, 1));
+      Map<MatrixXc, Unaligned, DynamicStride> projm_(param.matProj, param.cur_dim, param.cur_dim, DynamicStride(param.ld, 1));
+      Map<MatrixXc, Unaligned, DynamicStride> evecs_(projm.get(), param.cur_dim, param.cur_dim, DynamicStride(param.ld, 1));
 
-      SelfAdjointEigenSolver<MatrixXcd> es_projm( projm_ );
+      SelfAdjointEigenSolver<MatrixXc> es_projm( projm_ );
       evecs_.block(0, 0, param.cur_dim, param.cur_dim) = es_projm.eigenvectors();
     } else {
       errorQuda("Library type %d is currently not supported", param.eig_global.extlib_type);
@@ -104,11 +107,11 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
       blas::caxpy(&projm.get()[i * param.ld], rv, res); // multiblas
       *r_sloppy = *r;
       param.matDeflation(*Av_sloppy, *r_sloppy);
-      double3 dotnorm = cDotProductNormA(*r_sloppy, *Av_sloppy);
-      double eval = dotnorm.x / dotnorm.z;
+      auto dotnorm = cDotProductNormA(*r_sloppy, *Av_sloppy);
+      auto eval = dotnorm[0] / dotnorm[2];
       blas::xpay(*Av_sloppy, -eval, *r_sloppy);
-      double relerr = sqrt(norm2(*r_sloppy) / dotnorm.z);
-      printfQuda("Eigenvalue %d: %1.12e Residual: %1.12e\n", i + 1, eval, relerr);
+      auto relerr = sqrt(norm2(*r_sloppy) / dotnorm[2]);
+      printfQuda("Eigenvalue %d: %1.12e Residual: %1.12e\n", i + 1, double(eval), double(relerr));
     }
   }
 
@@ -120,11 +123,11 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
 
     if(param.cur_dim == 0) return;//nothing to do
 
-    std::unique_ptr<Complex[] > vec(new Complex[param.ld]);
+    std::unique_ptr<complex_t[] > vec(new complex_t[param.ld]);
 
-    double check_nrm2 = norm2(b);
+    auto check_nrm2 = norm2(b);
 
-    printfQuda("\nSource norm (gpu): %1.15e, curr deflation space dim = %d\n", sqrt(check_nrm2), param.cur_dim);
+    printfQuda("\nSource norm (gpu): %1.15e, curr deflation space dim = %d\n", double(sqrt(check_nrm2)), param.cur_dim);
 
     ColorSpinorField *b_sloppy = param.RV->Precision() != b.Precision() ? r_sloppy : &b;
     *b_sloppy = b;
@@ -137,11 +140,11 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
 
     if (!param.use_inv_ritz) {
       if (param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB) {
-        Map<MatrixXcd, Unaligned, DynamicStride> projm_(param.matProj, param.cur_dim, param.cur_dim,
+        Map<MatrixXc, Unaligned, DynamicStride> projm_(param.matProj, param.cur_dim, param.cur_dim,
                                                         DynamicStride(param.ld, 1));
-        Map<VectorXcd, Unaligned> vec_(vec.get(), param.cur_dim);
+        Map<VectorXc, Unaligned> vec_(vec.get(), param.cur_dim);
 
-        VectorXcd vec2_(param.cur_dim);
+        VectorXc vec2_(param.cur_dim);
         vec2_ = projm_.fullPivHouseholderQr().solve(vec_);
         vec_ = vec2_;
       } else {
@@ -157,7 +160,7 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
     blas::caxpy(vec.get(), rv_, out_); //multiblas
 
     check_nrm2 = norm2(x);
-    printfQuda("\nDeflated guess spinor norm (gpu): %1.15e\n", sqrt(check_nrm2));
+    printfQuda("\nDeflated guess spinor norm (gpu): %1.15e\n", double(sqrt(check_nrm2)));
   }
 
   void Deflation::increment(ColorSpinorField &Vm, int n_ev)
@@ -184,7 +187,7 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
     const int cdot_pipeline_length  = 4;
 
     for (int i = first_idx; i < (first_idx + n_ev); i++) {
-      std::unique_ptr<Complex[]> alpha(new Complex[i]);
+      std::unique_ptr<complex_t[]> alpha(new complex_t[i]);
 
       ColorSpinorField *accum = param.eig_global.cuda_prec_ritz != QUDA_DOUBLE_PRECISION ? r : &param.RV->Component(i);
       *accum = param.RV->Component(i);
@@ -238,24 +241,24 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
     printfQuda("\nNew curr deflation space dim = %d\n", param.cur_dim);
   }
 
-  void Deflation::reduce(double tol, int max_n_ev)
+  void Deflation::reduce(real_t tol, int max_n_ev)
   {
     if (param.cur_dim < max_n_ev) {
       printf("\nToo big number of eigenvectors was requested, switched to maximum available number %d\n", param.cur_dim);
       max_n_ev = param.cur_dim;
     }
 
-    std::unique_ptr<double[]> evals(new double[param.cur_dim]);
-    std::unique_ptr<Complex, decltype(pinned_deleter)> projm(
-      pinned_allocator(param.ld * param.cur_dim * sizeof(Complex)), pinned_deleter);
+    std::unique_ptr<real_t[]> evals(new real_t[param.cur_dim]);
+    std::unique_ptr<complex_t, decltype(pinned_deleter)> projm(
+      pinned_allocator(param.ld * param.cur_dim * sizeof(complex_t)), pinned_deleter);
 
-    memcpy(projm.get(), param.matProj, param.ld * param.cur_dim * sizeof(Complex));
+    memcpy(projm.get(), param.matProj, param.ld * param.cur_dim * sizeof(complex_t));
 
     if (param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB) {
-      Map<MatrixXcd, Unaligned, DynamicStride> projm_(projm.get(), param.cur_dim, param.cur_dim,
-                                                      DynamicStride(param.ld, 1));
-      Map<VectorXd, Unaligned> evals_(evals.get(), param.cur_dim);
-      SelfAdjointEigenSolver<MatrixXcd> es(projm_);
+      Map<MatrixXc, Unaligned, DynamicStride> projm_(projm.get(), param.cur_dim, param.cur_dim,
+                                                     DynamicStride(param.ld, 1));
+      Map<VectorX, Unaligned> evals_(evals.get(), param.cur_dim);
+      SelfAdjointEigenSolver<MatrixXc> es(projm_);
       projm_ = es.eigenvectors();
       evals_ = es.eigenvalues();
     } else {
@@ -265,7 +268,7 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
     // reset projection matrix, now we will use inverse ritz values when deflate an initial guess:
     param.use_inv_ritz = true;
     for (int i = 0; i < param.cur_dim; i++) {
-      if (fabs(evals[i]) > 1e-16) {
+      if (abs(evals[i]) > 1e-16) {
         param.invRitzVals[i] = 1.0 / evals[i];
       } else {
         errorQuda("Cannot invert Ritz value");
@@ -283,7 +286,7 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
     std::unique_ptr<ColorSpinorField> buff(ColorSpinorField::Create(csParam));
 
     int idx = 0;
-    double relerr = 0.0;
+    real_t relerr = 0.0;
     bool do_residual_check = (tol != 0.0);
 
     while ((relerr < tol) && (idx < max_n_ev)) {
@@ -298,11 +301,11 @@ if( param.eig_global.extlib_type == QUDA_EIGEN_EXTLIB ) {
       if (do_residual_check) { // if tol=0.0 then disable relative residual norm check
         *r_sloppy = *r;
         param.matDeflation(*Av_sloppy, *r_sloppy);
-        double3 dotnorm = cDotProductNormA(*r_sloppy, *Av_sloppy);
-        double eval = dotnorm.x / dotnorm.z;
+        auto dotnorm = cDotProductNormA(*r_sloppy, *Av_sloppy);
+        auto eval = dotnorm[0] / dotnorm[2];
         blas::xpay(*Av_sloppy, -eval, *r_sloppy);
-        relerr = sqrt(norm2(*r_sloppy) / dotnorm.z);
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Eigenvalue: %1.12e Residual: %1.12e\n", eval, relerr);
+        relerr = sqrt(norm2(*r_sloppy) / dotnorm[2]);
+        logQuda(QUDA_VERBOSE, "Eigenvalue: %1.12e Residual: %1.12e\n", double(eval), double(relerr));
       }
 
       idx++;
diff --git a/lib/dirac_clover.cpp b/lib/dirac_clover.cpp
index 6bb8e56df5..11c518e1a4 100644
--- a/lib/dirac_clover.cpp
+++ b/lib/dirac_clover.cpp
@@ -32,7 +32,7 @@ namespace quda {
   /** Applies the operator (A + k D) */
   void DiracClover::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, 
 			       const QudaParity parity, const ColorSpinorField &x,
-			       const double &k) const
+			       const real_t &k) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -82,13 +82,13 @@ namespace quda {
     // do nothing
   }
 
-  void DiracClover::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double, double mu,
-                                   double mu_factor, bool) const
+  void DiracClover::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t, real_t mu,
+                                   real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     CoarseOp(Y, X, T, *gauge, clover, kappa, mass, a, mu_factor, QUDA_CLOVER_DIRAC, QUDA_MATPC_INVALID);
   }
 
@@ -146,7 +146,7 @@ namespace quda {
   // xpay version of the above
   void DiracCloverPC::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, 
 				 const QudaParity parity, const ColorSpinorField &x,
-				 const double &k) const
+				 const real_t &k) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -158,7 +158,7 @@ namespace quda {
   // Apply the even-odd preconditioned clover-improved Dirac operator
   void DiracCloverPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
-    double kappa2 = -kappa*kappa;
+    real_t kappa2 = -kappa*kappa;
     auto tmp = getFieldTmp(in);
 
     bool symmetric =(matpcType == QUDA_MATPC_EVEN_EVEN || matpcType == QUDA_MATPC_ODD_ODD) ? true : false;
@@ -281,13 +281,13 @@ namespace quda {
     }
   }
 
-  void DiracCloverPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double, double mu,
-                                     double mu_factor, bool) const
+  void DiracCloverPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t, real_t mu,
+                                     real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = - 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = - 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     CoarseOp(Y, X, T, *gauge, clover, kappa, mass, a, -mu_factor, QUDA_CLOVERPC_DIRAC, matpcType);
   }
 
diff --git a/lib/dirac_clover_hasenbusch_twist.cpp b/lib/dirac_clover_hasenbusch_twist.cpp
index 93600c8299..2950c193d5 100644
--- a/lib/dirac_clover_hasenbusch_twist.cpp
+++ b/lib/dirac_clover_hasenbusch_twist.cpp
@@ -71,10 +71,10 @@ namespace quda
     Mdag(out, tmp);
   }
 
-  void DiracCloverHasenbuschTwist::createCoarseOp(GaugeField &, GaugeField &, const Transfer &, double, double, double,
-                                                  double, bool) const
+  void DiracCloverHasenbuschTwist::createCoarseOp(GaugeField &, GaugeField &, const Transfer &, real_t, real_t, real_t,
+                                                  real_t, bool) const
   {
-    // double a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    // real_t a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     // CoarseOp(Y, X, T, *gauge, &clover, kappa, a, mu_factor, QUDA_CLOVER_DIRAC, QUDA_MATPC_INVALID);
     errorQuda("Not Yet Implemented");
   }
@@ -109,7 +109,7 @@ namespace quda
   // xpay version of the above
   void DiracCloverHasenbuschTwistPC::DslashXpayTwistClovInv(ColorSpinorField &out, const ColorSpinorField &in,
                                                             const QudaParity parity, const ColorSpinorField &x,
-                                                            const double &k, const double &b) const
+                                                            const real_t &k, const real_t &b) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -123,7 +123,7 @@ namespace quda
   // xpay version of the above
   void DiracCloverHasenbuschTwistPC::DslashXpayTwistNoClovInv(ColorSpinorField &out, const ColorSpinorField &in,
                                                               const QudaParity parity, const ColorSpinorField &x,
-                                                              const double &k, const double &b) const
+                                                              const real_t &k, const real_t &b) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -137,7 +137,7 @@ namespace quda
   // Apply the even-odd preconditioned clover-improved Dirac operator
   void DiracCloverHasenbuschTwistPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
-    double kappa2 = -kappa * kappa;
+    real_t kappa2 = -kappa * kappa;
     auto tmp = getFieldTmp(in);
 
     bool symmetric = (matpcType == QUDA_MATPC_EVEN_EVEN || matpcType == QUDA_MATPC_ODD_ODD) ? true : false;
@@ -183,10 +183,10 @@ namespace quda
     Mdag(out, tmp);
   }
 
-  void DiracCloverHasenbuschTwistPC::createCoarseOp(GaugeField &, GaugeField &, const Transfer &, double, double,
-                                                    double, double, bool) const
+  void DiracCloverHasenbuschTwistPC::createCoarseOp(GaugeField &, GaugeField &, const Transfer &, real_t, real_t,
+                                                    real_t, real_t, bool) const
   {
-    // double a = - 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    // real_t a = - 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     // CoarseOp(Y, X, T, *gauge, &clover, kappa, a, -mu_factor,QUDA_CLOVERPC_DIRAC, matpcType);
     errorQuda("Not yet implemented\n");
   }
diff --git a/lib/dirac_coarse.cpp b/lib/dirac_coarse.cpp
index 3681257170..c5b4e1ffd6 100644
--- a/lib/dirac_coarse.cpp
+++ b/lib/dirac_coarse.cpp
@@ -415,7 +415,7 @@ namespace quda {
   }
 
   void DiracCoarse::DslashXpay(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &in,
-                               QudaParity parity, cvector_ref<const ColorSpinorField> &x, double k) const
+                               QudaParity parity, cvector_ref<const ColorSpinorField> &x, real_t k) const
   {
     if (k!=1.0) errorQuda("%s not supported for k!=1.0", __func__);
 
@@ -474,13 +474,13 @@ namespace quda {
   }
 
   //Make the coarse operator one level down.  Pass both the coarse gauge field and coarse clover field.
-  void DiracCoarse::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double, double mu,
-                                   double mu_factor, bool) const
+  void DiracCoarse::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t, real_t mu,
+                                   real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Coarse operators only support aggregation coarsening");
 
-    double a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     if (checkLocation(Y, X) == QUDA_CPU_FIELD_LOCATION) {
       initializeLazy(QUDA_CPU_FIELD_LOCATION);
       CoarseCoarseOp(Y, X, T, *(this->Y_h), *(this->X_h), *(this->Xinv_h), kappa, mass, a, mu_factor, QUDA_COARSE_DIRAC,
@@ -542,7 +542,7 @@ namespace quda {
   }
 
   void DiracCoarsePC::DslashXpay(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &in,
-                                 QudaParity parity, cvector_ref<const ColorSpinorField> &x, double k) const
+                                 QudaParity parity, cvector_ref<const ColorSpinorField> &x, real_t k) const
   {
     // FIXME emulated for now
     Dslash(out, in, parity);
@@ -706,13 +706,13 @@ namespace quda {
   //Make the coarse operator one level down.  For the preconditioned
   //operator we are coarsening the Yhat links, not the Y links.  We
   //pass the fine clover fields, though they are actually ignored.
-  void DiracCoarsePC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double, double mu,
-                                     double mu_factor, bool) const
+  void DiracCoarsePC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t, real_t mu,
+                                     real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Coarse operators only support aggregation coarsening");
 
-    double a = -2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = -2.0 * kappa * mu * T.Vectors().TwistFlavor();
     if (checkLocation(Y, X) == QUDA_CPU_FIELD_LOCATION) {
       initializeLazy(QUDA_CPU_FIELD_LOCATION);
       CoarseCoarseOp(Y, X, T, *(this->Yhat_h), *(this->X_h), *(this->Xinv_h), kappa, mass, a, -mu_factor,
diff --git a/lib/dirac_domain_wall.cpp b/lib/dirac_domain_wall.cpp
index cc29f2927f..3c8a630603 100644
--- a/lib/dirac_domain_wall.cpp
+++ b/lib/dirac_domain_wall.cpp
@@ -58,7 +58,7 @@ namespace quda {
 
   void DiracDomainWall::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, 
 				   const QudaParity parity, const ColorSpinorField &x,
-				   const double &k) const
+				   const real_t &k) const
   {
     checkDWF(out, in);
     checkParitySpinor(in, out);
@@ -140,7 +140,7 @@ namespace quda {
   void DiracDomainWallPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
     checkDWF(out, in);
-    double kappa2 = -kappa5*kappa5;
+    auto kappa2 = -kappa5*kappa5;
     auto tmp = getFieldTmp(in);
 
     if (matpcType == QUDA_MATPC_EVEN_EVEN) {
diff --git a/lib/dirac_domain_wall_4d.cpp b/lib/dirac_domain_wall_4d.cpp
index 7c69233f70..b6a86cc3aa 100644
--- a/lib/dirac_domain_wall_4d.cpp
+++ b/lib/dirac_domain_wall_4d.cpp
@@ -45,7 +45,7 @@ namespace quda {
 
   // Modification for the 4D preconditioned domain wall operator
   void DiracDomainWall4D::Dslash4Xpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-      const ColorSpinorField &x, const double &k) const
+      const ColorSpinorField &x, const real_t &k) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -57,7 +57,7 @@ namespace quda {
   }
 
   void DiracDomainWall4D::Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                      const double &k) const
+                                      const real_t &k) const
   {
     checkDWF(out, in);
     checkParitySpinor(in, out);
@@ -138,7 +138,7 @@ namespace quda {
   }
 
   void DiracDomainWall4DPC::M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                      const double &b) const
+                                      const real_t &b) const
   {
     checkDWF(out, in);
     checkParitySpinor(in, out);
@@ -154,7 +154,7 @@ namespace quda {
   void DiracDomainWall4DPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
     if ( in.Ndim() != 5 || out.Ndim() != 5) errorQuda("Wrong number of dimensions\n");
-    double kappa2 = kappa5*kappa5;
+    auto kappa2 = kappa5*kappa5;
     auto tmp = getFieldTmp(in);
 
     int odd_bit = (matpcType == QUDA_MATPC_ODD_ODD || matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) ? 1 : 0;
diff --git a/lib/dirac_improved_staggered.cpp b/lib/dirac_improved_staggered.cpp
index b6423f9a02..3b8a1669ea 100644
--- a/lib/dirac_improved_staggered.cpp
+++ b/lib/dirac_improved_staggered.cpp
@@ -36,7 +36,7 @@ namespace quda {
   }
 
   void DiracImprovedStaggered::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-      const ColorSpinorField &x, const double &k) const
+      const ColorSpinorField &x, const real_t &k) const
   {    
     checkParitySpinor(in, out);
 
@@ -107,7 +107,7 @@ namespace quda {
     // do nothing
   }
   
-  void DiracImprovedStaggered::SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const double, const double,
+  void DiracImprovedStaggered::SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const real_t, const real_t,
                              const int t0, const QudaParity parity) const
   {
     checkSpinorAlias(in, out);
@@ -138,8 +138,8 @@ namespace quda {
     flops += ( laplace3D > 3 ? 570ll : 426ll ) * ( in.Volume() / ( is_time_slice ? in.X(3) : 1 ) );
   }  
 
-  void DiracImprovedStaggered::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double, double mass,
-                                              double, double, bool allow_truncation) const
+  void DiracImprovedStaggered::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t, real_t mass,
+                                              real_t, real_t, bool allow_truncation) const
   {
     if (T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD || T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD_DROP_LONG)
       errorQuda("The optimized improved Kahler-Dirac operator is not built through createCoarseOp");
@@ -284,8 +284,8 @@ namespace quda {
     }
   }
 
-  void DiracImprovedStaggeredPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double, double mass,
-                                                double, double, bool allow_truncation) const
+  void DiracImprovedStaggeredPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t, real_t mass,
+                                                real_t, real_t, bool allow_truncation) const
   {
     if (T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD || T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD_DROP_LONG)
       errorQuda("The optimized improved Kahler-Dirac operator is not built through createCoarseOp");
diff --git a/lib/dirac_improved_staggered_kd.cpp b/lib/dirac_improved_staggered_kd.cpp
index 39e6080cd6..a8d4e61bea 100644
--- a/lib/dirac_improved_staggered_kd.cpp
+++ b/lib/dirac_improved_staggered_kd.cpp
@@ -37,7 +37,7 @@ namespace quda
   }
 
   void DiracImprovedStaggeredKD::DslashXpay(ColorSpinorField &, const ColorSpinorField &, const QudaParity,
-                                            const ColorSpinorField &, const double &) const
+                                            const ColorSpinorField &, const real_t &) const
   {
     errorQuda("The improved staggered Kahler-Dirac operator does not have a single parity form");
   }
@@ -162,8 +162,8 @@ namespace quda
     longGauge = long_gauge_in;
   }
 
-  void DiracImprovedStaggeredKD::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double, double mass,
-                                                double, double, bool allow_truncation) const
+  void DiracImprovedStaggeredKD::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t, real_t mass,
+                                                real_t, real_t, bool allow_truncation) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Staggered KD operators only support aggregation coarsening");
diff --git a/lib/dirac_mobius.cpp b/lib/dirac_mobius.cpp
index d60d8060fc..4c81cd9dce 100644
--- a/lib/dirac_mobius.cpp
+++ b/lib/dirac_mobius.cpp
@@ -9,11 +9,11 @@ namespace quda {
 
   DiracMobius::DiracMobius(const DiracParam &param) : DiracDomainWall(param), zMobius(false)
   {
-    memcpy(b_5, param.b_5, sizeof(Complex) * param.Ls);
-    memcpy(c_5, param.c_5, sizeof(Complex) * param.Ls);
+    memcpy(b_5, param.b_5, sizeof(complex_t) * param.Ls);
+    memcpy(c_5, param.c_5, sizeof(complex_t) * param.Ls);
 
-    double b = b_5[0].real();
-    double c = c_5[0].real();
+    auto b = b_5[0].real();
+    auto c = c_5[0].real();
     mobius_kappa_b = 0.5 / (b * (m5 + 4.) + 1.);
     mobius_kappa_c = 0.5 / (c * (m5 + 4.) - 1.);
 
@@ -93,7 +93,7 @@ namespace quda {
 
   // Modification for the 4D preconditioned Mobius domain wall operator
   void DiracMobius::Dslash4Xpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                const ColorSpinorField &x, const double &k) const
+                                const ColorSpinorField &x, const real_t &k) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -105,7 +105,7 @@ namespace quda {
   }
 
   void DiracMobius::Dslash4preXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                   const double &k) const
+                                   const real_t &k) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -122,7 +122,7 @@ namespace quda {
 
   // The xpay operator bakes in a factor of kappa_b^2
   void DiracMobius::Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                const double &k) const
+                                const real_t &k) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -141,7 +141,7 @@ namespace quda {
     checkFullSpinor(out, in);
 
     // zMobius breaks the following code. Refer to the zMobius check in DiracMobius::DiracMobius(param)
-    double mobius_kappa_b = 0.5 / (b_5[0].real() * (4.0 + m5) + 1.0);
+    real_t mobius_kappa_b = 0.5 / (b_5[0].real() * (4.0 + m5) + 1.0);
     auto tmp = getFieldTmp(in);
 
     // cannot use Xpay variants since it will scale incorrectly for this operator
@@ -230,7 +230,7 @@ namespace quda {
 
   // The xpay operator bakes in a factor of kappa_b^2
   void DiracMobiusPC::M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                const double &k) const
+                                const real_t &k) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -282,7 +282,7 @@ namespace quda {
   }
 
   void DiracMobiusPC::Dslash4M5invXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                       const ColorSpinorField &x, const double &a) const
+                                       const ColorSpinorField &x, const real_t &a) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -300,7 +300,7 @@ namespace quda {
   }
 
   void DiracMobiusPC::Dslash4M5preXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                       const ColorSpinorField &x, const double &a) const
+                                       const ColorSpinorField &x, const real_t &a) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -320,7 +320,7 @@ namespace quda {
   }
 
   void DiracMobiusPC::Dslash4XpayM5mob(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                       const ColorSpinorField &x, const double &a) const
+                                       const ColorSpinorField &x, const real_t &a) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -340,7 +340,7 @@ namespace quda {
   }
 
   void DiracMobiusPC::Dslash4M5preXpayM5mob(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                            const ColorSpinorField &x, const double &a) const
+                                            const ColorSpinorField &x, const real_t &a) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -362,7 +362,7 @@ namespace quda {
   }
 
   void DiracMobiusPC::Dslash4M5invXpayM5inv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                                            const ColorSpinorField &x, const double &a, ColorSpinorField &y) const
+                                            const ColorSpinorField &x, const real_t &a, ColorSpinorField &y) const
   {
     checkDWF(in, out);
     checkParitySpinor(in, out);
@@ -647,16 +647,16 @@ namespace quda {
 
     if (zMobius) { errorQuda("DiracMobiusEofa doesn't currently support zMobius.\n"); }
 
-    double b = b_5[0].real();
-    double c = c_5[0].real();
+    real_t b = b_5[0].real();
+    real_t c = c_5[0].real();
 
-    double alpha = b + c;
+    double alpha = double(b + c); // intentionally double not real_t
 
-    double eofa_norm = alpha * (mq3 - mq2) * std::pow(alpha + 1., 2. * Ls)
+    real_t eofa_norm = alpha * (mq3 - mq2) * std::pow(alpha + 1., 2. * Ls)
       / (std::pow(alpha + 1., Ls) + mq2 * std::pow(alpha - 1., Ls))
       / (std::pow(alpha + 1., Ls) + mq3 * std::pow(alpha - 1., Ls));
 
-    double N = (eofa_pm ? +1. : -1.) * (2. * this->eofa_shift * eofa_norm)
+    real_t N = (eofa_pm ? +1. : -1.) * (2. * this->eofa_shift * eofa_norm)
       * (std::pow(alpha + 1., Ls) + this->mq1 * std::pow(alpha - 1., Ls)) / (b * (m5 + 4.) + 1.);
 
     // Here the signs are somewhat mixed:
@@ -667,7 +667,7 @@ namespace quda {
         = N * std::pow(-1., s) * std::pow(alpha - 1., s) / std::pow(alpha + 1., Ls + s + 1);
     }
 
-    double factor = -mobius_kappa * mass;
+    real_t factor = -mobius_kappa * mass;
     if (eofa_pm) {
       // eofa_pm = plus
       // Computing x
@@ -727,7 +727,7 @@ namespace quda {
   }
 
   void DiracMobiusEofa::m5_eofa_xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                     double a) const
+                                     real_t a) const
   {
     if (in.Ndim() != 5 || out.Ndim() != 5) errorQuda("Wrong number of dimensions\n");
 
@@ -752,7 +752,7 @@ namespace quda {
     checkFullSpinor(out, in);
 
     // FIXME broken for variable coefficients
-    double mobius_kappa_b = 0.5 / (b_5[0].real() * (4.0 + m5) + 1.0);
+    real_t mobius_kappa_b = 0.5 / (b_5[0].real() * (4.0 + m5) + 1.0);
     auto tmp = getFieldTmp(in);
 
     // cannot use Xpay variants since it will scale incorrectly for this operator
@@ -822,7 +822,7 @@ namespace quda {
   }
 
   void DiracMobiusEofaPC::m5inv_eofa_xpay(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x,
-                                          double a) const
+                                          real_t a) const
   {
     if (in.Ndim() != 5 || out.Ndim() != 5) errorQuda("Wrong number of dimensions\n");
 
diff --git a/lib/dirac_staggered.cpp b/lib/dirac_staggered.cpp
index eb04c249b1..95a1f86ea7 100644
--- a/lib/dirac_staggered.cpp
+++ b/lib/dirac_staggered.cpp
@@ -30,7 +30,7 @@ namespace quda {
 
   void DiracStaggered::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, 
 				  const QudaParity parity, const ColorSpinorField &x,
-				  const double &k) const
+				  const real_t &k) const
   {    
     checkParitySpinor(in, out);
 
@@ -103,8 +103,8 @@ namespace quda {
     // do nothing
   }
 
-  void DiracStaggered::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double, double mass, double,
-                                      double, bool) const
+  void DiracStaggered::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t, real_t mass, real_t,
+                                      real_t, bool) const
   {
     if (T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD || T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD_DROP_LONG)
       errorQuda("The optimized Kahler-Dirac operator is not built through createCoarseOp");
@@ -115,7 +115,7 @@ namespace quda {
     StaggeredCoarseOp(Y, X, T, *gauge, *gauge, *gauge, mass, allow_truncation, QUDA_STAGGERED_DIRAC, QUDA_MATPC_INVALID);
   }
   
-  void DiracStaggered::SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const double, const double,
+  void DiracStaggered::SmearOp(ColorSpinorField &out, const ColorSpinorField &in, const real_t, const real_t,
                              const int t0, const QudaParity parity) const
   {
     checkSpinorAlias(in, out);
@@ -284,8 +284,8 @@ namespace quda {
 
   }
 
-  void DiracStaggeredPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double, double mass, double,
-                                        double, bool) const
+  void DiracStaggeredPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t, real_t mass, real_t,
+                                        real_t, bool) const
   {
     if (T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD || T.getTransferType() == QUDA_TRANSFER_OPTIMIZED_KD_DROP_LONG)
       errorQuda("The optimized Kahler-Dirac operator is not built through createCoarseOp");
diff --git a/lib/dirac_staggered_kd.cpp b/lib/dirac_staggered_kd.cpp
index db339402da..c08407c099 100644
--- a/lib/dirac_staggered_kd.cpp
+++ b/lib/dirac_staggered_kd.cpp
@@ -37,7 +37,7 @@ namespace quda
   }
 
   void DiracStaggeredKD::DslashXpay(ColorSpinorField &, const ColorSpinorField &, const QudaParity,
-                                    const ColorSpinorField &, const double &) const
+                                    const ColorSpinorField &, const real_t &) const
   {
     errorQuda("The staggered Kahler-Dirac operator does not have a single parity form");
   }
@@ -155,8 +155,8 @@ namespace quda
     Dirac::updateFields(gauge_in, nullptr, nullptr, nullptr);
   }
 
-  void DiracStaggeredKD::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double, double mass, double,
-                                        double, bool) const
+  void DiracStaggeredKD::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t, real_t mass, real_t,
+                                        real_t, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Staggered KD operators only support aggregation coarsening");
diff --git a/lib/dirac_twisted_clover.cpp b/lib/dirac_twisted_clover.cpp
index 25d91776a7..fce24c4308 100644
--- a/lib/dirac_twisted_clover.cpp
+++ b/lib/dirac_twisted_clover.cpp
@@ -71,7 +71,7 @@ namespace quda {
   }
 
   void DiracTwistedClover::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity,
-                                      const ColorSpinorField &x, const double &k) const
+                                      const ColorSpinorField &x, const real_t &k) const
   {
 
     if (in.TwistFlavor() == QUDA_TWIST_SINGLET) {
@@ -148,13 +148,13 @@ namespace quda {
     clover->prefetch(mem_space, stream, CloverPrefetchType::CLOVER_CLOVER_PREFETCH_TYPE);
   }
 
-  void DiracTwistedClover::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double,
-                                          double mu, double mu_factor, bool) const
+  void DiracTwistedClover::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t,
+                                          real_t mu, real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     CoarseOp(Y, X, T, *gauge, clover, kappa, mass, a, mu_factor, QUDA_TWISTED_CLOVER_DIRAC, QUDA_MATPC_INVALID);
   }
 
@@ -200,7 +200,7 @@ namespace quda {
   }
 
   void DiracTwistedCloverPC::WilsonDslashXpay(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity,
-                                              const ColorSpinorField &x, double k) const
+                                              const ColorSpinorField &x, real_t k) const
   {
     if (in.TwistFlavor() == QUDA_TWIST_SINGLET) {
       DiracWilson::DslashXpay(out, in, parity, x, k);
@@ -242,7 +242,7 @@ namespace quda {
 
   // xpay version of the above
   void DiracTwistedCloverPC::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-      const ColorSpinorField &x, const double &k) const
+      const ColorSpinorField &x, const real_t &k) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -271,7 +271,7 @@ namespace quda {
 
   void DiracTwistedCloverPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
-    double kappa2 = -kappa*kappa;
+    real_t kappa2 = -kappa*kappa;
     auto tmp = getFieldTmp(in);
 
     bool symmetric =(matpcType == QUDA_MATPC_EVEN_EVEN || matpcType == QUDA_MATPC_ODD_ODD) ? true : false;
@@ -366,13 +366,13 @@ namespace quda {
     TwistCloverInv(odd_bit ? x.Even() : x.Odd(), tmp, odd_bit ? QUDA_EVEN_PARITY : QUDA_ODD_PARITY);
   }
 
-  void DiracTwistedCloverPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double,
-                                            double mu, double mu_factor, bool) const
+  void DiracTwistedCloverPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t,
+                                            real_t mu, real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = -2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = -2.0 * kappa * mu * T.Vectors().TwistFlavor();
     CoarseOp(Y, X, T, *gauge, clover, kappa, mass, a, -mu_factor, QUDA_TWISTED_CLOVERPC_DIRAC, matpcType);
   }
 
diff --git a/lib/dirac_twisted_mass.cpp b/lib/dirac_twisted_mass.cpp
index 0c2911c851..1e2b6fafaf 100644
--- a/lib/dirac_twisted_mass.cpp
+++ b/lib/dirac_twisted_mass.cpp
@@ -61,7 +61,7 @@ namespace quda {
   }
 
   void DiracTwistedMass::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, QudaParity parity,
-      const ColorSpinorField &x, const double &k) const
+      const ColorSpinorField &x, const real_t &k) const
   {
 
     if (in.TwistFlavor() == QUDA_TWIST_SINGLET) {
@@ -121,13 +121,13 @@ namespace quda {
     // do nothing
   }
 
-  void DiracTwistedMass::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double,
-                                        double mu, double mu_factor, bool) const
+  void DiracTwistedMass::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t,
+                                        real_t mu, real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = 2.0 * kappa * mu;
+    real_t a = 2.0 * kappa * mu;
     CloverField *c = nullptr;
     CoarseOp(Y, X, T, *gauge, c, kappa, mass, a, mu_factor, QUDA_TWISTED_MASS_DIRAC, QUDA_MATPC_INVALID);
   }
@@ -168,17 +168,17 @@ namespace quda {
       errorQuda("Twist flavor not set %d\n", in.TwistFlavor());
 
     if (in.TwistFlavor() == QUDA_TWIST_SINGLET) {
-      double a = -2.0 * kappa * mu; // for inverse twist
-      double b = 1.0 / (1.0 + a * a);
+      real_t a = -2.0 * kappa * mu; // for inverse twist
+      real_t b = 1.0 / (1.0 + a * a);
 
       bool asymmetric
           = (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC || matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) && dagger;
       ApplyTwistedMassPreconditioned(out, in, *gauge, b, a, false, in, parity, dagger, asymmetric, commDim, profile);
       flops += 1392ll * in.Volume(); // flops numbers are approximate since they will vary depending on the dagger or not
-    } else {//TWIST doublet :
-      double a = 2.0 * kappa * mu;
-      double b = 2.0 * kappa * epsilon;
-      double c = 1.0 / (1.0 + a * a - b * b);
+    } else {//TWIST real_tt :
+      real_t a = 2.0 * kappa * mu;
+      real_t b = 2.0 * kappa * epsilon;
+      real_t c = 1.0 / (1.0 + a * a - b * b);
 
       bool asymmetric
           = (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC || matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) && dagger;
@@ -190,7 +190,7 @@ namespace quda {
 
   // xpay version of the above
   void DiracTwistedMassPC::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-				      const ColorSpinorField &x, const double &k) const
+				      const ColorSpinorField &x, const real_t &k) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -200,17 +200,17 @@ namespace quda {
       errorQuda("Twist flavor not set %d\n", in.TwistFlavor());
 
     if(in.TwistFlavor() == QUDA_TWIST_SINGLET) {
-      double a = -2.0 * kappa * mu; // for inverse twist
-      double b = k / (1.0 + a * a);
+      real_t a = -2.0 * kappa * mu; // for inverse twist
+      real_t b = k / (1.0 + a * a);
       // asymmetric should never be true here since we never need to apply 1 + k * A^{-1} D^\dagger
       bool asymmetric
           = (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC || matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) && dagger;
       ApplyTwistedMassPreconditioned(out, in, *gauge, b, a, true, x, parity, dagger, asymmetric, commDim, profile);
       flops += 1416ll * in.Volume(); // flops numbers are approximate since they will vary depending on the dagger or not
-    } else {//TWIST_DOUBLET:
-      double a = 2.0 * kappa * mu;
-      double b = 2.0 * kappa * epsilon;
-      double c = 1.0 / (1.0 + a * a - b * b);
+    } else {//TWIST_REAL_TT:
+      real_t a = 2.0 * kappa * mu;
+      real_t b = 2.0 * kappa * epsilon;
+      real_t c = 1.0 / (1.0 + a * a - b * b);
 
       bool asymmetric
           = (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC || matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) && dagger;
@@ -223,7 +223,7 @@ namespace quda {
 
   void DiracTwistedMassPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
-    double kappa2 = -kappa*kappa;
+    real_t kappa2 = -kappa*kappa;
     auto tmp = getFieldTmp(in);
 
     bool symmetric =(matpcType == QUDA_MATPC_EVEN_EVEN || matpcType == QUDA_MATPC_ODD_ODD) ? true : false;
@@ -286,12 +286,12 @@ namespace quda {
         errorQuda("MatPCType %d not valid for DiracTwistedMassPC", matpcType);
       }
 
-    } else { // doublet:
+    } else { // real_tt:
 
       // repurpose the preconditioned dslash as a vectorized operator: 1+kappa*D
-      double mu_ = mu;
+      real_t mu_ = mu;
       mu = 0.0;
-      double epsilon_ = epsilon;
+      real_t epsilon_ = epsilon;
       epsilon = 0.0;
 
       // we desire solution to full system
@@ -314,7 +314,7 @@ namespace quda {
       mu = mu_;
       epsilon = epsilon_;
 
-    } // end of doublet
+    } // end of real_tt
 
     if (symmetric) TwistInv(*src, tmp);
 
@@ -343,9 +343,9 @@ namespace quda {
         errorQuda("MatPCType %d not valid for DiracTwistedMassPC", matpcType);
       }
     } else { // twist doublet:
-      double mu_ = mu;
+      real_t mu_ = mu;
       mu = 0.0;
-      double epsilon_ = epsilon;
+      real_t epsilon_ = epsilon;
       epsilon = 0.0;
 
       if (matpcType == QUDA_MATPC_EVEN_EVEN ||  matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) {
@@ -365,13 +365,13 @@ namespace quda {
     TwistInv(odd_bit ? x.Even() : x.Odd(), tmp);
   }
 
-  void DiracTwistedMassPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double,
-                                          double mu, double mu_factor, bool) const
+  void DiracTwistedMassPC::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t,
+                                          real_t mu, real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = -2.0 * kappa * mu;
+    real_t a = -2.0 * kappa * mu;
     CloverField *c = nullptr;
     CoarseOp(Y, X, T, *gauge, c, kappa, mass, a, -mu_factor, QUDA_TWISTED_MASSPC_DIRAC, matpcType);
   }
diff --git a/lib/dirac_wilson.cpp b/lib/dirac_wilson.cpp
index 336d7d38be..be9e2ee8f5 100644
--- a/lib/dirac_wilson.cpp
+++ b/lib/dirac_wilson.cpp
@@ -32,7 +32,7 @@ namespace quda {
   }
 
   void DiracWilson::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
-                               const ColorSpinorField &x, const double &k) const
+                               const ColorSpinorField &x, const real_t &k) const
   {
     checkParitySpinor(in, out);
     checkSpinorAlias(in, out);
@@ -73,13 +73,13 @@ namespace quda {
     // do nothing
   }
 
-  void DiracWilson::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, double kappa, double, double mu,
-                                   double mu_factor, bool) const
+  void DiracWilson::createCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, real_t kappa, real_t, real_t mu,
+                                   real_t mu_factor, bool) const
   {
     if (T.getTransferType() != QUDA_TRANSFER_AGGREGATE)
       errorQuda("Wilson-type operators only support aggregation coarsening");
 
-    double a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
+    real_t a = 2.0 * kappa * mu * T.Vectors().TwistFlavor();
     CloverField *c = nullptr;
     CoarseOp(Y, X, T, *gauge, c, kappa, mass, a, mu_factor, QUDA_WILSON_DIRAC, QUDA_MATPC_INVALID);
   }
@@ -107,7 +107,7 @@ namespace quda {
 
   void DiracWilsonPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
-    double kappa2 = -kappa*kappa;
+    real_t kappa2 = -kappa*kappa;
     auto tmp = getFieldTmp(in);
 
     if (matpcType == QUDA_MATPC_EVEN_EVEN) {
diff --git a/lib/dslash5_domain_wall.cu b/lib/dslash5_domain_wall.cu
index 10e6ae8a48..4602891425 100644
--- a/lib/dslash5_domain_wall.cu
+++ b/lib/dslash5_domain_wall.cu
@@ -12,11 +12,11 @@ namespace quda
     ColorSpinorField &out;
     const ColorSpinorField &in;
     const ColorSpinorField &x;
-    double m_f;
-    double m_5;
-    const Complex *b_5;
-    const Complex *c_5;
-    double a;
+    real_t m_f;
+    real_t m_5;
+    const complex_t *b_5;
+    const complex_t *c_5;
+    real_t a;
     bool dagger;
     bool xpay;
     Dslash5Type type;
@@ -92,8 +92,8 @@ namespace quda
     }
 
   public:
-    Dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double m_f,
-            double m_5, const Complex *b_5, const Complex *c_5, double a, bool dagger, Dslash5Type type) :
+    Dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t m_f,
+            real_t m_5, const complex_t *b_5, const complex_t *c_5, real_t a, bool dagger, Dslash5Type type) :
       TunableKernel3D(in, in.X(4), in.SiteSubset()),
       out(out),
       in(in),
@@ -168,16 +168,16 @@ namespace quda
   // Apply the 5th dimension dslash operator to a colorspinor field
   // out = Dslash5*in
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double m_f,
-                    double m_5, const Complex *b_5, const Complex *c_5, double a, bool dagger, Dslash5Type type)
+  void ApplyDslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t m_f,
+                    real_t m_5, const complex_t *b_5, const complex_t *c_5, real_t a, bool dagger, Dslash5Type type)
   {
     if (in.PCType() != QUDA_4D_PC) errorQuda("Only 4-d preconditioned fields are supported");
     checkLocation(out, in, x); // check all locations match
     instantiate<Dslash5>(out, in, x, m_f, m_5, b_5, c_5, a, dagger, type);
   }
 #else
-  void ApplyDslash5(ColorSpinorField &, const ColorSpinorField &, const ColorSpinorField &, double,
-                    double, const Complex *, const Complex *, double, bool, Dslash5Type)
+  void ApplyDslash5(ColorSpinorField &, const ColorSpinorField &, const ColorSpinorField &, real_t,
+                    real_t, const complex_t *, const complex_t *, real_t, bool, Dslash5Type)
   {
     errorQuda("Domain wall dslash has not been built");
   }
diff --git a/lib/dslash5_mobius_eofa.cu b/lib/dslash5_mobius_eofa.cu
index f97ff5f80f..429850294a 100644
--- a/lib/dslash5_mobius_eofa.cu
+++ b/lib/dslash5_mobius_eofa.cu
@@ -15,21 +15,21 @@ namespace quda
       ColorSpinorField &out;
       const ColorSpinorField &in;
       const ColorSpinorField &x;
-      double m_f;
-      double m_5;
-      const Complex *b_5;
-      const Complex *c_5;
-      double a;
+      real_t m_f;
+      real_t m_5;
+      const complex_t *b_5;
+      const complex_t *c_5;
+      real_t a;
       bool eofa_pm;
-      double inv;
-      double kappa;
-      const double *eofa_u;
-      const double *eofa_x;
-      const double *eofa_y;
+      real_t inv;
+      real_t kappa;
+      const real_t *eofa_u;
+      const real_t *eofa_x;
+      const real_t *eofa_y;
       bool dagger;
       bool xpay;
       Dslash5Type type;
-      double sherman_morrison;
+      real_t sherman_morrison;
 
       static constexpr bool shared = true; // whether to use shared memory cache blocking for M5inv
 
@@ -83,10 +83,10 @@ namespace quda
       }
 
     public:
-      Dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const double m_f,
-              const double m_5, const Complex *b_5, const Complex *c_5, double a, bool eofa_pm, double inv,
-              double kappa, const double *eofa_u, const double *eofa_x, const double *eofa_y,
-              double sherman_morrison, bool dagger, Dslash5Type type) :
+      Dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, const real_t m_f,
+              const real_t m_5, const complex_t *b_5, const complex_t *c_5, real_t a, bool eofa_pm, real_t inv,
+              real_t kappa, const real_t *eofa_u, const real_t *eofa_x, const real_t *eofa_y,
+              real_t sherman_morrison, bool dagger, Dslash5Type type) :
         TunableKernel3D(in, in.X(4), in.SiteSubset()),
         out(out),
         in(in),
@@ -170,19 +170,19 @@ namespace quda
     // Apply the 5th dimension dslash operator to a colorspinor field
     // out = Dslash5*in
 #ifdef GPU_DOMAIN_WALL_DIRAC
-    void apply_dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, double m_f,
-                       double m_5, const Complex *b_5, const Complex *c_5, double a, int eofa_pm, double inv,
-                       double kappa, const double *eofa_u, const double *eofa_x, const double *eofa_y,
-                       double sherman_morrison, bool dagger, Dslash5Type type)
+    void apply_dslash5(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &x, real_t m_f,
+                       real_t m_5, const complex_t *b_5, const complex_t *c_5, real_t a, int eofa_pm, real_t inv,
+                       real_t kappa, const real_t *eofa_u, const real_t *eofa_x, const real_t *eofa_y,
+                       real_t sherman_morrison, bool dagger, Dslash5Type type)
     {
       checkLocation(out, in, x); // check all locations match
       instantiate<Dslash5>(out, in, x, m_f, m_5, b_5, c_5, a, eofa_pm, inv, kappa, eofa_u, eofa_x, eofa_y,
                            sherman_morrison, dagger, type);
     }
 #else
-    void apply_dslash5(ColorSpinorField &, const ColorSpinorField &, const ColorSpinorField &, double,
-                       double, const Complex *, const Complex *, double, int, double,
-                       double, const double *, const double *, const double *, double, bool, Dslash5Type)
+    void apply_dslash5(ColorSpinorField &, const ColorSpinorField &, const ColorSpinorField &, real_t,
+                       real_t, const complex_t *, const complex_t *, real_t, int, real_t,
+                       real_t, const real_t *, const real_t *, const real_t *, real_t, bool, Dslash5Type)
     {
       errorQuda("Mobius EOFA dslash has not been built");
     }
diff --git a/lib/dslash_clover_helper.cu b/lib/dslash_clover_helper.cu
index accc50d31a..9da207ec90 100644
--- a/lib/dslash_clover_helper.cu
+++ b/lib/dslash_clover_helper.cu
@@ -59,9 +59,9 @@ namespace quda {
     ColorSpinorField &out;
     const ColorSpinorField &in;
     const CloverField &clover;
-    double kappa;
-    double mu;
-    double epsilon;
+    real_t kappa;
+    real_t mu;
+    real_t epsilon;
     int parity;
     bool inverse;
     int dagger;
@@ -75,7 +75,7 @@ namespace quda {
 
   public:
     TwistClover(ColorSpinorField &out, const ColorSpinorField &in, const CloverField &clover,
-                double kappa, double mu, double epsilon, int parity, int dagger, QudaTwistGamma5Type twist) :
+                real_t kappa, real_t mu, real_t epsilon, int parity, int dagger, QudaTwistGamma5Type twist) :
       TunableKernel3D(in, in.TwistFlavor(), in.SiteSubset()),
       out(out),
       in(in),
@@ -129,13 +129,13 @@ namespace quda {
 #ifdef GPU_TWISTED_CLOVER_DIRAC
   //Apply the twisted-clover matrix field to a colorspinor field
   void ApplyTwistClover(ColorSpinorField &out, const ColorSpinorField &in, const CloverField &clover,
-			double kappa, double mu, double epsilon, int parity, int dagger, QudaTwistGamma5Type twist)
+			real_t kappa, real_t mu, real_t epsilon, int parity, int dagger, QudaTwistGamma5Type twist)
   {
     instantiate<TwistClover>(out, in, clover, kappa, mu, epsilon, parity, dagger, twist);
   }
 #else
   void ApplyTwistClover(ColorSpinorField &, const ColorSpinorField &, const CloverField &,
-			double, double, double, int, int, QudaTwistGamma5Type)
+			real_t, real_t, real_t, int, int, QudaTwistGamma5Type)
   {
     errorQuda("Twisted-clover dslash has not been built");
   }
diff --git a/lib/dslash_coarse.hpp b/lib/dslash_coarse.hpp
index fd755394b4..b5fdf7acf4 100644
--- a/lib/dslash_coarse.hpp
+++ b/lib/dslash_coarse.hpp
@@ -22,7 +22,7 @@ namespace quda {
     cvector_ref<const ColorSpinorField> &inB;
     const GaugeField &Y;
     const GaugeField &X;
-    const double kappa;
+    const real_t kappa;
     const int parity;
     const int nParity;
     const int nSrc;
@@ -142,7 +142,7 @@ namespace quda {
 
   public:
     DslashCoarse(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
-                 cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, double kappa,
+                 cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, real_t kappa,
                  int parity, MemoryLocation *halo_location, const ColorSpinorField &halo) :
       TunableKernel3D(out[0], out[0].SiteSubset() * out.size(), 1),
       out(out),
@@ -286,7 +286,7 @@ namespace quda {
             typename ghostFloat, bool dagger, int coarseColor, bool use_mma, int nVec>
   inline void ApplyCoarse(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
                           cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X,
-                          double kappa, int parity, bool dslash, bool clover, DslashType type,
+                          real_t kappa, int parity, bool dslash, bool clover, DslashType type,
                           MemoryLocation *halo_location, const ColorSpinorField &halo)
   {
     if (Y.FieldOrder() != X.FieldOrder())
@@ -386,7 +386,7 @@ namespace quda {
     const ColorSpinorField &halo;
     const GaugeField &Y;
     const GaugeField &X;
-    double kappa;
+    real_t kappa;
     int parity;
     bool dslash;
     bool clover;
@@ -396,7 +396,7 @@ namespace quda {
 
     DslashCoarseLaunch(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
                        cvector_ref<const ColorSpinorField> &inB, const ColorSpinorField &halo, const GaugeField &Y,
-                       const GaugeField &X, double kappa, int parity, bool dslash, bool clover, const int *commDim,
+                       const GaugeField &X, real_t kappa, int parity, bool dslash, bool clover, const int *commDim,
                        QudaPrecision halo_precision) :
       out(out),
       inA(inA),
diff --git a/lib/dslash_coarse.in.cpp b/lib/dslash_coarse.in.cpp
index d2a51102e8..642292b579 100644
--- a/lib/dslash_coarse.in.cpp
+++ b/lib/dslash_coarse.in.cpp
@@ -38,7 +38,7 @@ namespace quda
 
   template <bool use_mma, int Nc, int... N>
   void ApplyCoarse(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
-                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, double kappa,
+                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, real_t kappa,
                    int parity, bool dslash, bool clover, bool dagger, const int *commDim, QudaPrecision halo_precision,
                    IntList<Nc, N...>)
   {
@@ -97,7 +97,7 @@ namespace quda
   //  out(x) = M^dagger*in = X^dagger*in - kappa*\sum_mu Y^\dagger_{-\mu}(x)in(x+mu) + Y_mu(x-mu)in(x-mu)
   //  Uses the kappa normalization for the Wilson operator.
   void ApplyCoarse(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
-                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, double kappa,
+                   cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X, real_t kappa,
                    int parity, bool dslash, bool clover, bool dagger, const int *commDim, QudaPrecision halo_precision,
                    bool use_mma)
   {
diff --git a/lib/dslash_coarse.in.cu b/lib/dslash_coarse.in.cu
index 0db5524f73..10999b03a7 100644
--- a/lib/dslash_coarse.in.cu
+++ b/lib/dslash_coarse.in.cu
@@ -12,7 +12,7 @@ namespace quda {
   template<>
   void ApplyCoarse<dagger, coarseColor>(cvector_ref<ColorSpinorField> &out, cvector_ref<const ColorSpinorField> &inA,
                                         cvector_ref<const ColorSpinorField> &inB, const GaugeField &Y, const GaugeField &X,
-                                        double kappa, int parity, bool dslash, bool clover, const int *commDim, QudaPrecision halo_precision)
+                                        real_t kappa, int parity, bool dslash, bool clover, const int *commDim, QudaPrecision halo_precision)
   {
     if constexpr (is_enabled_multigrid()) {
       // create a halo ndim+1 field for batched comms
diff --git a/lib/dslash_domain_wall_4d.cu b/lib/dslash_domain_wall_4d.cu
index a41285dc14..fea6405646 100644
--- a/lib/dslash_domain_wall_4d.cu
+++ b/lib/dslash_domain_wall_4d.cu
@@ -38,8 +38,8 @@ namespace quda
 
   template <typename Float, int nColor, QudaReconstructType recon> struct DomainWall4DApply {
 
-    inline DomainWall4DApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                             double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x, int parity,
+    inline DomainWall4DApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                             real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x, int parity,
                              bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -54,15 +54,15 @@ namespace quda
   // Apply the 4-d preconditioned domain-wall Dslash operator
   // out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
 #if defined(GPU_DOMAIN_WALL_DIRAC) || defined(GPU_NDEG_TWISTED_CLOVER_DIRAC)
-  void ApplyDomainWall4D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_5,
-                         const Complex *b_5, const Complex *c_5, const ColorSpinorField &x, int parity, bool dagger,
+  void ApplyDomainWall4D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_5,
+                         const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x, int parity, bool dagger,
                          const int *comm_override, TimeProfile &profile)
   {
     instantiate<DomainWall4DApply>(out, in, U, a, m_5, b_5, c_5, x, parity, dagger, comm_override, profile);
   }
 #else
-  void ApplyDomainWall4D(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double, double,
-                         const Complex *, const Complex *, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
+  void ApplyDomainWall4D(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t, real_t,
+                         const complex_t *, const complex_t *, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_fused_m5.hpp b/lib/dslash_domain_wall_4d_fused_m5.hpp
index 3ba9e77c39..de18431bf9 100644
--- a/lib/dslash_domain_wall_4d_fused_m5.hpp
+++ b/lib/dslash_domain_wall_4d_fused_m5.hpp
@@ -130,9 +130,9 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct DomainWall4DApplyFusedM5 {
 
     template <Dslash5Type dslash5_type_impl, Dslash5Type... N>
-    inline DomainWall4DApplyFusedM5(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                    double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                    ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+    inline DomainWall4DApplyFusedM5(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                    real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                    ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                     Dslash5TypeList<dslash5_type_impl, N...>, TimeProfile &profile)
     {
 #ifdef NVSHMEM_COMMS
diff --git a/lib/dslash_domain_wall_4d_m5inv.cu b/lib/dslash_domain_wall_4d_m5inv.cu
index a206a0ff75..10d85b94be 100644
--- a/lib/dslash_domain_wall_4d_m5inv.cu
+++ b/lib/dslash_domain_wall_4d_m5inv.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5inv
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                              double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                              real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                               TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::M5_INV_MOBIUS>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5inv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                              double, const Complex *, const Complex *, const ColorSpinorField &,
-                              ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5inv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                              real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                              ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_m5inv_m5inv.cu b/lib/dslash_domain_wall_4d_m5inv_m5inv.cu
index c9e580acf0..7fdbcea5d5 100644
--- a/lib/dslash_domain_wall_4d_m5inv_m5inv.cu
+++ b/lib/dslash_domain_wall_4d_m5inv_m5inv.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5inv + m5inv-dagger
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5invM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5invM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::M5_INV_MOBIUS_M5_INV_DAG>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5invM5inv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                                   double, const Complex *, const Complex *, const ColorSpinorField &,
-                                   ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5invM5inv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                                   real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                                   ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_m5inv_m5pre.cu b/lib/dslash_domain_wall_4d_m5inv_m5pre.cu
index 2c71b958a2..4eea37f2ba 100644
--- a/lib/dslash_domain_wall_4d_m5inv_m5pre.cu
+++ b/lib/dslash_domain_wall_4d_m5inv_m5pre.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5inv + m5pre
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5invM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5invM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::M5_INV_MOBIUS_M5_PRE>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5invM5pre(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                                   double, const Complex *, const Complex *, const ColorSpinorField &,
-                                   ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5invM5pre(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                                   real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                                   ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_m5mob.cu b/lib/dslash_domain_wall_4d_m5mob.cu
index c05edcb4fa..d0e3a19865 100644
--- a/lib/dslash_domain_wall_4d_m5mob.cu
+++ b/lib/dslash_domain_wall_4d_m5mob.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                              double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                              real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                               TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::DSLASH5_MOBIUS>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5mob(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                              double, const Complex *, const Complex *, const ColorSpinorField &,
-                              ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5mob(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                              real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                              ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_m5pre.cu b/lib/dslash_domain_wall_4d_m5pre.cu
index 12d43adb8f..42efd3704a 100644
--- a/lib/dslash_domain_wall_4d_m5pre.cu
+++ b/lib/dslash_domain_wall_4d_m5pre.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5pre
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                              double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5pre(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                              real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                              ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                               TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::DSLASH5_MOBIUS_PRE>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5pre(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                              double, const Complex *, const Complex *, const ColorSpinorField &,
-                              ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5pre(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                              real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                              ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_m5pre_m5inv.cu b/lib/dslash_domain_wall_4d_m5pre_m5inv.cu
index 4b9fbac5e6..c797ebc821 100644
--- a/lib/dslash_domain_wall_4d_m5pre_m5inv.cu
+++ b/lib/dslash_domain_wall_4d_m5pre_m5inv.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5pre + m5inv
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5preM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5preM5inv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::M5_PRE_MOBIUS_M5_INV>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5preM5inv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                                   double, const Complex *, const Complex *, const ColorSpinorField &,
-                                   ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5preM5inv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                                   real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                                   ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_4d_m5pre_m5mob.cu b/lib/dslash_domain_wall_4d_m5pre_m5mob.cu
index 04d39856eb..6126c21b69 100644
--- a/lib/dslash_domain_wall_4d_m5pre_m5mob.cu
+++ b/lib/dslash_domain_wall_4d_m5pre_m5mob.cu
@@ -11,9 +11,9 @@ namespace quda
   //   i.e. out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // ... and then m5pre + m5
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall4DM5preM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                   double m_5, const Complex *b_5, const Complex *c_5, const ColorSpinorField &x,
-                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, double m_f,
+  void ApplyDomainWall4DM5preM5mob(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                   real_t m_5, const complex_t *b_5, const complex_t *c_5, const ColorSpinorField &x,
+                                   ColorSpinorField &y, int parity, bool dagger, const int *comm_override, real_t m_f,
                                    TimeProfile &profile)
   {
     auto dummy_list = Dslash5TypeList<Dslash5Type::DSLASH5_MOBIUS_PRE_M5_MOB>();
@@ -21,9 +21,9 @@ namespace quda
                                           dummy_list, profile);
   }
 #else
-  void ApplyDomainWall4DM5preM5mob(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                                   double, const Complex *, const Complex *, const ColorSpinorField &,
-                                   ColorSpinorField &, int, bool, const int *, double, TimeProfile &)
+  void ApplyDomainWall4DM5preM5mob(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                                   real_t, const complex_t *, const complex_t *, const ColorSpinorField &,
+                                   ColorSpinorField &, int, bool, const int *, real_t, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
   }
diff --git a/lib/dslash_domain_wall_5d.cu b/lib/dslash_domain_wall_5d.cu
index 38b2aea600..6d07ac6425 100644
--- a/lib/dslash_domain_wall_5d.cu
+++ b/lib/dslash_domain_wall_5d.cu
@@ -65,11 +65,11 @@ namespace quda
 
   template <typename Float, int nColor, QudaReconstructType recon> struct DomainWall5DApply {
 
-    inline DomainWall5DApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-        double m_f, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
+    inline DomainWall5DApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+        real_t m_f, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 5;
-      DomainWall5DArg<Float, nColor, nDim, recon> arg(out, in, U, a, m_f, a != 0.0, x, parity, dagger, comm_override);
+      DomainWall5DArg<Float, nColor, nDim, recon> arg(out, in, U, a, m_f, a != real_t(0.0), x, parity, dagger, comm_override);
       DomainWall5D<decltype(arg)> dwf(arg, out, in);
 
       dslash::DslashPolicyTune<decltype(dwf)> policy(dwf, in, in.getDslashConstant().volume_4d_cb, in.getDslashConstant().ghostFaceCB, profile);
@@ -79,13 +79,13 @@ namespace quda
   // Apply the 4-d preconditioned domain-wall Dslash operator
   // out(x) = M*in = in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
 #ifdef GPU_DOMAIN_WALL_DIRAC
-  void ApplyDomainWall5D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double m_f,
+  void ApplyDomainWall5D(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t m_f,
       const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<DomainWall5DApply>(out, in, U, a, m_f, x, parity, dagger, comm_override, profile);
   }
 #else
-  void ApplyDomainWall5D(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double, double,
+  void ApplyDomainWall5D(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t, real_t,
                          const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Domain-wall dslash has not been built");
diff --git a/lib/dslash_gamma_helper.cu b/lib/dslash_gamma_helper.cu
index 2e76504afd..17143f0d32 100644
--- a/lib/dslash_gamma_helper.cu
+++ b/lib/dslash_gamma_helper.cu
@@ -44,16 +44,16 @@ namespace quda {
     ColorSpinorField &out;
     const ColorSpinorField &in;
     int d;
-    double kappa;
-    double mu;
-    double epsilon;
+    real_t kappa;
+    real_t mu;
+    real_t epsilon;
     int dagger;
     QudaTwistGamma5Type type;
     unsigned int minThreads() const { return in.VolumeCB() / (in.Ndim() == 5 ? in.X(4) : 1); }
 
   public:
-    TwistGammaApply(ColorSpinorField &out, const ColorSpinorField &in, int d, double kappa, double mu,
-                    double epsilon, int dagger, QudaTwistGamma5Type type) :
+    TwistGammaApply(ColorSpinorField &out, const ColorSpinorField &in, int d, real_t kappa, real_t mu,
+                    real_t epsilon, int dagger, QudaTwistGamma5Type type) :
       TunableKernel2D(in, in.SiteSubset()),
       out(out),
       in(in),
@@ -83,12 +83,12 @@ namespace quda {
   //Apply the Gamma matrix to a colorspinor field
   //out(x) = gamma_d*in
 #ifdef GPU_TWISTED_MASS_DIRAC
-  void ApplyTwistGamma(ColorSpinorField &out, const ColorSpinorField &in, int d, double kappa, double mu, double epsilon, int dagger, QudaTwistGamma5Type type)
+  void ApplyTwistGamma(ColorSpinorField &out, const ColorSpinorField &in, int d, real_t kappa, real_t mu, real_t epsilon, int dagger, QudaTwistGamma5Type type)
   {
     instantiate<TwistGammaApply>(out, in, d, kappa, mu, epsilon, dagger, type);
   }
 #else
-  void ApplyTwistGamma(ColorSpinorField &, const ColorSpinorField &, int, double, double, double, int, QudaTwistGamma5Type)
+  void ApplyTwistGamma(ColorSpinorField &, const ColorSpinorField &, int, real_t, real_t, real_t, int, QudaTwistGamma5Type)
   {
     errorQuda("Twisted mass dslash has not been built");
   }
diff --git a/lib/dslash_improved_staggered.cu b/lib/dslash_improved_staggered.cu
index 41c3327510..a62e3f3fef 100644
--- a/lib/dslash_improved_staggered.cu
+++ b/lib/dslash_improved_staggered.cu
@@ -146,7 +146,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon_l> struct ImprovedStaggeredApply {
 
     inline ImprovedStaggeredApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &L,
-                                  const GaugeField &U, double a, const ColorSpinorField &x, int parity, bool dagger,
+                                  const GaugeField &U, real_t a, const ColorSpinorField &x, int parity, bool dagger,
                                   const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -162,7 +162,7 @@ namespace quda
 
 #ifdef GPU_STAGGERED_DIRAC
   void ApplyImprovedStaggered(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                              const GaugeField &L, double a, const ColorSpinorField &x, int parity, bool dagger,
+                              const GaugeField &L, real_t a, const ColorSpinorField &x, int parity, bool dagger,
                               const int *comm_override, TimeProfile &profile)
   {
     for (int i = 0; i < 4; i++) {
@@ -178,7 +178,7 @@ namespace quda
   }
 #else
   void ApplyImprovedStaggered(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                              const GaugeField &, double, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
+                              const GaugeField &, real_t, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Staggered dslash has not been built");
   }
diff --git a/lib/dslash_mdw_fused.in.cu b/lib/dslash_mdw_fused.in.cu
index bf0639cab3..cb6fa9f721 100644
--- a/lib/dslash_mdw_fused.in.cu
+++ b/lib/dslash_mdw_fused.in.cu
@@ -11,8 +11,8 @@ namespace quda
 #if defined(GPU_DOMAIN_WALL_DIRAC) && defined(QUDA_MMA_AVAILABLE)
     template <>
     void apply_fused_dslash_impl<Ls>(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                     ColorSpinorField &y, const ColorSpinorField &x, double m_f, double m_5,
-                                     const Complex *b_5, const Complex *c_5, bool dagger, int parity, int shift[4],
+                                     ColorSpinorField &y, const ColorSpinorField &x, real_t m_f, real_t m_5,
+                                     const complex_t *b_5, const complex_t *c_5, bool dagger, int parity, int shift[4],
                                      int halo_shift[4], MdwfFusedDslashType type)
     {
       checkLocation(out, in); // check all locations match
@@ -22,8 +22,8 @@ namespace quda
 #else
     template <>
     void apply_fused_dslash_impl<Ls>(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                     ColorSpinorField &, const ColorSpinorField &, double, double, const Complex *,
-                                     const Complex *, bool, int, int[4], int[4], MdwfFusedDslashType)
+                                     ColorSpinorField &, const ColorSpinorField &, real_t, real_t, const complex_t *,
+                                     const complex_t *, bool, int, int[4], int[4], MdwfFusedDslashType)
     {
       errorQuda("Domain wall dslash with tensor cores has not been built");
     }
diff --git a/lib/dslash_mdw_fused.in.hpp b/lib/dslash_mdw_fused.in.hpp
index c97922a776..250383a2f9 100644
--- a/lib/dslash_mdw_fused.in.hpp
+++ b/lib/dslash_mdw_fused.in.hpp
@@ -17,8 +17,8 @@ namespace quda
 
     template <int Ls>
     void apply_fused_dslash_impl(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                 ColorSpinorField &y, const ColorSpinorField &x, double m_f, double m_5,
-                                 const Complex *b_5, const Complex *c_5, bool dagger, int parity, int shift[4],
+                                 ColorSpinorField &y, const ColorSpinorField &x, real_t m_f, real_t m_5,
+                                 const complex_t *b_5, const complex_t *c_5, bool dagger, int parity, int shift[4],
                                  int halo_shift[4], MdwfFusedDslashType type);
 
     template <int...> struct IntList {
@@ -26,8 +26,8 @@ namespace quda
 
     template <int Ls, int... N>
     void apply_fused_dslash_list(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                 ColorSpinorField &y, const ColorSpinorField &x, double m_f, double m_5,
-                                 const Complex *b_5, const Complex *c_5, bool dagger, int parity, int shift[4],
+                                 ColorSpinorField &y, const ColorSpinorField &x, real_t m_f, real_t m_5,
+                                 const complex_t *b_5, const complex_t *c_5, bool dagger, int parity, int shift[4],
                                  int halo_shift[4], MdwfFusedDslashType type, IntList<Ls, N...>)
     {
       if (in.X(4) == Ls) {
@@ -43,8 +43,8 @@ namespace quda
 
 #if defined(GPU_DOMAIN_WALL_DIRAC) && defined(QUDA_MMA_AVAILABLE)
     void inline apply_fused_dslash(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                   ColorSpinorField &y, const ColorSpinorField &x, double m_f, double m_5,
-                                   const Complex *b_5, const Complex *c_5, bool dagger, int parity, int shift[4],
+                                   ColorSpinorField &y, const ColorSpinorField &x, real_t m_f, real_t m_5,
+                                   const complex_t *b_5, const complex_t *c_5, bool dagger, int parity, int shift[4],
                                    int halo_shift[4], MdwfFusedDslashType type)
     {
       // clang-format off
@@ -54,8 +54,8 @@ namespace quda
     }
 #else
     void inline apply_fused_dslash(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                   ColorSpinorField &, const ColorSpinorField &, double, double,
-                                   const Complex *, const Complex *, bool, int, int[4],
+                                   ColorSpinorField &, const ColorSpinorField &, real_t, real_t,
+                                   const complex_t *, const complex_t *, bool, int, int[4],
                                    int[4], MdwfFusedDslashType)
     {
       errorQuda("Domain wall dslash with tensor cores has not been built");
diff --git a/lib/dslash_mdw_fused_impl.hpp b/lib/dslash_mdw_fused_impl.hpp
index 4a09d35123..f7727b69d8 100644
--- a/lib/dslash_mdw_fused_impl.hpp
+++ b/lib/dslash_mdw_fused_impl.hpp
@@ -24,10 +24,10 @@ namespace quda
       const GaugeField &U;
       ColorSpinorField &y;
       const ColorSpinorField &x;
-      double m_f;
-      double m_5;
-      const Complex *b_5;
-      const Complex *c_5;
+      real_t m_f;
+      real_t m_5;
+      const complex_t *b_5;
+      const complex_t *c_5;
       int parity;
       int dim[4];
       int *shift;
@@ -132,7 +132,7 @@ namespace quda
 
     public:
       FusedDslash(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, ColorSpinorField &y,
-                  const ColorSpinorField &x, double m_f, double m_5, const Complex *b_5, const Complex *c_5,
+                  const ColorSpinorField &x, real_t m_f, real_t m_5, const complex_t *b_5, const complex_t *c_5,
                   bool dagger, int parity, int shift[4], int halo_shift[4], MdwfFusedDslashType type) :
         TunableGridStrideKernel2D(in, x.X(4)),
         out(out),
diff --git a/lib/dslash_ndeg_twisted_clover.cu b/lib/dslash_ndeg_twisted_clover.cu
index 2081320192..ecd59ee2fa 100644
--- a/lib/dslash_ndeg_twisted_clover.cu
+++ b/lib/dslash_ndeg_twisted_clover.cu
@@ -76,8 +76,8 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct NdegTwistedCloverApply {
     
     inline NdegTwistedCloverApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                  const CloverField &A, double a,
-                                  double b, double c, const ColorSpinorField &x, int parity, bool dagger,
+                                  const CloverField &A, real_t a,
+                                  real_t b, real_t c, const ColorSpinorField &x, int parity, bool dagger,
                                   const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -91,15 +91,15 @@ namespace quda
 
 #ifdef GPU_NDEG_TWISTED_CLOVER_DIRAC
   void ApplyNdegTwistedClover(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-                              double a, double b,
-                              double c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+                              real_t a, real_t b,
+                              real_t c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                               TimeProfile &profile)
   {
     instantiate<NdegTwistedCloverApply>(out, in, U, A, a, b, c, x, parity, dagger, comm_override, profile);
   }
 #else
   void ApplyNdegTwistedClover(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, const CloverField &,
-                              double, double, double, const ColorSpinorField &, int, bool, const int *,
+                              real_t, real_t, real_t, const ColorSpinorField &, int, bool, const int *,
                               TimeProfile &)
   {
     errorQuda("Non-degenerate twisted-clover dslash has not been built");
diff --git a/lib/dslash_ndeg_twisted_clover_preconditioned.cu b/lib/dslash_ndeg_twisted_clover_preconditioned.cu
index a852529a3b..12ded23e35 100644
--- a/lib/dslash_ndeg_twisted_clover_preconditioned.cu
+++ b/lib/dslash_ndeg_twisted_clover_preconditioned.cu
@@ -99,7 +99,7 @@ namespace quda
     
     inline NdegTwistedCloverPreconditionedApply(ColorSpinorField &out, const ColorSpinorField &in,
                                                 const GaugeField &U, const CloverField &A,
-                                                double a, double b, double c, bool xpay,
+                                                real_t a, real_t b, real_t c, bool xpay,
                                                 const ColorSpinorField &x, int parity, bool dagger,
                                                 const int *comm_override, TimeProfile &profile)
     {
@@ -114,7 +114,7 @@ namespace quda
 #ifdef GPU_NDEG_TWISTED_CLOVER_DIRAC
   void ApplyNdegTwistedCloverPreconditioned(ColorSpinorField &out, const ColorSpinorField &in,
                                             const GaugeField &U, const CloverField &A,
-                                            double a, double b, double c, bool xpay,
+                                            real_t a, real_t b, real_t c, bool xpay,
                                             const ColorSpinorField &x, int parity, bool dagger,
                                             const int *comm_override, TimeProfile &profile)
   {
@@ -122,7 +122,7 @@ namespace quda
   }
 #else
   void ApplyNdegTwistedCloverPreconditioned(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, const CloverField &,
-                                            double, double, double, bool, const ColorSpinorField &, int, bool,
+                                            real_t, real_t, real_t, bool, const ColorSpinorField &, int, bool,
                                             const int *, TimeProfile &)
   {
     errorQuda("Non-degenerate preconditioned twisted-clover dslash has not been built");
diff --git a/lib/dslash_ndeg_twisted_mass.cu b/lib/dslash_ndeg_twisted_mass.cu
index 7ae48e0acf..3e17989393 100644
--- a/lib/dslash_ndeg_twisted_mass.cu
+++ b/lib/dslash_ndeg_twisted_mass.cu
@@ -53,8 +53,8 @@ namespace quda
 
   template <typename Float, int nColor, QudaReconstructType recon> struct NdegTwistedMassApply {
 
-    inline NdegTwistedMassApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-                                double b, double c, const ColorSpinorField &x, int parity, bool dagger,
+    inline NdegTwistedMassApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+                                real_t b, real_t c, const ColorSpinorField &x, int parity, bool dagger,
                                 const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -66,15 +66,15 @@ namespace quda
   };
 
 #ifdef GPU_NDEG_TWISTED_MASS_DIRAC
-  void ApplyNdegTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
-                            double c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+  void ApplyNdegTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
+                            real_t c, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                             TimeProfile &profile)
   {
     instantiate<NdegTwistedMassApply>(out, in, U, a, b, c, x, parity, dagger, comm_override, profile);
   }
 #else
-  void ApplyNdegTwistedMass(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double, double,
-                            double, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
+  void ApplyNdegTwistedMass(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t, real_t,
+                            real_t, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Non-degenerate twisted-mass dslash has not been built");
   }
diff --git a/lib/dslash_ndeg_twisted_mass_preconditioned.cu b/lib/dslash_ndeg_twisted_mass_preconditioned.cu
index d076dea140..c61d55d6d1 100644
--- a/lib/dslash_ndeg_twisted_mass_preconditioned.cu
+++ b/lib/dslash_ndeg_twisted_mass_preconditioned.cu
@@ -95,7 +95,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct NdegTwistedMassPreconditionedApply {
 
     inline NdegTwistedMassPreconditionedApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-        double a, double b, double c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
+        real_t a, real_t b, real_t c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
         const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -118,7 +118,7 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator, with a = -kappa.
 #ifdef GPU_NDEG_TWISTED_MASS_DIRAC
   void ApplyNdegTwistedMassPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-      double a, double b, double c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
+      real_t a, real_t b, real_t c, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
       const int *comm_override, TimeProfile &profile)
   {
     instantiate<NdegTwistedMassPreconditionedApply>(
@@ -126,7 +126,7 @@ namespace quda
   }
 #else
   void ApplyNdegTwistedMassPreconditioned(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                          double, double, double, bool, const ColorSpinorField &, int, bool, bool,
+                                          real_t, real_t, real_t, bool, const ColorSpinorField &, int, bool, bool,
                                           const int *, TimeProfile &)
   {
     errorQuda("Non-degenerate preconditioned twisted-mass dslash has not been built");
diff --git a/lib/dslash_pack2.cu b/lib/dslash_pack2.cu
index 1a20aa153d..fd6bb4af1e 100644
--- a/lib/dslash_pack2.cu
+++ b/lib/dslash_pack2.cu
@@ -63,9 +63,9 @@ protected:
     const int parity;
     const int nParity;
     int work_items;
-    const double a;
-    const double b;
-    const double c;
+    const real_t a;
+    const real_t b;
+    const real_t c;
     int twist; // only has meaning for nSpin=4
 #ifdef NVSHMEM_COMMS
     const int shmem;
@@ -169,8 +169,8 @@ protected:
     }
 
 public:
-  Pack(void *ghost[], const ColorSpinorField &in, MemoryLocation location, int nFace, bool dagger, int parity, double a,
-       double b, double c,
+  Pack(void *ghost[], const ColorSpinorField &in, MemoryLocation location, int nFace, bool dagger, int parity, real_t a,
+       real_t b, real_t c,
 #ifdef NVSHMEM_COMMS
        int shmem) :
 #else
@@ -371,7 +371,7 @@ public:
 
   template <typename Float, int nColor> struct GhostPack {
     GhostPack(const ColorSpinorField &in, void *ghost[], MemoryLocation location, int nFace, bool dagger, int parity,
-              bool spin_project, double a, double b, double c, int shmem, const qudaStream_t &stream)
+              bool spin_project, real_t a, real_t b, real_t c, int shmem, const qudaStream_t &stream)
     {
       if (spin_project) {
         Pack<Float, nColor, true> pack(ghost, in, location, nFace, dagger, parity, a, b, c, shmem);
@@ -385,7 +385,7 @@ public:
 
   // Pack the ghost for the Dslash operator
   void PackGhost(void *ghost[2 * QUDA_MAX_DIM], const ColorSpinorField &in, MemoryLocation location, int nFace,
-                 bool dagger, int parity, bool spin_project, double a, double b, double c, int shmem,
+                 bool dagger, int parity, bool spin_project, real_t a, real_t b, real_t c, int shmem,
                  const qudaStream_t &stream)
   {
     int nDimPack = 0;
diff --git a/lib/dslash_staggered.cu b/lib/dslash_staggered.cu
index 267cb760ad..694d471eaf 100644
--- a/lib/dslash_staggered.cu
+++ b/lib/dslash_staggered.cu
@@ -47,7 +47,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon_u> struct StaggeredApply {
 
 #if defined(BUILD_MILC_INTERFACE) || defined(BUILD_TIFR_INTERFACE)
-    StaggeredApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
+    StaggeredApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
                    const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                    TimeProfile &profile)
     {
@@ -82,7 +82,7 @@ namespace quda
       }
     }
 #else
-    StaggeredApply(ColorSpinorField &, const ColorSpinorField &, const GaugeField &U, double,
+    StaggeredApply(ColorSpinorField &, const ColorSpinorField &, const GaugeField &U, real_t,
                    const ColorSpinorField &, int, bool, const int *, TimeProfile &)
     {
       errorQuda("Unsupported combination of staggered phase type %d gauge link type %d and reconstruct %d", U.StaggeredPhase(), U.LinkType(), U.Reconstruct());
@@ -91,13 +91,13 @@ namespace quda
   };
 
 #ifdef GPU_STAGGERED_DIRAC
-  void ApplyStaggered(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
+  void ApplyStaggered(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
                       const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<StaggeredApply, StaggeredReconstruct>(out, in, U, a, x, parity, dagger, comm_override, profile);
   }
 #else
-  void ApplyStaggered(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,  double,
+  void ApplyStaggered(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
                       const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Staggered dslash has not been built");
diff --git a/lib/dslash_twisted_clover.cu b/lib/dslash_twisted_clover.cu
index 1d0e63ae2e..6cc3160d75 100644
--- a/lib/dslash_twisted_clover.cu
+++ b/lib/dslash_twisted_clover.cu
@@ -65,7 +65,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct TwistedCloverApply {
 
     inline TwistedCloverApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                              const CloverField &C, double a, double b, const ColorSpinorField &x, int parity,
+                              const CloverField &C, real_t a, real_t b, const ColorSpinorField &x, int parity,
                               bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -81,14 +81,14 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator, with a = -kappa.
 #ifdef GPU_TWISTED_CLOVER_DIRAC
   void ApplyTwistedClover(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &C,
-                          double a, double b, const ColorSpinorField &x, int parity, bool dagger,
+                          real_t a, real_t b, const ColorSpinorField &x, int parity, bool dagger,
                           const int *comm_override, TimeProfile &profile)
   {
     instantiate<TwistedCloverApply>(out, in, U, C, a, b, x, parity, dagger, comm_override, profile);
   }
 #else
   void ApplyTwistedClover(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, const CloverField &,
-                          double, double, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
+                          real_t, real_t, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Twisted-clover dslash has not been built");
   }
diff --git a/lib/dslash_twisted_clover_preconditioned.cu b/lib/dslash_twisted_clover_preconditioned.cu
index 5e94ed300a..64a61ad664 100644
--- a/lib/dslash_twisted_clover_preconditioned.cu
+++ b/lib/dslash_twisted_clover_preconditioned.cu
@@ -111,7 +111,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct TwistedCloverPreconditionedApply {
 
     inline TwistedCloverPreconditionedApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-        const CloverField &C, double a, double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
+        const CloverField &C, real_t a, real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
         const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -129,14 +129,14 @@ namespace quda
   */
 #ifdef GPU_TWISTED_CLOVER_DIRAC
   void ApplyTwistedCloverPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-      const CloverField &C, double a, double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
+      const CloverField &C, real_t a, real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger,
       const int *comm_override, TimeProfile &profile)
   {
     instantiate<TwistedCloverPreconditionedApply>(out, in, U, C, a, b, xpay, x, parity, dagger, comm_override, profile);
   }
 #else
   void ApplyTwistedCloverPreconditioned(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                        const CloverField &, double, double, bool, const ColorSpinorField &, int, bool,
+                                        const CloverField &, real_t, real_t, bool, const ColorSpinorField &, int, bool,
                                         const int *, TimeProfile &)
   {
     errorQuda("Twisted-clover dslash has not been built");
diff --git a/lib/dslash_twisted_mass.cu b/lib/dslash_twisted_mass.cu
index a0dba6701e..c7ff62f1a8 100644
--- a/lib/dslash_twisted_mass.cu
+++ b/lib/dslash_twisted_mass.cu
@@ -49,7 +49,7 @@ namespace quda
 
   template <typename Float, int nColor, QudaReconstructType recon> struct TwistedMassApply {
 
-    inline TwistedMassApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
+    inline TwistedMassApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
                             const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                             TimeProfile &profile)
     {
@@ -65,14 +65,14 @@ namespace quda
   // out(x) = M*in = (1 + i*b*gamma_5)*in(x) + a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // Uses the kappa normalization for the Wilson operator, with a = -kappa.
 #ifdef GPU_TWISTED_MASS_DIRAC
-  void ApplyTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a, double b,
+  void ApplyTwistedMass(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a, real_t b,
                         const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                         TimeProfile &profile)
   {
     instantiate<TwistedMassApply>(out, in, U, a, b, x, parity, dagger, comm_override, profile);
   }
 #else
-  void ApplyTwistedMass(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double, double,
+  void ApplyTwistedMass(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t, real_t,
                         const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Twisted-mass dslash has not been built");
diff --git a/lib/dslash_twisted_mass_preconditioned.cu b/lib/dslash_twisted_mass_preconditioned.cu
index 35a36052ad..cad249dc4e 100644
--- a/lib/dslash_twisted_mass_preconditioned.cu
+++ b/lib/dslash_twisted_mass_preconditioned.cu
@@ -71,7 +71,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct TwistedMassPreconditionedApply {
 
     inline TwistedMassPreconditionedApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-        double a, double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
+        real_t a, real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
         const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -95,16 +95,16 @@ namespace quda
     out = x + A^{-1} D * in = x + a*(1 + i*b*gamma_5)*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   */
 #ifdef GPU_TWISTED_MASS_DIRAC
-  void ApplyTwistedMassPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
-      double b, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
+  void ApplyTwistedMassPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
+      real_t b, bool xpay, const ColorSpinorField &x, int parity, bool dagger, bool asymmetric,
       const int *comm_override, TimeProfile &profile)
   {
     instantiate<TwistedMassPreconditionedApply>(
         out, in, U, a, b, xpay, x, parity, dagger, asymmetric, comm_override, profile);
   }
 #else
-  void ApplyTwistedMassPreconditioned(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
-                                      double, bool, const ColorSpinorField &, int, bool, bool, const int *, TimeProfile &)
+  void ApplyTwistedMassPreconditioned(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
+                                      real_t, bool, const ColorSpinorField &, int, bool, bool, const int *, TimeProfile &)
   {
     errorQuda("Twisted-mass dslash has not been built");
   }
diff --git a/lib/dslash_wilson.cu b/lib/dslash_wilson.cu
index 0f82c2373d..d19dafac77 100644
--- a/lib/dslash_wilson.cu
+++ b/lib/dslash_wilson.cu
@@ -37,7 +37,7 @@ namespace quda
 
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonApply {
 
-    inline WilsonApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
+    inline WilsonApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
                        const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -52,13 +52,13 @@ namespace quda
   // out(x) = M*in = - a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu)
   // Uses the a normalization for the Wilson operator.
 #ifdef GPU_WILSON_DIRAC
-  void ApplyWilson(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, double a,
+  void ApplyWilson(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, real_t a,
                    const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<WilsonApply, WilsonReconstruct>(out, in, U, a, x, parity, dagger, comm_override, profile);
   }
 #else
-  void ApplyWilson(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, double,
+  void ApplyWilson(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, real_t,
                    const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Wilson dslash has not been built");
diff --git a/lib/dslash_wilson_clover.cu b/lib/dslash_wilson_clover.cu
index 3a5f569750..6f0dccd59a 100644
--- a/lib/dslash_wilson_clover.cu
+++ b/lib/dslash_wilson_clover.cu
@@ -65,7 +65,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonCloverApply {
 
     inline WilsonCloverApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-        double a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
+        real_t a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
       WilsonCloverArg<Float, nColor, nDim, recon> arg(out, in, U, A, a, 0.0, x, parity, dagger, comm_override);
@@ -78,7 +78,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonCloverWithTwistApply {
 
     inline WilsonCloverWithTwistApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                      const CloverField &A, double a, double b, const ColorSpinorField &x, int parity,
+                                      const CloverField &A, real_t a, real_t b, const ColorSpinorField &x, int parity,
                                       bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -94,13 +94,13 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator.
 #ifdef GPU_CLOVER_DIRAC
   void ApplyWilsonClover(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, const CloverField &A,
-      double a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
+      real_t a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<WilsonCloverApply>(out, in, U, A, a, x, parity, dagger, comm_override, profile);
   }
 #else
   void ApplyWilsonClover(ColorSpinorField &, const ColorSpinorField &, const GaugeField &, const CloverField &,
-                         double, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
+                         real_t, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Clover dslash has not been built");
   }
diff --git a/lib/dslash_wilson_clover_hasenbusch_twist.cu b/lib/dslash_wilson_clover_hasenbusch_twist.cu
index cc7694462e..965e795795 100644
--- a/lib/dslash_wilson_clover_hasenbusch_twist.cu
+++ b/lib/dslash_wilson_clover_hasenbusch_twist.cu
@@ -74,7 +74,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonCloverHasenbuschTwistApply {
 
     inline WilsonCloverHasenbuschTwistApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                            const CloverField &A, double a, double b, const ColorSpinorField &x,
+                                            const CloverField &A, real_t a, real_t b, const ColorSpinorField &x,
                                             int parity, bool dagger, const int *comm_override, TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -90,14 +90,14 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator.
 #ifdef GPU_CLOVER_HASENBUSCH_TWIST
   void ApplyWilsonCloverHasenbuschTwist(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                        const CloverField &A, double a, double b, const ColorSpinorField &x, int parity,
+                                        const CloverField &A, real_t a, real_t b, const ColorSpinorField &x, int parity,
                                         bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<WilsonCloverHasenbuschTwistApply>(out, in, U, A, a, b, x, parity, dagger, comm_override, profile);
   }
 #else
   void ApplyWilsonCloverHasenbuschTwist(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                        const CloverField &, double, double, const ColorSpinorField &, int,
+                                        const CloverField &, real_t, real_t, const ColorSpinorField &, int,
                                         bool, const int *, TimeProfile &)
   {
     errorQuda("Clover Hasensbuch Twist dslash has not been built");
diff --git a/lib/dslash_wilson_clover_hasenbusch_twist_preconditioned.cu b/lib/dslash_wilson_clover_hasenbusch_twist_preconditioned.cu
index ca8ce572d9..9437d404ab 100644
--- a/lib/dslash_wilson_clover_hasenbusch_twist_preconditioned.cu
+++ b/lib/dslash_wilson_clover_hasenbusch_twist_preconditioned.cu
@@ -117,7 +117,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonCloverHasenbuschTwistPCNoClovInvApply {
 
     inline WilsonCloverHasenbuschTwistPCNoClovInvApply(ColorSpinorField &out, const ColorSpinorField &in,
-                                                       const GaugeField &U, const CloverField &A, double a, double b,
+                                                       const GaugeField &U, const CloverField &A, real_t a, real_t b,
                                                        const ColorSpinorField &x, int parity, bool dagger,
                                                        const int *comm_override, TimeProfile &profile)
     {
@@ -136,7 +136,7 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator.
 #ifdef GPU_CLOVER_HASENBUSCH_TWIST
   void ApplyWilsonCloverHasenbuschTwistPCNoClovInv(ColorSpinorField &out, const ColorSpinorField &in,
-                                                   const GaugeField &U, const CloverField &A, double a, double b,
+                                                   const GaugeField &U, const CloverField &A, real_t a, real_t b,
                                                    const ColorSpinorField &x, int parity, bool dagger,
                                                    const int *comm_override, TimeProfile &profile)
   {
@@ -145,7 +145,7 @@ namespace quda
   }
 #else
   void ApplyWilsonCloverHasenbuschTwistPCNoClovInv(ColorSpinorField &, const ColorSpinorField &,
-                                                   const GaugeField &, const CloverField &, double, double,
+                                                   const GaugeField &, const CloverField &, real_t, real_t,
                                                    const ColorSpinorField &, int, bool, const int *, TimeProfile &)
   {
     errorQuda("Clover Hasenbusch Twist dslash has not been built");
@@ -264,7 +264,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonCloverHasenbuschTwistPCClovInvApply {
 
     inline WilsonCloverHasenbuschTwistPCClovInvApply(ColorSpinorField &out, const ColorSpinorField &in,
-                                                     const GaugeField &U, const CloverField &A, double kappa, double mu,
+                                                     const GaugeField &U, const CloverField &A, real_t kappa, real_t mu,
                                                      const ColorSpinorField &x, int parity, bool dagger,
                                                      const int *comm_override, TimeProfile &profile)
     {
@@ -282,7 +282,7 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator.
 #ifdef GPU_CLOVER_HASENBUSCH_TWIST
   void ApplyWilsonCloverHasenbuschTwistPCClovInv(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-                                                 const CloverField &A, double a, double b, const ColorSpinorField &x,
+                                                 const CloverField &A, real_t a, real_t b, const ColorSpinorField &x,
                                                  int parity, bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<WilsonCloverHasenbuschTwistPCClovInvApply>(out, in, U, A, a, b, x, parity, dagger, comm_override,
@@ -290,7 +290,7 @@ namespace quda
   }
 #else
   void ApplyWilsonCloverHasenbuschTwistPCClovInv(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                                 const CloverField &, double, double, const ColorSpinorField &,
+                                                 const CloverField &, real_t, real_t, const ColorSpinorField &,
                                                  int, bool, const int *, TimeProfile &)
   {
     errorQuda("Clover Hasenbusch Twist dslash has not been built");
diff --git a/lib/dslash_wilson_clover_preconditioned.cu b/lib/dslash_wilson_clover_preconditioned.cu
index 2552c92e8e..a9b96b0da7 100644
--- a/lib/dslash_wilson_clover_preconditioned.cu
+++ b/lib/dslash_wilson_clover_preconditioned.cu
@@ -110,7 +110,7 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon> struct WilsonCloverPreconditionedApply {
 
     inline WilsonCloverPreconditionedApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-        const CloverField &A, double a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+        const CloverField &A, real_t a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
         TimeProfile &profile)
     {
       constexpr int nDim = 4;
@@ -126,14 +126,14 @@ namespace quda
   // Uses the kappa normalization for the Wilson operator.
 #ifdef GPU_CLOVER_DIRAC
   void ApplyWilsonCloverPreconditioned(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U,
-      const CloverField &A, double a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+      const CloverField &A, real_t a, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
       TimeProfile &profile)
   {
     instantiate<WilsonCloverPreconditionedApply>(out, in, U, A, a, x, parity, dagger, comm_override, profile);
   }
 #else
   void ApplyWilsonCloverPreconditioned(ColorSpinorField &, const ColorSpinorField &, const GaugeField &,
-                                       const CloverField &, double, const ColorSpinorField &, int, bool, const int *,
+                                       const CloverField &, real_t, const ColorSpinorField &, int, bool, const int *,
                                        TimeProfile &)
   {
     errorQuda("Clover dslash has not been built");
diff --git a/lib/eig_block_trlm.cpp b/lib/eig_block_trlm.cpp
index 160af9dff4..7ff0474816 100644
--- a/lib/eig_block_trlm.cpp
+++ b/lib/eig_block_trlm.cpp
@@ -16,6 +16,9 @@
 
 namespace quda
 {
+
+  using MatrixXc = Matrix<complex_t, Dynamic, Dynamic>;
+
   // Thick Restarted Block Lanczos Method constructor
   BLKTRLM::BLKTRLM(const DiracMatrix &mat, QudaEigParam *eig_param, TimeProfile &profile) :
     TRLM(mat, eig_param, profile)
@@ -46,8 +49,8 @@ namespace quda
     block_data_length = block_size * block_size;
     auto arrow_mat_array_size = block_data_length * n_blocks;
     // Tridiagonal/Arrow matrix
-    block_alpha.resize(arrow_mat_array_size, 0.0);
-    block_beta.resize(arrow_mat_array_size, 0.0);
+    block_alpha.resize(arrow_mat_array_size, real_t(0.0));
+    block_beta.resize(arrow_mat_array_size, real_t(0.0));
 
     // Temp storage used in blockLanczosStep
     jth_block.resize(block_data_length);
@@ -55,7 +58,7 @@ namespace quda
     if (!profile_running) profile.TPSTOP(QUDA_PROFILE_INIT);
   }
 
-  void BLKTRLM::operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals)
+  void BLKTRLM::operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals)
   {
     // Pre-launch checks and preparation
     //---------------------------------------------------------------------------
@@ -83,8 +86,8 @@ namespace quda
     checkChebyOpMax(kSpace);
 
     // Convergence and locking criteria
-    double mat_norm = 0.0;
-    double epsilon = setEpsilon(kSpace[0].Precision());
+    real_t mat_norm = 0.0;
+    real_t epsilon = setEpsilon(kSpace[0].Precision());
 
     // Print Eigensolver params
     printEigensolverSetup();
@@ -107,14 +110,14 @@ namespace quda
 
       // mat_norm is updated.
       for (int i = num_locked; i < n_kr; i++)
-        if (fabs(alpha[i]) > mat_norm) mat_norm = fabs(alpha[i]);
+        if (abs(alpha[i]) > mat_norm) mat_norm = abs(alpha[i]);
 
       // Locking check
       iter_locked = 0;
       for (int i = 1; i < (n_kr - num_locked); i++) {
         if (residua[i + num_locked] < epsilon * mat_norm) {
-          logQuda(QUDA_DEBUG_VERBOSE, "**** Locking %d resid=%+.6e condition=%.6e ****\n", i, residua[i + num_locked],
-                  epsilon * mat_norm);
+          logQuda(QUDA_DEBUG_VERBOSE, "**** Locking %d resid=%+.6e condition=%.6e ****\n", i, double(residua[i + num_locked]),
+                  double(epsilon * mat_norm));
           iter_locked = i;
         } else {
           // Unlikely to find new locked pairs
@@ -126,8 +129,8 @@ namespace quda
       iter_converged = iter_locked;
       for (int i = iter_locked + 1; i < n_kr - num_locked; i++) {
         if (residua[i + num_locked] < tol * mat_norm) {
-          logQuda(QUDA_DEBUG_VERBOSE, "**** Converged %d resid=%+.6e condition=%.6e ****\n", i, residua[i + num_locked],
-                  tol * mat_norm);
+          logQuda(QUDA_DEBUG_VERBOSE, "**** Converged %d resid=%+.6e condition=%.6e ****\n", i, double(residua[i + num_locked]),
+                  double(tol * mat_norm));
           iter_converged = i;
         } else {
           // Unlikely to find new converged pairs
@@ -162,7 +165,7 @@ namespace quda
       logQuda(QUDA_DEBUG_VERBOSE, "num_keep = %d\n", num_keep);
       logQuda(QUDA_DEBUG_VERBOSE, "num_locked = %d\n", num_locked);
       for (int i = 0; i < n_kr; i++) {
-        logQuda(QUDA_DEBUG_VERBOSE, "Ritz[%d] = %.16e residual[%d] = %.16e\n", i, alpha[i], i, residua[i]);
+        logQuda(QUDA_DEBUG_VERBOSE, "Ritz[%d] = %.16e residual[%d] = %.16e\n", i, double(alpha[i]), i, double(residua[i]));
       }
 
       // Check for convergence
@@ -192,7 +195,7 @@ namespace quda
 
       // Dump all Ritz values and residua
       for (int i = 0; i < n_conv; i++) {
-        logQuda(QUDA_SUMMARIZE, "RitzValue[%04d]: (%+.16e, %+.16e) residual %.16e\n", i, alpha[i], 0.0, residua[i]);
+        logQuda(QUDA_SUMMARIZE, "RitzValue[%04d]: (%+.16e, %+.16e) residual %.16e\n", i, double(alpha[i]), 0.0, double(residua[i]));
       }
 
       // Compute eigenvalues
@@ -223,7 +226,7 @@ namespace quda
 
     if (j - start > 0) {
       int blocks = (j - start) / block_size;
-      std::vector<Complex> beta_(blocks * block_data_length);
+      std::vector<complex_t> beta_(blocks * block_data_length);
 
       // Switch beta block order from COLUMN to ROW major
       // This switches the block from upper to lower triangular
@@ -245,7 +248,7 @@ namespace quda
 
     // a_j = v_j^dag * r
     // Block dot products stored in alpha_block.
-    std::vector<Complex> block_alpha_(block_size);
+    std::vector<complex_t> block_alpha_(block_size);
     blas::cDotProduct(block_alpha_, {v.begin() + j, v.begin() + j + block_size}, {r.begin(), r.end()});
     for (auto i = 0u; i < block_alpha_.size(); i++) block_alpha[arrow_offset + i] = block_alpha_[i];
 
@@ -254,7 +257,7 @@ namespace quda
     for (int b = 0; b < block_size; b++) {
       for (int c = 0; c < block_size; c++) {
         idx = b * block_size + c;
-        jth_block[idx] = -1.0 * block_alpha[arrow_offset + idx];
+        jth_block[idx] = -block_alpha[arrow_offset + idx];
       }
     }
 
@@ -283,12 +286,12 @@ namespace quda
       // Compute R_{k}
       logQuda(QUDA_DEBUG_VERBOSE, "Orthonormalisation attempt k = %d\n", k);
       for (int b = 0; b < block_size; b++) {
-        double norm = sqrt(blas::norm2(r[b]));
+        auto norm = sqrt(blas::norm2(r[b]));
         blas::ax(1.0 / norm, r[b]);
         jth_block[b * (block_size + 1)] = norm;
         for (int c = b + 1; c < block_size; c++) {
 
-          Complex cnorm = blas::cDotProduct(r[b], r[c]);
+          complex_t cnorm = blas::cDotProduct(r[b], r[c]);
           blas::caxpy(-cnorm, r[b], r[c]);
 
           idx = c * block_size + b;
@@ -325,9 +328,9 @@ namespace quda
     } else {
       // Compute BetaNew_ac = (R_k)_ab * Beta_bc
       // Use Eigen, it's neater
-      MatrixXcd betaN = MatrixXcd::Zero(block_size, block_size);
-      MatrixXcd beta = MatrixXcd::Zero(block_size, block_size);
-      MatrixXcd Rk = MatrixXcd::Zero(block_size, block_size);
+      MatrixXc betaN = MatrixXc::Zero(block_size, block_size);
+      MatrixXc beta = MatrixXc::Zero(block_size, block_size);
+      MatrixXc Rk = MatrixXc::Zero(block_size, block_size);
       int idx = 0;
 
       // Populate matrices
@@ -365,7 +368,7 @@ namespace quda
     int num_locked_offset = (num_locked / block_size) * block_data_length;
 
     // Eigen objects
-    MatrixXcd T = MatrixXcd::Zero(dim, dim);
+    MatrixXc T = MatrixXc::Zero(dim, dim);
     block_ritz_mat.resize(dim * dim);
     int idx = 0;
 
@@ -420,7 +423,7 @@ namespace quda
     }
 
     // Eigensolve the arrow matrix
-    SelfAdjointEigenSolver<MatrixXcd> eigensolver;
+    SelfAdjointEigenSolver<MatrixXc> eigensolver;
     eigensolver.compute(T);
 
     // Populate the alpha array with eigenvalues
@@ -432,13 +435,13 @@ namespace quda
 
     // Use Sum of all beta values in the final block for
     // the convergence condition
-    double beta_sum = 0;
-    for (int i = 0; i < block_data_length; i++) beta_sum += fabs(block_beta[n_kr * block_size - block_data_length + i]);
+    real_t beta_sum = 0;
+    for (int i = 0; i < block_data_length; i++) beta_sum += abs(block_beta[n_kr * block_size - block_data_length + i]);
 
     for (int i = 0; i < blocks; i++) {
       for (int b = 0; b < block_size; b++) {
         idx = b * (block_size + 1);
-        residua[i * block_size + b + num_locked] = fabs(beta_sum * block_ritz_mat[dim * (i * block_size + b + 1) - 1]);
+        residua[i * block_size + b + num_locked] = abs(beta_sum * block_ritz_mat[dim * (i * block_size + b + 1) - 1]);
       }
     }
 
@@ -451,7 +454,7 @@ namespace quda
     int dim = n_kr - num_locked;
 
     // Multi-BLAS friendly array to store part of Ritz matrix we want
-    std::vector<Complex> ritz_mat_keep(dim * iter_keep);
+    std::vector<complex_t> ritz_mat_keep(dim * iter_keep);
     for (int j = 0; j < dim; j++) {
       for (int i = 0; i < iter_keep; i++) { ritz_mat_keep[j * iter_keep + i] = block_ritz_mat[i * dim + j]; }
     }
@@ -463,9 +466,9 @@ namespace quda
 
     // Compute new r blocks
     // Use Eigen, it's neater
-    MatrixXcd beta = MatrixXcd::Zero(block_size, block_size);
-    MatrixXcd ri = MatrixXcd::Zero(block_size, block_size);
-    MatrixXcd ritzi = MatrixXcd::Zero(block_size, block_size);
+    MatrixXc beta = MatrixXc::Zero(block_size, block_size);
+    MatrixXc ri = MatrixXc::Zero(block_size, block_size);
+    MatrixXc ritzi = MatrixXc::Zero(block_size, block_size);
     int blocks = iter_keep / block_size;
     int idx = 0;
     int beta_offset = n_kr * block_size - block_data_length;
diff --git a/lib/eig_iram.cpp b/lib/eig_iram.cpp
index 4817cf0fc7..e62a843065 100644
--- a/lib/eig_iram.cpp
+++ b/lib/eig_iram.cpp
@@ -16,6 +16,8 @@
 
 namespace quda
 {
+  using MatrixXc = Matrix<complex_t, Dynamic, Dynamic>;
+
   // Implicitly Restarted Arnoldi Method constructor
   IRAM::IRAM(const DiracMatrix &mat, QudaEigParam *eig_param, TimeProfile &profile) :
     EigenSolver(mat, eig_param, profile)
@@ -28,9 +30,9 @@ namespace quda
     Qmat.resize(n_kr);
     Rmat.resize(n_kr);
     for (int i = 0; i < n_kr; i++) {
-      upperHess[i].resize(n_kr, 0.0);
-      Qmat[i].resize(n_kr, 0.0);
-      Rmat[i].resize(n_kr, 0.0);
+      upperHess[i].resize(n_kr, real_t(0.0));
+      Qmat[i].resize(n_kr, real_t(0.0));
+      Rmat[i].resize(n_kr, real_t(0.0));
     }
 
     if (eig_param->qr_tol == 0) { eig_param->qr_tol = eig_param->tol * 1e-2; }
@@ -40,7 +42,7 @@ namespace quda
 
   // Arnoldi Member functions
   //---------------------------------------------------------------------------
-  void IRAM::arnoldiStep(std::vector<ColorSpinorField> &v, std::vector<ColorSpinorField> &r, double &beta, int j)
+  void IRAM::arnoldiStep(std::vector<ColorSpinorField> &v, std::vector<ColorSpinorField> &r, real_t &beta, int j)
   {
     beta = sqrt(blas::norm2(r[0]));
     if (j > 0) upperHess[j][j - 1] = beta;
@@ -52,7 +54,7 @@ namespace quda
     // r_{j} = M * v_{j};
     mat(r[0], v[j]);
 
-    double beta_pre = sqrt(blas::norm2(r[0]));
+    real_t beta_pre = sqrt(blas::norm2(r[0]));
 
     // Compute the j-th residual corresponding
     // to the j step factorization.
@@ -61,14 +63,14 @@ namespace quda
     // r_{j} <-  M * v_{j} - V_{j} * w_{j}
 
     // H_{j,i}_j = v_i^dag * r
-    std::vector<Complex> tmp(j + 1);
+    std::vector<complex_t> tmp(j + 1);
     blas::cDotProduct(tmp, {v.begin(), v.begin() + j + 1}, r);
 
     // Orthogonalise r_{j} against V_{j}.
     // r = r - H_{j,i} * v_j
     for (int i = 0; i < j + 1; i++) tmp[i] *= -1.0;
     blas::caxpy(tmp, {v.begin(), v.begin() + j + 1}, r);
-    for (int i = 0; i < j + 1; i++) upperHess[i][j] = -1.0 * tmp[i];
+    for (int i = 0; i < j + 1; i++) upperHess[i][j] = -tmp[i];
 
     // Re-orthogonalization / Iterative refinement phase
     // Maximum 100 tries.
@@ -92,8 +94,8 @@ namespace quda
     beta = sqrt(blas::norm2(r[0]));
     while (beta < 0.717 * beta_pre && orth_iter < orth_iter_max) {
 
-      logQuda(QUDA_DEBUG_VERBOSE, "beta = %e > 0.717*beta_pre = %e: Reorthogonalise at step %d, iter %d\n", beta,
-              0.717 * beta_pre, j, orth_iter);
+      logQuda(QUDA_DEBUG_VERBOSE, "beta = %e > 0.717*beta_pre = %e: Reorthogonalise at step %d, iter %d\n",
+              double(beta), 0.717 * double(beta_pre), j, orth_iter);
 
       beta_pre = beta;
 
@@ -116,60 +118,60 @@ namespace quda
   void IRAM::rotateBasis(std::vector<ColorSpinorField> &kSpace, int keep)
   {
     // Multi-BLAS friendly array to store the part of the rotation matrix
-    std::vector<Complex> Qmat_keep(n_kr * keep, 0.0);
+    std::vector<complex_t> Qmat_keep(n_kr * keep, real_t(0.0));
     for (int j = 0; j < n_kr; j++)
       for (int i = 0; i < keep; i++) { Qmat_keep[j * keep + i] = Qmat[j][i]; }
 
     rotateVecs(kSpace, Qmat_keep, n_kr, n_kr, keep, 0, profile);
   }
 
-  void IRAM::reorder(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals,
+  void IRAM::reorder(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals,
                      const QudaEigSpectrumType spec_type)
   {
     int n = n_kr;
-    std::vector<std::tuple<Complex, double, ColorSpinorField>> array(n);
+    std::vector<std::tuple<complex_t, real_t, ColorSpinorField>> array(n);
     for (int i = 0; i < n; i++) array[i] = std::make_tuple(evals[i], residua[i], std::move(kSpace[i]));
 
     switch (spec_type) {
     case QUDA_SPECTRUM_LM_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::tuple<Complex, double, ColorSpinorField> &a,
-                   const std::tuple<Complex, double, ColorSpinorField> &b) {
+                [](const std::tuple<complex_t, real_t, ColorSpinorField> &a,
+                   const std::tuple<complex_t, real_t, ColorSpinorField> &b) {
                   return (abs(std::get<0>(a)) > abs(std::get<0>(b)));
                 });
       break;
     case QUDA_SPECTRUM_SM_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::tuple<Complex, double, ColorSpinorField> &a,
-                   const std::tuple<Complex, double, ColorSpinorField> &b) {
+                [](const std::tuple<complex_t, real_t, ColorSpinorField> &a,
+                   const std::tuple<complex_t, real_t, ColorSpinorField> &b) {
                   return (abs(std::get<0>(a)) < abs(std::get<0>(b)));
                 });
       break;
     case QUDA_SPECTRUM_LR_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::tuple<Complex, double, ColorSpinorField> &a,
-                   const std::tuple<Complex, double, ColorSpinorField> &b) {
+                [](const std::tuple<complex_t, real_t, ColorSpinorField> &a,
+                   const std::tuple<complex_t, real_t, ColorSpinorField> &b) {
                   return (std::get<0>(a).real() > std::get<0>(b).real());
                 });
       break;
     case QUDA_SPECTRUM_SR_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::tuple<Complex, double, ColorSpinorField> &a,
-                   const std::tuple<Complex, double, ColorSpinorField> &b) {
+                [](const std::tuple<complex_t, real_t, ColorSpinorField> &a,
+                   const std::tuple<complex_t, real_t, ColorSpinorField> &b) {
                   return (std::get<0>(a).real() < std::get<0>(b).real());
                 });
       break;
     case QUDA_SPECTRUM_LI_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::tuple<Complex, double, ColorSpinorField> &a,
-                   const std::tuple<Complex, double, ColorSpinorField> &b) {
+                [](const std::tuple<complex_t, real_t, ColorSpinorField> &a,
+                   const std::tuple<complex_t, real_t, ColorSpinorField> &b) {
                   return (std::get<0>(a).imag() > std::get<0>(b).imag());
                 });
       break;
     case QUDA_SPECTRUM_SI_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::tuple<Complex, double, ColorSpinorField> &a,
-                   const std::tuple<Complex, double, ColorSpinorField> &b) {
+                [](const std::tuple<complex_t, real_t, ColorSpinorField> &a,
+                   const std::tuple<complex_t, real_t, ColorSpinorField> &b) {
                   return (std::get<0>(a).imag() < std::get<0>(b).imag());
                 });
       break;
@@ -184,13 +186,13 @@ namespace quda
     }
   }
 
-  void IRAM::qrShifts(const std::vector<Complex> evals, const int num_shifts)
+  void IRAM::qrShifts(const std::vector<complex_t> evals, const int num_shifts)
   {
     // This isn't really Eigen, but it's morally equivalent
     profile.TPSTART(QUDA_PROFILE_HOST_COMPUTE);
 
     // Reset Q to the identity, copy upper Hessenberg
-    MatrixXcd UHcopy = MatrixXcd::Zero(n_kr, n_kr);
+    MatrixXc UHcopy = MatrixXc::Zero(n_kr, n_kr);
     for (int i = 0; i < n_kr; i++) {
       for (int j = 0; j < n_kr; j++) {
         if (i == j)
@@ -214,18 +216,18 @@ namespace quda
     profile.TPSTOP(QUDA_PROFILE_HOST_COMPUTE);
   }
 
-  void IRAM::qrIteration(std::vector<std::vector<Complex>> &Q, std::vector<std::vector<Complex>> &R)
+  void IRAM::qrIteration(std::vector<std::vector<complex_t>> &Q, std::vector<std::vector<complex_t>> &R)
   {
-    Complex T11, T12, T21, T22, U1, U2;
-    double dV;
+    complex_t T11, T12, T21, T22, U1, U2;
+    real_t dV;
 
-    double tol = eig_param->qr_tol;
+    real_t tol = eig_param->qr_tol;
 
     // Allocate the rotation matrices.
-    std::vector<Complex> R11(n_kr - 1, 0.0);
-    std::vector<Complex> R12(n_kr - 1, 0.0);
-    std::vector<Complex> R21(n_kr - 1, 0.0);
-    std::vector<Complex> R22(n_kr - 1, 0.0);
+    std::vector<complex_t> R11(n_kr - 1, real_t {0.0});
+    std::vector<complex_t> R12(n_kr - 1, real_t {0.0});
+    std::vector<complex_t> R21(n_kr - 1, real_t {0.0});
+    std::vector<complex_t> R22(n_kr - 1, real_t {0.0});
 
     for (int i = 0; i < n_kr - 1; i++) {
 
@@ -263,7 +265,7 @@ namespace quda
 #pragma omp parallel for schedule(static, 32)
 #endif
       for (int j = i + 1; j < n_kr; j++) {
-        Complex temp = R[i][j];
+        complex_t temp = R[i][j];
         R[i][j] -= (T11 * temp + T12 * R[i + 1][j]);
         R[i + 1][j] -= (T21 * temp + T22 * R[i + 1][j]);
       }
@@ -280,7 +282,7 @@ namespace quda
 #pragma omp for schedule(static, 32) nowait
 #endif
           for (int i = 0; i < j + 2; i++) {
-            Complex temp = R[i][j];
+            complex_t temp = R[i][j];
             R[i][j] -= (R11[j] * temp + R12[j] * R[i][j + 1]);
             R[i][j + 1] -= (R21[j] * temp + R22[j] * R[i][j + 1]);
           }
@@ -288,7 +290,7 @@ namespace quda
 #pragma omp for schedule(static, 32) nowait
 #endif
           for (int i = 0; i < n_kr; i++) {
-            Complex temp = Q[i][j];
+            complex_t temp = Q[i][j];
             Q[i][j] -= (R11[j] * temp + R12[j] * Q[i][j + 1]);
             Q[i][j + 1] -= (R21[j] * temp + R22[j] * Q[i][j + 1]);
           }
@@ -299,29 +301,29 @@ namespace quda
     }
   }
 
-  void IRAM::eigensolveFromUpperHess(std::vector<Complex> &evals, const double beta)
+  void IRAM::eigensolveFromUpperHess(std::vector<complex_t> &evals, const real_t beta)
   {
     if (eig_param->use_eigen_qr) {
       profile.TPSTART(QUDA_PROFILE_EIGENQR);
       // Construct the upper Hessenberg matrix
-      MatrixXcd Q = MatrixXcd::Identity(n_kr, n_kr);
-      MatrixXcd R = MatrixXcd::Zero(n_kr, n_kr);
+      MatrixXc Q = MatrixXc::Identity(n_kr, n_kr);
+      MatrixXc R = MatrixXc::Zero(n_kr, n_kr);
       for (int i = 0; i < n_kr; i++) {
         for (int j = 0; j < n_kr; j++) { R(i, j) = upperHess[i][j]; }
       }
 
       // QR the upper Hessenberg matrix
-      Eigen::ComplexSchur<MatrixXcd> schurUH;
+      Eigen::ComplexSchur<MatrixXc> schurUH;
       schurUH.computeFromHessenberg(R, Q);
       profile.TPSTOP(QUDA_PROFILE_EIGENQR);
 
       profile.TPSTART(QUDA_PROFILE_EIGENEV);
       // Extract the upper triangular matrix, eigensolve, then
       // get the eigenvectors of the upper Hessenberg
-      MatrixXcd matUpper = MatrixXcd::Zero(n_kr, n_kr);
+      MatrixXc matUpper = MatrixXc::Zero(n_kr, n_kr);
       matUpper = schurUH.matrixT().triangularView<Eigen::Upper>();
       matUpper.conservativeResize(n_kr, n_kr);
-      Eigen::ComplexEigenSolver<MatrixXcd> eigenSolver(matUpper);
+      Eigen::ComplexEigenSolver<MatrixXc> eigenSolver(matUpper);
       Q = schurUH.matrixU() * eigenSolver.eigenvectors();
 
       // Update eigenvalues, residuia, and the Q matrix
@@ -346,11 +348,11 @@ namespace quda
 
       // This is about as high as one cat get in double without causing
       // the Arnoldi to compute more restarts.
-      double tol = eig_param->qr_tol;
+      real_t tol = eig_param->qr_tol;
       int max_iter = 100000;
       int iter = 0;
 
-      Complex temp, discriminant, sol1, sol2, eval;
+      complex_t temp, discriminant, sol1, sol2, eval;
       for (int i = n_kr - 2; i >= 0; i--) {
         while (iter < max_iter) {
           if (abs(Rmat[i + 1][i]) < tol) {
@@ -361,11 +363,11 @@ namespace quda
             // Compute the 2 eigenvalues via the quadratic formula
             //----------------------------------------------------
             // The discriminant
-            temp = (Rmat[i][i] - Rmat[i + 1][i + 1]) * (Rmat[i][i] - Rmat[i + 1][i + 1]) / 4.0;
+            temp = (Rmat[i][i] - Rmat[i + 1][i + 1]) * (Rmat[i][i] - Rmat[i + 1][i + 1]) / real_t(4.0);
             discriminant = sqrt(Rmat[i + 1][i] * Rmat[i][i + 1] + temp);
 
             // Reuse temp
-            temp = (Rmat[i][i] + Rmat[i + 1][i + 1]) / 2.0;
+            temp = (Rmat[i][i] + Rmat[i + 1][i + 1]) / real_t(2.0);
 
             sol1 = temp - Rmat[i + 1][i + 1] + discriminant;
             sol2 = temp - Rmat[i + 1][i + 1] - discriminant;
@@ -392,8 +394,8 @@ namespace quda
       // Compute the eigevectors of the origial upper Hessenberg
       // This is now very cheap because the input matrix to Eigen
       // is upper triangular.
-      MatrixXcd Q = MatrixXcd::Zero(n_kr, n_kr);
-      MatrixXcd R = MatrixXcd::Zero(n_kr, n_kr);
+      MatrixXc Q = MatrixXc::Zero(n_kr, n_kr);
+      MatrixXc R = MatrixXc::Zero(n_kr, n_kr);
       for (int i = 0; i < n_kr; i++) {
         for (int j = 0; j < n_kr; j++) {
           Q(i, j) = Qmat[i][j];
@@ -401,10 +403,10 @@ namespace quda
         }
       }
 
-      MatrixXcd matUpper = MatrixXcd::Zero(n_kr, n_kr);
+      MatrixXc matUpper = MatrixXc::Zero(n_kr, n_kr);
       matUpper = R.triangularView<Eigen::Upper>();
       matUpper.conservativeResize(n_kr, n_kr);
-      Eigen::ComplexEigenSolver<MatrixXcd> eigenSolver(matUpper);
+      Eigen::ComplexEigenSolver<MatrixXc> eigenSolver(matUpper);
       Q *= eigenSolver.eigenvectors();
 
       // Update eigenvalues, residuia, and the Q matrix
@@ -419,7 +421,7 @@ namespace quda
     }
   }
 
-  void IRAM::operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals)
+  void IRAM::operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals)
   {
     // Override any user input for block size.
     block_size = 1;
@@ -447,9 +449,9 @@ namespace quda
     mat(r[0], kSpace[0]);
 
     // Convergence criteria
-    double epsilon = setEpsilon(kSpace[0].Precision());
-    double epsilon23 = pow(epsilon, 2.0 / 3.0);
-    double beta = 0.0;
+    auto epsilon = setEpsilon(kSpace[0].Precision());
+    real_t epsilon23 = pow(epsilon, 2.0 / 3.0);
+    real_t beta = 0.0;
 
     // Print Eigensolver params
     printEigensolverSetup();
@@ -484,10 +486,11 @@ namespace quda
       iter_converged = 0;
       for (int i = 0; i < n_ev; i++) {
         int idx = n_kr - 1 - i;
-        double rtemp = std::max(epsilon23, abs(evals[idx]));
+        auto rtemp = std::max(epsilon23, abs(evals[idx]));
         if (residua[idx] < tol * rtemp) {
           iter_converged++;
-          logQuda(QUDA_DEBUG_VERBOSE, "residuum[%d] = %e, condition = %e\n", i, residua[idx], tol * abs(evals[idx]));
+          logQuda(QUDA_DEBUG_VERBOSE, "residuum[%d] = %e, condition = %e\n", i, double(residua[idx]),
+                  double(tol * abs(evals[idx])));
         } else {
           // Unlikely to find new converged eigenvalues
           break;
diff --git a/lib/eig_trlm.cpp b/lib/eig_trlm.cpp
index 00d3941527..dda2d5c1ca 100644
--- a/lib/eig_trlm.cpp
+++ b/lib/eig_trlm.cpp
@@ -16,6 +16,9 @@
 
 namespace quda
 {
+
+  using MatrixX = Matrix<real_t, Dynamic, Dynamic>;
+
   // Thick Restarted Lanczos Method constructor
   TRLM::TRLM(const DiracMatrix &mat, QudaEigParam *eig_param, TimeProfile &profile) :
     EigenSolver(mat, eig_param, profile)
@@ -37,7 +40,7 @@ namespace quda
     if (!profile_running) profile.TPSTOP(QUDA_PROFILE_INIT);
   }
 
-  void TRLM::operator()(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals)
+  void TRLM::operator()(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals)
   {
     // Override any user input for block size.
     block_size = 1;
@@ -64,8 +67,8 @@ namespace quda
     checkChebyOpMax(kSpace);
 
     // Convergence and locking criteria
-    double mat_norm = 0.0;
-    double epsilon = setEpsilon(kSpace[0].Precision());
+    real_t mat_norm = 0.0;
+    real_t epsilon = setEpsilon(kSpace[0].Precision());
 
     // Print Eigensolver params
     printEigensolverSetup();
@@ -88,14 +91,14 @@ namespace quda
 
       // mat_norm is updated.
       for (int i = num_locked; i < n_kr; i++)
-        if (fabs(alpha[i]) > mat_norm) mat_norm = fabs(alpha[i]);
+        if (abs(alpha[i]) > mat_norm) mat_norm = abs(alpha[i]);
 
       // Locking check
       iter_locked = 0;
       for (int i = 1; i < (n_kr - num_locked); i++) {
         if (residua[i + num_locked] < epsilon * mat_norm) {
-          logQuda(QUDA_DEBUG_VERBOSE, "**** Locking %d resid=%+.6e condition=%.6e ****\n", i, residua[i + num_locked],
-                  epsilon * mat_norm);
+          logQuda(QUDA_DEBUG_VERBOSE, "**** Locking %d resid=%+.6e condition=%.6e ****\n", i, double(residua[i + num_locked]),
+                  double(epsilon * mat_norm));
           iter_locked = i;
         } else {
           // Unlikely to find new locked pairs
@@ -107,8 +110,8 @@ namespace quda
       iter_converged = iter_locked;
       for (int i = iter_locked + 1; i < n_kr - num_locked; i++) {
         if (residua[i + num_locked] < tol * mat_norm) {
-          logQuda(QUDA_DEBUG_VERBOSE, "**** Converged %d resid=%+.6e condition=%.6e ****\n", i, residua[i + num_locked],
-                  tol * mat_norm);
+          logQuda(QUDA_DEBUG_VERBOSE, "**** Converged %d resid=%+.6e condition=%.6e ****\n", i, double(residua[i + num_locked]),
+                  double(tol * mat_norm));
           iter_converged = i;
         } else {
           // Unlikely to find new converged pairs
@@ -135,7 +138,7 @@ namespace quda
       logQuda(QUDA_DEBUG_VERBOSE, "num_keep = %d\n", num_keep);
       logQuda(QUDA_DEBUG_VERBOSE, "num_locked = %d\n", num_locked);
       for (int i = 0; i < n_kr; i++) {
-        logQuda(QUDA_DEBUG_VERBOSE, "Ritz[%d] = %.16e residual[%d] = %.16e\n", i, alpha[i], i, residua[i]);
+        logQuda(QUDA_DEBUG_VERBOSE, "Ritz[%d] = %.16e residual[%d] = %.16e\n", i, double(alpha[i]), i, double(residua[i]));
       }
 
       // Check for convergence
@@ -167,7 +170,7 @@ namespace quda
 
       // Dump all Ritz values and residua if using Chebyshev
       for (int i = 0; i < n_conv && eig_param->use_poly_acc; i++) {
-        logQuda(QUDA_SUMMARIZE, "RitzValue[%04d]: (%+.16e, %+.16e) residual %.16e\n", i, alpha[i], 0.0, residua[i]);
+        logQuda(QUDA_SUMMARIZE, "RitzValue[%04d]: (%+.16e, %+.16e) residual %.16e\n", i, double(alpha[i]), 0.0, double(residua[i]));
       }
 
       // Compute eigenvalues/singular values
@@ -198,7 +201,7 @@ namespace quda
     int start = (j > num_keep) ? j - 1 : 0;
 
     if (j - start > 0) {
-      std::vector<double> beta_ = {beta.begin() + start, beta.begin() + j};
+      std::vector<real_t> beta_ = {beta.begin() + start, beta.begin() + j};
       for (auto & bi : beta_) bi = -bi;
 
       // r = r - b_{j-1} * v_{j-1}
@@ -250,7 +253,7 @@ namespace quda
     int arrow_pos = num_keep - num_locked;
 
     // Eigen objects
-    MatrixXd A = MatrixXd::Zero(dim, dim);
+    MatrixX A = MatrixX::Zero(dim, dim);
     ritz_mat.resize(dim * dim, 0.0);
 
     // Invert the spectrum due to chebyshev
@@ -284,7 +287,7 @@ namespace quda
     }
 
     // Eigensolve the arrow matrix
-    SelfAdjointEigenSolver<MatrixXd> eigensolver;
+    SelfAdjointEigenSolver<MatrixX> eigensolver;
     eigensolver.compute(A);
 
     // repopulate ritz matrix
@@ -292,7 +295,7 @@ namespace quda
       for (int j = 0; j < dim; j++) ritz_mat[dim * i + j] = eigensolver.eigenvectors().col(i)[j];
 
     for (int i = 0; i < dim; i++) {
-      residua[i + num_locked] = fabs(beta[n_kr - 1] * eigensolver.eigenvectors().col(i)[dim - 1]);
+      residua[i + num_locked] = abs(beta[n_kr - 1] * eigensolver.eigenvectors().col(i)[dim - 1]);
       // Update the alpha array
       alpha[i + num_locked] = eigensolver.eigenvalues()[i];
     }
@@ -311,7 +314,7 @@ namespace quda
     int dim = n_kr - num_locked;
 
     // Multi-BLAS friendly array to store part of Ritz matrix we want
-    std::vector<double> ritz_mat_keep(dim * iter_keep);
+    std::vector<real_t> ritz_mat_keep(dim * iter_keep);
     for (int j = 0; j < dim; j++) {
       for (int i = 0; i < iter_keep; i++) { ritz_mat_keep[j * iter_keep + i] = ritz_mat[i * dim + j]; }
     }
diff --git a/lib/eigensolve_quda.cpp b/lib/eigensolve_quda.cpp
index 00c888dd88..04995b134a 100644
--- a/lib/eigensolve_quda.cpp
+++ b/lib/eigensolve_quda.cpp
@@ -20,6 +20,9 @@
 namespace quda
 {
 
+  using MatrixX = Matrix<real_t, Dynamic, Dynamic>;
+  using MatrixXc = Matrix<complex_t, Dynamic, Dynamic>;
+
   // Eigensolver class
   //-----------------------------------------------------------------------------
   EigenSolver::EigenSolver(const DiracMatrix &mat, QudaEigParam *eig_param, TimeProfile &profile) :
@@ -179,7 +182,7 @@ namespace quda
     if (eig_param->use_poly_acc) {
       if (eig_param->a_max <= 0.0) {
         // Use part of the kSpace as temps
-        eig_param->a_max = estimateChebyOpMax(kSpace[block_size + 2], kSpace[block_size + 1]);
+        eig_param->a_max = double(estimateChebyOpMax(kSpace[block_size + 2], kSpace[block_size + 1]));
         logQuda(QUDA_SUMMARIZE, "Chebyshev maximum estimate: %e.\n", eig_param->a_max);
       }
       if (eig_param->a_min >= eig_param->a_max)
@@ -187,11 +190,11 @@ namespace quda
     }
   }
 
-  void EigenSolver::prepareKrylovSpace(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals)
+  void EigenSolver::prepareKrylovSpace(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals)
   {
     resize(kSpace, n_kr + block_size, QUDA_ZERO_FIELD_CREATE); // increase Krylov space to n_kr + block_size
     resize(r, block_size, QUDA_ZERO_FIELD_CREATE, kSpace[0]);  // create residual
-    evals.resize(n_kr, 0.0);                                   // increase evals space to n_ev
+    evals.resize(n_kr, real_t(0.0));                                   // increase evals space to n_ev
   }
 
   void EigenSolver::printEigensolverSetup()
@@ -201,7 +204,7 @@ namespace quda
     logQuda(QUDA_SUMMARIZE, "********************************\n");
 
     logQuda(QUDA_VERBOSE, "spectrum %s\n", spectrum);
-    logQuda(QUDA_VERBOSE, "tol %.4e\n", tol);
+    logQuda(QUDA_VERBOSE, "tol %.4e\n", double(tol));
     logQuda(QUDA_VERBOSE, "n_conv %d\n", n_conv);
     logQuda(QUDA_VERBOSE, "n_ev %d\n", n_ev);
     logQuda(QUDA_VERBOSE, "n_kr %d\n", n_kr);
@@ -238,7 +241,7 @@ namespace quda
     }
   }
 
-  void EigenSolver::cleanUpEigensolver(std::vector<ColorSpinorField> &kSpace, std::vector<Complex> &evals)
+  void EigenSolver::cleanUpEigensolver(std::vector<ColorSpinorField> &kSpace, std::vector<complex_t> &evals)
   {
     r.clear();
 
@@ -278,15 +281,15 @@ namespace quda
     if (eig_param->poly_deg == 0) errorQuda("Polynomial acceleration requested with zero polynomial degree");
 
     // Compute the polynomial accelerated operator.
-    double a = eig_param->a_min;
-    double b = eig_param->a_max;
-    double delta = (b - a) / 2.0;
-    double theta = (b + a) / 2.0;
-    double sigma1 = -delta / theta;
-    double sigma;
-    double d1 = sigma1 / delta;
-    double d2 = 1.0;
-    double d3;
+    real_t a = eig_param->a_min;
+    real_t b = eig_param->a_max;
+    real_t delta = (b - a) / 2.0;
+    real_t theta = (b + a) / 2.0;
+    real_t sigma1 = -delta / theta;
+    real_t sigma;
+    real_t d1 = sigma1 / delta;
+    real_t d2 = 1.0;
+    real_t d3;
 
     // out = d2 * in + d1 * out
     // C_1(x) = x
@@ -306,7 +309,7 @@ namespace quda
     // Using Chebyshev polynomial recursion relation,
     // C_{m+1}(x) = 2*x*C_{m} - C_{m-1}
 
-    double sigma_old = sigma1;
+    real_t sigma_old = sigma1;
 
     // construct C_{m+1}(x)
     for (int i = 2; i < eig_param->poly_deg; i++) {
@@ -330,13 +333,13 @@ namespace quda
     for (auto i = 0u; i < in.size(); i++) std::swap(out[i], tmp2[i]);
   }
 
-  double EigenSolver::estimateChebyOpMax(ColorSpinorField &out, ColorSpinorField &in)
+  real_t EigenSolver::estimateChebyOpMax(ColorSpinorField &out, ColorSpinorField &in)
   {
     RNG rng(in, 1234);
     spinorNoise(in, rng, QUDA_NOISE_UNIFORM);
 
     // Power iteration
-    double norm = 0.0;
+    real_t norm = 0.0;
     for (int i = 0; i < 100; i++) {
       if ((i + 1) % 10 == 0) {
         norm = sqrt(blas::norm2(in));
@@ -347,7 +350,7 @@ namespace quda
     }
 
     // Compute spectral radius estimate
-    double result = blas::reDotProduct(out, in);
+    auto result = blas::reDotProduct(out, in);
 
     // Increase final result by 10% for safety
     return result * 1.10;
@@ -356,25 +359,26 @@ namespace quda
   bool EigenSolver::orthoCheck(std::vector<ColorSpinorField> &vecs, int size)
   {
     bool orthed = true;
-    const Complex Unit(1.0, 0.0);
+    const complex_t Unit(1.0, 0.0);
 
-    std::vector<Complex> H(size * size);
+    std::vector<complex_t> H(size * size);
     blas::hDotProduct(H, {vecs.begin(), vecs.begin() + size}, {vecs.begin(), vecs.begin() + size});
 
-    double epsilon = setEpsilon(vecs[0].Precision());
+    real_t epsilon = setEpsilon(vecs[0].Precision());
 
     for (int i = 0; i < size; i++) {
       for (int j = 0; j < size; j++) {
         auto cnorm = H[i * size + j];
         if (j != i) {
           if (abs(cnorm) > 5.0 * epsilon) {
-            logQuda(QUDA_SUMMARIZE, "Norm <%d|%d>^2 = ||(%e,%e)|| = %e\n", i, j, cnorm.real(), cnorm.imag(), abs(cnorm));
+            logQuda(QUDA_SUMMARIZE, "Norm <%d|%d>^2 = ||(%e,%e)|| = %e\n", i, j,
+                    double(cnorm.real()), double(cnorm.imag()), double(abs(cnorm)));
             orthed = false;
           }
         } else {
           if (abs(Unit - cnorm) > 5.0 * epsilon) {
-            logQuda(QUDA_SUMMARIZE, "1 - Norm <%d|%d>^2 = 1 - ||(%e,%e)|| = %e\n", i, j, cnorm.real(), cnorm.imag(),
-                    abs(Unit - cnorm));
+            logQuda(QUDA_SUMMARIZE, "1 - Norm <%d|%d>^2 = 1 - ||(%e,%e)|| = %e\n", i, j, double(cnorm.real()), double(cnorm.imag()),
+                    double(abs(Unit - cnorm)));
             orthed = false;
           }
         }
@@ -393,12 +397,12 @@ namespace quda
         if (i - j < h_block_size) array_size = i - j;
         logQuda(QUDA_DEBUG_VERBOSE, "Current block size = %d\n", array_size);
 
-        std::vector<Complex> s(array_size);
+        std::vector<complex_t> s(array_size);
         blas::cDotProduct(s, {vecs.begin() + j, vecs.begin() + j + array_size}, vecs[i]); // <j|i> with i normalised.
         for (auto k = 0; k < array_size; k++) s[k] *= -1.0;
         blas::caxpy(s, {vecs.begin() + j, vecs.begin() + j + array_size}, vecs[i]); // i = i - proj_{j}(i) = i - <j|i> * j
       }
-      double norm = sqrt(blas::norm2(vecs[i]));
+      real_t norm = sqrt(blas::norm2(vecs[i]));
       blas::ax(1.0 / norm, vecs[i]); // i/<i|i>
     }
   }
@@ -413,7 +417,7 @@ namespace quda
       auto array_size = block_array_size * rvecs.size();
       logQuda(QUDA_DEBUG_VERBOSE, "Current block array size = %d\n", block_array_size);
 
-      std::vector<Complex> s(array_size);
+      std::vector<complex_t> s(array_size);
 
       // Block dot products stored in s.
       blas::cDotProduct(s, {vecs.begin() + j, vecs.begin() + j + block_array_size}, {rvecs.begin(), rvecs.end()});
@@ -504,7 +508,7 @@ namespace quda
     }
   }
 
-  void EigenSolver::computeSVD(std::vector<ColorSpinorField> &evecs, std::vector<Complex> &evals)
+  void EigenSolver::computeSVD(std::vector<ColorSpinorField> &evecs, std::vector<complex_t> &evals)
   {
     logQuda(QUDA_SUMMARIZE, "Computing SVD of M\n");
 
@@ -512,7 +516,7 @@ namespace quda
     if (evecs.size() < (unsigned int)(2 * n_conv))
       errorQuda("Incorrect deflation space sized %d passed to computeSVD, expected %d", (int)(evecs.size()), 2 * n_conv);
 
-    std::vector<double> sigma_tmp(n_conv);
+    std::vector<real_t> sigma_tmp(n_conv);
 
     for (int i = 0; i < n_conv; i++) {
 
@@ -527,7 +531,7 @@ namespace quda
       //--------------------------------------------------------------------------
 
       // Lambda already contains the square root of the eigenvalue of the norm op.
-      Complex lambda = evals[i];
+      complex_t lambda = evals[i];
 
       // M*Rev_i = M*Rsv_i = sigma_i Lsv_i
       mat.Expose()->M(evecs[n_conv + i], evecs[i]);
@@ -538,8 +542,8 @@ namespace quda
       // Normalise the Lsv: sigma_i Lsv_i -> Lsv_i
       blas::ax(1.0 / sigma_tmp[i], evecs[n_conv + i]);
 
-      logQuda(QUDA_SUMMARIZE, "Sval[%04d] = %+.16e sigma - sqrt(|lambda|) = %+.16e\n", i, sigma_tmp[i],
-              sigma_tmp[i] - sqrt(abs(lambda.real())));
+      logQuda(QUDA_SUMMARIZE, "Sval[%04d] = %+.16e sigma - sqrt(|lambda|) = %+.16e\n", i, double(sigma_tmp[i]),
+              double(sigma_tmp[i] - sqrt(abs(lambda.real()))));
 
       evals[i] = sigma_tmp[i];
       //--------------------------------------------------------------------------
@@ -548,7 +552,7 @@ namespace quda
 
   // Deflate vec, place result in vec_defl
   void EigenSolver::deflateSVD(cvector_ref<ColorSpinorField> &sol, cvector_ref<const ColorSpinorField> &src,
-                               cvector_ref<const ColorSpinorField> &evecs, const std::vector<Complex> &evals,
+                               cvector_ref<const ColorSpinorField> &evecs, const std::vector<complex_t> &evals,
                                bool accumulate) const
   {
     // number of evecs
@@ -568,7 +572,7 @@ namespace quda
     // for all i computed eigenvectors and values.
 
     // 1. Take block inner product: L_i^dag * vec = A_i
-    std::vector<Complex> s(n_defl * src.size());
+    std::vector<complex_t> s(n_defl * src.size());
     blas::cDotProduct(s, {evecs.begin() + eig_param->n_conv, evecs.begin() + eig_param->n_conv + n_defl},
                       {src.begin(), src.end()});
 
@@ -582,7 +586,7 @@ namespace quda
   }
 
   void EigenSolver::computeEvals(std::vector<ColorSpinorField> &evecs,
-                                 std::vector<Complex> &evals, int size)
+                                 std::vector<complex_t> &evals, int size)
   {
     if (size > (int)evecs.size())
       errorQuda("Requesting %d eigenvectors with only storage allocated for %lu", size, evecs.size());
@@ -600,21 +604,21 @@ namespace quda
       // lambda_i = v_i^dag A v_i / (v_i^dag * v_i)
       evals[i] = blas::cDotProduct(evecs[i], temp) / sqrt(blas::norm2(evecs[i]));
       // Measure ||lambda_i*v_i - A*v_i||
-      Complex n_unit(-1.0, 0.0);
+      complex_t n_unit(-1.0, 0.0);
       blas::caxpby(evals[i], evecs[i], n_unit, temp);
       residua[i] = sqrt(blas::norm2(temp));
       // eig_param->invert_param->true_res_offset[i] = residua[i];
 
       // If size = n_conv, this routine is called post sort
       if (size == n_conv)
-        logQuda(QUDA_SUMMARIZE, "Eval[%04d] = (%+.16e,%+.16e) ||%+.16e|| Residual = %+.16e\n", i, evals[i].real(),
-                evals[i].imag(), abs(evals[i]), residua[i]);
+        logQuda(QUDA_SUMMARIZE, "Eval[%04d] = (%+.16e,%+.16e) ||%+.16e|| Residual = %+.16e\n", i, double(evals[i].real()),
+                double(evals[i].imag()), double(abs(evals[i])), double(residua[i]));
     }
   }
 
   // Deflate vec, place result in vec_defl
   void EigenSolver::deflate(cvector_ref<ColorSpinorField> &sol, cvector_ref<const ColorSpinorField> &src,
-                            cvector_ref<const ColorSpinorField> &evecs, const std::vector<Complex> &evals,
+                            cvector_ref<const ColorSpinorField> &evecs, const std::vector<complex_t> &evals,
                             bool accumulate) const
   {
     // number of evecs
@@ -630,7 +634,7 @@ namespace quda
     // for all i computed eigenvectors and values.
 
     // 1. Take block inner product: (V_i)^dag * vec = A_i
-    std::vector<Complex> s(n_defl * src.size());
+    std::vector<complex_t> s(n_defl * src.size());
     blas::cDotProduct(s, {evecs.begin(), evecs.begin() + n_defl}, {src.begin(), src.end()});
 
     // 2. Perform block caxpy: V_i * (L_i)^{-1} * A_i
@@ -643,7 +647,7 @@ namespace quda
   }
 
   void EigenSolver::loadFromFile(std::vector<ColorSpinorField> &kSpace,
-                                 std::vector<Complex> &evals)
+                                 std::vector<complex_t> &evals)
   {
     // Set suggested parity of fields
     const QudaParity mat_parity = impliedParityFromMatPC(mat.getMatPCType());
@@ -663,7 +667,7 @@ namespace quda
     computeEvals(kSpace, evals);
   }
 
-  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<Complex> &x, std::vector<Complex> &y)
+  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<complex_t> &x, std::vector<complex_t> &y)
   {
     if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
       switch (spec_type) {
@@ -677,43 +681,43 @@ namespace quda
       }
     }
 
-    std::vector<std::pair<Complex, Complex>> array(n);
+    std::vector<std::pair<complex_t, complex_t>> array(n);
     for (int i = 0; i < n; i++) array[i] = std::make_pair(x[i], y[i]);
 
     switch (spec_type) {
     case QUDA_SPECTRUM_LM_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::pair<Complex, Complex> &a, const std::pair<Complex, Complex> &b) {
+                [](const std::pair<complex_t, complex_t> &a, const std::pair<complex_t, complex_t> &b) {
                   return (abs(a.first) < abs(b.first));
                 });
       break;
     case QUDA_SPECTRUM_SM_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::pair<Complex, Complex> &a, const std::pair<Complex, Complex> &b) {
+                [](const std::pair<complex_t, complex_t> &a, const std::pair<complex_t, complex_t> &b) {
                   return (abs(a.first) > abs(b.first));
                 });
       break;
     case QUDA_SPECTRUM_LR_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::pair<Complex, Complex> &a, const std::pair<Complex, Complex> &b) {
+                [](const std::pair<complex_t, complex_t> &a, const std::pair<complex_t, complex_t> &b) {
                   return (a.first).real() < (b.first).real();
                 });
       break;
     case QUDA_SPECTRUM_SR_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::pair<Complex, Complex> &a, const std::pair<Complex, Complex> &b) {
+                [](const std::pair<complex_t, complex_t> &a, const std::pair<complex_t, complex_t> &b) {
                   return (a.first).real() > (b.first).real();
                 });
       break;
     case QUDA_SPECTRUM_LI_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::pair<Complex, Complex> &a, const std::pair<Complex, Complex> &b) {
+                [](const std::pair<complex_t, complex_t> &a, const std::pair<complex_t, complex_t> &b) {
                   return (a.first).imag() < (b.first).imag();
                 });
       break;
     case QUDA_SPECTRUM_SI_EIG:
       std::sort(array.begin(), array.begin() + n,
-                [](const std::pair<Complex, Complex> &a, const std::pair<Complex, Complex> &b) {
+                [](const std::pair<complex_t, complex_t> &a, const std::pair<complex_t, complex_t> &b) {
                   return (a.first).imag() > (b.first).imag();
                 });
       break;
@@ -728,28 +732,28 @@ namespace quda
   }
 
   // Overloaded version of sortArrays to deal with real y array.
-  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<Complex> &x, std::vector<double> &y)
+  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<complex_t> &x, std::vector<real_t> &y)
   {
-    std::vector<Complex> y_tmp(n, 0.0);
+    std::vector<complex_t> y_tmp(n, real_t(0.0));
     for (int i = 0; i < n; i++) y_tmp[i].real(y[i]);
     sortArrays(spec_type, n, x, y_tmp);
     for (int i = 0; i < n; i++) y[i] = y_tmp[i].real();
   }
 
   // Overloaded version of sortArrays to deal with real x array.
-  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<double> &x, std::vector<Complex> &y)
+  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<real_t> &x, std::vector<complex_t> &y)
   {
-    std::vector<Complex> x_tmp(n, 0.0);
+    std::vector<complex_t> x_tmp(n, real_t(0.0));
     for (int i = 0; i < n; i++) x_tmp[i].real(x[i]);
     sortArrays(spec_type, n, x_tmp, y);
     for (int i = 0; i < n; i++) x[i] = x_tmp[i].real();
   }
 
   // Overloaded version of sortArrays to deal with real x and y array.
-  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<double> &x, std::vector<double> &y)
+  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<real_t> &x, std::vector<real_t> &y)
   {
-    std::vector<Complex> x_tmp(n, 0.0);
-    std::vector<Complex> y_tmp(n, 0.0);
+    std::vector<complex_t> x_tmp(n, real_t(0.0));
+    std::vector<complex_t> y_tmp(n, real_t(0.0));
     for (int i = 0; i < n; i++) {
       x_tmp[i].real(x[i]);
       y_tmp[i].real(y[i]);
@@ -762,12 +766,12 @@ namespace quda
   }
 
   // Overloaded version of sortArrays to deal with complex x and integer y array.
-  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<Complex> &x, std::vector<int> &y)
+  void EigenSolver::sortArrays(QudaEigSpectrumType spec_type, int n, std::vector<complex_t> &x, std::vector<int> &y)
   {
-    std::vector<Complex> y_tmp(n, 0.0);
+    std::vector<complex_t> y_tmp(n, real_t(0.0));
     for (int i = 0; i < n; i++) y_tmp[i].real(y[i]);
     sortArrays(spec_type, n, x, y_tmp);
-    for (int i = 0; i < n; i++) y[i] = (int)(y_tmp[i].real());
+    for (int i = 0; i < n; i++) y[i] = int(y_tmp[i].real());
   }
 
   /**
@@ -775,8 +779,8 @@ namespace quda
      arithmetic (real or complex)
    */
   template <class T> struct eigen_matrix_map;
-  template <> struct eigen_matrix_map<double> { using type = MatrixXd; };
-  template <> struct eigen_matrix_map<Complex> { using type = MatrixXcd; };
+  template <> struct eigen_matrix_map<real_t> { using type = MatrixX; };
+  template <> struct eigen_matrix_map<complex_t> { using type = MatrixXc; };
   template <class T> using eigen_matrix_t = typename eigen_matrix_map<T>::type;
 
   template <typename T>
@@ -905,10 +909,10 @@ namespace quda
     }
   }
 
-  template void EigenSolver::rotateVecs<double>(std::vector<ColorSpinorField> &kSpace, const std::vector<double> &rot_array,
+  template void EigenSolver::rotateVecs<real_t>(std::vector<ColorSpinorField> &kSpace, const std::vector<real_t> &rot_array,
                                                 int offset, int dim, int keep, int locked, TimeProfile &profile);
 
-  template void EigenSolver::rotateVecs<Complex>(std::vector<ColorSpinorField> &kSpace, const std::vector<Complex> &rot_array,
-                                                 int offset, int dim, int keep, int locked, TimeProfile &profile);
+  template void EigenSolver::rotateVecs<complex_t>(std::vector<ColorSpinorField> &kSpace, const std::vector<complex_t> &rot_array,
+                                                   int offset, int dim, int keep, int locked, TimeProfile &profile);
 
 } // namespace quda
diff --git a/lib/gauge_ape.cu b/lib/gauge_ape.cu
index 248b7d1d6c..f428c56584 100644
--- a/lib/gauge_ape.cu
+++ b/lib/gauge_ape.cu
@@ -16,7 +16,7 @@ namespace quda {
 
   public:
     // (2,3): 2 for parity in the y thread dim, 3 corresponds to mapping direction to the z thread dim
-    GaugeAPE(GaugeField &out, const GaugeField &in, double alpha) :
+    GaugeAPE(GaugeField &out, const GaugeField &in, real_t alpha) :
       TunableKernel3D(in, 2, apeDim),
       out(out),
       in(in),
@@ -49,7 +49,7 @@ namespace quda {
 
   }; // GaugeAPE
 
-  void APEStep(GaugeField &out, GaugeField& in, double alpha)
+  void APEStep(GaugeField &out, GaugeField& in, real_t alpha)
   {
     checkPrecision(out, in);
     checkReconstruct(out, in);
diff --git a/lib/gauge_covdev.cpp b/lib/gauge_covdev.cpp
index e3a9e751e4..7b64830499 100644
--- a/lib/gauge_covdev.cpp
+++ b/lib/gauge_covdev.cpp
@@ -49,7 +49,7 @@ namespace quda {
   }
 
   void GaugeCovDev::DslashXpay(ColorSpinorField &, const ColorSpinorField &, const QudaParity, const ColorSpinorField &,
-                               const double &) const
+                               const real_t &) const
   {
     //do nothing
   }
diff --git a/lib/gauge_field.cpp b/lib/gauge_field.cpp
index d1700709fc..3c5a4ea4d0 100644
--- a/lib/gauge_field.cpp
+++ b/lib/gauge_field.cpp
@@ -880,8 +880,8 @@ namespace quda {
       if (g.nFace != nFace) errorQuda("nFace does not match %d %d", nFace, g.nFace);
       if (g.fixed != fixed) errorQuda("fixed does not match %d %d", fixed, g.fixed);
       if (g.t_boundary != t_boundary) errorQuda("t_boundary does not match %d %d", t_boundary, g.t_boundary);
-      if (g.anisotropy != anisotropy) errorQuda("anisotropy does not match %e %e", anisotropy, g.anisotropy);
-      if (g.tadpole != tadpole) errorQuda("tadpole does not match %e %e", tadpole, g.tadpole);
+      if (g.anisotropy != anisotropy) errorQuda("anisotropy does not match %e %e", double(anisotropy), double(g.anisotropy));
+      if (g.tadpole != tadpole) errorQuda("tadpole does not match %e %e", double(tadpole), double(g.tadpole));
     }
     catch(std::bad_cast &e) {
       errorQuda("Failed to cast reference to GaugeField");
@@ -1121,9 +1121,9 @@ namespace quda {
     output << "order = " << param.order << std::endl;
     output << "fixed = " << param.fixed << std::endl;
     output << "link_type = " << param.link_type << std::endl;
-    output << "t_boundary = " << param.t_boundary << std::endl;
-    output << "anisotropy = " << param.anisotropy << std::endl;
-    output << "tadpole = " << param.tadpole << std::endl;
+    output << "t_boundary = " << double(param.t_boundary) << std::endl;
+    output << "anisotropy = " << double(param.anisotropy) << std::endl;
+    output << "tadpole = " << double(param.tadpole) << std::endl;
     output << "create = " << param.create << std::endl;
     output << "geometry = " << param.geometry << std::endl;
     output << "staggeredPhaseType = " << param.staggeredPhaseType << std::endl;
@@ -1169,21 +1169,21 @@ namespace quda {
   }
 
   // Return the L2 norm squared of the gauge field
-  double norm2(const GaugeField &a)
+  real_t norm2(const GaugeField &a)
   {
     ColorSpinorField b(colorSpinorParam(a));
     return blas::norm2(b);
   }
 
   // Return the L1 norm of the gauge field
-  double norm1(const GaugeField &a)
+  real_t norm1(const GaugeField &a)
   {
     ColorSpinorField b(colorSpinorParam(a));
     return blas::norm1(b);
   }
 
   // Scale the gauge field by the constant a
-  void ax(const double &a, GaugeField &u)
+  void ax(const real_t &a, GaugeField &u)
   {
     ColorSpinorField b(colorSpinorParam(u));
     blas::ax(a, b);
diff --git a/lib/gauge_fix_fft.cu b/lib/gauge_fix_fft.cu
index 1de3980332..236cf9c3b3 100644
--- a/lib/gauge_fix_fft.cu
+++ b/lib/gauge_fix_fft.cu
@@ -67,8 +67,8 @@ namespace quda {
       TuneParam tp = tuneLaunch(*this, getTuning(), getVerbosity());
       launch<FixQualityFFT>(arg.result, tp, stream, arg);
 
-      arg.result[0] /= static_cast<double>(3 * Arg::gauge_dir * meta.Volume());
-      arg.result[1] /= static_cast<double>(3 * meta.Volume());
+      arg.result[0] /= static_cast<real_t>(3 * Arg::gauge_dir * meta.Volume());
+      arg.result[1] /= static_cast<real_t>(3 * meta.Volume());
     }
 
     long long flops() const { return (36 * Arg::gauge_dir + 65) * meta.Volume(); }
@@ -183,7 +183,7 @@ namespace quda {
 
   template <typename Float, QudaReconstructType recon, int gauge_dir>
   void gaugeFixingFFT(GaugeField& data, int Nsteps, int verbose_interval,
-                      double alpha0, int autotune, double tolerance, int stopWtheta)
+                      real_t alpha0, int autotune, real_t tolerance, int stopWtheta)
   {
     TimeProfile profileInternalGaugeFixFFT("InternalGaugeFixQudaFFT", false);
 
@@ -191,8 +191,8 @@ namespace quda {
 
     if (getVerbosity() >= QUDA_SUMMARIZE) {
       printfQuda("\tAuto tune active: %s\n", autotune ? "true" : "false");      
-      printfQuda("\tAlpha parameter of the Steepest Descent Method: %e\n", alpha0);
-      printfQuda("\tTolerance: %lf\n", tolerance);
+      printfQuda("\tAlpha parameter of the Steepest Descent Method: %e\n", double(alpha0));
+      printfQuda("\tTolerance: %lf\n", double(tolerance));
       printfQuda("\tStop criterion method: %s\n", stopWtheta ? "Theta" : "Delta");
       printfQuda("\tMaximum number of iterations: %d\n", Nsteps);
       printfQuda("\tPrint convergence results at every %d steps\n", verbose_interval);
@@ -216,10 +216,10 @@ namespace quda {
     GaugeFixQualityFFTArg<Float, recon, gauge_dir> argQ(data, arg.delta);
     GaugeFixQuality<decltype(argQ)> gfixquality(argQ, data);
     gfixquality.apply(device::get_default_stream());
-    double action0 = argQ.getAction();
-    if(getVerbosity() >= QUDA_SUMMARIZE) printf("Step: %d\tAction: %.16e\ttheta: %.16e\n", 0, argQ.getAction(), argQ.getTheta());
+    auto action0 = argQ.getAction();
+    logQuda(QUDA_SUMMARIZE, "Step: %d\tAction: %.16e\ttheta: %.16e\n", 0, double(argQ.getAction()), double(argQ.getTheta()));
 
-    double diff = 0.0;
+    real_t diff = 0.0;
     int iter = 0;
     for (iter = 0; iter < Nsteps; iter++) {
       for (int k = 0; k < 6; k++) {
@@ -282,10 +282,11 @@ namespace quda {
       // Measure gauge quality and recalculate new Delta(x)
       //------------------------------------------------------------------------
       gfixquality.apply(device::get_default_stream());
-      double action = argQ.getAction();
+      real_t action = argQ.getAction();
       diff = abs(action0 - action);
       if ((iter % verbose_interval) == (verbose_interval - 1) && getVerbosity() >= QUDA_SUMMARIZE)
-        printf("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1, argQ.getAction(), argQ.getTheta(), diff);
+        printf("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1,
+               double(argQ.getAction()), double(argQ.getTheta()), double(diff));
       if ( autotune && ((action - action0) < -1e-14) ) {
         if ( arg.alpha > 0.01 ) {
           arg.alpha = 0.95 * arg.alpha;
@@ -301,7 +302,7 @@ namespace quda {
       action0 = action;
     }
     if ((iter % verbose_interval) != (verbose_interval - 1) && getVerbosity() >= QUDA_SUMMARIZE)
-      printf("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1, argQ.getAction(), argQ.getTheta(), diff);
+      printf("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1, double(argQ.getAction()), double(argQ.getTheta()), double(diff));
     
     // Reunitarize at end
     const double unitarize_eps = 1e-14;
@@ -363,7 +364,7 @@ namespace quda {
 
   template<typename Float, int nColors, QudaReconstructType recon> struct GaugeFixingFFT {
     GaugeFixingFFT(GaugeField& data, int gauge_dir, int Nsteps, int verbose_interval,
-                   double alpha, int autotune, double tolerance, int stopWtheta)
+                   real_t alpha, int autotune, real_t tolerance, int stopWtheta)
     {
       if (gauge_dir != 3) {
 	if (getVerbosity() > QUDA_SUMMARIZE) printfQuda("Starting Landau gauge fixing with FFTs...\n");
@@ -386,8 +387,8 @@ namespace quda {
    * @param[in] tolerance, torelance value to stop the method, if this value is zero then the method stops when iteration reachs the maximum number of steps defined by Nsteps
    * @param[in] stopWtheta, 0 for MILC criterion and 1 to use the theta value
    */
-  void gaugeFixingFFT(GaugeField& data, const int gauge_dir, const int Nsteps, const int verbose_interval, const double alpha,
-                      const int autotune, const double tolerance, const int stopWtheta)
+  void gaugeFixingFFT(GaugeField& data, const int gauge_dir, const int Nsteps, const int verbose_interval, const real_t alpha,
+                      const int autotune, const real_t tolerance, const int stopWtheta)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     if (comm_partitioned()) errorQuda("Gauge Fixing with FFTs in multi-GPU support NOT implemented yet!");
diff --git a/lib/gauge_fix_ovr.cu b/lib/gauge_fix_ovr.cu
index 064ed5b158..f021acadfc 100644
--- a/lib/gauge_fix_ovr.cu
+++ b/lib/gauge_fix_ovr.cu
@@ -62,7 +62,7 @@ namespace quda {
   template<typename Float, QudaReconstructType recon, int gauge_dir>
   class GaugeFix : TunableKernel2D {
     GaugeField &u;
-    double relax_boost;
+    real_t relax_boost;
     int *borderpoints[2];
     int parity;
     unsigned long threads;
@@ -96,7 +96,7 @@ namespace quda {
     unsigned int minThreads() const { return threads; }
 
   public:
-    GaugeFix(GaugeField &u, double relax_boost, int *borderpoints[2], bool halo, int threads) :
+    GaugeFix(GaugeField &u, real_t relax_boost, int *borderpoints[2], bool halo, int threads) :
       TunableKernel2D(u, 8),
       u(u),
       relax_boost(relax_boost),
@@ -189,8 +189,8 @@ namespace quda {
       TuneParam tp = tuneLaunch(*this, getTuning(), getVerbosity());
       launch<FixQualityOVR>(arg.result, tp, stream, arg);
 
-      arg.result[0] /= static_cast<double>(3 * Arg::gauge_dir * 2 * arg.threads.x * comm_size());
-      arg.result[1] /= static_cast<double>(3 * 2 * arg.threads.x * comm_size());
+      arg.result[0] /= static_cast<real_t>(3 * Arg::gauge_dir * 2 * arg.threads.x * comm_size());
+      arg.result[1] /= static_cast<real_t>(3 * 2 * arg.threads.x * comm_size());
     }
 
     long long flops() const { return (36LL * Arg::gauge_dir + 65LL) * meta.Volume(); }
@@ -227,7 +227,7 @@ namespace quda {
 
   template <typename Float, QudaReconstructType recon, int gauge_dir>
   void gaugeFixingOVR(GaugeField &data,const int Nsteps, const int verbose_interval,
-                      const double relax_boost, const double tolerance,
+                      const real_t relax_boost, const real_t tolerance,
                       const int reunit_interval, const int stopWtheta)
   {
     TimeProfile profileInternalGaugeFixOVR("InternalGaugeFixQudaOVR", false);
@@ -237,8 +237,8 @@ namespace quda {
     double byte = 0;
 
     if (getVerbosity() >= QUDA_SUMMARIZE) {
-      printfQuda("\tOverrelaxation boost parameter: %e\n", relax_boost);
-      printfQuda("\tTolerance: %le\n", tolerance);
+      printfQuda("\tOverrelaxation boost parameter: %e\n", double(relax_boost));
+      printfQuda("\tTolerance: %le\n", double(tolerance));
       printfQuda("\tStop criterion method: %s\n", stopWtheta ? "Theta" : "Delta");
       printfQuda("\tMaximum number of iterations: %d\n", Nsteps);
       printfQuda("\tReunitarize at every %d steps\n", reunit_interval);
@@ -315,8 +315,8 @@ namespace quda {
     GaugeFixQuality.apply(device::get_default_stream());
     flop += (double)GaugeFixQuality.flops();
     byte += (double)GaugeFixQuality.bytes();
-    double action0 = argQ.getAction();
-    if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Step: %d\tAction: %.16e\ttheta: %.16e\n", 0, argQ.getAction(), argQ.getTheta());
+    real_t action0 = argQ.getAction();
+    logQuda(QUDA_VERBOSE, "Step: %d\tAction: %.16e\ttheta: %.16e\n", 0, double(argQ.getAction()), double(argQ.getTheta()));
 
     *num_failures_h = 0;
     unitarizeLinks(data, data, num_failures_d);
@@ -413,10 +413,11 @@ namespace quda {
       flop += (double)GaugeFixQuality.flops();
       byte += (double)GaugeFixQuality.bytes();
 
-      double action = argQ.getAction();
-      double diff = abs(action0 - action);
+      real_t action = argQ.getAction();
+      real_t diff = abs(action0 - action);
       if ((iter % verbose_interval) == (verbose_interval - 1) && getVerbosity() >= QUDA_SUMMARIZE)
-        printfQuda("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1, argQ.getAction(), argQ.getTheta(), diff);
+        printfQuda("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1,
+                   double(argQ.getAction()), double(argQ.getTheta()), double(diff));
       if (stopWtheta) {
         if (argQ.getTheta() < tolerance) break;
       } else {
@@ -437,9 +438,10 @@ namespace quda {
       GaugeFixQuality.apply(device::get_default_stream());
       flop += (double)GaugeFixQuality.flops();
       byte += (double)GaugeFixQuality.bytes();
-      double action = argQ.getAction();
-      double diff = abs(action0 - action);
-      if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1, argQ.getAction(), argQ.getTheta(), diff);
+      real_t action = argQ.getAction();
+      real_t diff = abs(action0 - action);
+      logQuda(QUDA_VERBOSE, "Step: %d\tAction: %.16e\ttheta: %.16e\tDelta: %.16e\n", iter + 1,
+              double(argQ.getAction()), double(argQ.getTheta()), double(diff));
     }
 
     for (int i = 0; i < 2 && nlinksfaces; i++) managed_free(borderpoints[i]);
@@ -474,7 +476,7 @@ namespace quda {
 
   template <typename Float, int nColor, QudaReconstructType recon> struct GaugeFixingOVR {
   GaugeFixingOVR(GaugeField& data, const int gauge_dir, const int Nsteps, const int verbose_interval,
-                 const double relax_boost, const double tolerance, const int reunit_interval, const int stopWtheta)
+                 const real_t relax_boost, const real_t tolerance, const int reunit_interval, const int stopWtheta)
     {
       if (gauge_dir == 4) {
 	if (getVerbosity() >= QUDA_SUMMARIZE) printfQuda("Starting Landau gauge fixing...\n");
@@ -499,8 +501,8 @@ namespace quda {
    * @param[in] reunit_interval, reunitarize gauge field when iteration count is a multiple of this
    * @param[in] stopWtheta, 0 for MILC criterion and 1 to use the theta value
    */
-  void gaugeFixingOVR(GaugeField& data, const int gauge_dir, const int Nsteps, const int verbose_interval, const double relax_boost,
-                      const double tolerance, const int reunit_interval, const int stopWtheta)
+  void gaugeFixingOVR(GaugeField& data, const int gauge_dir, const int Nsteps, const int verbose_interval, const real_t relax_boost,
+                      const real_t tolerance, const int reunit_interval, const int stopWtheta)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     instantiate<GaugeFixingOVR>(data, gauge_dir, Nsteps, verbose_interval, relax_boost, tolerance, reunit_interval, stopWtheta);
diff --git a/lib/gauge_force.cu b/lib/gauge_force.cu
index 5e43fa64e6..bf7c8a68d0 100644
--- a/lib/gauge_force.cu
+++ b/lib/gauge_force.cu
@@ -9,12 +9,12 @@ namespace quda {
   {
     const GaugeField &u;
     GaugeField &mom;
-    double epsilon;
+    real_t epsilon;
     const paths<4> &p;
     unsigned int minThreads() const { return mom.VolumeCB(); }
 
   public:
-    ForceGauge(const GaugeField &u, GaugeField &mom, double epsilon, const paths<4> &p) :
+    ForceGauge(const GaugeField &u, GaugeField &mom, real_t epsilon, const paths<4> &p) :
       TunableKernel3D(u, 2, 4),
       u(u),
       mom(mom),
@@ -45,8 +45,8 @@ namespace quda {
 
   template<typename Float, int nColor, QudaReconstructType recon_u> using GaugePath = ForceGauge<Float,nColor,recon_u,false>;
 
-  void gaugeForce(GaugeField& mom, const GaugeField& u, double epsilon, std::vector<int**>& input_path,
-                  std::vector<int>& length, std::vector<double>& path_coeff, int num_paths, int path_max_length)
+  void gaugeForce(GaugeField& mom, const GaugeField& u, real_t epsilon, std::vector<int**>& input_path,
+                  std::vector<int>& length, std::vector<real_t>& path_coeff, int num_paths, int path_max_length)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     checkPrecision(mom, u);
@@ -61,8 +61,8 @@ namespace quda {
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
   }
   
-  void gaugePath(GaugeField& out, const GaugeField& u, double coeff, std::vector<int**>& input_path,
-		 std::vector<int>& length, std::vector<double>& path_coeff, int num_paths, int path_max_length)
+  void gaugePath(GaugeField& out, const GaugeField& u, real_t coeff, std::vector<int**>& input_path,
+		 std::vector<int>& length, std::vector<real_t>& path_coeff, int num_paths, int path_max_length)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     checkPrecision(out, u);
diff --git a/lib/gauge_laplace.cpp b/lib/gauge_laplace.cpp
index 18ab9e3802..7c63a1a731 100644
--- a/lib/gauge_laplace.cpp
+++ b/lib/gauge_laplace.cpp
@@ -34,7 +34,7 @@ namespace quda {
 
   void GaugeLaplace::DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, 
 			       const QudaParity parity, const ColorSpinorField &x,
-			       const double &k) const
+			       const real_t &k) const
   {
     checkSpinorAlias(in, out);
 
@@ -92,7 +92,7 @@ namespace quda {
 
   void GaugeLaplacePC::M(ColorSpinorField &out, const ColorSpinorField &in) const
   {
-    double kappa2 = -kappa*kappa;
+    auto kappa2 = -kappa*kappa;
     auto tmp = getFieldTmp(in);
 
     if (matpcType == QUDA_MATPC_EVEN_EVEN) {
diff --git a/lib/gauge_loop_trace.cu b/lib/gauge_loop_trace.cu
index 0b1af50ba4..3bcc9b1f12 100644
--- a/lib/gauge_loop_trace.cu
+++ b/lib/gauge_loop_trace.cu
@@ -9,14 +9,14 @@ namespace quda {
   template<typename Float, int nColor, QudaReconstructType recon>
   class GaugeLoopTrace : public TunableMultiReduction {
     const GaugeField &u;
-    using reduce_t = array<double, 2>;
+    using reduce_t = array<real_t, 2>;
     std::vector<reduce_t>& loop_traces;
-    double factor;
+    real_t factor;
     const paths<1> p;
 
   public:
     // max block size of 8 is arbitrary for now
-    GaugeLoopTrace(const GaugeField &u, std::vector<reduce_t> &loop_traces, double factor, const paths<1>& p) :
+    GaugeLoopTrace(const GaugeField &u, std::vector<reduce_t> &loop_traces, real_t factor, const paths<1>& p) :
       TunableMultiReduction(u, 2u, p.num_paths, 8),
       u(u),
       loop_traces(loop_traces),
@@ -52,18 +52,18 @@ namespace quda {
     }
   };
 
-  void gaugeLoopTrace(const GaugeField& u, std::vector<Complex>& loop_traces, double factor, std::vector<int**>& input_path,
-		 std::vector<int>& length, std::vector<double>& path_coeff, int num_paths, int path_max_length)
+  void gaugeLoopTrace(const GaugeField& u, std::vector<complex_t>& loop_traces, real_t factor, std::vector<int**>& input_path,
+		 std::vector<int>& length, std::vector<real_t>& path_coeff, int num_paths, int path_max_length)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     paths<1> p(input_path, length, path_coeff, num_paths, path_max_length);
 
-    std::vector<array<double, 2>> tr_array(loop_traces.size());
+    std::vector<array<real_t, 2>> tr_array(loop_traces.size());
 
     // gauge field must be passed as first argument so we peel off its reconstruct type
     instantiate<GaugeLoopTrace, ReconstructNo12>(u, tr_array, factor, p);
 
-    for (auto i = 0u; i < tr_array.size(); i++) { loop_traces[i] = Complex(tr_array[i][0], tr_array[i][1]); }
+    for (auto i = 0u; i < tr_array.size(); i++) { loop_traces[i] = complex_t(tr_array[i][0], tr_array[i][1]); }
 
     p.free();
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
diff --git a/lib/gauge_norm.in.cu b/lib/gauge_norm.in.cu
index 0da4412d17..de18ac815a 100644
--- a/lib/gauge_norm.in.cu
+++ b/lib/gauge_norm.in.cu
@@ -13,8 +13,8 @@ namespace quda {
   };
 
   template <typename reg_type, typename real, int Nc, QudaGaugeFieldOrder order>
-  double norm(const GaugeField &u, int d, norm_type_ type) {
-    double norm_ = 0.0;
+  real_t norm(const GaugeField &u, int d, norm_type_ type) {
+    real_t norm_ = 0.0;
     switch(type) {
     case   NORM1: norm_ = FieldOrder<reg_type,Nc,1,order,true,real>(const_cast<GaugeField &>(u)).norm1(d);   break;
     case   NORM2: norm_ = FieldOrder<reg_type,Nc,1,order,true,real>(const_cast<GaugeField &>(u)).norm2(d);   break;
@@ -36,10 +36,10 @@ namespace quda {
   };
 
   template <typename T, bool fixed, int nColor>
-  double norm(const GaugeField &u, int d, norm_type_ type) {
+  real_t norm(const GaugeField &u, int d, norm_type_ type) {
     using reg_t = typename type_mapper<T, fixed>::reg_t;
     using store_t = typename type_mapper<T, fixed>::store_t;
-    double norm_ = 0.0;
+    real_t norm_ = 0.0;
     switch (u.FieldOrder()) {
     case QUDA_FLOAT2_GAUGE_ORDER: norm_ = norm<reg_t, store_t, nColor, QUDA_FLOAT2_GAUGE_ORDER>(u, d, type); break;
     case QUDA_QDP_GAUGE_ORDER:    norm_ = norm<reg_t, store_t, nColor, QUDA_QDP_GAUGE_ORDER>(u, d, type); break;
@@ -52,9 +52,9 @@ namespace quda {
   template <int...> struct IntList { };
 
   template <typename T, bool fixed, int nColor, int...N>
-  double norm(const GaugeField &u, int d, norm_type_ type, IntList<nColor, N...>)
+  real_t norm(const GaugeField &u, int d, norm_type_ type, IntList<nColor, N...>)
   {
-    double norm_ = 0.0;
+    real_t norm_ = 0.0;
     if (u.Ncolor() == 3 && u.Ncolor() == nColor) {
       norm_ = norm<T, fixed, nColor>(u, d, type);
     } else if (u.Ncolor() > 3 && u.Ncolor() / 2 == nColor) {
@@ -70,7 +70,7 @@ namespace quda {
   }
 
   template <typename T> struct Norm {
-    Norm(const GaugeField &u, double &nrm, int d, bool fixed, norm_type_ type)
+    Norm(const GaugeField &u, real_t &nrm, int d, bool fixed, norm_type_ type)
     {
       if (fixed && u.Precision() > QUDA_SINGLE_PRECISION)
         errorQuda("Fixed point override only enabled for 8-bit, 16-bit and 32-bit fields");
@@ -80,30 +80,30 @@ namespace quda {
     }
   };
 
-  double GaugeField::norm1(int d, bool fixed) const {
+  real_t GaugeField::norm1(int d, bool fixed) const {
     if (reconstruct != QUDA_RECONSTRUCT_NO) errorQuda("Unsupported reconstruct=%d", reconstruct);
-    double nrm = 0.0;
+    real_t nrm = 0.0;
     instantiatePrecision<Norm>(*this, nrm, d, fixed, NORM1);
     return nrm;
   }
 
-  double GaugeField::norm2(int d, bool fixed) const {
+  real_t GaugeField::norm2(int d, bool fixed) const {
     if (reconstruct != QUDA_RECONSTRUCT_NO) errorQuda("Unsupported reconstruct=%d", reconstruct);
-    double nrm = 0.0;
+    real_t nrm = 0.0;
     instantiatePrecision<Norm>(*this, nrm, d, fixed, NORM2);
     return nrm;
   }
 
-  double GaugeField::abs_max(int d, bool fixed) const {
+  real_t GaugeField::abs_max(int d, bool fixed) const {
     if (reconstruct != QUDA_RECONSTRUCT_NO) errorQuda("Unsupported reconstruct=%d", reconstruct);
-    double nrm = 0.0;
+    real_t nrm = 0.0;
     instantiatePrecision<Norm>(*this, nrm, d, fixed, ABS_MAX);
     return nrm;
   }
 
-  double GaugeField::abs_min(int d, bool fixed) const {
+  real_t GaugeField::abs_min(int d, bool fixed) const {
     if (reconstruct != QUDA_RECONSTRUCT_NO) errorQuda("Unsupported reconstruct=%d", reconstruct);
-    double nrm = std::numeric_limits<double>::infinity();
+    real_t nrm = std::numeric_limits<double>::infinity();
     instantiatePrecision<Norm>(*this, nrm, d, fixed, ABS_MIN);
     return nrm;
   }
diff --git a/lib/gauge_observable.cpp b/lib/gauge_observable.cpp
index 041dc6164d..af2a23761f 100644
--- a/lib/gauge_observable.cpp
+++ b/lib/gauge_observable.cpp
@@ -1,3 +1,4 @@
+#include <complex_quda.h>
 #include <gauge_field.h>
 #include <gauge_tools.h>
 #include <gauge_path_quda.h>
@@ -19,18 +20,22 @@ namespace quda
     }
 
     if (param.compute_plaquette) {
-      double3 plaq = plaquette(u);
-      param.plaquette[0] = plaq.x;
-      param.plaquette[1] = plaq.y;
-      param.plaquette[2] = plaq.z;
+      auto plaq = plaquette(u);
+      param.plaquette[0] = double(plaq[0]);
+      param.plaquette[1] = double(plaq[1]);
+      param.plaquette[2] = double(plaq[2]);
     }
 
-    if (param.compute_polyakov_loop) { gaugePolyakovLoop(param.ploop, u, 3, profile); }
+    if (param.compute_polyakov_loop) {
+      auto ploop = gaugePolyakovLoop(u, 3, profile);
+      param.ploop[0] = double(ploop[0]);
+      param.ploop[1] = double(ploop[1]);
+    }
 
     if (param.compute_gauge_loop_trace) {
       // wrap 1-d arrays in std::vector
       std::vector<int> path_length_v(param.num_paths);
-      std::vector<double> loop_coeff_v(param.num_paths);
+      std::vector<real_t> loop_coeff_v(param.num_paths);
       for (int i = 0; i < param.num_paths; i++) {
         path_length_v[i] = param.path_length[i];
         loop_coeff_v[i] = param.loop_coeff[i];
@@ -41,13 +46,16 @@ namespace quda
       for (int d = 0; d < 1; d++) { input_path_v[d] = param.input_path_buff; }
 
       // prepare trace storage
-      std::vector<Complex> loop_traces(param.num_paths);
+      std::vector<complex_t> loop_traces(param.num_paths);
 
       // actually do the computation
       gaugeLoopTrace(u, loop_traces, param.factor, input_path_v, path_length_v, loop_coeff_v, param.num_paths,
                      param.max_length);
 
-      for (int i = 0; i < param.num_paths; i++) { memcpy(param.traces + i, &loop_traces[i], sizeof(Complex)); }
+      for (int i = 0; i < param.num_paths; i++) {
+        complex<double> lt = loop_traces[i];
+        memcpy(&param.traces[i], &lt, sizeof(complex<double>));
+      }
     }
 
     // no point constructing Fmunu unless we are going to use it
@@ -74,10 +82,14 @@ namespace quda
       void *d_qDensity = param.compute_qcharge_density ? pool_device_malloc(size) : nullptr;
       profile.TPSTOP(QUDA_PROFILE_INIT);
 
+      array<real_t, 3> energy;
+      real_t qcharge;
       if (param.compute_qcharge_density)
-        computeQChargeDensity(param.energy, param.qcharge, d_qDensity, gaugeFmunu);
+        qcharge = computeQChargeDensity(energy, d_qDensity, gaugeFmunu);
       else
-        computeQCharge(param.energy, param.qcharge, gaugeFmunu);
+        qcharge = computeQCharge(energy, gaugeFmunu);
+      for (int i = 0; i < 3; i++) param.energy[i] = double(energy[i]);
+      param.qcharge = double(qcharge);
 
       if (param.compute_qcharge_density) {
         profile.TPSTART(QUDA_PROFILE_D2H);
diff --git a/lib/gauge_plaq.cu b/lib/gauge_plaq.cu
index ee48d2e3d2..221b34f963 100644
--- a/lib/gauge_plaq.cu
+++ b/lib/gauge_plaq.cu
@@ -8,10 +8,10 @@ namespace quda {
   template<typename Float, int nColor, QudaReconstructType recon>
   class GaugePlaq : public TunableReduction2D {
     const GaugeField &u;
-    array<double, 2> &plq;
+    array<real_t, 2> &plq;
 
   public:
-    GaugePlaq(const GaugeField &u, array<double, 2> &plq) :
+    GaugePlaq(const GaugeField &u, array<real_t, 2> &plq) :
       TunableReduction2D(u),
       u(u),
       plq(plq)
@@ -35,14 +35,14 @@ namespace quda {
     long long bytes() const { return u.Bytes(); }
   };
 
-  double3 plaquette(const GaugeField &U)
+  array<real_t, 3> plaquette(const GaugeField &U)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
-    array<double, 2> plq{0.0, 0.0};
+    array<real_t, 2> plq{0.0, 0.0};
     instantiate<GaugePlaq, ReconstructGauge>(U, plq);
-    double3 plaq = make_double3(0.5*(plq[0] + plq[1]), plq[0], plq[1]);
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
-    return plaq;
+
+    return{0.5*(plq[0] + plq[1]), plq[0], plq[1]};
   }
 
 } // namespace quda
diff --git a/lib/gauge_polyakov_loop.cu b/lib/gauge_polyakov_loop.cu
index 99ae5ea149..26c8c07173 100644
--- a/lib/gauge_polyakov_loop.cu
+++ b/lib/gauge_polyakov_loop.cu
@@ -81,11 +81,10 @@ namespace quda {
   template<typename Float, int nColor, QudaReconstructType recon>
   class GaugePolyakovLoopTrace : public TunableReduction2D {
     const GaugeField &u;
-    using reduce_t = array<double, 2>;
-    reduce_t &ploop;
+    array<real_t, 2> &ploop;
 
   public:
-    GaugePolyakovLoopTrace(const GaugeField &u, array<double, 2> &ploop) :
+    GaugePolyakovLoopTrace(const GaugeField &u, array<real_t, 2> &ploop) :
       TunableReduction2D(u),
       u(u),
       ploop(ploop)
@@ -132,12 +131,12 @@ namespace quda {
     instantiate<GaugeInsertTimeslice>(u, s, timeslice);
   }
 
-  void gaugePolyakovLoop(double ploop[2], const GaugeField& u, int dir, TimeProfile &profile) {
+  array<real_t, 2> gaugePolyakovLoop(const GaugeField& u, int dir, TimeProfile &profile) {
 
     if (dir != 3) errorQuda("Unsupported direction %d", dir);
 
     // output array
-    array<double, 2> loop;
+    array<real_t, 2> loop;
 
     std::unique_ptr<GaugeField> condensed_field;
 
@@ -250,12 +249,11 @@ namespace quda {
     // Trace over remaining bits
     profile.TPSTART(QUDA_PROFILE_COMPUTE);
     instantiate<GaugePolyakovLoopTrace>(G, loop);
-    // We normalize by the 3-d volume, times the 4-d communications dim to cancel out redundant counting
-    auto vol3d = u.LocalVolume() * comm_dim(0) * comm_dim(1) * comm_dim(2) * comm_dim(3) / (u.X()[3] - 2 * u.R()[3]);
-    ploop[0] = loop[0] / vol3d;
-    ploop[1] = loop[1] / vol3d;
     profile.TPSTOP(QUDA_PROFILE_COMPUTE);
 
+    // We normalize by the 3-d volume, times the 4-d communications dim to cancel out redundant counting
+    auto vol3d = u.LocalVolume() * comm_dim(0) * comm_dim(1) * comm_dim(2) * comm_dim(3) / (u.X()[3] - 2 * u.R()[3]);
+    return {loop[0] / vol3d, loop[1] / vol3d};
   }
 
 } // namespace quda
diff --git a/lib/gauge_qcharge.cu b/lib/gauge_qcharge.cu
index 3b4e584b02..9451de3e16 100644
--- a/lib/gauge_qcharge.cu
+++ b/lib/gauge_qcharge.cu
@@ -9,13 +9,13 @@ namespace quda
   template <typename Float, int nColor, QudaReconstructType recon>
   class QCharge : TunableReduction2D {
     const GaugeField &Fmunu;
-    double *energy;
-    double &qcharge;
+    array<real_t, 3> &energy;
+    real_t &qcharge;
     void *qdensity;
     bool density;
 
   public:
-    QCharge(const GaugeField &Fmunu, double energy[3], double &qcharge, void *qdensity, bool density) :
+    QCharge(const GaugeField &Fmunu, array<real_t, 3> &energy, real_t &qcharge, void *qdensity, bool density) :
       TunableReduction2D(Fmunu),
       Fmunu(Fmunu),
       energy(energy),
@@ -33,7 +33,7 @@ namespace quda
     {
       TuneParam tp = tuneLaunch(*this, getTuning(), getVerbosity());
 
-      typename Arg<>::reduce_t result{};
+      array<real_t, 3> result{};
       if (!density) {
         Arg<false> arg(Fmunu, static_cast<Float*>(qdensity));
         launch<qCharge>(result, tp, stream, arg);
@@ -60,18 +60,22 @@ namespace quda
     long long bytes() const { return Fmunu.Bytes() + Fmunu.Volume() * (density * Fmunu.Precision()); }
   }; // QChargeCompute
 
-  void computeQCharge(double energy[3], double &qcharge, const GaugeField &Fmunu)
+  real_t computeQCharge(array<real_t, 3> &energy, const GaugeField &Fmunu)
   {
+    real_t qcharge;
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     instantiate<QCharge, ReconstructNone>(Fmunu, energy, qcharge, nullptr, false);
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
+    return qcharge;
   }
 
-  void computeQChargeDensity(double energy[3], double &qcharge, void *qdensity, const GaugeField &Fmunu)
+  real_t computeQChargeDensity(array<real_t, 3> &energy, void *qdensity, const GaugeField &Fmunu)
   {
+    real_t qcharge;
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     instantiate<QCharge, ReconstructNone>(Fmunu, energy, qcharge, qdensity, true);
     getProfile().TPSTOP(QUDA_PROFILE_COMPUTE);
+    return qcharge;
   }
 
 } // namespace quda
diff --git a/lib/gauge_random.cu b/lib/gauge_random.cu
index f3bfe8e22c..0c158ca1e1 100644
--- a/lib/gauge_random.cu
+++ b/lib/gauge_random.cu
@@ -13,20 +13,20 @@ namespace quda {
   {
     GaugeField &U;
     RNG &rng;
-    Float sigma;
+    real_t sigma;
     bool group;
     unsigned int minThreads() const { return U.VolumeCB(); }
 
   public:
-    GaugeGauss(GaugeField &U, RNG &rng, double sigma) :
+    GaugeGauss(GaugeField &U, RNG &rng, real_t sigma) :
       TunableKernel2D(U, 2),
       U(U),
       rng(rng),
-      sigma(static_cast<Float>(sigma)),
+      sigma(sigma),
       group(U.LinkType() == QUDA_SU3_LINKS)
     {
       if (group) {
-        logQuda(QUDA_SUMMARIZE, "Creating Gaussian distributed Lie group field with sigma = %e\n", sigma);
+        logQuda(QUDA_SUMMARIZE, "Creating Gaussian distributed Lie group field with sigma = %e\n", double(sigma));
       } else {
         logQuda(QUDA_SUMMARIZE, "Creating Gaussian distributed Lie algebra field\n");
       }
@@ -50,7 +50,7 @@ namespace quda {
     void postTune() { rng.restore(); }
   };
 
-  void gaugeGauss(GaugeField &U, RNG &rng, double sigma)
+  void gaugeGauss(GaugeField &U, RNG &rng, real_t sigma)
   {
     if (!U.isNative()) errorQuda("Order %d with %d reconstruct not supported", U.Order(), U.Reconstruct());
     if (U.LinkType() != QUDA_SU3_LINKS && U.LinkType() != QUDA_MOMENTUM_LINKS)
@@ -70,7 +70,7 @@ namespace quda {
     getProfile().TPSTOP(QUDA_PROFILE_COMMS);
   }
 
-  void gaugeGauss(GaugeField &U, unsigned long long seed, double sigma)
+  void gaugeGauss(GaugeField &U, unsigned long long seed, real_t sigma)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMMS);
     RNG randstates(U, seed);
diff --git a/lib/gauge_stout.cu b/lib/gauge_stout.cu
index f537ca60ea..5bb5328381 100644
--- a/lib/gauge_stout.cu
+++ b/lib/gauge_stout.cu
@@ -24,7 +24,7 @@ namespace quda {
 
   public:
     // (2,3): 2 for parity in the y thread dim, 3 corresponds to mapping direction to the z thread dim
-    GaugeSTOUT(GaugeField &out, const GaugeField &in, bool improved, double rho, double epsilon = 0.0) :
+    GaugeSTOUT(GaugeField &out, const GaugeField &in, bool improved, real_t rho, real_t epsilon = 0.0) :
       TunableKernel3D(in, 2, improved ? 4 : 3),
       out(out),
       in(in),
@@ -64,7 +64,7 @@ namespace quda {
               out.Reconstruct() * out.Precision()) * stoutDim * in.LocalVolume();    }
   };
 
-  void STOUTStep(GaugeField &out, GaugeField &in, double rho)
+  void STOUTStep(GaugeField &out, GaugeField &in, real_t rho)
   {
     checkPrecision(out, in);
     checkReconstruct(out, in);
@@ -78,7 +78,7 @@ namespace quda {
     out.exchangeExtendedGhost(out.R(), false);
   }
 
-  void OvrImpSTOUTStep(GaugeField &out, GaugeField& in, double rho, double epsilon)
+  void OvrImpSTOUTStep(GaugeField &out, GaugeField& in, real_t rho, real_t epsilon)
   {
     checkPrecision(out, in);
     checkReconstruct(out, in);
diff --git a/lib/gauge_wilson_flow.cu b/lib/gauge_wilson_flow.cu
index d92fb0a68c..2a9c765fce 100644
--- a/lib/gauge_wilson_flow.cu
+++ b/lib/gauge_wilson_flow.cu
@@ -29,7 +29,7 @@ namespace quda {
     }
 
   public:
-    GaugeWFlowStep(GaugeField &out, GaugeField &temp, const GaugeField &in, const double epsilon, const QudaGaugeSmearType wflow_type, const WFlowStepType step_type) :
+    GaugeWFlowStep(GaugeField &out, GaugeField &temp, const GaugeField &in, const real_t epsilon, const QudaGaugeSmearType wflow_type, const WFlowStepType step_type) :
       TunableKernel3D(in, 2, wflow_dim),
       out(out),
       temp(temp),
@@ -125,7 +125,7 @@ namespace quda {
     }
   }; // GaugeWFlowStep
 
-  void WFlowStep(GaugeField &out, GaugeField &temp, GaugeField &in, const double epsilon, const QudaGaugeSmearType smear_type)
+  void WFlowStep(GaugeField &out, GaugeField &temp, GaugeField &in, const real_t epsilon, const QudaGaugeSmearType smear_type)
   {
     checkPrecision(out, temp, in);
     checkReconstruct(out, in);
diff --git a/lib/interface_quda.cpp b/lib/interface_quda.cpp
index e63f9c1dc4..cf95788406 100644
--- a/lib/interface_quda.cpp
+++ b/lib/interface_quda.cpp
@@ -851,10 +851,10 @@ void loadCloverQuda(void *h_clover, void *h_clovinv, QudaInvertParam *inv_param)
 
   bool clover_update = false;
   // If either of the clover params have changed, trigger a recompute
-  double csw_old = cloverPrecise ? cloverPrecise->Csw() : 0.0;
-  double coeff_old = cloverPrecise ? cloverPrecise->Coeff() : 0.0;
-  double rho_old = cloverPrecise ? cloverPrecise->Rho() : 0.0;
-  double mu2_old = cloverPrecise ? cloverPrecise->Mu2() : 0.0;
+  auto csw_old = cloverPrecise ? cloverPrecise->Csw() : 0.0;
+  auto coeff_old = cloverPrecise ? cloverPrecise->Coeff() : 0.0;
+  auto rho_old = cloverPrecise ? cloverPrecise->Rho() : 0.0;
+  auto mu2_old = cloverPrecise ? cloverPrecise->Mu2() : 0.0;
   if (!cloverPrecise || invalidate_clover || inv_param->clover_coeff != coeff_old || inv_param->clover_csw != csw_old
       || inv_param->clover_csw != csw_old || inv_param->clover_rho != rho_old
       || 4 * inv_param->kappa * inv_param->kappa * inv_param->mu * inv_param->mu != mu2_old)
@@ -897,8 +897,8 @@ void loadCloverQuda(void *h_clover, void *h_clovinv, QudaInvertParam *inv_param)
     if ((!h_clovinv || inv_param->compute_clover_inverse) && !clover::dynamic_inverse()) {
       cloverInvert(*cloverPrecise, inv_param->compute_clover_trlog);
       if (inv_param->compute_clover_trlog) {
-        inv_param->trlogA[0] = cloverPrecise->TrLog()[0];
-        inv_param->trlogA[1] = cloverPrecise->TrLog()[1];
+        inv_param->trlogA[0] = double(cloverPrecise->TrLog()[0]);
+        inv_param->trlogA[1] = double(cloverPrecise->TrLog()[1]);
       }
     }
   } else {
@@ -1448,7 +1448,7 @@ namespace quda {
 
   void setDiracParam(DiracParam &diracParam, QudaInvertParam *inv_param, const bool pc)
   {
-    double kappa = inv_param->kappa;
+    real_t kappa = inv_param->kappa;
     if (inv_param->dirac_order == QUDA_CPS_WILSON_DIRAC_ORDER) {
       kappa *= gaugePrecise->Anisotropy();
     }
@@ -1477,11 +1477,11 @@ namespace quda {
       }
       diracParam.type = pc ? QUDA_MOBIUS_DOMAIN_WALLPC_EOFA_DIRAC : QUDA_MOBIUS_DOMAIN_WALL_EOFA_DIRAC;
       diracParam.Ls = inv_param->Ls;
-      if (sizeof(Complex) != sizeof(double _Complex)) {
+      if (sizeof(complex_t) != sizeof(double _Complex)) {
         errorQuda("Irreconcilable difference between interface and internal complex number conventions");
       }
-      memcpy(diracParam.b_5, inv_param->b_5, sizeof(Complex) * inv_param->Ls);
-      memcpy(diracParam.c_5, inv_param->c_5, sizeof(Complex) * inv_param->Ls);
+      memcpy(diracParam.b_5, inv_param->b_5, sizeof(complex_t) * inv_param->Ls);
+      memcpy(diracParam.c_5, inv_param->c_5, sizeof(complex_t) * inv_param->Ls);
       diracParam.eofa_shift = inv_param->eofa_shift;
       diracParam.eofa_pm = inv_param->eofa_pm;
       diracParam.mq1 = inv_param->mq1;
@@ -1493,16 +1493,17 @@ namespace quda {
 	errorQuda("Length of Ls dimension %d greater than QUDA_MAX_DWF_LS %d", inv_param->Ls, QUDA_MAX_DWF_LS);
       diracParam.type = pc ? QUDA_MOBIUS_DOMAIN_WALLPC_DIRAC : QUDA_MOBIUS_DOMAIN_WALL_DIRAC;
       diracParam.Ls = inv_param->Ls;
-      if (sizeof(Complex) != sizeof(double _Complex)) {
+      if (sizeof(complex_t) != sizeof(double _Complex)) {
         errorQuda("Irreconcilable difference between interface and internal complex number conventions");
       }
-      memcpy(diracParam.b_5, inv_param->b_5, sizeof(Complex) * inv_param->Ls);
-      memcpy(diracParam.c_5, inv_param->c_5, sizeof(Complex) * inv_param->Ls);
+      memcpy(diracParam.b_5, inv_param->b_5, sizeof(complex_t) * inv_param->Ls);
+      memcpy(diracParam.c_5, inv_param->c_5, sizeof(complex_t) * inv_param->Ls);
       if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
         printfQuda("Printing b_5 and c_5 values\n");
         for (int i = 0; i < diracParam.Ls; i++) {
-          printfQuda("fromQUDA diracParam: b5[%d] = %f + i%f, c5[%d] = %f + i%f\n", i, diracParam.b_5[i].real(),
-              diracParam.b_5[i].imag(), i, diracParam.c_5[i].real(), diracParam.c_5[i].imag());
+          printfQuda("fromQUDA diracParam: b5[%d] = %f + i%f, c5[%d] = %f + i%f\n",
+                     i, double(diracParam.b_5[i].real()), double(diracParam.b_5[i].imag()),
+                     i, double(diracParam.c_5[i].real()), double(diracParam.c_5[i].imag()));
           // printfQuda("fromQUDA inv_param: b5[%d] = %f %f c5[%d] = %f %f\n", i, inv_param->b_5[i], i,
           // inv_param->c_5[i] ); printfQuda("fromQUDA creal: b5[%d] = %f %f c5[%d] = %f %f \n", i,
           // creal(inv_param->b_5[i]), cimag(inv_param->b_5[i]), i, creal(inv_param->c_5[i]), cimag(inv_param->c_5[i]) );
@@ -1736,7 +1737,7 @@ namespace quda {
 
     logQuda(QUDA_DEBUG_VERBOSE, "Mass rescale: Kappa is: %g\n", kappa);
     logQuda(QUDA_DEBUG_VERBOSE, "Mass rescale: mass normalization: %d\n", param.mass_normalization);
-    logQuda(QUDA_DEBUG_VERBOSE, "Mass rescale: norm of source in = %g\n", blas::norm2(b));
+    logQuda(QUDA_DEBUG_VERBOSE, "Mass rescale: norm of source in = %g\n", double(blas::norm2(b)));
 
     // staggered dslash uses mass normalization internally
     if (param.dslash_type == QUDA_ASQTAD_DSLASH || param.dslash_type == QUDA_STAGGERED_DSLASH) {
@@ -1800,7 +1801,7 @@ namespace quda {
         errorQuda("Solution type %d not supported", param.solution_type);
     }
 
-    logQuda(QUDA_DEBUG_VERBOSE, "Mass rescale: norm of source out = %g\n", blas::norm2(b));
+    logQuda(QUDA_DEBUG_VERBOSE, "Mass rescale: norm of source out = %g\n", double(blas::norm2(b)));
   }
 }
 
@@ -1841,7 +1842,7 @@ void dslashQuda(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaParity
 
   profileDslash.TPSTART(QUDA_PROFILE_COMPUTE);
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", blas::norm2(in_h), blas::norm2(in));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", double(blas::norm2(in_h)), double(blas::norm2(in)));
 
   if (inv_param->mass_normalization == QUDA_KAPPA_NORMALIZATION &&
       (inv_param->dslash_type == QUDA_STAGGERED_DSLASH ||
@@ -1873,7 +1874,7 @@ void dslashQuda(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaParity
 
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", blas::norm2(out_h), blas::norm2(out));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
 
   profileDslash.TPSTART(QUDA_PROFILE_FREE);
   delete dirac; // clean up
@@ -1906,7 +1907,7 @@ void MatQuda(void *h_out, void *h_in, QudaInvertParam *inv_param)
   ColorSpinorField in(cudaParam);
   in = in_h;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", blas::norm2(in_h), blas::norm2(in));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", double(blas::norm2(in_h)), double(blas::norm2(in)));
 
   cudaParam.create = QUDA_NULL_FIELD_CREATE;
   cudaParam.location = QUDA_CUDA_FIELD_LOCATION;
@@ -1938,7 +1939,7 @@ void MatQuda(void *h_out, void *h_in, QudaInvertParam *inv_param)
   ColorSpinorField out_h(cpuParam);
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", blas::norm2(out_h), blas::norm2(out));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
 
   popVerbosity();
 }
@@ -1967,7 +1968,7 @@ void MatDagMatQuda(void *h_out, void *h_in, QudaInvertParam *inv_param)
   ColorSpinorField in(cudaParam);
   in = in_h;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", blas::norm2(in_h), blas::norm2(in));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", double(blas::norm2(in_h)), double(blas::norm2(in)));
 
   cudaParam.create = QUDA_NULL_FIELD_CREATE;
   ColorSpinorField out(cudaParam);
@@ -2001,7 +2002,7 @@ void MatDagMatQuda(void *h_out, void *h_in, QudaInvertParam *inv_param)
   ColorSpinorField out_h(cpuParam);
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", blas::norm2(out_h), blas::norm2(out));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
 
   popVerbosity();
 }
@@ -2148,7 +2149,7 @@ void cloverQuda(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaParity
   ColorSpinorField in(cudaParam);
   in = in_h;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", blas::norm2(in_h), blas::norm2(in));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", double(blas::norm2(in_h)), double(blas::norm2(in)));
 
   cudaParam.create = QUDA_NULL_FIELD_CREATE;
   ColorSpinorField out(cudaParam);
@@ -2175,7 +2176,7 @@ void cloverQuda(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaParity
   ColorSpinorField out_h(cpuParam);
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", blas::norm2(out_h), blas::norm2(out));
+  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
 
   popVerbosity();
 }
@@ -2281,7 +2282,7 @@ void eigensolveQuda(void **host_evecs, double _Complex *host_evals, QudaEigParam
   }
 
   // Simple vector for eigenvalues.
-  std::vector<Complex> evals(eig_param->n_conv, 0.0);
+  std::vector<complex_t> evals(eig_param->n_conv, real_t(0.0));
   //------------------------------------------------------
 
   // Sanity checks for operator/eigensolver compatibility.
@@ -2341,7 +2342,7 @@ void eigensolveQuda(void **host_evecs, double _Complex *host_evals, QudaEigParam
   // Transfer Eigenpairs back to host if using GPU eigensolver. The copy
   // will automatically rotate from device UKQCD gamma basis to the
   // host side gamma basis.
-  for (int i = 0; i < eig_param->n_conv; i++) { memcpy(host_evals + i, &evals[i], sizeof(Complex)); }
+  for (int i = 0; i < eig_param->n_conv; i++) { memcpy(host_evals + i, &evals[i], sizeof(complex_t)); }
   if (!(eig_param->arpack_check)) {
     for (int i = 0; i < n_eig; i++) host_evecs_[i] = kSpace[i];
   }
@@ -2788,23 +2789,23 @@ void invertQuda(void *hp_x, void *hp_b, QudaInvertParam *param)
 
   profileInvert.TPSTART(QUDA_PROFILE_PREAMBLE);
 
-  double nb = blas::norm2(b);
+  real_t nb = blas::norm2(b);
   if (nb==0.0) errorQuda("Source has zero norm");
 
   if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-    printfQuda("Source: CPU = %g, CUDA copy = %g\n", blas::norm2(h_b), nb);
+    printfQuda("Source: CPU = %g, CUDA copy = %g\n", double(blas::norm2(h_b)), double(nb));
     if (param->use_init_guess == QUDA_USE_INIT_GUESS_YES) {
-      printfQuda("Initial guess: CPU = %g, CUDA copy = %g\n", blas::norm2(h_x), blas::norm2(x));
+      printfQuda("Initial guess: CPU = %g, CUDA copy = %g\n", double(blas::norm2(h_x)), double(blas::norm2(x)));
     }
   } else if (getVerbosity() >= QUDA_VERBOSE) {
-    printfQuda("Source: %g\n", nb);
-    if (param->use_init_guess == QUDA_USE_INIT_GUESS_YES) { printfQuda("Initial guess: %g\n", blas::norm2(x)); }
+    printfQuda("Source: %g\n", double(nb));
+    if (param->use_init_guess == QUDA_USE_INIT_GUESS_YES) { printfQuda("Initial guess: %g\n", double(blas::norm2(x))); }
   }
 
   // rescale the source and solution vectors to help prevent the onset of underflow
   if (param->solver_normalization == QUDA_SOURCE_NORMALIZATION) {
-    blas::ax(1.0 / sqrt(nb), b);
-    blas::ax(1.0 / sqrt(nb), x);
+    blas::ax(rsqrt(nb), b);
+    blas::ax(rsqrt(nb), x);
   }
 
   massRescale(b, *param, false);
@@ -2812,15 +2813,15 @@ void invertQuda(void *hp_x, void *hp_b, QudaInvertParam *param)
   dirac.prepare(in, out, x, b, param->solution_type);
 
   if (getVerbosity() >= QUDA_VERBOSE) {
-    double nin = blas::norm2(*in);
-    double nout = blas::norm2(*out);
-    printfQuda("Prepared source = %g\n", nin);
-    printfQuda("Prepared solution = %g\n", nout);
+    auto nin = blas::norm2(*in);
+    auto nout = blas::norm2(*out);
+    printfQuda("Prepared source = %g\n", double(nin));
+    printfQuda("Prepared solution = %g\n", double(nout));
   }
 
   if (getVerbosity() >= QUDA_VERBOSE) {
-    double nin = blas::norm2(*in);
-    printfQuda("Prepared source post mass rescale = %g\n", nin);
+    auto nin = blas::norm2(*in);
+    printfQuda("Prepared source post mass rescale = %g\n", double(nin));
   }
 
   // solution_type specifies *what* system is to be solved.
@@ -2968,7 +2969,7 @@ void invertQuda(void *hp_x, void *hp_b, QudaInvertParam *param)
     solverParam.updateInvertParam(*param);
   }
 
-  if (getVerbosity() >= QUDA_VERBOSE) { printfQuda("Solution = %g\n", blas::norm2(x)); }
+  if (getVerbosity() >= QUDA_VERBOSE) { printfQuda("Solution = %g\n", double(blas::norm2(x))); }
 
   profileInvert.TPSTART(QUDA_PROFILE_EPILOGUE);
   if (param->chrono_make_resident) {
@@ -3014,15 +3015,15 @@ void invertQuda(void *hp_x, void *hp_b, QudaInvertParam *param)
   profileInvert.TPSTART(QUDA_PROFILE_EPILOGUE);
 
   if (param->compute_action) {
-    Complex action = blas::cDotProduct(b, x);
-    param->action[0] = action.real();
-    param->action[1] = action.imag();
+    auto action = blas::cDotProduct(b, x);
+    param->action[0] = double(action.real());
+    param->action[1] = double(action.imag());
   }
 
   if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-    printfQuda("Reconstructed solution: CUDA = %g, CPU copy = %g\n", blas::norm2(x), blas::norm2(h_x));
+    printfQuda("Reconstructed solution: CUDA = %g, CPU copy = %g\n", double(blas::norm2(x)), double(blas::norm2(h_x)));
   } else if (getVerbosity() >= QUDA_VERBOSE) {
-    printfQuda("Reconstructed solution: %g\n", blas::norm2(x));
+    printfQuda("Reconstructed solution: %g\n", double(blas::norm2(x)));
   }
   profileInvert.TPSTOP(QUDA_PROFILE_EPILOGUE);
 
@@ -3536,7 +3537,7 @@ void invertMultiShiftQuda(void **hp_x, void *hp_b, QudaInvertParam *param)
   dirac.prefetch(QUDA_CUDA_FIELD_LOCATION);
   diracSloppy.prefetch(QUDA_CUDA_FIELD_LOCATION);
 
-  std::vector<double> r2_old(param->num_offset);
+  std::vector<real_t> r2_old(param->num_offset);
 
   // Grab the dimension array of the input gauge field.
   const auto X = (param->dslash_type == QUDA_ASQTAD_DSLASH) ? gaugeFatPrecise->X() : gaugePrecise->X();
@@ -3591,13 +3592,13 @@ void invertMultiShiftQuda(void **hp_x, void *hp_b, QudaInvertParam *param)
   profileMulti.TPSTART(QUDA_PROFILE_PREAMBLE);
 
   // Check source norms
-  double nb = blas::norm2(b);
+  real_t nb = blas::norm2(b);
   if (nb==0.0) errorQuda("Source has zero norm");
 
   if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-    printfQuda("Source: CPU = %g, CUDA copy = %g\n", blas::norm2(h_b), nb);
+    printfQuda("Source: CPU = %g, CUDA copy = %g\n", double(blas::norm2(h_b)), double(nb));
   } else if (getVerbosity() >= QUDA_VERBOSE) {
-    printfQuda("Source: %g\n", nb);
+    printfQuda("Source: %g\n", double(nb));
   }
 
   // rescale the source vector to help prevent the onset of underflow
@@ -3756,10 +3757,10 @@ void invertMultiShiftQuda(void **hp_x, void *hp_b, QudaInvertParam *param)
   for (int i = 0; i < param->num_offset; i++) param->offset[i] = unscaled_shifts[i];
 
   if (param->compute_action) {
-    Complex action(0);
-    for (int i = 0; i < param->num_offset; i++) action += param->residue[i] * blas::cDotProduct(b, x[i]);
-    param->action[0] = action.real();
-    param->action[1] = action.imag();
+    complex_t action(0);
+    for (int i = 0; i < param->num_offset; i++) action += real_t(param->residue[i]) * blas::cDotProduct(b, x[i]);
+    param->action[0] = double(action.real());
+    param->action[1] = double(action.imag());
   }
 
   for(int i=0; i < param->num_offset; i++) {
@@ -3767,7 +3768,7 @@ void invertMultiShiftQuda(void **hp_x, void *hp_b, QudaInvertParam *param)
       blas::ax(sqrt(nb), x[i]);
     }
 
-    if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Solution %d = %g\n", i, blas::norm2(x[i]));
+    if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Solution %d = %g\n", i, double(blas::norm2(x[i])));
 
     if (!param->make_resident_solution) *h_x[i] = x[i];
   }
@@ -3955,7 +3956,7 @@ int computeGaugeForceQuda(void* mom, void* siteLink,  int*** input_path_buf, int
 
   // wrap 1-d arrays in std::vector
   std::vector<int> path_length_v(num_paths);
-  std::vector<double> loop_coeff_v(num_paths);
+  std::vector<real_t> loop_coeff_v(num_paths);
   for (int i = 0; i < num_paths; i++) {
     path_length_v[i] = path_length[i];
     loop_coeff_v[i] = loop_coeff[i];
@@ -4034,7 +4035,7 @@ int computeGaugePathQuda(void *out, void *siteLink, int ***input_path_buf, int *
 
   // wrap 1-d arrays in a std::vector
   std::vector<int> path_length_v(num_paths);
-  std::vector<double> loop_coeff_v(num_paths);
+  std::vector<real_t> loop_coeff_v(num_paths);
   for (int i = 0; i < num_paths; i++) {
     path_length_v[i] = path_length[i];
     loop_coeff_v[i] = loop_coeff[i];
@@ -4691,7 +4692,7 @@ void computeCloverForceQuda(void *h_mom, double dt, void **h_x, void **, double
 
   profileCloverForce.TPSTOP(QUDA_PROFILE_INIT);
 
-  std::vector<double> force_coeff(nvector);
+  std::vector<real_t> force_coeff(nvector);
   // loop over different quark fields
   for(int i=0; i<nvector; i++){
     ColorSpinorField &x = *(quarkX[i]);
@@ -4741,7 +4742,7 @@ void computeCloverForceQuda(void *h_mom, double dt, void **h_x, void **, double
   computeCloverSigmaTrace(oprod, *cloverPrecise, 2.0*ck*multiplicity*dt);
 
   /* Now the U dA/dU terms */
-  std::vector< std::vector<double> > ferm_epsilon(nvector);
+  std::vector< std::vector<real_t> > ferm_epsilon(nvector);
   for (int shift = 0; shift < nvector; shift++) {
     ferm_epsilon[shift].reserve(2);
     ferm_epsilon[shift][0] = 2.0*ck*coeff[shift]*dt;
@@ -4975,10 +4976,10 @@ void plaqQuda(double plaq[3])
   GaugeField *data = extendedGaugeResident ? extendedGaugeResident : createExtendedGauge(*gaugePrecise, R, profilePlaq);
   extendedGaugeResident = data;
 
-  double3 plaq3 = quda::plaquette(*data);
-  plaq[0] = plaq3.x;
-  plaq[1] = plaq3.y;
-  plaq[2] = plaq3.z;
+  auto plaq3 = quda::plaquette(*data);
+  plaq[0] = double(plaq3[0]);
+  plaq[1] = double(plaq3[1]);
+  plaq[2] = double(plaq3[2]);
 
   popProfile();
 }
@@ -5062,9 +5063,9 @@ void performWuppertalnStep(void *h_out, void *h_in, QudaInvertParam *inv_param,
   in = in_h;
 
   if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-    double cpu = blas::norm2(in_h);
-    double gpu = blas::norm2(in);
-    printfQuda("In CPU %e CUDA %e\n", cpu, gpu);
+    auto cpu = blas::norm2(in_h);
+    auto gpu = blas::norm2(in);
+    printfQuda("In CPU %e CUDA %e\n", double(cpu), double(gpu));
   }
 
   cudaParam.create = QUDA_NULL_FIELD_CREATE;
@@ -5086,8 +5087,8 @@ void performWuppertalnStep(void *h_out, void *h_in, QudaInvertParam *inv_param,
     if (i) in = out;
     ApplyLaplace(out, in, *precise, 3, a, b, in, parity, false, comm_dim, profileWuppertal);
     if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-      double norm = blas::norm2(out);
-      printfQuda("Step %d, vector norm %e\n", i, norm);
+      auto norm = blas::norm2(out);
+      printfQuda("Step %d, vector norm %e\n", i, double(norm));
     }
   }
 
@@ -5097,9 +5098,9 @@ void performWuppertalnStep(void *h_out, void *h_in, QudaInvertParam *inv_param,
   out_h = out;
 
   if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-    double cpu = blas::norm2(out_h);
-    double gpu = blas::norm2(out);
-    printfQuda("Out CPU %e CUDA %e\n", cpu, gpu);
+    auto cpu = blas::norm2(out_h);
+    auto gpu = blas::norm2(out);
+    printfQuda("Out CPU %e CUDA %e\n", double(cpu), double(gpu));
   }
 
   if (gaugeSmeared != nullptr)
@@ -5219,8 +5220,8 @@ void performTwoLinkGaussianSmearNStep(void *h_in, QudaQuarkSmearParam *smear_par
     
     qsmear_op.Expose()->SmearOp(out, in, a, 0.0, smear_param->t0, parity);
     if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
-      double norm = blas::norm2(out);
-      printfQuda("Step %d, vector norm %e\n", i, norm);
+      real_t norm = blas::norm2(out);
+      printfQuda("Step %d, vector norm %e\n", i, double(norm));
     }
     blas::xpay(temp1, -1.0, out);
     blas::zero(temp1);
diff --git a/lib/inv_bicgstab_quda.cpp b/lib/inv_bicgstab_quda.cpp
index c5d3bf90a1..1e2d00aa70 100644
--- a/lib/inv_bicgstab_quda.cpp
+++ b/lib/inv_bicgstab_quda.cpp
@@ -34,7 +34,7 @@ namespace quda {
     profile.TPSTOP(QUDA_PROFILE_FREE);
   }
 
-  int reliable(double &rNorm, double &maxrx, double &maxrr, const double &r2, const double &delta) {
+  int reliable(real_t &rNorm, real_t &maxrx, real_t &maxrr, const real_t &r2, const real_t &delta) {
     // reliable updates
     rNorm = sqrt(r2);
     if (rNorm > maxrx) maxrx = rNorm;
@@ -75,8 +75,8 @@ namespace quda {
 
     ColorSpinorField *x_sloppy, *r_sloppy, *r_0;
 
-    double b2 = blas::norm2(b); // norm sq of source
-    double r2;               // norm sq of residual
+    real_t b2 = blas::norm2(b); // norm sq of source
+    real_t r2;               // norm sq of residual
 
     if (param.deflate) {
       // Construct the eigensolver and deflation space if requested.
@@ -186,31 +186,31 @@ namespace quda {
     ColorSpinorField &xSloppy = *x_sloppy;
     ColorSpinorField &r0 = *r_0;
 
-    double stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
+    auto stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
 
     const bool use_heavy_quark_res =
       (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
-    double heavy_quark_res = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x,r).z) : 0.0;
+    auto heavy_quark_res = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x,r)[2]) : real_t(0.0);
     const int heavy_quark_check = param.heavy_quark_check; // how often to check the heavy quark residual
 
-    double delta = param.delta;
+    real_t delta = param.delta;
 
     int k = 0;
     int rUpdate = 0;
 
-    Complex rho(1.0, 0.0);
-    Complex rho0 = rho;
-    Complex alpha(1.0, 0.0);
-    Complex omega(1.0, 0.0);
-    Complex beta;
+    complex_t rho(1.0, 0.0);
+    complex_t rho0 = rho;
+    complex_t alpha(1.0, 0.0);
+    complex_t omega(1.0, 0.0);
+    complex_t beta;
 
-    double3 rho_r2;
-    double3 omega_t2;
+    array<real_t, 3> rho_r2;
+    array<real_t, 3> omega_t2;
 
-    double rNorm = sqrt(r2);
+    real_t rNorm = sqrt(r2);
     //double r0Norm = rNorm;
-    double maxrr = rNorm;
-    double maxrx = rNorm;
+    real_t maxrr = rNorm;
+    real_t maxrx = rNorm;
 
     PrintStats("BiCGstab", k, r2, b2, heavy_quark_res);
 
@@ -226,15 +226,15 @@ namespace quda {
 
     if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
       printfQuda("BiCGstab debug: x2=%e, r2=%e, v2=%e, p2=%e, tmp2=%e r0=%e t2=%e\n",
-		 blas::norm2(x), blas::norm2(rSloppy), blas::norm2(v), blas::norm2(p),
-		 blas::norm2(tmp), blas::norm2(r0), blas::norm2(t));
+		 double(blas::norm2(x)), double(blas::norm2(rSloppy)), double(blas::norm2(v)),
+                 double(blas::norm2(p)), double(blas::norm2(tmp)), double(blas::norm2(r0)), double(blas::norm2(t)));
 
     while ( !convergence(r2, heavy_quark_res, stop, param.tol_hq) &&
 	    k < param.maxiter) {
 
       matSloppy(v, p);
 
-      Complex r0v;
+      complex_t r0v;
       if (param.pipeline) {
 	r0v = blas::cDotProduct(r0, v);
 	if (k>0) rho = blas::cDotProduct(r0, r);
@@ -253,11 +253,11 @@ namespace quda {
       if (param.pipeline) {
 	// omega = (t, r) / (t, t)
 	omega_t2 = blas::cDotProductNormA(t, rSloppy);
-	Complex tr = Complex(omega_t2.x, omega_t2.y);
-	double t2 = omega_t2.z;
+	complex_t tr = complex_t(omega_t2[0], omega_t2[1]);
+	real_t t2 = omega_t2[2];
 	omega = tr / t2;
-	double s2 = blas::norm2(rSloppy);
-	Complex r0t = blas::cDotProduct(r0, t);
+	real_t s2 = blas::norm2(rSloppy);
+	complex_t r0t = blas::cDotProduct(r0, t);
 	beta = -r0t / r0v;
 	r2 = s2 - real(omega * conj(tr)) ;
 
@@ -266,7 +266,7 @@ namespace quda {
       } else {
 	// omega = (t, r) / (t, t)
 	omega_t2 = blas::cDotProductNormA(t, rSloppy);
-	omega = Complex(omega_t2.x / omega_t2.z, omega_t2.y / omega_t2.z);
+	omega = complex_t(omega_t2[0] / omega_t2[2], omega_t2[1] / omega_t2[2]);
       }
 
       if (param.pipeline && !updateR) {
@@ -278,17 +278,17 @@ namespace quda {
 	//x += alpha*p + omega*r, r -= omega*t, r2 = (r,r), rho = (r0, r)
 	rho_r2 = blas::caxpbypzYmbwcDotProductUYNormY(alpha, p, omega, rSloppy, xSloppy, t, r0);
 	rho0 = rho;
-	rho = Complex(rho_r2.x, rho_r2.y);
-	r2 = rho_r2.z;
+	rho = complex_t(rho_r2[0], rho_r2[1]);
+	r2 = rho_r2[2];
       }
 
       if (use_heavy_quark_res && k%heavy_quark_check==0) {
         if (&x != &xSloppy) {
            blas::copy(tmp,y);
-           heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(xSloppy, tmp, rSloppy).z);
+           heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(xSloppy, tmp, rSloppy)[2]);
         } else {
            blas::copy(r, rSloppy);
-           heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x, y, r).z);
+           heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x, y, r)[2]);
         }
       }
 
@@ -326,8 +326,8 @@ namespace quda {
       PrintStats("BiCGstab", k, r2, b2, heavy_quark_res);
       if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
 	printfQuda("BiCGstab debug: x2=%e, r2=%e, v2=%e, p2=%e, tmp2=%e r0=%e t2=%e\n",
-		   blas::norm2(x), blas::norm2(rSloppy), blas::norm2(v), blas::norm2(p),
-		   blas::norm2(tmp), blas::norm2(r0), blas::norm2(t));
+		   double(blas::norm2(x)), double(blas::norm2(rSloppy)), double(blas::norm2(v)), double(blas::norm2(p)),
+		   double(blas::norm2(tmp)), double(blas::norm2(r0)), double(blas::norm2(t)));
 
       // update p
       if (!param.pipeline || updateR) {// need to update if not pipeline or did a reliable update
@@ -358,7 +358,7 @@ namespace quda {
       // Calculate the true residual
       mat(r, x);
       param.true_res = sqrt(blas::xmyNorm(b, r) / b2);
-      param.true_res_hq = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x,r).z) : 0.0;
+      param.true_res_hq = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x,r)[2]) : real_t(0.0);
 
       PrintSummary("BiCGstab", k, r2, b2, stop, param.tol_hq);
     }
diff --git a/lib/inv_bicgstabl_quda.cpp b/lib/inv_bicgstabl_quda.cpp
index 0393fe308c..244d45da21 100644
--- a/lib/inv_bicgstabl_quda.cpp
+++ b/lib/inv_bicgstabl_quda.cpp
@@ -26,8 +26,8 @@ namespace quda {
   // Compute the MR portion of BiCGstab-L
   void BiCGstabL::computeMR(ColorSpinorField &x_sloppy, bool fixed_iteration)
   {
-    using matrix = Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>;
-    using vector = Matrix<std::complex<double>, Dynamic, 1>;
+    using matrix = Matrix<std::complex<real_t>, Dynamic, Dynamic, RowMajor>;
+    using vector = Matrix<std::complex<real_t>, Dynamic, 1>;
 
     // Compute gamma: minimize ||r - R \gamma||, where R is an L x R matrix
     // of r_1, r_2, ...
@@ -37,7 +37,7 @@ namespace quda {
     auto r_dagger_vec = {r.begin() + 1, r.begin() + n_krylov + 1};
     auto r_vec = {r.begin(), r.begin() + n_krylov + 1};
 
-    std::vector<Complex> r_dagger_dot_r((n_krylov + 1) * n_krylov);
+    std::vector<complex_t> r_dagger_dot_r((n_krylov + 1) * n_krylov);
     blas::cDotProduct(r_dagger_dot_r, r_dagger_vec, r_vec) ;
 
     matrix R_dag_R(n_krylov, n_krylov);
@@ -68,7 +68,7 @@ namespace quda {
     // Update omega for the next BiCG iteration
     omega = gamma(n_krylov - 1);
 
-    std::vector<Complex> gamma_(n_krylov);
+    std::vector<complex_t> gamma_(n_krylov);
 
     if (!fixed_iteration) {
 
@@ -85,11 +85,11 @@ namespace quda {
         // r = r[0] - \sum_{j=1}^L \gamma_L r_L
         // we see that if we're a bit clever with zero padding we can
         // reuse r between the two updates.
-        std::vector<Complex> gamma_for_x(n_krylov + 1);
+        std::vector<complex_t> gamma_for_x(n_krylov + 1);
         for (int i = 0; i < n_krylov; i++) gamma_for_x[i] = gamma(i);
         gamma_for_x[n_krylov] = 0; // do not want to update with last r
 
-        std::vector<Complex> gamma_for_r(n_krylov + 1);
+        std::vector<complex_t> gamma_for_r(n_krylov + 1);
         gamma_for_r[0] = 0; // do not want to update with first r
         for (int i = 0; i < n_krylov; i++) gamma_for_r[i + 1] = -gamma(i);
 
@@ -125,7 +125,7 @@ namespace quda {
   // Big change is we need to go from 1 to n_krylov, not 0 to n_krylov-1.
   void BiCGstabL::computeTau(int begin, int size, int j)
   {
-    std::vector<Complex> Tau(size);
+    std::vector<complex_t> Tau(size);
     blas::cDotProduct(Tau, {r.begin() + begin, r.begin() + begin + size}, r[j]); // vectorized dot product
 
     for (int k = 0; k < size; k++) { tau[(begin + k) * (n_krylov + 1) + j] = Tau[k] / sigma[begin + k]; }
@@ -133,7 +133,7 @@ namespace quda {
 
   void BiCGstabL::updateR(int begin, int size, int j)
   {
-    std::vector<Complex> tau_(size);
+    std::vector<complex_t> tau_(size);
     for (int i = 0; i < size; i++) { tau_[i] = -tau[(i + begin) * (n_krylov + 1) + j]; }
 
     auto r_ = {r.begin() + begin, r.begin() + begin + size};
@@ -201,9 +201,9 @@ namespace quda {
 
       // sigma_j = r_j^2, gamma'_j = <r_0, r_j>/sigma_j
       // rjr.x = Re(<r[j],r[0]), rjr.y = Im(<r[j],r[0]>), rjr.z = <r[j],r[j]>
-      double3 rjr = blas::cDotProductNormA(r[j], r[0]);
-      sigma[j] = rjr.z;
-      gamma_prime[j] = Complex(rjr.x, rjr.y) / sigma[j];
+      auto rjr = blas::cDotProductNormA(r[j], r[0]);
+      sigma[j] = rjr[2];
+      gamma_prime[j] = complex_t(rjr[0], rjr[1]) / sigma[j];
     }
 
     // gamma[n_krylov] = gamma'[n_krylov], omega = gamma[n_krylov]
@@ -230,7 +230,7 @@ namespace quda {
 
     // Update U
     {
-      std::vector<Complex> gamma_(n_krylov);
+      std::vector<complex_t> gamma_(n_krylov);
       for (int i = 0; i < n_krylov; i++) { gamma_[i] = -gamma[i + 1]; }
       blas::caxpy(gamma_, {u.begin() + 1, u.end()}, u[0]);
     }
@@ -241,8 +241,8 @@ namespace quda {
       // the alternative way would be un-fusing some calls, which would require
       // loading and saving x twice. In a solve where the sloppy precision is lower than
       // the full precision, this can be a killer.
-      std::vector<Complex> gamma_prime_prime_(n_krylov + 1);
-      std::vector<Complex> gamma_prime_(n_krylov + 1);
+      std::vector<complex_t> gamma_prime_prime_(n_krylov + 1);
+      std::vector<complex_t> gamma_prime_(n_krylov + 1);
       gamma_prime_prime_[0] = gamma[1];
       gamma_prime_prime_[n_krylov] = 0.0; // x never gets updated with r[n_krylov]
       gamma_prime_[0] = 0.0;              // r[0] never gets updated with r[0]... obvs.
@@ -279,8 +279,8 @@ namespace quda {
     std::vector<ColorSpinorField> &r;
     std::vector<ColorSpinorField> &u;
 
-    Complex &alpha;
-    Complex &beta;
+    complex_t &alpha;
+    complex_t &beta;
 
     BiCGstabLUpdateType update_type;
 
@@ -299,7 +299,7 @@ namespace quda {
 
   public:
     BiCGstabLUpdate(ColorSpinorField &x, std::vector<ColorSpinorField> &r, std::vector<ColorSpinorField> &u,
-                    Complex &alpha, Complex &beta, BiCGstabLUpdateType update_type, int j_max, int n_update) :
+                    complex_t &alpha, complex_t &beta, BiCGstabLUpdateType update_type, int j_max, int n_update) :
       x(x), r(r), u(u), alpha(alpha), beta(beta), update_type(update_type), j_max(j_max), n_update(n_update)
     {
 
@@ -319,7 +319,7 @@ namespace quda {
       if (update_type == BICGSTABL_UPDATE_U)
       {
         for (int i = (count * j_max) / n_update; i < ((count + 1) * j_max) / n_update && i < j_max; i++) {
-          blas::caxpby(1.0, r[i], -beta, u[i]);
+          blas::caxpby(real_t(1.0), r[i], -beta, u[i]);
         }
       }
       else // (update_type == BICGSTABL_UPDATE_R)
@@ -374,7 +374,7 @@ namespace quda {
   // Code to check for reliable updates, copied from inv_bicgstab_quda.cpp
   // Technically, there are ways to check both 'x' and 'r' for reliable updates...
   // the current status in BiCGstab is to just look for reliable updates in 'r'.
-  int BiCGstabL::reliable(double &rNorm, double &maxrx, double &maxrr, const double &r2, const double &delta) {
+  int BiCGstabL::reliable(real_t &rNorm, real_t &maxrx, real_t &maxrr, const real_t &r2, const real_t &delta) {
     // reliable updates
     rNorm = sqrt(r2);
     if (rNorm > maxrx) maxrx = rNorm;
@@ -453,8 +453,8 @@ namespace quda {
 
     // compute b2, but only if we need to
     bool fixed_iteration = param.sloppy_converge && n_krylov == param.maxiter && !param.compute_true_res;
-    double b2 = !fixed_iteration ? blas::norm2(b) : 1.0; // norm sq of source.
-    double r2;                  // norm sq of residual
+    real_t b2 = !fixed_iteration ? blas::norm2(b) : real_t(1.0); // norm sq of source.
+    real_t r2;                  // norm sq of residual
 
     if (param.deflate) {
       // Construct the eigensolver and deflation space if requested.
@@ -555,11 +555,11 @@ namespace quda {
     alpha = 0.0;
     omega = 1.0;
 
-    double stop = !fixed_iteration ? stopping(param.tol, b2, param.residual_type) : 0.0; // stopping condition of solver.
+    real_t stop = !fixed_iteration ? stopping(param.tol, b2, param.residual_type) : real_t(0.0); // stopping condition of solver.
 
     const bool use_heavy_quark_res =
       (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
-    double heavy_quark_res = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x, r_full).z) : 0.0;
+    real_t heavy_quark_res = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x, r_full)[2]) : real_t(0.0);
     const int heavy_quark_check = param.heavy_quark_check; // how often to check the heavy quark residual
 
     blas::flops = 0;
@@ -580,10 +580,10 @@ namespace quda {
 
     // Various variables related to reliable updates.
     int rUpdate = 0; // count reliable updates.
-    double delta = param.delta; // delta for reliable updates.
-    double rNorm = sqrt(r2); // The current residual norm.
-    double maxrr = rNorm; // The maximum residual norm since the last reliable update.
-    double maxrx = rNorm; // The same. Would be different if we did 'x' reliable updates.
+    real_t delta = param.delta; // delta for reliable updates.
+    real_t rNorm = sqrt(r2); // The current residual norm.
+    real_t maxrr = rNorm; // The maximum residual norm since the last reliable update.
+    real_t maxrx = rNorm; // The same. Would be different if we did 'x' reliable updates.
 
     PrintStats(solver_name.c_str(), total_iter, r2, b2, heavy_quark_res);
     while (!convergence(r2, 0.0, stop, 0.0) && total_iter < param.maxiter) {
@@ -601,7 +601,7 @@ namespace quda {
 
         // for i = 0 .. j, u[i] = r[i] - beta*u[i]
         // All but i = j is hidden in Dslash auxillary work (overlapping comms and compute).
-        blas::caxpby(1.0, r[j], -beta, u[j]);
+        blas::caxpby(real_t(1.0), r[j], -beta, u[j]);
         if (j > 0)
         {
           dslash::aux_worker = &bicgstabl_update;
@@ -651,10 +651,10 @@ namespace quda {
         if (use_heavy_quark_res && total_iter % heavy_quark_check == 0) {
           if (&x != &x_sloppy) {
             blas::copy(temp, y);
-            heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x_sloppy, temp, r[0]).z);
+            heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x_sloppy, temp, r[0])[2]);
           } else {
             blas::copy(r_full, r[0]);
-            heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x, y, r_full).z);
+            heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x, y, r_full)[2]);
           }
         }
       }
@@ -721,9 +721,9 @@ namespace quda {
     // !param.is_preconditioner comes from bicgstab, param.compute_true_res came from gcr.
     if (!param.is_preconditioner && param.compute_true_res) { // do not do the below if this is an inner solver.
       mat(r_full, x);
-      double true_res = blas::xmyNorm(b, r_full);
-      param.true_res = sqrt(true_res / b2);
-      param.true_res_hq = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x, r[0]).z) : 0.0;
+      real_t true_res = blas::xmyNorm(b, r_full);
+      param.true_res = real_t(sqrt(true_res / b2));
+      param.true_res_hq = use_heavy_quark_res ? sqrt(blas::HeavyQuarkResidualNorm(x, r[0])[2]) : 0.0;
     }
 
     // Reset flops counters.
diff --git a/lib/inv_ca_cg.cpp b/lib/inv_ca_cg.cpp
index ec95bf3ffe..c6efd4b30f 100644
--- a/lib/inv_ca_cg.cpp
+++ b/lib/inv_ca_cg.cpp
@@ -69,7 +69,7 @@ namespace quda
     create(x, b);
 
     const int iter0 = param.iter;
-    double b2 = param.compute_true_res ? blas::norm2(b) : 0.0;
+    real_t b2 = param.compute_true_res ? blas::norm2(b) : 0.0;
 
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       // compute initial residual
@@ -96,11 +96,11 @@ namespace quda
       mmdag.Expose()->M(xp, x);
       blas::xpay(b, -1.0, xp); // xp now holds the residual
 
-      double r2;
+      real_t r2;
       if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-        double3 h3 = blas::HeavyQuarkResidualNorm(x, xp);
-        r2 = h3.y;
-        param.true_res_hq = sqrt(h3.z);
+        auto h3 = blas::HeavyQuarkResidualNorm(x, xp);
+        r2 = h3[1];
+        param.true_res_hq = sqrt(h3[2]);
       } else {
         r2 = blas::norm2(xp);
       }
@@ -148,7 +148,7 @@ namespace quda
     create(x, b);
 
     const int iter0 = param.iter;
-    double b2 = 0.0;
+    real_t b2 = 0.0;
     if (param.compute_true_res) {
       b2 = blas::norm2(b);
       if (b2 == 0.0) { // compute initial residual vector
@@ -166,11 +166,11 @@ namespace quda
       blas::xpay(b, -1.0, br); // br now holds the residual
 
       if (param.compute_true_res) {
-        double r2;
+        real_t r2;
         if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-          double3 h3 = blas::HeavyQuarkResidualNorm(x, br);
-          r2 = h3.y;
-          param.true_res_hq = sqrt(h3.z);
+          auto h3 = blas::HeavyQuarkResidualNorm(x, br);
+          r2 = h3[1];
+          param.true_res_hq = sqrt(h3[2]);
         } else {
           r2 = blas::norm2(br);
         }
@@ -225,10 +225,10 @@ namespace quda
   }
 
   // template!
-  template <int N> void compute_alpha_N(const std::vector<double> &Q_AQandg, std::vector<double> &alpha)
+  template <int N> void compute_alpha_N(const std::vector<real_t> &Q_AQandg, std::vector<real_t> &alpha)
   {
-    typedef Matrix<double, N, N, RowMajor> matrix;
-    typedef Matrix<double, N, 1> vector;
+    typedef Matrix<real_t, N, N, RowMajor> matrix;
+    typedef Matrix<real_t, N, 1> vector;
 
     matrix matQ_AQ(N, N);
     vector vecg(N);
@@ -269,8 +269,8 @@ namespace quda
       case 12: compute_alpha_N<12>(Q_AQandg, alpha); break;
 #endif
     default: // failsafe
-      typedef Matrix<double, Dynamic, Dynamic, RowMajor> matrix;
-      typedef Matrix<double, Dynamic, 1> vector;
+      typedef Matrix<real_t, Dynamic, Dynamic, RowMajor> matrix;
+      typedef Matrix<real_t, Dynamic, 1> vector;
 
       const int N = Q.size();
       matrix matQ_AQ(N, N);
@@ -297,9 +297,9 @@ namespace quda
 
   // template!
   template <int N>
-  void compute_beta_N(const std::vector<double> &Q_AQandg, std::vector<double> &Q_AS, std::vector<double> &beta)
+  void compute_beta_N(const std::vector<real_t> &Q_AQandg, std::vector<real_t> &Q_AS, std::vector<real_t> &beta)
   {
-    typedef Matrix<double, N, N, RowMajor> matrix;
+    typedef Matrix<real_t, N, N, RowMajor> matrix;
 
     matrix matQ_AQ(N, N);
     for (int i = 0; i < N; i++) {
@@ -339,7 +339,7 @@ namespace quda
       case 12: compute_beta_N<12>(Q_AQandg, Q_AS, beta); break;
 #endif
     default: // failsafe
-      typedef Matrix<double, Dynamic, Dynamic, RowMajor> matrix;
+      typedef Matrix<real_t, Dynamic, Dynamic, RowMajor> matrix;
 
       const int N = Q.size();
       matrix matQ_AQ(N, N);
@@ -363,7 +363,7 @@ namespace quda
   }
 
   // Code to check for reliable updates
-  int CACG::reliable(double &rNorm, double &maxrr, int &rUpdate, const double &r2, const double &delta)
+  int CACG::reliable(real_t &rNorm, real_t &maxrr, int &rUpdate, const real_t &r2, const real_t &delta)
   {
     // reliable updates
     rNorm = sqrt(r2);
@@ -421,8 +421,8 @@ namespace quda
 
     // compute b2, but only if we need to
     bool fixed_iteration = param.sloppy_converge && n_krylov == param.maxiter && !param.compute_true_res;
-    double b2 = !fixed_iteration ? blas::norm2(b) : 1.0;
-    double r2 = 0.0; // if zero source then we will exit immediately doing no work
+    real_t b2 = !fixed_iteration ? blas::norm2(b) : 1.0;
+    real_t r2 = 0.0; // if zero source then we will exit immediately doing no work
 
     if (param.deflate) {
       // Construct the eigensolver and deflation space.
@@ -482,7 +482,7 @@ namespace quda
       // Perform 100 power iterations, normalizing every 10 mat-vecs, using r as an initial seed
       // and Q[0]/AQ[0] as temporaries for the power iterations
       lambda_max = 1.1 * Solver::performPowerIterations(matSloppy, r, Q[0], AQ[0], 100, 10);
-      logQuda(QUDA_SUMMARIZE, "CA-CG Approximate lambda max = 1.1 x %e\n", lambda_max / 1.1);
+      logQuda(QUDA_SUMMARIZE, "CA-CG Approximate lambda max = 1.1 x %e\n", double(lambda_max / 1.1));
 
       lambda_init = true;
 
@@ -505,7 +505,7 @@ namespace quda
       }
     }
 
-    double stop = !fixed_iteration ? stopping(param.tol, b2, param.residual_type) : 0.0; // stopping condition of solver
+    real_t stop = !fixed_iteration ? stopping(param.tol, b2, param.residual_type) : 0.0; // stopping condition of solver
 
     const bool use_heavy_quark_res = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
 
@@ -515,8 +515,8 @@ namespace quda
     const int maxResIncrease = param.max_res_increase; // check if we reached the limit of our tolerance
     const int maxResIncreaseTotal = param.max_res_increase_total;
 
-    double heavy_quark_res = 0.0; // heavy quark residual
-    if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+    real_t heavy_quark_res = 0.0; // heavy quark residual
+    if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
     int resIncrease = 0;
     int resIncreaseTotal = 0;
@@ -527,19 +527,19 @@ namespace quda
       profile.TPSTART(QUDA_PROFILE_COMPUTE);
     }
     int total_iter = 0;
-    double r2_old = r2;
+    real_t r2_old = r2;
     bool l2_converge = false;
 
     // Various variables related to reliable updates.
     int rUpdate = 0;             // count reliable updates.
-    double delta = param.delta;  // delta for reliable updates.
-    double rNorm = sqrt(r2);     // The current residual norm.
-    double maxrr = rNorm;        // The maximum residual norm since the last reliable update.
-    double maxr_deflate = rNorm; // The maximum residual since the last deflation
+    real_t delta = param.delta;  // delta for reliable updates.
+    real_t rNorm = sqrt(r2);     // The current residual norm.
+    real_t maxrr = rNorm;        // The maximum residual norm since the last reliable update.
+    real_t maxr_deflate = rNorm; // The maximum residual since the last deflation
 
     // Factors which map linear operator onto [-1,1]
-    double m_map = 2. / (lambda_max - lambda_min);
-    double b_map = -(lambda_max + lambda_min) / (lambda_max - lambda_min);
+    real_t m_map = 2. / (lambda_max - lambda_min);
+    real_t b_map = -(lambda_max + lambda_min) / (lambda_max - lambda_min);
 
     blas::copy(S[0], r); // no op if uni-precision
 
@@ -638,7 +638,7 @@ namespace quda
 
         blas::copy(S[0], r);
 
-        if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+        if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
         // break-out check if we have reached the limit of the precision
         if (r2 > r2_old) {
@@ -646,7 +646,7 @@ namespace quda
           resIncreaseTotal++;
           warningQuda(
             "CA-CG: new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-            sqrt(r2), sqrt(r2_old), resIncreaseTotal);
+            double(sqrt(r2)), double(sqrt(r2_old)), resIncreaseTotal);
           if (resIncrease > maxResIncrease or resIncreaseTotal > maxResIncreaseTotal) {
             warningQuda("CA-CG: solver exiting due to too many true residual norm increases");
             break;
@@ -668,10 +668,10 @@ namespace quda
     if (param.compute_true_res) {
       // Calculate the true residual
       mat(r, x);
-      double true_res = blas::xmyNorm(b, r);
+      real_t true_res = blas::xmyNorm(b, r);
       param.true_res = sqrt(true_res / b2);
       param.true_res_hq
-        = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? sqrt(blas::HeavyQuarkResidualNorm(x, r).z) : 0.0;
+        = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]) : 0.0;
     }
 
     if (!param.is_preconditioner) {
diff --git a/lib/inv_ca_gcr.cpp b/lib/inv_ca_gcr.cpp
index f9e605ea86..4a9bdb266d 100644
--- a/lib/inv_ca_gcr.cpp
+++ b/lib/inv_ca_gcr.cpp
@@ -66,10 +66,10 @@ namespace quda
     } // init
   }
 
-  void CAGCR::solve(std::vector<Complex> &psi_, std::vector<ColorSpinorField> &q, ColorSpinorField &b)
+  void CAGCR::solve(std::vector<complex_t> &psi_, std::vector<ColorSpinorField> &q, ColorSpinorField &b)
   {
-    typedef Matrix<Complex, Dynamic, Dynamic> matrix;
-    typedef Matrix<Complex, Dynamic, 1> vector;
+    typedef Matrix<complex_t, Dynamic, Dynamic> matrix;
+    typedef Matrix<complex_t, Dynamic, 1> vector;
 
     const int N = q.size();
     vector phi(N), psi(N);
@@ -80,7 +80,7 @@ namespace quda
     // compute rhs vector phi = Q* b = (q_i, b)
 
     // Construct the matrix Q* Q = (A P)* (A P) = (q_i, q_j) = (A p_i, A p_j)
-    std::vector<Complex> A_(N * (N + 1));
+    std::vector<complex_t> A_(N * (N + 1));
 
     blas::cDotProduct(A_, q, {q, b});
     for (int i = 0; i < N; i++) {
@@ -90,12 +90,12 @@ namespace quda
 #else
     // two reductions but uses the Hermitian block dot product
     // compute rhs vector phi = Q* b = (q_i, b)
-    std::vector<Complex> phi_(N);
+    std::vector<complex_t> phi_(N);
     blas::cDotProduct(phi_, q, b);
     for (int i = 0; i < N; i++) phi(i) = phi_[i];
 
     // Construct the matrix Q* Q = (A P)* (A P) = (q_i, q_j) = (A p_i, A p_j)
-    std::vector<Complex> A_(N * N);
+    std::vector<complex_t> A_(N * N);
     blas::hDotProduct(A_, q, q);
     for (int i = 0; i < N; i++)
       for (int j = 0; j < N; j++) A(i, j) = A_[i * N + j];
@@ -149,8 +149,8 @@ namespace quda
 
     // compute b2, but only if we need to
     bool fixed_iteration = param.sloppy_converge && n_krylov == param.maxiter && !param.compute_true_res;
-    double b2 = !fixed_iteration ? blas::norm2(b) : 1.0;
-    double r2 = 0.0; // if zero source then we will exit immediately doing no work
+    real_t b2 = !fixed_iteration ? blas::norm2(b) : 1.0;
+    real_t r2 = 0.0; // if zero source then we will exit immediately doing no work
 
     if (param.deflate) {
       // Construct the eigensolver and deflation space if requested.
@@ -224,8 +224,7 @@ namespace quda
       // Perform 100 power iterations, normalizing every 10 mat-vecs, using r_ as an initial seed
       // and q[0]/q[1] as temporaries for the power iterations. Technically illegal if n_krylov == 1, but in that case lambda_max isn't used anyway.
       lambda_max = 1.1 * Solver::performPowerIterations(matSloppy, r, q[0], q[1], 100, 10);
-      logQuda(QUDA_SUMMARIZE, "CA-GCR Approximate lambda max = 1.1 x %e\n", lambda_max / 1.1);
-
+      logQuda(QUDA_SUMMARIZE, "CA-GCR Approximate lambda max = 1.1 x %e\n", double(lambda_max / 1.1));
       lambda_init = true;
 
       if (!param.is_preconditioner) {
@@ -235,8 +234,8 @@ namespace quda
     }
 
     // Factors which map linear operator onto [-1,1]
-    double m_map = 2. / (lambda_max - lambda_min);
-    double b_map = -(lambda_max + lambda_min) / (lambda_max - lambda_min);
+    real_t m_map = 2. / (lambda_max - lambda_min);
+    real_t b_map = -(lambda_max + lambda_min) / (lambda_max - lambda_min);
 
     // Check to see that we're not trying to invert on a zero-field source
     if (b2 == 0) {
@@ -251,7 +250,7 @@ namespace quda
       }
     }
 
-    double stop = !fixed_iteration ? stopping(param.tol, b2, param.residual_type) : 0.0; // stopping condition of solver
+    real_t stop = !fixed_iteration ? stopping(param.tol, b2, param.residual_type) : 0.0; // stopping condition of solver
 
     const bool use_heavy_quark_res = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
 
@@ -261,8 +260,8 @@ namespace quda
     const int maxResIncrease = param.max_res_increase; // check if we reached the limit of our tolerance
     const int maxResIncreaseTotal = param.max_res_increase_total;
 
-    double heavy_quark_res = 0.0; // heavy quark residual
-    if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+    real_t heavy_quark_res = 0.0; // heavy quark residual
+    if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
     int resIncrease = 0;
     int resIncreaseTotal = 0;
@@ -274,8 +273,8 @@ namespace quda
     }
     int total_iter = 0;
     int restart = 0;
-    double r2_old = r2;
-    double maxr_deflate = sqrt(r2);
+    real_t r2_old = r2;
+    real_t maxr_deflate = sqrt(r2);
     bool l2_converge = false;
 
     blas::copy(p[0], r); // no op if uni-precision
@@ -326,7 +325,7 @@ namespace quda
           maxr_deflate = sqrt(r2);
         }
 
-        if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+        if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
         // break-out check if we have reached the limit of the precision
         if (r2 > r2_old) {
@@ -334,7 +333,7 @@ namespace quda
           resIncreaseTotal++;
           warningQuda(
             "CA-GCR: new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-            sqrt(r2), sqrt(r2_old), resIncreaseTotal);
+            double(sqrt(r2)), double(sqrt(r2_old)), resIncreaseTotal);
           if (resIncrease > maxResIncrease or resIncreaseTotal > maxResIncreaseTotal) {
             warningQuda("CA-GCR: solver exiting due to too many true residual norm increases");
             break;
@@ -368,10 +367,10 @@ namespace quda
     if (param.compute_true_res) {
       // Calculate the true residual
       mat(r, x);
-      double true_res = blas::xmyNorm(b, r);
+      real_t true_res = blas::xmyNorm(b, r);
       param.true_res = sqrt(true_res / b2);
       param.true_res_hq
-        = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? sqrt(blas::HeavyQuarkResidualNorm(x, r).z) : 0.0;
+        = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]) : 0.0;
     }
 
     if (!param.is_preconditioner) {
diff --git a/lib/inv_cg3_quda.cpp b/lib/inv_cg3_quda.cpp
index 42ab22fcab..ab080f1041 100644
--- a/lib/inv_cg3_quda.cpp
+++ b/lib/inv_cg3_quda.cpp
@@ -77,7 +77,7 @@ namespace quda {
     create(x, b);
 
     const int iter0 = param.iter;
-    double b2 = param.compute_true_res ? blas::norm2(b) : 0.0;
+    real_t b2 = param.compute_true_res ? blas::norm2(b) : 0.0;
 
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       // compute initial residual
@@ -104,11 +104,11 @@ namespace quda {
       mmdag.Expose()->M(xp, x);
       blas::xpay(b, -1.0, xp); // xp now holds the residual
 
-      double r2;
+      real_t r2;
       if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-        double3 h3 = blas::HeavyQuarkResidualNorm(x, xp);
-        r2 = h3.y;
-        param.true_res_hq = sqrt(h3.z);
+        auto h3 = blas::HeavyQuarkResidualNorm(x, xp);
+        r2 = h3[1];
+        param.true_res_hq = sqrt(h3[2]);
       } else {
         r2 = blas::norm2(xp);
       }
@@ -155,7 +155,7 @@ namespace quda {
     create(x, b);
 
     const int iter0 = param.iter;
-    double b2 = 0.0;
+    real_t b2 = 0.0;
     if (param.compute_true_res) {
       b2 = blas::norm2(b);
       if (b2 == 0.0) { // compute initial residual vector
@@ -173,11 +173,11 @@ namespace quda {
       blas::xpay(b, -1.0, br); // br now holds the residual
 
       if (param.compute_true_res) {
-        double r2;
+        real_t r2;
         if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-          double3 h3 = blas::HeavyQuarkResidualNorm(x, br);
-          r2 = h3.y;
-          param.true_res_hq = sqrt(h3.z);
+          auto h3 = blas::HeavyQuarkResidualNorm(x, br);
+          r2 = h3[1];
+          param.true_res_hq = sqrt(h3[2]);
         } else {
           r2 = blas::norm2(br);
         }
@@ -197,7 +197,7 @@ namespace quda {
     profile.TPSTART(QUDA_PROFILE_INIT);
 
     // Check to see that we're not trying to invert on a zero-field source    
-    double b2 = blas::norm2(b);
+    real_t b2 = blas::norm2(b);
     if(b2 == 0 &&
        (param.compute_null_vector == QUDA_COMPUTE_NULL_VECTOR_NO || param.use_init_guess == QUDA_USE_INIT_GUESS_NO)){
       profile.TPSTOP(QUDA_PROFILE_INIT);
@@ -242,7 +242,7 @@ namespace quda {
     ColorSpinorField &xS_old = *xS_oldp;
     ColorSpinorField &tmpS = *tmpSp;
 
-    double stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
+    auto stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
 
     const bool use_heavy_quark_res =
       (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
@@ -258,8 +258,8 @@ namespace quda {
     // these are only used if we use the heavy_quark_res
     const int hqmaxresIncrease = maxResIncrease + 1;
     int heavy_quark_check = param.heavy_quark_check; // how often to check the heavy quark residual
-    double heavy_quark_res = 0.0; // heavy quark residual
-    double heavy_quark_res_old = 0.0;  // heavy quark residual
+    real_t heavy_quark_res = 0.0; // heavy quark residual
+    real_t heavy_quark_res_old = 0.0;  // heavy quark residual
     int hqresIncrease = 0;
     bool L2breakdown = false;
 
@@ -271,7 +271,7 @@ namespace quda {
     blas::flops = 0;
 
     // compute initial residual depending on whether we have an initial guess or not
-    double r2;
+    real_t r2;
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       mat(r, x);
       r2 = blas::xmyNorm(b, r);
@@ -292,7 +292,7 @@ namespace quda {
     blas::copy(rS, r);
 
     if (use_heavy_quark_res) {
-      heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+      heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
       heavy_quark_res_old = heavy_quark_res;
     }
 
@@ -300,24 +300,25 @@ namespace quda {
     if (convergence(r2, heavy_quark_res, stop, param.tol_hq)) return;
     profile.TPSTART(QUDA_PROFILE_COMPUTE);
 
-    double r2_old = r2;
-    double rNorm  = sqrt(r2);
-    double r0Norm = rNorm;
-    double maxrx  = rNorm;
-    double maxrr  = rNorm;
-    double delta  = param.delta;
+    real_t r2_old = r2;
+    real_t rNorm  = sqrt(r2);
+    real_t r0Norm = rNorm;
+    real_t maxrx  = rNorm;
+    real_t maxrr  = rNorm;
+    real_t delta  = param.delta;
     bool restart = false;
 
     int k = 0;
     PrintStats("CG3", k, r2, b2, heavy_quark_res);
-    double rho = 1.0, gamma = 1.0;
+    real_t rho = 1.0;
+    real_t gamma = 1.0;
 
     while ( !convergence(r2, heavy_quark_res, stop, param.tol_hq) && k < param.maxiter) {
 
       matSloppy(ArS, rS);
-      double gamma_old = gamma;
-      double rAr = blas::reDotProduct(rS,ArS);
-      gamma = r2/rAr;
+      real_t gamma_old = gamma;
+      real_t rAr = blas::reDotProduct(rS,ArS);
+      gamma = r2 / rAr;
       
       // CG3 step
       if (k == 0 || restart) { // First iteration
@@ -356,9 +357,9 @@ namespace quda {
         heavy_quark_res_old = heavy_quark_res;
         if (mixed_precision) {
           blas::copy(tmpS,y);
-          heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(xS, tmpS, rS).z);
+          heavy_quark_res = sqrt(blas::xpyHeavyQuarkResidualNorm(xS, tmpS, rS)[2]);
         } else {
-          heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(xS, rS).z);
+          heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(xS, rS)[2]);
         }
       }
 
@@ -386,7 +387,7 @@ namespace quda {
           r2 = blas::xmyNorm(b, r);
           param.true_res = sqrt(r2 / b2);
           if (use_heavy_quark_res) {
-            heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(y, r).z);
+            heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(y, r)[2]);
             param.true_res_hq = heavy_quark_res;
           }
           rNorm = sqrt(r2);
@@ -398,7 +399,7 @@ namespace quda {
             blas::copy(rS, r);
             blas::axpy(-1., xS, xS_old);
             // we preserve the orthogonality between the previous residual and the new
-            Complex rr_old = blas::cDotProduct(rS, rS_old);
+            complex_t rr_old = blas::cDotProduct(rS, rS_old);
             r2_old = blas::caxpyNorm(-rr_old/r2, rS, rS_old);
             blas::zero(xS);
           }
@@ -410,7 +411,7 @@ namespace quda {
           resIncreaseTotal++;
           warningQuda(
             "CG3: new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-            sqrt(r2), r0Norm, resIncreaseTotal);
+            double(sqrt(r2)), double(r0Norm), resIncreaseTotal);
           if (resIncrease > maxResIncrease or resIncreaseTotal > maxResIncreaseTotal) {
             if (use_heavy_quark_res) {
               L2breakdown = true;
@@ -432,7 +433,8 @@ namespace quda {
           L2breakdown = false;
           if (heavy_quark_res > heavy_quark_res_old) {
             hqresIncrease++;
-            warningQuda("CG3: new reliable HQ residual norm %e is greater than previous reliable residual norm %e", heavy_quark_res, heavy_quark_res_old);
+            warningQuda("CG3: new reliable HQ residual norm %e is greater than previous reliable residual norm %e",
+                        double(heavy_quark_res), double(heavy_quark_res_old));
             // break out if we do not improve here anymore
             if (hqresIncrease > hqmaxresIncrease) {
               warningQuda("CG3: solver exiting due to too many heavy quark residual norm increases");
@@ -448,7 +450,7 @@ namespace quda {
           // we update sloppy and old fields
           if (!convergence(r2, heavy_quark_res, stop, param.tol_hq)) {
             // we preserve the orthogonality between the previous residual and the new
-            Complex rr_old = blas::cDotProduct(rS, rS_old);
+            complex_t rr_old = blas::cDotProduct(rS, rS_old);
             r2_old = blas::caxpyNorm(-rr_old/r2, rS, rS_old);
           }
         }
@@ -458,8 +460,8 @@ namespace quda {
           resIncrease++;
           resIncreaseTotal++;
           warningQuda(
-            "CG3: new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-            sqrt(r2), r0Norm, resIncreaseTotal);
+                      "CG3: new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
+                      double(sqrt(r2)), double(r0Norm), resIncreaseTotal);
           if (resIncrease > maxResIncrease or resIncreaseTotal > maxResIncreaseTotal) {
               warningQuda("CG3: solver exiting due to too many true residual norm increases");
               break;
@@ -486,7 +488,7 @@ namespace quda {
     if (!mixed_precision && param.compute_true_res) {
       mat(r, x);
       param.true_res = sqrt(blas::xmyNorm(b, r) / b2);
-      if (use_heavy_quark_res) param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+      if (use_heavy_quark_res) param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
     }
 
     PrintSummary("CG3", k, r2, b2, stop, param.tol_hq);
diff --git a/lib/inv_cg_quda.cpp b/lib/inv_cg_quda.cpp
index 15bdf23002..1278a88b5a 100644
--- a/lib/inv_cg_quda.cpp
+++ b/lib/inv_cg_quda.cpp
@@ -96,7 +96,7 @@ namespace quda {
     create(x, b);
 
     const int iter0 = param.iter;
-    double b2 = param.compute_true_res ? blas::norm2(b) : 0.0;
+    auto b2 = param.compute_true_res ? blas::norm2(b) : real_t(0.0);
 
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       // compute initial residual
@@ -123,11 +123,11 @@ namespace quda {
       mmdag.Expose()->M(xp, x);
       blas::xpay(b, -1.0, xp); // xp now holds the residual
 
-      double r2;
+      real_t r2;
       if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-        double3 h3 = blas::HeavyQuarkResidualNorm(x, xp);
-        r2 = h3.y;
-        param.true_res_hq = sqrt(h3.z);
+        auto h3 = blas::HeavyQuarkResidualNorm(x, xp);
+        r2 = h3[1];
+        param.true_res_hq = sqrt(h3[2]);
       } else {
         r2 = blas::norm2(xp);
       }
@@ -175,10 +175,10 @@ namespace quda {
     create(x, b);
 
     const int iter0 = param.iter;
-    double b2 = 0.0;
+    real_t b2 = 0.0;
     if (param.compute_true_res) {
       b2 = blas::norm2(b);
-      if (b2 == 0.0) { // compute initial residual vector
+      if (b2 == real_t(0.0)) { // compute initial residual vector
         mdagm.Expose()->M(br, x);
         b2 = blas::norm2(br);
       }
@@ -193,11 +193,11 @@ namespace quda {
       blas::xpay(b, -1.0, br); // br now holds the residual
 
       if (param.compute_true_res) {
-        double r2;
+        real_t r2;
         if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-          double3 h3 = blas::HeavyQuarkResidualNorm(x, br);
-          r2 = h3.y;
-          param.true_res_hq = sqrt(h3.z);
+          auto h3 = blas::HeavyQuarkResidualNorm(x, br);
+          r2 = h3[1];
+          param.true_res_hq = sqrt(h3[2]);
         } else {
           r2 = blas::norm2(br);
         }
@@ -207,7 +207,7 @@ namespace quda {
     }
   }
 
-  void CG::operator()(ColorSpinorField &x, ColorSpinorField &b, ColorSpinorField *p_init, double r2_old_init)
+  void CG::operator()(ColorSpinorField &x, ColorSpinorField &b, ColorSpinorField *p_init, real_t r2_old_init)
   {
     if (param.is_preconditioner) commGlobalReductionPush(param.global_reduction);
 
@@ -250,7 +250,7 @@ namespace quda {
 
     if (!param.is_preconditioner) profile.TPSTART(QUDA_PROFILE_INIT);
 
-    double b2 = blas::norm2(b);
+    real_t b2 = blas::norm2(b);
 
     // Check to see that we're not trying to invert on a zero-field source
     if (b2 == 0 && param.compute_null_vector == QUDA_COMPUTE_NULL_VECTOR_NO) {
@@ -307,8 +307,8 @@ namespace quda {
     const double u = precisionEpsilon(param.precision_sloppy);
     const double uhigh = precisionEpsilon(); // solver precision
 
-    double Anorm = 0;
-    double beta = 0;
+    real_t Anorm = 0;
+    real_t beta = 0;
 
     // for alternative reliable updates
     if (advanced_feature && alternative_reliable) {
@@ -318,7 +318,7 @@ namespace quda {
     }
 
     // compute initial residual
-    double r2 = 0.0;
+    real_t r2 = 0.0;
     if (advanced_feature && param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       // Compute r = b - A * x
       mat(r, x);
@@ -347,10 +347,10 @@ namespace quda {
     csParam.create = QUDA_NULL_FIELD_CREATE;
     XUpdateBatch x_update_batch(Np, p_init ? *p_init : rSloppy, csParam);
 
-    double r2_old = 0.0;
+    real_t r2_old = 0.0;
     if (r2_old_init != 0.0 and p_init) {
       r2_old = r2_old_init;
-      Complex rp = blas::cDotProduct(rSloppy, x_update_batch.get_current_field()) / (r2);
+      auto rp = blas::cDotProduct(rSloppy, x_update_batch.get_current_field()) / (r2);
       blas::caxpy(-rp, rSloppy, x_update_batch.get_current_field());
       beta = r2 / r2_old;
       blas::xpayz(rSloppy, beta, x_update_batch.get_current_field(), x_update_batch.get_current_field());
@@ -361,10 +361,9 @@ namespace quda {
       profile.TPSTART(QUDA_PROFILE_PREAMBLE);
     }
 
-    double stop = stopping(param.tol, b2, param.residual_type);  // stopping condition of solver
+    auto stop = stopping(param.tol, b2, param.residual_type);  // stopping condition of solver
 
-    auto alpha = std::make_unique<double[]>(Np);
-    double pAp;
+    real_t pAp;
 
     if (!param.is_preconditioner) {
       profile.TPSTOP(QUDA_PROFILE_PREAMBLE);
@@ -394,20 +393,20 @@ namespace quda {
 
     while ( !converged && k < param.maxiter ) {
       matSloppy(Ap, x_update_batch.get_current_field());
-      double sigma;
+      real_t sigma;
 
       bool breakdown = false;
       if (advanced_feature && param.pipeline) {
-        double Ap2;
+        real_t Ap2;
         if(alternative_reliable){
-          double4 quadruple = blas::quadrupleCGReduction(rSloppy, Ap, x_update_batch.get_current_field());
-          r2 = quadruple.x;
-          Ap2 = quadruple.y;
-          pAp = quadruple.z;
-          ru.update_ppnorm(quadruple.w);
+          auto quadruple = blas::quadrupleCGReduction(rSloppy, Ap, x_update_batch.get_current_field());
+          r2 = quadruple[0];
+          Ap2 = quadruple[1];
+          pAp = quadruple[2];
+          ru.update_ppnorm(quadruple[3]);
         } else {
-          double3 triplet = blas::tripleCGReduction(rSloppy, Ap, x_update_batch.get_current_field());
-          r2 = triplet.x; Ap2 = triplet.y; pAp = triplet.z;
+          auto triplet = blas::tripleCGReduction(rSloppy, Ap, x_update_batch.get_current_field());
+          r2 = triplet[0]; Ap2 = triplet[1]; pAp = triplet[2];
         }
         r2_old = r2;
         x_update_batch.get_current_alpha() = r2 / pAp;
@@ -424,9 +423,9 @@ namespace quda {
 
         // alternative reliable updates,
         if (advanced_feature && alternative_reliable) {
-          double3 pAppp = blas::cDotProductNormA(x_update_batch.get_current_field(), Ap);
-          pAp = pAppp.x;
-          ru.update_ppnorm(pAppp.z);
+          auto pAppp = blas::cDotProductNormA(x_update_batch.get_current_field(), Ap);
+          pAp = pAppp[0];
+          ru.update_ppnorm(pAppp[2]);
         } else {
           pAp = blas::reDotProduct(x_update_batch.get_current_field(), Ap);
         }
@@ -435,8 +434,8 @@ namespace quda {
 
         // here we are deploying the alternative beta computation
         auto cg_norm = blas::axpyCGNorm(-x_update_batch.get_current_alpha(), Ap, rSloppy);
-        r2 = cg_norm.x;  // (r_new, r_new)
-        sigma = cg_norm.y >= 0.0 ? cg_norm.y : r2;  // use r2 if (r_k+1, r_k+1-r_k) breaks
+        r2 = cg_norm[0];  // (r_new, r_new)
+        sigma = cg_norm[1] >= 0.0 ? cg_norm[1] : r2;  // use r2 if (r_k+1, r_k+1-r_k) breaks
       }
 
       // reliable update conditions
@@ -509,7 +508,7 @@ namespace quda {
         }
 
         // explicitly restore the orthogonality of the gradient vector
-        Complex rp = blas::cDotProduct(rSloppy, x_update_batch.get_current_field()) / (r2);
+        auto rp = blas::cDotProduct(rSloppy, x_update_batch.get_current_field()) / (r2);
         blas::caxpy(-rp, rSloppy, x_update_batch.get_current_field());
 
         beta = r2 / r2_old;
@@ -558,7 +557,7 @@ namespace quda {
       // compute the true residuals
       mat(r, x);
       param.true_res = sqrt(blas::xmyNorm(b, r) / b2);
-      param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+      param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
     }
 
     PrintSummary("CG", k, r2, b2, stop, 0.0);
@@ -594,7 +593,7 @@ namespace quda {
 
     profile.TPSTART(QUDA_PROFILE_INIT);
 
-    double b2 = blas::norm2(b);
+    auto b2 = blas::norm2(b);
 
     // Detect whether this is a pure double solve or not; informs the necessity of some stability checks
     bool is_pure_double = (param.precision == QUDA_DOUBLE_PRECISION && param.precision_sloppy == QUDA_DOUBLE_PRECISION);
@@ -651,7 +650,7 @@ namespace quda {
     const double hq_res_stall_check = is_pure_double ? 0. : uhigh * uhigh * 1e-60;
 
     // compute initial residual
-    double r2 = 0.0;
+    real_t r2 = 0.0;
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       // Compute r = b - A * x
       mat(r, x);
@@ -670,17 +669,17 @@ namespace quda {
     blas::copy(rSloppy, r);
     blas::copy(p, rSloppy);
 
-    double r2_old = 0.0;
+    real_t r2_old = 0.0;
 
     profile.TPSTOP(QUDA_PROFILE_INIT);
     profile.TPSTART(QUDA_PROFILE_PREAMBLE);
 
-    double stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
+    auto stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
 
     // compute the initial heavy quark residual
-    double hq_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+    real_t hq_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
-    double alpha, beta, sigma, pAp;
+    real_t alpha, beta, sigma, pAp;
 
     // Whether or not we also need to compute the L2 norm
     const bool L2_required = param.residual_type & (QUDA_L2_RELATIVE_RESIDUAL | QUDA_L2_ABSOLUTE_RESIDUAL);
@@ -705,13 +704,13 @@ namespace quda {
     // Trackers for the L2 norm:
     //  rNorm: current iterated |r|
     // r0Norm: computed |r| at the last reliable update
-    double rNorm = sqrt(r2);
-    double r0Norm = rNorm;
+    auto rNorm = sqrt(r2);
+    auto r0Norm = rNorm;
 
     // If the computed |r| goes above r0Norm between reliable updates,
     // update this ceiling. This goes into "R" type reliable updates.
-    double maxrx = L2breakdown ? hq_res : rNorm;
-    double maxrr = L2breakdown ? hq_res : rNorm;
+    auto maxrx = L2breakdown ? hq_res : rNorm;
+    auto maxrr = L2breakdown ? hq_res : rNorm;
 
     // Triggers for explicitly counting residual updates and checking for L2breakdown.
     // * updateX broadly maps to if the iterated residual has dropped by a factor of delta
@@ -732,7 +731,7 @@ namespace quda {
 
     // Trackers for the HQ residual
     // hq0Res: computed HQ residual at the last reliable updated
-    double hq0Res = hq_res;
+    auto hq0Res = hq_res;
 
     // Counter for the number of times in a row the computed heavy quark residual has
     // jumped above the previously computed heavy quark residual.
@@ -759,8 +758,8 @@ namespace quda {
 
       // here we are deploying the alternative beta computation
       auto cg_norm = blas::axpyCGNorm(-alpha, Ap, rSloppy);
-      r2 = cg_norm.x;                            // (r_new, r_new)
-      sigma = cg_norm.y >= 0.0 ? cg_norm.y : r2; // use r2 if (r_k+1, r_k+1-r_k) breaks
+      r2 = cg_norm[0];                            // (r_new, r_new)
+      sigma = cg_norm[1] >= 0.0 ? cg_norm[1] : r2; // use r2 if (r_k+1, r_k+1-r_k) breaks
       rNorm = sqrt(r2);
 
       // If the iterated norm has dropped by more than a factor of delta, trigger
@@ -817,10 +816,10 @@ namespace quda {
         if (k % param.heavy_quark_check == 0) {
           if (&x != &xSloppy) {
             blas::copy(tmp, y);
-            hq_res = sqrt(blas::xpyHeavyQuarkResidualNorm(xSloppy, tmp, rSloppy).z);
+            hq_res = sqrt(blas::xpyHeavyQuarkResidualNorm(xSloppy, tmp, rSloppy)[2]);
           } else {
             blas::copy(r, rSloppy);
-            hq_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x, y, r).z);
+            hq_res = sqrt(blas::xpyHeavyQuarkResidualNorm(x, y, r)[2]);
           }
         }
 
@@ -838,7 +837,7 @@ namespace quda {
         // Recompute the exact residual and heavy quark residual
         r2 = blas::xmyNorm(b, r);
         rNorm = sqrt(r2);
-        hq_res = sqrt(blas::HeavyQuarkResidualNorm(y, r).z);
+        hq_res = sqrt(blas::HeavyQuarkResidualNorm(y, r)[2]);
 
         // Copy and update fields
         blas::copy(rSloppy, r); // no op when these pointers alias
@@ -896,7 +895,7 @@ namespace quda {
           // ...tell the world about it too.
           warningQuda(
             "new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-            sqrt(r2), r0Norm, resIncreaseTotal);
+            double(sqrt(r2)), double(r0Norm), resIncreaseTotal);
 
           // If the norm is ridiculously small in magnitude, we've exceeded the maximums on various
           // ways we keep track of residual increases, or the L2 norm converged, we say "we're good here"
@@ -904,7 +903,7 @@ namespace quda {
           if (rNorm < L2breakdown_eps || resIncrease > param.max_res_increase
               || resIncreaseTotal > param.max_res_increase_total || r2 < stop) {
             L2breakdown = true;
-            warningQuda("L2 breakdown %e, %e", rNorm, L2breakdown_eps);
+            warningQuda("L2 breakdown %e, %e", double(rNorm), double(L2breakdown_eps));
 
             // We also have to do a logic correction, switching the reliable update baselines we set above
             // from the L2 norm over to the HQ residual.
@@ -924,8 +923,8 @@ namespace quda {
           hqresIncrease++;
 
           // Tell the world about it
-          warningQuda("CG: new reliable HQ residual norm %e is greater than previous reliable residual norm %e", hq_res,
-                      hq0Res);
+          warningQuda("CG: new reliable HQ residual norm %e is greater than previous reliable residual norm %e",
+                      double(hq_res), double(hq0Res));
 
           // And if it's increased too many times in a row, flunk out of the solve.
           if (hqresIncrease > param.max_hq_res_increase) {
@@ -950,7 +949,7 @@ namespace quda {
           // If we're still in the L2 norm part of the solve, we explicitly restore
           // the orthogonality of the gradient vector, recompute beta, update `p`, and carry on with our lives.
           logQuda(QUDA_DEBUG_VERBOSE, "Regular restart == explicit gradient vector re-orthogonalization\n");
-          Complex rp = blas::cDotProduct(rSloppy, p) / (r2);
+          auto rp = blas::cDotProduct(rSloppy, p) / (r2);
           blas::caxpy(-rp, rSloppy, p);
 
           beta = r2 / r2_old;
@@ -1001,7 +1000,7 @@ namespace quda {
       // compute the true residuals
       mat(r, x);
       param.true_res = sqrt(blas::xmyNorm(b, r) / b2);
-      param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+      param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
     }
 
     PrintSummary("CG", k, r2, b2, stop, param.tol_hq);
@@ -1137,7 +1136,7 @@ namespace quda {
     MatrixXcd C = MatrixXcd::Zero(param.num_src, param.num_src);
     MatrixXcd S = MatrixXcd::Identity(param.num_src, param.num_src);
     MatrixXcd pAp = MatrixXcd::Identity(param.num_src, param.num_src);
-    quda::Complex *AC = new quda::Complex[param.num_src * param.num_src];
+    complex_t *AC = new complex_t[param.num_src * param.num_src];
 
 #ifdef MWVERBOSE
     MatrixXcd pTp = MatrixXcd::Identity(param.num_src, param.num_src);
@@ -1325,7 +1324,7 @@ namespace quda {
     for (int i = 0; i < param.num_src; i++) {
       mat(r.Component(i), x.Component(i));
       param.true_res = sqrt(blas::xmyNorm(b.Component(i), r.Component(i)) / b2[i]);
-      param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x.Component(i), r.Component(i)).z);
+      param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x.Component(i), r.Component(i))[2]);
       param.true_res_offset[i] = param.true_res;
       param.true_res_hq_offset[i] = param.true_res_hq;
 
@@ -1485,7 +1484,7 @@ void CG::solve(ColorSpinorField& x, ColorSpinorField& b) {
   for(int i = 0; i < param.num_src; i++){
     stop[i] = stopping(param.tol, b2[i], param.residual_type);  // stopping condition of solver
     if (use_heavy_quark_res) {
-      heavy_quark_res[i] = sqrt(blas::HeavyQuarkResidualNorm(x.Component(i), r.Component(i)).z);
+      heavy_quark_res[i] = sqrt(blas::HeavyQuarkResidualNorm(x.Component(i), r.Component(i))[2]);
       heavy_quark_res_old[i] = heavy_quark_res[i];   // heavy quark residual
     }
   }
@@ -1739,12 +1738,12 @@ void CG::solve(ColorSpinorField& x, ColorSpinorField& b) {
         if (&x != &xSloppy) {
           blas::copy(tmp, y);   //  FIXME: check whether copy works here
           for(int i=0; i<param.num_src; i++){
-            heavy_quark_res[i] = sqrt(blas::xpyHeavyQuarkResidualNorm(xSloppy.Component(i), tmp.Component(i), rSloppy.Component(i)).z);
+            heavy_quark_res[i] = sqrt(blas::xpyHeavyQuarkResidualNorm(xSloppy.Component(i), tmp.Component(i), rSloppy.Component(i))[2]);
           }
         } else {
           blas::copy(r, rSloppy);  //  FIXME: check whether copy works here
           for(int i=0; i<param.num_src; i++){
-            heavy_quark_res[i] = sqrt(blas::xpyHeavyQuarkResidualNorm(x.Component(i), y.Component(i), r.Component(i)).z);
+            heavy_quark_res[i] = sqrt(blas::xpyHeavyQuarkResidualNorm(x.Component(i), y.Component(i), r.Component(i))[2]);
           }
         }
       }
@@ -1775,7 +1774,7 @@ void CG::solve(ColorSpinorField& x, ColorSpinorField& b) {
       // calculate new reliable HQ resididual
       if (use_heavy_quark_res){
         for(int i=0; i<param.num_src; i++){
-          heavy_quark_res[i] = sqrt(blas::HeavyQuarkResidualNorm(y.Component(i), r.Component(i)).z);
+          heavy_quark_res[i] = sqrt(blas::HeavyQuarkResidualNorm(y.Component(i), r.Component(i))[2]);
         }
       }
 
@@ -1894,7 +1893,7 @@ void CG::solve(ColorSpinorField& x, ColorSpinorField& b) {
   for(int i=0; i<param.num_src; i++){
     mat(r.Component(i), x.Component(i));
     param.true_res = sqrt(blas::xmyNorm(b.Component(i), r.Component(i)) / b2[i]);
-    param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x.Component(i), r.Component(i)).z);
+    param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x.Component(i), r.Component(i))[2]);
     param.true_res_offset[i] = param.true_res;
     param.true_res_hq_offset[i] = param.true_res_hq;
 
diff --git a/lib/inv_eigcg_quda.cpp b/lib/inv_eigcg_quda.cpp
index 57a963a20e..7d91d5855f 100644
--- a/lib/inv_eigcg_quda.cpp
+++ b/lib/inv_eigcg_quda.cpp
@@ -26,13 +26,13 @@ namespace quda {
    using namespace blas;
 
    using DynamicStride   = Stride<Dynamic, Dynamic>;
-   using DenseMatrix     = MatrixXcd;
-   using VectorSet       = MatrixXcd;
-   using Vector          = VectorXcd;
-   using RealVector      = VectorXd;
+   using DenseMatrix     = Matrix<complex_t, Dynamic, Dynamic>;
+   using VectorSet       = Matrix<complex_t, Dynamic, Dynamic>;
+   using Vector          = Matrix<complex_t, Dynamic, 1>;
+   using RealVector      = Matrix<real_t, Dynamic, 1>;
 
 //special types needed for compatibility with QUDA blas:
-   using RowMajorDenseMatrix = Matrix<Complex, Dynamic, Dynamic, RowMajor>;
+   using RowMajorDenseMatrix = Matrix<complex_t, Dynamic, Dynamic, RowMajor>;
 
    static int max_eigcg_cycles = 4;//how many eigcg cycles do we allow?
 
@@ -56,7 +56,7 @@ namespace quda {
      int id; // cuurent search spase index
 
      int restarts;
-     double global_stop;
+     real_t global_stop;
 
      bool run_residual_correction; // used in mixed precision cycles
 
@@ -84,7 +84,7 @@ namespace quda {
      }
 
      // method for constructing Lanczos matrix :
-     inline void SetLanczos(Complex diag_val, Complex offdiag_val)
+     inline void SetLanczos(complex_t diag_val, complex_t offdiag_val)
      {
        if (run_residual_correction) return;
 
@@ -117,11 +117,11 @@ namespace quda {
        restarts += 1;
      }
 
-     void RestartLanczos(ColorSpinorField *w, ColorSpinorFieldSet *v, const double inv_sqrt_r2)
+     void RestartLanczos(ColorSpinorField *w, ColorSpinorFieldSet *v, const real_t inv_sqrt_r2)
      {
        Tm.setZero();
 
-       auto s = std::make_unique<Complex[]>(2 * k);
+       auto s = std::make_unique<complex_t[]>(2 * k);
 
        for (int i = 0; i < 2 * k; i++) Tm(i, i) = Tmvals(i); //??
 
@@ -132,7 +132,7 @@ namespace quda {
 
        blas::cDotProduct(s.get(), w_, v_);
 
-       Map<VectorXcd, Unaligned> s_(s.get(), 2 * k);
+       Map<Vector, Unaligned> s_(s.get(), 2 * k);
        s_ *= inv_sqrt_r2;
 
        Tm.col(2 * k).segment(0, 2 * k) = s_;
@@ -149,23 +149,23 @@ namespace quda {
      const int m = args.m;
      const int k = args.k;
      //Solve m dim eigenproblem:
-     SelfAdjointEigenSolver<MatrixXcd> es_tm(args.Tm);
+     SelfAdjointEigenSolver<DenseMatrix> es_tm(args.Tm);
      args.ritzVecs.leftCols(k) = es_tm.eigenvectors().leftCols(k);
      //Solve m-1 dim eigenproblem:
-     SelfAdjointEigenSolver<MatrixXcd> es_tm1(Map<MatrixXcd, Unaligned, DynamicStride >(args.Tm.data(), (m-1), (m-1), DynamicStride(m, 1)));
-     Block<MatrixXcd>(args.ritzVecs.derived(), 0, k, m-1, k) = es_tm1.eigenvectors().leftCols(k);
+     SelfAdjointEigenSolver<DenseMatrix> es_tm1(Map<DenseMatrix, Unaligned, DynamicStride >(args.Tm.data(), (m-1), (m-1), DynamicStride(m, 1)));
+     Block<DenseMatrix>(args.ritzVecs.derived(), 0, k, m-1, k) = es_tm1.eigenvectors().leftCols(k);
      args.ritzVecs.block(m-1, k, 1, k).setZero();
 
-     MatrixXcd Q2k(MatrixXcd::Identity(m, 2*k));
-     HouseholderQR<MatrixXcd> ritzVecs2k_qr( Map<MatrixXcd, Unaligned >(args.ritzVecs.data(), m, 2*k) );
+     DenseMatrix Q2k(DenseMatrix::Identity(m, 2*k));
+     HouseholderQR<DenseMatrix> ritzVecs2k_qr( Map<DenseMatrix, Unaligned >(args.ritzVecs.data(), m, 2*k) );
      Q2k.applyOnTheLeft( ritzVecs2k_qr.householderQ() );
 
      //2. Construct H = QH*Tm*Q :
      args.H2k = Q2k.adjoint()*args.Tm*Q2k;
 
      /* solve the small evecm1 2n_ev x 2n_ev eigenproblem */
-     SelfAdjointEigenSolver<MatrixXcd> es_h2k(args.H2k);
-     Block<MatrixXcd>(args.ritzVecs.derived(), 0, 0, m, 2*k) = Q2k * es_h2k.eigenvectors();
+     SelfAdjointEigenSolver<DenseMatrix> es_h2k(args.H2k);
+     Block<DenseMatrix>(args.ritzVecs.derived(), 0, 0, m, 2*k) = Q2k * es_h2k.eigenvectors();
      args.Tmvals.segment(0,2*k) = es_h2k.eigenvalues();//this is ok
 
      return;
@@ -280,7 +280,7 @@ namespace quda {
     }
   }
 
- void IncEigCG::RestartVT(const double beta, const double rho)
+ void IncEigCG::RestartVT(const real_t beta, const real_t rho)
   {
     EigCGArgs &args = *eigcg_args;
 
@@ -298,7 +298,7 @@ namespace quda {
     std::vector<ColorSpinorField*> v2k(args.V2k->Components());
 
     RowMajorDenseMatrix Alpha(args.ritzVecs.topLeftCorner(args.m, 2*args.k));
-    blas::caxpy( static_cast<Complex*>(Alpha.data()), vm , v2k);
+    blas::caxpy( static_cast<complex_t*>(Alpha.data()), vm , v2k);
 
     for(int i = 0; i < 2*args.k; i++)  blas::copy(Vm->Component(i), args.V2k->Component(i));
 
@@ -319,7 +319,7 @@ namespace quda {
     return;
   }
 
-  void IncEigCG::UpdateVm(ColorSpinorField &res, double beta, double sqrtr2)
+  void IncEigCG::UpdateVm(ColorSpinorField &res, real_t beta, real_t sqrtr2)
   {
     EigCGArgs &args = *eigcg_args;
 
@@ -352,7 +352,7 @@ namespace quda {
     profile.TPSTART(QUDA_PROFILE_INIT);
 
     // Check to see that we're not trying to invert on a zero-field source
-    const double b2 = blas::norm2(b);
+    auto b2 = blas::norm2(b);
     if (b2 == 0) {
       profile.TPSTOP(QUDA_PROFILE_INIT);
       printfQuda("Warning: inverting on zero-field source\n");
@@ -396,7 +396,7 @@ namespace quda {
       init = true;
     }
 
-    double local_stop = x.Precision() == QUDA_DOUBLE_PRECISION ? b2*param.tol*param.tol :  b2*1e-11;
+    auto local_stop = x.Precision() == QUDA_DOUBLE_PRECISION ? b2*param.tol*param.tol :  b2*1e-11;
 
     EigCGArgs &args = *eigcg_args;
 
@@ -423,7 +423,7 @@ namespace quda {
 
     // compute initial residual
     matSloppy(r, x);
-    double r2 = blas::xmyNorm(b, r);
+    auto r2 = blas::xmyNorm(b, r);
 
     ColorSpinorField *z  = (K != nullptr) ? ColorSpinorField::Create(csParam) : rp;//
 
@@ -449,20 +449,20 @@ namespace quda {
     profile.TPSTOP(QUDA_PROFILE_INIT);
     profile.TPSTART(QUDA_PROFILE_PREAMBLE);
 
-    double heavy_quark_res = 0.0;  // heavy quark res idual
+    real_t heavy_quark_res = 0.0;  // heavy quark res idual
 
-    if (use_heavy_quark_res)  heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+    if (use_heavy_quark_res)  heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
-    double pAp;
-    double alpha=1.0, alpha_inv=1.0, beta=0.0, alpha_old_inv = 1.0;
+    real_t pAp;
+    real_t alpha=1.0, alpha_inv=1.0, beta=0.0, alpha_old_inv = 1.0;
 
-    double lanczos_diag, lanczos_offdiag;
+    real_t lanczos_diag, lanczos_offdiag;
 
     profile.TPSTOP(QUDA_PROFILE_PREAMBLE);
     profile.TPSTART(QUDA_PROFILE_COMPUTE);
     blas::flops = 0;
 
-    double rMinvr = blas::reDotProduct(r,*z);
+    auto rMinvr = blas::reDotProduct(r,*z);
     //Begin EigCG iterations:
     args.restarts = 0;
 
@@ -494,7 +494,7 @@ namespace quda {
         blas::copy(*z, pPre);
       }
       //
-      double rMinvr_old   = rMinvr;
+      auto rMinvr_old   = rMinvr;
       rMinvr = K ? blas::reDotProduct(r,*z) : r2;
       beta                = rMinvr / rMinvr_old;
       blas::axpyZpbx(alpha, *p, y, *z, beta);
@@ -528,7 +528,7 @@ namespace quda {
     // compute the true residuals
     matSloppy(r, x);
     param.true_res = sqrt(blas::xmyNorm(b, r) / b2);
-    param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+    param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
     PrintSummary("eigCG", k, r2, b2, args.global_stop, param.tol_hq);
 
@@ -549,7 +549,7 @@ namespace quda {
     deflated_solver *defl_p = static_cast<deflated_solver*>(param.deflation_op);
     Deflation &defl         = *(defl_p->defl);
 
-    const double full_tol    = Kparam.tol;
+    auto full_tol = Kparam.tol;
     Kparam.tol         = Kparam.tol_restart;
 
     ColorSpinorParam csParam(x);
@@ -618,7 +618,7 @@ namespace quda {
      if(param.rhs_idx == 0) max_eigcg_cycles = param.eigcg_max_restarts;
 
      const bool mixed_prec = (param.precision != param.precision_sloppy);
-     const double b2       = norm2(in);
+     auto b2       = norm2(in);
 
      deflated_solver *defl_p = static_cast<deflated_solver*>(param.deflation_op);
      Deflation &defl         = *(defl_p->defl);
@@ -646,7 +646,7 @@ namespace quda {
      //deflate initial guess ('out'-field):
      mat(r, out);
      //
-     double r2 = xmyNorm(in, r);
+     auto r2 = xmyNorm(in, r);
 
      csParam.setPrecision(param.precision_sloppy);
 
@@ -655,7 +655,7 @@ namespace quda {
      ColorSpinorField *rp_sloppy = ( mixed_prec ) ? ColorSpinorField::Create(csParam) : rp;
      ColorSpinorField &rSloppy = *rp_sloppy;
 
-     const double stop = b2*param.tol*param.tol;
+     auto stop = b2*param.tol*param.tol;
      //start iterative refinement cycles (or just one eigcg call for full (solo) precision solver):
      int logical_rhs_id = 0;
      bool dcg_cycle    = false; 
@@ -701,7 +701,7 @@ namespace quda {
        r2 = blas::xmyNorm(in, r);
 
        param.true_res = sqrt(r2 / b2);
-       param.true_res_hq = sqrt(HeavyQuarkResidualNorm(out,r).z);
+       param.true_res_hq = sqrt(HeavyQuarkResidualNorm(out,r)[2]);
        PrintSummary( !dcg_cycle ? "EigCG:" : "DCG (correction cycle):", iters, r2, b2, stop, param.tol_hq);
 
        if( getVerbosity() >= QUDA_VERBOSE ) { 
@@ -730,7 +730,7 @@ namespace quda {
        Vm = nullptr;
 
        const int max_n_ev = defl.size(); // param.m;
-       printfQuda("\nRequested to reserve %d eigenvectors with max tol %le.\n", max_n_ev, param.eigenval_tol);
+       printfQuda("\nRequested to reserve %d eigenvectors with max tol %le.\n", max_n_ev, double(param.eigenval_tol));
        defl.reduce(param.eigenval_tol, max_n_ev);
      }
      return;
diff --git a/lib/inv_gcr_quda.cpp b/lib/inv_gcr_quda.cpp
index 9227f573b3..fa92187baf 100644
--- a/lib/inv_gcr_quda.cpp
+++ b/lib/inv_gcr_quda.cpp
@@ -21,9 +21,9 @@ namespace quda {
     return ds + 0.000001*dus;
   }
 
-  void GCR::computeBeta(std::vector<Complex> &beta, std::vector<ColorSpinorField> &Ap, int i, int N, int k)
+  void GCR::computeBeta(std::vector<complex_t> &beta, std::vector<ColorSpinorField> &Ap, int i, int N, int k)
   {
-    std::vector<Complex> Beta(N, 0.0);
+    std::vector<complex_t> Beta(N, real_t(0.0));
     blas::cDotProduct(Beta, {Ap.begin() + i, Ap.begin() + i + N}, Ap[k]); // vectorized dot product
 
 #if 0
@@ -36,14 +36,14 @@ namespace quda {
     for (int j = 0; j < N; j++) beta[(i + j) * n_krylov + k] = Beta[j];
   }
 
-  void GCR::updateAp(std::vector<Complex> &beta, std::vector<ColorSpinorField> &Ap, int begin, int size, int k)
+  void GCR::updateAp(std::vector<complex_t> &beta, std::vector<ColorSpinorField> &Ap, int begin, int size, int k)
   {
-    std::vector<Complex> beta_(size);
+    std::vector<complex_t> beta_(size);
     for (int i = 0; i < size; i++) beta_[i] = -beta[(i + begin) * n_krylov + k];
     blas::caxpy(beta_, {Ap.begin() + begin, Ap.begin() + begin + size}, Ap[k]);
   }
 
-  void GCR::orthoDir(std::vector<Complex> &beta, std::vector<ColorSpinorField> &Ap, int k, int pipeline)
+  void GCR::orthoDir(std::vector<complex_t> &beta, std::vector<ColorSpinorField> &Ap, int k, int pipeline)
   {
     switch (pipeline) {
     case 0: // no kernel fusion
@@ -82,8 +82,8 @@ namespace quda {
     }
   }
 
-  void GCR::backSubs(const std::vector<Complex> &alpha, const std::vector<Complex> &beta,
-                     const std::vector<double> &gamma, std::vector<Complex> &delta, int n)
+  void GCR::backSubs(const std::vector<complex_t> &alpha, const std::vector<complex_t> &beta,
+                     const std::vector<real_t> &gamma, std::vector<complex_t> &delta, int n)
   {
     for (int k=n-1; k>=0;k--) {
       delta[k] = alpha[k];
@@ -92,10 +92,10 @@ namespace quda {
     }
   }
 
-  void GCR::updateSolution(ColorSpinorField &x, const std::vector<Complex> &alpha, const std::vector<Complex> &beta,
-                           std::vector<double> &gamma, int k, std::vector<ColorSpinorField> &p)
+  void GCR::updateSolution(ColorSpinorField &x, const std::vector<complex_t> &alpha, const std::vector<complex_t> &beta,
+                           std::vector<real_t> &gamma, int k, std::vector<ColorSpinorField> &p)
   {
-    std::vector<Complex> delta(k);
+    std::vector<complex_t> delta(k);
 
     // Update the solution vector
     backSubs(alpha, beta, gamma, delta, k);
@@ -218,8 +218,8 @@ namespace quda {
       }
     }
 
-    double b2 = blas::norm2(b);  // norm sq of source
-    double r2;                // norm sq of residual
+    real_t b2 = blas::norm2(b);  // norm sq of source
+    real_t r2;                // norm sq of residual
 
     // compute initial residual depending on whether we have an initial guess or not
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
@@ -256,7 +256,7 @@ namespace quda {
       }
     }
 
-    double stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
+    real_t stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
 
     const bool use_heavy_quark_res = 
       (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
@@ -267,8 +267,8 @@ namespace quda {
     const int maxResIncrease = param.max_res_increase; // check if we reached the limit of our tolerance
     const int maxResIncreaseTotal = param.max_res_increase_total;
 
-    double heavy_quark_res = 0.0; // heavy quark residual
-    if(use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x,r).z);
+    real_t heavy_quark_res = 0.0; // heavy quark residual
+    if(use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x,r)[2]);
 
     int resIncrease = 0;
     int resIncreaseTotal = 0;
@@ -282,8 +282,8 @@ namespace quda {
 
     int total_iter = 0;
     int restart = 0;
-    double r2_old = r2;
-    double maxr_deflate = sqrt(r2);
+    real_t r2_old = r2;
+    real_t maxr_deflate = sqrt(r2);
     bool l2_converge = false;
 
     int pipeline = param.pipeline;
@@ -312,11 +312,11 @@ namespace quda {
 
       orthoDir(beta, Ap, k, pipeline);
 
-      double3 Apr = blas::cDotProductNormA(Ap[k], K ? r_sloppy : p[k]);
+      auto Apr = blas::cDotProductNormA(Ap[k], K ? r_sloppy : p[k]);
 
-      gamma[k] = sqrt(Apr.z); // gamma[k] = Ap[k]
+      gamma[k] = sqrt(Apr[2]); // gamma[k] = Ap[k]
       if (gamma[k] == 0.0) errorQuda("GCR breakdown");
-      alpha[k] = Complex(Apr.x, Apr.y) / gamma[k]; // alpha = (1/|Ap|) * (Ap, r)
+      alpha[k] = complex_t(Apr[0], Apr[1]) / gamma[k]; // alpha = (1/|Ap|) * (Ap, r)
 
       // r -= (1/|Ap|^2) * (Ap, r) r, Ap *= 1/|Ap|
       r2 = blas::cabxpyzAxNorm(1.0 / gamma[k], -alpha[k], Ap[k], K ? r_sloppy : p[k], K ? r_sloppy : p[k + 1]);
@@ -348,14 +348,14 @@ namespace quda {
           maxr_deflate = sqrt(r2);
         }
 
-        if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+        if (use_heavy_quark_res) heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
         // break-out check if we have reached the limit of the precision
         if (r2 > r2_old) {
           resIncrease++;
           resIncreaseTotal++;
           warningQuda("GCR: new reliable residual norm %e is greater than previous reliable residual norm %e (total #inc %i)",
-        	      sqrt(r2), sqrt(r2_old), resIncreaseTotal);
+        	      double(sqrt(r2)), double(sqrt(r2_old)), resIncreaseTotal);
           if (resIncrease > maxResIncrease or resIncreaseTotal > maxResIncreaseTotal) {
             warningQuda("GCR: solver exiting due to too many true residual norm increases");
             break;
@@ -398,10 +398,10 @@ namespace quda {
     if (param.compute_true_res) {
       // Calculate the true residual
       mat(r, x);
-      double true_res = blas::xmyNorm(b, r);
+      real_t true_res = blas::xmyNorm(b, r);
       param.true_res = sqrt(true_res / b2);
       if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL)
-	param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x,r).z);
+	param.true_res_hq = sqrt(blas::HeavyQuarkResidualNorm(x,r)[2]);
       else
 	param.true_res_hq = 0.0;
       //if (param.preserve_source == QUDA_PRESERVE_SOURCE_NO) blas::copy(b, r);
diff --git a/lib/inv_gmresdr_quda.cpp b/lib/inv_gmresdr_quda.cpp
index 389206853e..2e7725795a 100644
--- a/lib/inv_gmresdr_quda.cpp
+++ b/lib/inv_gmresdr_quda.cpp
@@ -29,20 +29,19 @@ namespace quda {
   using namespace std;
 
   using DynamicStride = Stride<Dynamic, Dynamic>;
-
-  using DenseMatrix = MatrixXcd;
-  using VectorSet = MatrixXcd;
-  using Vector = VectorXcd;
+  using DenseMatrix = Matrix<complex_t, Dynamic, Dynamic>;
+  using VectorSet = Matrix<complex_t, Dynamic, Dynamic>;
+  using Vector = Matrix<complex_t, Dynamic, 1>;
 
   // special types needed for compatibility with QUDA blas:
-  using RowMajorDenseMatrix = Matrix<Complex, Dynamic, Dynamic, RowMajor>;
+  using RowMajorDenseMatrix = Matrix<complex_t, Dynamic, Dynamic, RowMajor>;
 
   struct SortedEvals {
 
-    double _val;
+    real_t _val;
     int _idx;
 
-    SortedEvals(double val, int idx) : _val(val), _idx(idx) {};
+    SortedEvals(real_t val, int idx) : _val(val), _idx(idx) {};
     static bool SelectSmall(SortedEvals v1, SortedEvals v2) { return (v1._val < v2._val); }
   };
 
@@ -60,7 +59,7 @@ namespace quda {
     int k;
     int restarts;
 
-    Complex *c;
+    complex_t *c;
 
     ColorSpinorFieldSet *Vkp1; // high-precision accumulation array
 
@@ -73,7 +72,7 @@ namespace quda {
       restarts(0),
       Vkp1(nullptr)
     {
-      c = static_cast<Complex *>(ritzVecs.col(k).data());
+      c = static_cast<complex_t *>(ritzVecs.col(k).data());
     }
 
     inline void ResetArgs()
@@ -97,10 +96,9 @@ namespace quda {
     DenseMatrix cH = args.H.block(0, 0, args.m, args.m).adjoint();
     DenseMatrix Gk = args.H.block(0, 0, args.m, args.m);
 
-    VectorSet harVecs = MatrixXcd::Zero(args.m, args.m);
-    Vector harVals = VectorXcd::Zero(args.m);
-
-    Vector em = VectorXcd::Zero(args.m);
+    VectorSet harVecs = VectorSet::Zero(args.m, args.m);
+    Vector harVals = Vector::Zero(args.m);
+    Vector em = Vector::Zero(args.m);
 
     em(args.m - 1) = norm(args.H(args.m, args.m - 1));
     Gk.col(args.m - 1) += cH.colPivHouseholderQr().solve(em);
@@ -116,7 +114,7 @@ namespace quda {
     std::stable_sort(sorted_evals.begin(), sorted_evals.end(), SortedEvals::SelectSmall);
 
     for (int e = 0; e < args.k; e++)
-      memcpy(args.ritzVecs.col(e).data(), harVecs.col(sorted_evals[e]._idx).data(), (args.m) * sizeof(Complex));
+      memcpy(args.ritzVecs.col(e).data(), harVecs.col(sorted_evals[e]._idx).data(), (args.m) * sizeof(complex_t));
 
     return;
   }
@@ -126,7 +124,7 @@ namespace quda {
   template <> void ComputeEta<libtype::eigen_lib>(GMResDRArgs &args)
   {
 
-    Map<VectorXcd, Unaligned> c_(args.c, args.m + 1);
+    Map<Vector, Unaligned> c_(args.c, args.m + 1);
     args.eta = args.H.jacobiSvd(ComputeThinU | ComputeThinV).solve(c_);
 
     return;
@@ -237,13 +235,13 @@ namespace quda {
     std::vector<ColorSpinorField *> x_, r_;
     x_.push_back(x), r_.push_back(r);
 
-    blas::caxpy(static_cast<Complex *>(args.eta.data()), Z_, x_);
+    blas::caxpy(static_cast<complex_t *>(args.eta.data()), Z_, x_);
 
-    VectorXcd minusHeta = -(args.H * args.eta);
-    Map<VectorXcd, Unaligned> c_(args.c, args.m + 1);
+    Vector minusHeta = -(args.H * args.eta);
+    Map<Vector, Unaligned> c_(args.c, args.m + 1);
     c_ += minusHeta;
 
-    blas::caxpy(static_cast<Complex *>(minusHeta.data()), V_, r_);
+    blas::caxpy(static_cast<complex_t *>(minusHeta.data()), V_, r_);
     return;
   }
 
@@ -257,9 +255,9 @@ namespace quda {
       errorQuda("Library type %d is currently not supported.\n", param.extlib_type);
     }
 
-    DenseMatrix Qkp1(MatrixXcd::Identity((args.m + 1), (args.k + 1)));
+    DenseMatrix Qkp1(DenseMatrix::Identity((args.m + 1), (args.k + 1)));
 
-    HouseholderQR<MatrixXcd> qr(args.ritzVecs);
+    HouseholderQR<DenseMatrix> qr(args.ritzVecs);
     Qkp1.applyOnTheLeft(qr.householderQ());
 
     DenseMatrix Res = Qkp1.adjoint() * args.H * Qkp1.topLeftCorner(args.m, args.k);
@@ -272,7 +270,7 @@ namespace quda {
     std::vector<ColorSpinorField *> vm(Vm->Components());
 
     RowMajorDenseMatrix Alpha(Qkp1); // convert Qkp1 to Row-major format first
-    blas::caxpy(static_cast<Complex *>(Alpha.data()), vm, vkp1);
+    blas::caxpy(static_cast<complex_t *>(Alpha.data()), vm, vkp1);
 
     for (int i = 0; i < (args.m + 1); i++) {
       if (i < (args.k + 1)) {
@@ -287,7 +285,7 @@ namespace quda {
       std::vector<ColorSpinorField *> vk(args.Vkp1->Components().begin(), args.Vkp1->Components().begin() + args.k);
 
       RowMajorDenseMatrix Beta(Qkp1.topLeftCorner(args.m, args.k));
-      blas::caxpy(static_cast<Complex *>(Beta.data()), z, vk);
+      blas::caxpy(static_cast<complex_t *>(Beta.data()), z, vk);
 
       for (int i = 0; i < (args.m); i++) {
         if (i < (args.k))
@@ -298,7 +296,7 @@ namespace quda {
     }
 
     for (int j = 0; j < args.k; j++) {
-      Complex alpha = cDotProduct(Vm->Component(j), Vm->Component(args.k));
+      complex_t alpha = cDotProduct(Vm->Component(j), Vm->Component(args.k));
       caxpy(-alpha, Vm->Component(j), Vm->Component(args.k));
     }
 
@@ -313,11 +311,11 @@ namespace quda {
     int j = start_idx;
     GMResDRArgs &args = *gmresdr_args;
 
-    std::unique_ptr<Complex[]> givensH((do_givens) ? new Complex[(args.m + 1) * args.m] : nullptr);
-    std::unique_ptr<Complex[]> cn((do_givens) ? new Complex[args.m] : nullptr);
-    std::unique_ptr<double[]> sn((do_givens) ? new double[args.m] : nullptr);
+    std::unique_ptr<complex_t[]> givensH((do_givens) ? new complex_t[(args.m + 1) * args.m] : nullptr);
+    std::unique_ptr<complex_t[]> cn((do_givens) ? new complex_t[args.m] : nullptr);
+    std::unique_ptr<real_t[]> sn((do_givens) ? new real_t[args.m] : nullptr);
 
-    Complex c0 = args.c[0];
+    complex_t c0 = args.c[0];
 
     while (j < args.m) {
       if (K) {
@@ -337,7 +335,7 @@ namespace quda {
       args.H(0, j) = cDotProduct(Vm->Component(0), Vm->Component(j + 1));
       caxpy(-args.H(0, j), Vm->Component(0), Vm->Component(j + 1));
 
-      Complex h0 = do_givens ? args.H(0, j) : 0.0;
+      complex_t h0 = do_givens ? args.H(0, j) : complex_t(0.0);
 
       for (int i = 1; i <= j; i++) {
         args.H(i, j) = cDotProduct(Vm->Component(i), Vm->Component(j + 1));
@@ -349,10 +347,10 @@ namespace quda {
         }
       }
 
-      args.H(j + 1, j) = Complex(sqrt(norm2(Vm->Component(j + 1))), 0.0);
+      args.H(j + 1, j) = complex_t(sqrt(norm2(Vm->Component(j + 1))), 0.0);
       blas::ax(1.0 / args.H(j + 1, j).real(), Vm->Component(j + 1));
       if (do_givens) {
-        double inv_denom = 1.0 / sqrt(norm(h0) + norm(args.H(j + 1, j)));
+        real_t inv_denom = rsqrt(norm(h0) + norm(args.H(j + 1, j)));
         cn[j] = h0 * inv_denom;
         sn[j] = args.H(j + 1, j).real() * inv_denom;
         givensH[j * (args.m + 1) + j] = conj(cn[j]) * h0 + sn[j] * args.H(j + 1, j);
@@ -365,15 +363,15 @@ namespace quda {
     }
 
     if (do_givens) {
-      Map<MatrixXcd, Unaligned, DynamicStride> givensH_(givensH.get(), args.m, args.m, DynamicStride(args.m + 1, 1));
-      memcpy(args.eta.data(), args.c, args.m * sizeof(Complex));
-      memset((void *)args.c, 0, (args.m + 1) * sizeof(Complex));
+      Map<DenseMatrix, Unaligned, DynamicStride> givensH_(givensH.get(), args.m, args.m, DynamicStride(args.m + 1, 1));
+      memcpy(args.eta.data(), args.c, args.m * sizeof(complex_t));
+      memset((void *)args.c, 0, (args.m + 1) * sizeof(complex_t));
       args.c[0] = c0;
 
       givensH_.triangularView<Upper>().solveInPlace<OnTheLeft>(args.eta);
 
     } else {
-      memset((void *)args.c, 0, (args.m + 1) * sizeof(Complex));
+      memset((void *)args.c, 0, (args.m + 1) * sizeof(complex_t));
 
       std::vector<ColorSpinorField *> v_(Vm->Components().begin(), Vm->Components().begin() + args.k + 1);
       std::vector<ColorSpinorField *> r_;
@@ -388,8 +386,8 @@ namespace quda {
   {
     profile.TPSTART(QUDA_PROFILE_INIT);
 
-    const double tol_threshold     = 1.2;
-    const double det_max_deviation = 0.4;
+    const real_t tol_threshold     = 1.2;
+    const real_t det_max_deviation = 0.4;
 
     ColorSpinorField *ep = nullptr;
 
@@ -446,16 +444,16 @@ namespace quda {
 
     int tot_iters = 0;
 
-    double normb = norm2( b );
-    double stop  = param.tol*param.tol* normb;  
+    real_t normb = norm2( b );
+    real_t stop  = param.tol*param.tol* normb;  
 
     mat(r, x);
     
-    double r2 = xmyNorm(b, r);
-    double b2 = r2;
-    args.c[0] = Complex(sqrt(r2), 0.0);
+    real_t r2 = xmyNorm(b, r);
+    real_t b2 = r2;
+    args.c[0] = complex_t(sqrt(r2), 0.0);
 
-    printfQuda("\nInitial residual squared: %1.16e, source %1.16e, tolerance %1.16e\n", r2, sqrt(normb), param.tol);
+    printfQuda("\nInitial residual squared: %1.16e, source %1.16e, tolerance %1.16e\n", double(r2), double(sqrt(normb)), double(param.tol));
 
     rSloppy = r;
 
@@ -473,8 +471,8 @@ namespace quda {
 
     const bool use_heavy_quark_res = (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) ? true : false;
 
-    double heavy_quark_res = 0.0;  
-    if (use_heavy_quark_res)  heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r).z);
+    real_t heavy_quark_res = 0.0;  
+    if (use_heavy_quark_res)  heavy_quark_res = sqrt(blas::HeavyQuarkResidualNorm(x, r)[2]);
 
 
     int restart_idx = 0, j = 0, check_interval = 4;
@@ -488,7 +486,7 @@ namespace quda {
       r2 = norm2(rSloppy);
 
       bool do_clean_restart = false;
-      double ext_r2 = 1.0;
+      real_t ext_r2 = 1.0;
 
       if ((restart_idx + 1) % check_interval) {
         mat(y, e);
@@ -497,7 +495,7 @@ namespace quda {
         // can this be done as a single 2-d reduction?
         for (int l = 0; l < args.k + 1; l++) {
 
-          Complex *col = Gm.col(l).data();
+          complex_t *col = Gm.col(l).data();
 
           std::vector<ColorSpinorField *> v1_(Vm->Components().begin(), Vm->Components().begin() + args.k + 1);
           std::vector<ColorSpinorField *> v2_;
@@ -507,11 +505,11 @@ namespace quda {
 
         } // end l-loop
 
-        Complex detGm = Gm.determinant();
+        complex_t detGm = Gm.determinant();
 
         PrintStats("FGMResDR:", tot_iters, r2, b2, heavy_quark_res);
-        printfQuda("\nCheck cycle %d, true residual squared %1.15e, Gramm det : (%le, %le)\n", restart_idx, ext_r2,
-                   detGm.real(), detGm.imag());
+        printfQuda("\nCheck cycle %d, true residual squared %1.15e, Gramm det : (%le, %le)\n", restart_idx,
+                   double(ext_r2), double(detGm.real()), double(detGm.imag()));
 
         Gm.setZero();
 
@@ -525,7 +523,7 @@ namespace quda {
 
       } else {
 
-        printfQuda("\nClean restart for cycle %d, true residual squared %1.15e\n", restart_idx, ext_r2);
+        printfQuda("\nClean restart for cycle %d, true residual squared %1.15e\n", restart_idx, double(ext_r2));
         args.ResetArgs();
 
         // update solution:
@@ -533,7 +531,7 @@ namespace quda {
         r = y;
         zero(e);
 
-        args.c[0] = Complex(sqrt(ext_r2), 0.0);
+        args.c[0] = complex_t(sqrt(ext_r2), 0.0);
         blas::zero(Vm->Component(0));
         blas::axpy(1.0 / args.c[0].real(), rSloppy, Vm->Component(0));
 
@@ -568,7 +566,6 @@ namespace quda {
     param.rhs_idx += 1;
 
     if (ep) delete ep;
-    return;
   }
 
 } // namespace quda
diff --git a/lib/inv_mr_quda.cpp b/lib/inv_mr_quda.cpp
index 4f636bf279..c385dbcc67 100644
--- a/lib/inv_mr_quda.cpp
+++ b/lib/inv_mr_quda.cpp
@@ -67,8 +67,8 @@ namespace quda
       profile.TPSTART(QUDA_PROFILE_COMPUTE);
     }
 
-    double b2 = blas::norm2(b); // Save norm of b
-    double r2 = 0.0;            // if zero source then we will exit immediately doing no work
+    real_t b2 = blas::norm2(b); // Save norm of b
+    real_t r2 = 0.0;            // if zero source then we will exit immediately doing no work
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       mat(r, x);
       r2 = blas::xmyNorm(b, r); // r = b - Ax0
@@ -80,7 +80,7 @@ namespace quda
     blas::copy(r_sloppy, r);
 
     // if invalid residual then convergence is set by iteration count only
-    double stop = param.residual_type == QUDA_INVALID_RESIDUAL ? 0.0 : b2 * param.tol * param.tol;
+    real_t stop = param.residual_type == QUDA_INVALID_RESIDUAL ? 0.0 : b2 * param.tol * param.tol;
 
     int iter = 0;
     int step = 0;
@@ -90,7 +90,7 @@ namespace quda
     while (!converged) {
 
       int k = 0;
-      double scale = 1.0;
+      real_t scale = 1.0;
       if ((node_parity + step) % 2 == 0 && param.schwarz_type == QUDA_MULTIPLICATIVE_SCHWARZ) {
         // for multiplicative Schwarz we alternate updates depending on node parity
       } else {
@@ -98,7 +98,7 @@ namespace quda
         commGlobalReductionPush(param.global_reduction); // use local reductions for DD solver
 
         blas::zero(x_sloppy); // can get rid of this for a special first update kernel
-        double c2 = param.global_reduction == QUDA_BOOLEAN_TRUE ? r2 : blas::norm2(r); // c2 holds the initial r2
+        real_t c2 = param.global_reduction == QUDA_BOOLEAN_TRUE ? r2 : blas::norm2(r); // c2 holds the initial r2
         scale = c2 > 0.0 ? sqrt(c2) : 1.0;
 
         // domain-wise normalization of the initial residual to prevent underflow
@@ -113,8 +113,8 @@ namespace quda
 
           if (param.global_reduction) {
             auto Ar4 = blas::cDotProductNormAB(Ar, r_sloppy);
-            Complex alpha = Complex(Ar4.x, Ar4.y) / Ar4.z;
-            r2 = Ar4.w;
+            auto alpha = complex_t(Ar4[0], Ar4[1]) / Ar4[2];
+            r2 = Ar4[3];
             PrintStats("MR (inner)", iter, r2, b2, 0.0);
 
             // x += omega*alpha*r, r -= omega*alpha*Ar, r2 = blas::norm2(r)
diff --git a/lib/inv_mre.cpp b/lib/inv_mre.cpp
index 10733a6aaa..048438ab7c 100644
--- a/lib/inv_mre.cpp
+++ b/lib/inv_mre.cpp
@@ -12,11 +12,11 @@ namespace quda
 
   /* Solve the equation A p_k psi_k = b by minimizing the residual and
      using Eigen's SVD algorithm for numerical stability */
-  void MinResExt::solve(std::vector<Complex> &psi_, std::vector<ColorSpinorField> &p, std::vector<ColorSpinorField> &q,
+  void MinResExt::solve(std::vector<complex_t> &psi_, std::vector<ColorSpinorField> &p, std::vector<ColorSpinorField> &q,
                         const ColorSpinorField &b, bool hermitian)
   {
-    typedef Matrix<Complex, Dynamic, Dynamic> matrix;
-    typedef Matrix<Complex, Dynamic, 1> vector;
+    typedef Matrix<complex_t, Dynamic, Dynamic> matrix;
+    typedef Matrix<complex_t, Dynamic, 1> vector;
 
     const int N = q.size();
     vector phi(N), psi(N);
@@ -25,7 +25,7 @@ namespace quda
     // form the a Nx(N+1) matrix using only a single reduction - this
     // presently requires forgoing the matrix symmetry, but the improvement is well worth it
 
-    std::vector<Complex> A_(N * (N + 1));
+    std::vector<complex_t> A_(N * (N + 1));
 
     if (hermitian) {
       // linear system is Hermitian, solve directly
@@ -88,12 +88,12 @@ namespace quda
     // Orthonormalise the vector basis
     if (orthogonal) {
       for (int i = 0; i < N; i++) {
-        double p2 = blas::norm2(p[i]);
+        real_t p2 = blas::norm2(p[i]);
         blas::ax(1 / sqrt(p2), p[i]);
         if (!apply_mat) blas::ax(1 / sqrt(p2), q[i]);
 
         if (i + 1 < N) {
-          std::vector<Complex> alpha(N - (i + 1));
+          std::vector<complex_t> alpha(N - (i + 1));
           blas::cDotProduct(alpha, {p[i]}, {p.begin() + i + 1, p.end()});
           for (auto &a : alpha) a = -a;
           blas::caxpy(alpha, {p[i]}, {p.begin() + i + 1, p.end()});
@@ -111,7 +111,7 @@ namespace quda
       for (int i = 0; i < N; i++) mat(q[i], p[i]);
 
     // Solution coefficient vectors
-    std::vector<Complex> alpha(N);
+    std::vector<complex_t> alpha(N);
 
     if (b.Precision() != p[0].Precision()) { // need to make a sloppy copy of b
       ColorSpinorParam param(b);
@@ -130,7 +130,7 @@ namespace quda
       ColorSpinorField r(b);
       for (auto &a : alpha) a = -a;
       blas::caxpy(alpha, q, r);
-      printfQuda("MinResExt: N = %d, |res| / |src| = %e\n", N, sqrt(blas::norm2(r) / blas::norm2(b)));
+      printfQuda("MinResExt: N = %d, |res| / |src| = %e\n", N, double(sqrt(blas::norm2(r)) / double(blas::norm2(b))));
     }
 
     if (!running) getProfile().TPSTOP(QUDA_PROFILE_CHRONO);
diff --git a/lib/inv_multi_cg_quda.cpp b/lib/inv_multi_cg_quda.cpp
index b6757440f4..5a7993c38d 100644
--- a/lib/inv_multi_cg_quda.cpp
+++ b/lib/inv_multi_cg_quda.cpp
@@ -52,10 +52,10 @@ namespace quda {
     std::vector<ColorSpinorField> &p;
     std::vector<ColorSpinorField> &x;
 
-    std::vector<double> &alpha;
-    std::vector<double> &beta;
-    std::vector<double> &zeta;
-    std::vector<double> &zeta_old;
+    std::vector<real_t> &alpha;
+    std::vector<real_t> &beta;
+    std::vector<real_t> &zeta;
+    std::vector<real_t> &zeta_old;
 
     const int j_low;
     int n_shift;
@@ -70,8 +70,8 @@ namespace quda {
 
   public:
     ShiftUpdate(ColorSpinorField &r, std::vector<ColorSpinorField> &p, std::vector<ColorSpinorField> &x,
-                std::vector<double> &alpha, std::vector<double> &beta, std::vector<double> &zeta,
-                std::vector<double> &zeta_old, int j_low, int n_shift) :
+                std::vector<real_t> &alpha, std::vector<real_t> &beta, std::vector<real_t> &zeta,
+                std::vector<real_t> &zeta_old, int j_low, int n_shift) :
       r(r),
       p(p),
       x(x),
@@ -167,18 +167,18 @@ namespace quda {
   /**
      Compute the new values of alpha and zeta
    */
-  void updateAlphaZeta(std::vector<double> &alpha, std::vector<double> &zeta, std::vector<double> &zeta_old,
-                       const std::vector<double> &r2, const std::vector<double> &beta, double pAp, const double *offset,
+  void updateAlphaZeta(std::vector<real_t> &alpha, std::vector<real_t> &zeta, std::vector<real_t> &zeta_old,
+                       const std::vector<real_t> &r2, const std::vector<real_t> &beta, real_t pAp, const real_t *offset,
                        const int nShift, const int j_low)
   {
-    std::vector<double> alpha_old(alpha);
+    std::vector<real_t> alpha_old(alpha);
 
     alpha[0] = r2[0] / pAp;
     zeta[0] = 1.0;
     for (int j=1; j<nShift; j++) {
-      double c0 = zeta[j] * zeta_old[j] * alpha_old[j_low];
-      double c1 = alpha[j_low] * beta[j_low] * (zeta_old[j]-zeta[j]);
-      double c2 = zeta_old[j] * alpha_old[j_low] * (1.0 + (offset[j] - offset[0]) * alpha[j_low]);
+      real_t c0 = zeta[j] * zeta_old[j] * alpha_old[j_low];
+      real_t c1 = alpha[j_low] * beta[j_low] * (zeta_old[j]-zeta[j]);
+      real_t c2 = zeta_old[j] * alpha_old[j_low] * (1.0 + (offset[j] - offset[0]) * alpha[j_low]);
 
       zeta_old[j] = zeta[j];
       zeta[j] = (c1 + c2 != 0.0) ? c0 / (c1 + c2) : 0.0;
@@ -187,16 +187,16 @@ namespace quda {
   }
 
   void MultiShiftCG::operator()(std::vector<ColorSpinorField> &x, ColorSpinorField &b, std::vector<ColorSpinorField> &p,
-                                std::vector<double> &r2_old_array)
+                                std::vector<real_t> &r2_old_array)
   {
     pushOutputPrefix("MultiShiftCG: ");
     create(x, b, p);
 
     if (num_offset == 0) return;
 
-    double *offset = param.offset;
+    real_t *offset = param.offset;
 
-    const double b2 = blas::norm2(b);
+    const real_t b2 = blas::norm2(b);
     // Check to see that we're not trying to invert on a zero-field source
     if (b2 == 0) {
       warningQuda("inverting on zero-field source");
@@ -213,20 +213,20 @@ namespace quda {
     bool zero_refinement = param.precision_refinement_sloppy != param.precision;
 
     // this is the limit of precision possible
-    const double sloppy_tol= param.precision_sloppy == 8 ? std::numeric_limits<double>::epsilon() :
+    const real_t sloppy_tol= param.precision_sloppy == 8 ? std::numeric_limits<double>::epsilon() :
       ((param.precision_sloppy == 4) ? std::numeric_limits<float>::epsilon() : pow(2.,-17));
-    const double fine_tol = pow(10.,(-2*(int)b.Precision()+1));
-    std::vector<double> prec_tol(num_offset);
+    const real_t fine_tol = pow(10.,(-2*(int)b.Precision()+1));
+    std::vector<real_t> prec_tol(num_offset);
 
     prec_tol[0] = mixed ? sloppy_tol : fine_tol;
     for (int i=1; i<num_offset; i++) {
       prec_tol[i] = std::min(sloppy_tol,std::max(fine_tol,sqrt(param.tol_offset[i]*sloppy_tol)));
     }
 
-    std::vector<double> zeta(num_offset, 1.0);
-    std::vector<double> zeta_old(num_offset, 1.0);
-    std::vector<double> alpha(num_offset, 1.0);
-    std::vector<double> beta(num_offset, 0.0);
+    std::vector<real_t> zeta(num_offset, 1.0);
+    std::vector<real_t> zeta_old(num_offset, 1.0);
+    std::vector<real_t> alpha(num_offset, 1.0);
+    std::vector<real_t> beta(num_offset, 0.0);
 
     int j_low = 0;
     int num_offset_now = num_offset;
@@ -234,22 +234,22 @@ namespace quda {
     profile.TPSTART(QUDA_PROFILE_PREAMBLE);
 
     // stopping condition of each shift
-    std::vector<double> r2(num_offset, b2);
-    std::vector<double> stop(num_offset);
+    std::vector<real_t> r2(num_offset, b2);
+    std::vector<real_t> stop(num_offset);
     for (int i = 0; i < num_offset; i++) stop[i] = Solver::stopping(param.tol_offset[i], b2, param.residual_type);
 
     std::vector<int> iter(num_offset + 1, 0); // record how many iterations for each shift
     iter[num_offset] = 1;                     // this initial condition ensures that the heaviest shift can be removed
 
-    double r2_old;
-    double pAp;
+    real_t r2_old;
+    real_t pAp;
 
-    std::vector<double> rNorm(num_offset);
+    std::vector<real_t> rNorm(num_offset);
     for (int i = 0; i < num_offset; i++) rNorm[i] = sqrt(r2[i]);
-    std::vector<double> r0Norm(rNorm);
-    std::vector<double> maxrx(rNorm);
-    std::vector<double> maxrr(rNorm);
-    double delta = param.delta;
+    std::vector<real_t> r0Norm(rNorm);
+    std::vector<real_t> maxrx(rNorm);
+    std::vector<real_t> maxrr(rNorm);
+    real_t delta = param.delta;
 
     // this parameter determines how many consective reliable update
     // reisudal increases we tolerate before terminating the solver,
@@ -271,7 +271,7 @@ namespace quda {
     profile.TPSTOP(QUDA_PROFILE_PREAMBLE);
     profile.TPSTART(QUDA_PROFILE_COMPUTE);
 
-    logQuda(QUDA_VERBOSE, "%d iterations, <r,r> = %e, |r|/|b| = %e\n", k, r2[0], sqrt(r2[0] / b2));
+    logQuda(QUDA_VERBOSE, "%d iterations, <r,r> = %e, |r|/|b| = %e\n", k, double(r2[0]), double(sqrt(r2[0] / b2)));
 
     while ( !convergence(r2, stop, num_offset_now) &&  !exit_early && k < param.maxiter) {
 
@@ -298,8 +298,8 @@ namespace quda {
       r2_old_array[0] = r2_old;
 
       auto cg_norm = blas::axpyCGNorm(-alpha[j_low], Ap, r_sloppy);
-      r2[0] = cg_norm.x;
-      double zn = cg_norm.y;
+      r2[0] = cg_norm[0];
+      real_t zn = cg_norm[1];
 
       // reliable update conditions
       rNorm[0] = sqrt(r2[0]);
@@ -358,7 +358,7 @@ namespace quda {
 	  resIncrease++;
 	  resIncreaseTotal[reliable_shift]++;
           warningQuda("Shift %d, updated residual %e is greater than previous residual %e (total #inc %i)",
-                      reliable_shift, sqrt(r2[reliable_shift]), r0Norm[reliable_shift], resIncreaseTotal[reliable_shift]);
+                      reliable_shift, double(sqrt(r2[reliable_shift])), double(r0Norm[reliable_shift]), resIncreaseTotal[reliable_shift]);
 
           if (resIncrease > maxResIncrease or resIncreaseTotal[reliable_shift] > maxResIncreaseTotal) {
             warningQuda("solver exiting due to too many true residual norm increases");
@@ -370,7 +370,7 @@ namespace quda {
 
 	// explicitly restore the orthogonality of the gradient vector
 	for (int j=0; j<num_offset_now; j++) {
-          Complex rp = blas::cDotProduct(r_sloppy, p[j]) / (r2[0]);
+          auto rp = blas::cDotProduct(r_sloppy, p[j]) / (r2[0]);
           blas::caxpy(-rp, r_sloppy, p[j]);
         }
 
@@ -429,7 +429,7 @@ namespace quda {
         for (int j = 0; j < num_offset_now; j++) iter[j] = k;
       }
 
-      logQuda(QUDA_VERBOSE, "%d iterations, <r,r> = %e, |r|/|b| = %e\n", k, r2[0], sqrt(r2[0] / b2));
+      logQuda(QUDA_VERBOSE, "%d iterations, <r,r> = %e, |r|/|b| = %e\n", k, double(r2[0]), double(sqrt(r2[0] / b2)));
     }
 
     for (int i=0; i<num_offset; i++) {
@@ -460,9 +460,9 @@ namespace quda {
           } else if (i != 0) {
             blas::axpy(offset[i] - offset[0], x[i], r); // Offset it.
           }
-          double true_res = blas::xmyNorm(b, r);
+          auto true_res = blas::xmyNorm(b, r);
           param.true_res_offset[i] = sqrt(true_res / b2);
-          param.true_res_hq_offset[i] = sqrt(blas::HeavyQuarkResidualNorm(x[i], r).z);
+          param.true_res_hq_offset[i] = sqrt(blas::HeavyQuarkResidualNorm(x[i], r)[2]);
         } else {
           param.true_res_offset[i] = std::numeric_limits<double>::infinity();
           param.true_res_hq_offset[i] = std::numeric_limits<double>::infinity();
@@ -472,12 +472,12 @@ namespace quda {
 
       logQuda(QUDA_SUMMARIZE, "Converged after %d iterations\n", k);
       for (int i = 0; i < num_offset; i++) {
-        if (std::isinf(param.true_res_offset[i])) {
+        if (isinf(param.true_res_offset[i])) {
           logQuda(QUDA_SUMMARIZE, " shift=%d, %d iterations, relative residual: iterated = %e\n", i, iter[i],
-                  param.iter_res_offset[i]);
+                  double(param.iter_res_offset[i]));
         } else {
           logQuda(QUDA_SUMMARIZE, " shift=%d, %d iterations, relative residual: iterated = %e, true = %e\n", i, iter[i],
-                  param.iter_res_offset[i], param.true_res_offset[i]);
+                  double(param.iter_res_offset[i]), double(param.true_res_offset[i]));
         }
       }
 
@@ -486,7 +486,7 @@ namespace quda {
       for (int i = 0; i < num_offset; i++) {
         param.iter_res_offset[i] = sqrt(r2[i] / b2);
         logQuda(QUDA_SUMMARIZE, " shift=%d, %d iterations, relative residual: iterated = %e\n", i, iter[i],
-                param.iter_res_offset[i]);
+                double(param.iter_res_offset[i]));
       }
     }
 
diff --git a/lib/inv_pcg_quda.cpp b/lib/inv_pcg_quda.cpp
index 24d9259ef8..7babbc53ae 100644
--- a/lib/inv_pcg_quda.cpp
+++ b/lib/inv_pcg_quda.cpp
@@ -102,7 +102,7 @@ namespace quda
 
   void PreconCG::solve_and_collect(ColorSpinorField &x, ColorSpinorField &b,
                                    cvector_ref<ColorSpinorField> &v_r,
-                                   int collect_miniter, double collect_tol)
+                                   int collect_miniter, real_t collect_tol)
   {
     if (K) K->train_param(*this, b);
 
@@ -113,7 +113,7 @@ namespace quda
     // whether to select alternative reliable updates
     bool alternative_reliable = param.use_alternative_reliable;
 
-    double b2 = blas::norm2(b);
+    real_t b2 = blas::norm2(b);
 
     // Check to see that we're not trying to invert on a zero-field source
     if (b2 == 0 && param.compute_null_vector == QUDA_COMPUTE_NULL_VECTOR_NO) {
@@ -139,7 +139,7 @@ namespace quda
       }
     }
 
-    double Anorm = 0;
+    real_t Anorm = 0;
 
     // for alternative reliable updates
     if (alternative_reliable) {
@@ -149,7 +149,7 @@ namespace quda
     }
 
     // compute initial residual
-    double r2 = 0.0;
+    real_t r2 = 0.0;
     if (param.use_init_guess == QUDA_USE_INIT_GUESS_YES) {
       // Compute r = b - A * x
       mat(r, x);
@@ -186,16 +186,16 @@ namespace quda
     profile.TPSTOP(QUDA_PROFILE_INIT);
     profile.TPSTART(QUDA_PROFILE_PREAMBLE);
 
-    double stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
-    double heavy_quark_res = 0.0;                               // heavy quark residual
-    if (use_heavy_quark_res) heavy_quark_res = sqrt(HeavyQuarkResidualNorm(x, r).z);
+    real_t stop = stopping(param.tol, b2, param.residual_type); // stopping condition of solver
+    real_t heavy_quark_res = 0.0;                               // heavy quark residual
+    if (use_heavy_quark_res) heavy_quark_res = sqrt(HeavyQuarkResidualNorm(x, r)[2]);
 
-    double beta = 0.0;
-    double pAp;
-    double rMinvr = 0;
-    double rMinvr_old = 0.0;
-    double r_new_Minvr_old = 0.0;
-    double r2_old = 0;
+    real_t beta = 0.0;
+    real_t pAp;
+    real_t rMinvr = 0;
+    real_t rMinvr_old = 0.0;
+    real_t r_new_Minvr_old = 0.0;
+    real_t r2_old = 0;
     r2 = norm2(r);
 
     if (K) rMinvr = reDotProduct(r_sloppy, minvr_sloppy);
@@ -232,12 +232,12 @@ namespace quda
 
       matSloppy(Ap, x_update_batch.get_current_field());
 
-      double sigma;
+      real_t sigma;
       // alternative reliable updates,
       if (alternative_reliable) {
-        double3 pAppp = blas::cDotProductNormA(x_update_batch.get_current_field(), Ap);
-        pAp = pAppp.x;
-        ru.update_ppnorm(pAppp.z);
+        auto pAppp = blas::cDotProductNormA(x_update_batch.get_current_field(), Ap);
+        pAp = pAppp[0];
+        ru.update_ppnorm(pAppp[2]);
       } else {
         pAp = reDotProduct(x_update_batch.get_current_field(), Ap);
       }
@@ -246,9 +246,9 @@ namespace quda
       auto cg_norm = axpyCGNorm(-x_update_batch.get_current_alpha(), Ap, r_sloppy);
       // r --> r - alpha*A*p
       r2_old = r2;
-      r2 = cg_norm.x;
+      r2 = cg_norm[0];
 
-      sigma = cg_norm.y >= 0.0 ? cg_norm.y : r2; // use r2 if (r_k+1, r_k-1 - r_k) breaks
+      sigma = cg_norm[1] >= 0.0 ? cg_norm[1] : r2; // use r2 if (r_k+1, r_k-1 - r_k) breaks
 
       if (K) rMinvr_old = rMinvr;
 
@@ -261,7 +261,7 @@ namespace quda
 
       if (collect > 0 && k > collect_miniter && r2 < collect_tol * collect_tol * b2) {
         v_r[v_r.size() - collect] = r_sloppy;
-        logQuda(QUDA_VERBOSE, "Collecting r %2d: r2 / b2 = %12.8e, k = %5d\n", collect, sqrt(r2 / b2), k);
+        logQuda(QUDA_VERBOSE, "Collecting r %2d: r2 / b2 = %12.8e, k = %5d\n", collect, double(sqrt(r2 / b2)), k);
         collect--;
       }
 
@@ -323,7 +323,7 @@ namespace quda
         zero(x_sloppy);
 
         bool L2breakdown = false;
-        double L2breakdown_eps = 0;
+        real_t L2breakdown_eps = 0;
         if (ru.reliable_break(r2, stop, L2breakdown, L2breakdown_eps)) { break; }
 
         ru.update_norm(r2, y);
@@ -347,7 +347,7 @@ namespace quda
         } else {                        // standard CG - no preconditioning
 
           // explicitly restore the orthogonality of the gradient vector
-          double rp = reDotProduct(r_sloppy, x_update_batch.get_current_field()) / (r2);
+          real_t rp = reDotProduct(r_sloppy, x_update_batch.get_current_field()) / (r2);
           axpy(-rp, r_sloppy, x_update_batch.get_current_field());
 
           beta = r2 / r2_old;
@@ -390,7 +390,7 @@ namespace quda
 
     // compute the true residual
     mat(r, x);
-    double true_res = xmyNorm(b, r);
+    real_t true_res = xmyNorm(b, r);
     param.true_res = sqrt(true_res / b2);
 
     // reset the flops counters
diff --git a/lib/inv_sd_quda.cpp b/lib/inv_sd_quda.cpp
index cbb51bac01..4b102478ad 100644
--- a/lib/inv_sd_quda.cpp
+++ b/lib/inv_sd_quda.cpp
@@ -40,44 +40,43 @@ namespace quda {
       init = true;
     }
 
-    double b2 = norm2(b);
+    real_t b2 = norm2(b);
 
     zero(*r), zero(x);
-    double r2 = xmyNorm(b,*r);
-    double alpha=0.; 
-    double3 rAr;
+    real_t r2 = xmyNorm(b,*r);
+    real_t alpha=0.; 
 
     int k=0;
     while (k < param.maxiter - 1) {
       mat(*Ar, *r);
-      rAr = cDotProductNormA(*r, *Ar);
-      alpha = rAr.z/rAr.x;
+      auto rAr = cDotProductNormA(*r, *Ar);
+      alpha = rAr[2]/rAr[0];
       axpy(alpha, *r, x);
       axpy(-alpha, *Ar, *r);
 
       if(getVerbosity() >= QUDA_VERBOSE){
         r2 = norm2(*r);
-        printfQuda("Steepest Descent: %d iterations, |r| = %e, |r|/|b| = %e\n", k, sqrt(r2), sqrt(r2/b2));
+        printfQuda("Steepest Descent: %d iterations, |r| = %e, |r|/|b| = %e\n", k, double(sqrt(r2)), double(sqrt(r2/b2)));
       }
 
       ++k;
     }
 
-    rAr = cDotProductNormA(*r, *Ar);
-    alpha = rAr.z/rAr.x;
+    auto rAr = cDotProductNormA(*r, *Ar);
+    alpha = rAr[2] / rAr[0];
     axpy(alpha, *r, x);
     if(getVerbosity() >= QUDA_VERBOSE){
       axpy(-alpha, *Ar, *r);
       r2 = norm2(*r);
-      printfQuda("Steepest Descent: %d iterations, |r| = %e, |r|/|b| = %e\n", k, sqrt(r2), sqrt(r2/b2));
+      printfQuda("Steepest Descent: %d iterations, |r| = %e, |r|/|b| = %e\n", k, double(sqrt(r2)), double(sqrt(r2/b2)));
       ++k;
     }
 
     if(getVerbosity() >= QUDA_DEBUG_VERBOSE){
       // Compute the true residual
       mat(*r, x);
-      double true_r2 = xmyNorm(b,*r);
-      printfQuda("Steepest Descent: %d iterations, accumulated |r| = %e, true |r| = %e,  |r|/|b| = %e\n", k, sqrt(r2), sqrt(true_r2), sqrt(true_r2/b2));
+      real_t true_r2 = xmyNorm(b,*r);
+      printfQuda("Steepest Descent: %d iterations, accumulated |r| = %e, true |r| = %e,  |r|/|b| = %e\n", k, double(sqrt(r2)), double(sqrt(true_r2)), double(sqrt(true_r2/b2)));
     } // >= QUDA_DEBUG_VERBOSITY
 
     commGlobalReductionPop();
diff --git a/lib/laplace.cu b/lib/laplace.cu
index a0f18e4dd4..d50ec468dd 100644
--- a/lib/laplace.cu
+++ b/lib/laplace.cu
@@ -146,11 +146,11 @@ namespace quda
 
 #if (defined(GPU_STAGGERED_DIRAC) || defined(GPU_WILSON_DIRAC)) && defined(GPU_LAPLACE)
     inline LaplaceApply(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir,
-                        double a, double b, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
+                        real_t a, real_t b, const ColorSpinorField &x, int parity, bool dagger, const int *comm_override,
                         TimeProfile &profile)
 #else
     inline LaplaceApply(ColorSpinorField &, const ColorSpinorField &in, const GaugeField &, int,
-                        double, double, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
+                        real_t, real_t, const ColorSpinorField &, int, bool, const int *, TimeProfile &)
 #endif
     {
       if (in.Nspin() == 1) {
@@ -186,7 +186,7 @@ namespace quda
   // Apply the Laplace operator
   // out(x) = M*in = - a*\sum_mu U_{-\mu}(x)in(x+mu) + U^\dagger_mu(x-mu)in(x-mu) + b*in(x)
   // Omits direction 'dir' from the operator.
-  void ApplyLaplace(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir, double a, double b,
+  void ApplyLaplace(ColorSpinorField &out, const ColorSpinorField &in, const GaugeField &U, int dir, real_t a, real_t b,
                     const ColorSpinorField &x, int parity, bool dagger, const int *comm_override, TimeProfile &profile)
   {
     instantiate<LaplaceApply>(out, in, U, dir, a, b, x, parity, dagger, comm_override, profile);
diff --git a/lib/lattice_field.cpp b/lib/lattice_field.cpp
index b75b1dcff8..2dcbd640a3 100644
--- a/lib/lattice_field.cpp
+++ b/lib/lattice_field.cpp
@@ -617,7 +617,7 @@ namespace quda {
     output << "pad = " << param.pad << std::endl;
     output << "precision = " << param.Precision() << std::endl;
     output << "ghost_precision = " << param.GhostPrecision() << std::endl;
-    output << "scale = " << param.scale << std::endl;
+    output << "scale = " << double(param.scale) << std::endl;
 
     output << "ghostExchange = " << param.ghostExchange << std::endl;
     for (int i=0; i<param.nDim; i++) {
diff --git a/lib/madwf_ml.cpp b/lib/madwf_ml.cpp
index 2c36294a94..8b187e7dd1 100644
--- a/lib/madwf_ml.cpp
+++ b/lib/madwf_ml.cpp
@@ -12,10 +12,10 @@ namespace quda
   {
     if (getVerbosity() >= QUDA_VERBOSE) {
       printfQuda("Launching MADWF accelerator ... \n");
-      printfQuda("madwf_mu (low modes suppressor)                   = %.4f\n", param.madwf_diagonal_suppressor);
+      printfQuda("madwf_mu (low modes suppressor)                   = %.4f\n", double(param.madwf_diagonal_suppressor));
       printfQuda("madwf_ls (cheap Ls)                               = %d\n", param.madwf_ls);
       printfQuda("madwf_null_miniter                                = %d\n", param.madwf_null_miniter);
-      printfQuda("madwf_null_tol                                    = %4.2e\n", param.madwf_null_tol);
+      printfQuda("madwf_null_tol                                    = %4.2e\n", double(param.madwf_null_tol));
       printfQuda("madwf_train_maxiter (max # of iters for training) = %d\n", param.madwf_train_maxiter);
     }
   }
@@ -40,7 +40,7 @@ namespace quda
     blas::axpy(mu, in, out);
   }
 
-  double MadwfAcc::cost(const DiracMatrix &ref, Solver &base, ColorSpinorField &out, const ColorSpinorField &in)
+  real_t MadwfAcc::cost(const DiracMatrix &ref, Solver &base, ColorSpinorField &out, const ColorSpinorField &in)
   {
     ColorSpinorParam csParam(in);
     ColorSpinorField tmp1(csParam);
@@ -112,16 +112,14 @@ namespace quda
     ColorSpinorField lambda(csParam);
     ColorSpinorField Mchi(csParam);
 
-    double residual = 0.0;
+    real_t residual = 0.0;
     int count = 0;
     for (auto &phi : B) {
       residual += blas::norm2(phi);
-      if (getVerbosity() >= QUDA_VERBOSE) {
-        printfQuda("reference dslash norm %03d = %8.4e\n", count, blas::norm2(phi));
-      }
+      logQuda(QUDA_VERBOSE, "reference dslash norm %03d = %8.4e\n", count, double(blas::norm2(phi)));
       count++;
     }
-    if (getVerbosity() >= QUDA_VERBOSE) { printfQuda("reference dslash norm = %8.4e\n", residual); }
+    if (getVerbosity() >= QUDA_VERBOSE) { printfQuda("reference dslash norm = %8.4e\n", double(residual)); }
 
     csParam.x[4] = Ls_base;
     csParam.create = QUDA_ZERO_FIELD_CREATE;
@@ -145,13 +143,13 @@ namespace quda
     device_container P(param_size);
     device_container D_old(param_size);
 
-    double pmu = 0.0;
+    real_t pmu = 0.0;
 
     transfer_float alpha;
     transfer_float b = 0.8;
     if (getVerbosity() >= QUDA_VERBOSE) {
       printfQuda("beta          = %.3f\n", b);
-      printfQuda("training mu   = %.3f\n", mu);
+      printfQuda("training mu   = %.3f\n", double(mu));
     }
 
     profile.TPSTOP(QUDA_PROFILE_INIT);
@@ -160,9 +158,9 @@ namespace quda
     for (int iteration = 0; iteration < param.madwf_train_maxiter; iteration++) {
 
       device_container D(param_size);
-      double dmu = 0.0;
-      double chi2 = 0.0;
-      std::array<double, 5> a = {};
+      real_t dmu = 0.0;
+      real_t chi2 = 0.0;
+      std::array<real_t, 5> a = {};
 
       for (auto &phi : B) {
         chi2 += cost(ref, base, chi, phi);
@@ -192,7 +190,7 @@ namespace quda
       // line search
       for (auto &phi : B) {
 
-        double ind_chi2 = cost(ref, base, chi, phi);
+        real_t ind_chi2 = cost(ref, base, chi, phi);
         chi2 += ind_chi2;
 
         // ATx(ATphi, phi, T);
@@ -219,7 +217,7 @@ namespace quda
 
         ref(lambda, tmp);
 
-        std::vector<Complex> dot(9);
+        std::vector<complex_t> dot(9);
         blas::cDotProduct(dot, {chi, theta, lambda}, {chi, theta, lambda});
 
         a[0] += dot[0].real();
@@ -229,38 +227,34 @@ namespace quda
         a[4] += dot[8].real();
       }
 
-      std::array<double, 4> coeffs = {4.0 * a[4], 3.0 * a[3], 2.0 * a[2], a[1]};
+      std::array<real_t, 4> coeffs = {4.0 * a[4], 3.0 * a[3], 2.0 * a[2], a[1]};
       auto rs = cubic_formula(coeffs);
 
       alpha = 0;
-      double root_min = poly4(a, 0);
+      auto root_min = poly4(a, 0);
       for (auto r : rs) {
-        double eval = poly4(a, r);
+        auto eval = poly4(a, r);
         if (root_min > eval) {
           root_min = eval;
-          alpha = r;
+          alpha = transfer_float(r);
         }
       }
 
       axpby(device_param, 0.0f, device_param, -alpha, P);
       if (tune_suppressor) { mu -= alpha * pmu; }
 
-      if (getVerbosity() >= QUDA_SUMMARIZE) {
-        printfQuda("grad min iter %05d: %04d chi2 = %8.4e, chi2 %% = %8.4e, alpha = %+8.4e, mu = %+8.4e\n", comm_rank(),
-                   iteration, chi2, chi2 / residual, alpha, mu);
-      }
+      logQuda(QUDA_SUMMARIZE, "grad min iter %05d: %04d chi2 = %8.4e, chi2 %% = %8.4e, alpha = %+8.4e, mu = %+8.4e\n", comm_rank(),
+              iteration, double(chi2), double(chi2 / residual), double(alpha), double(mu));
     }
 
     trained = true;
 
-    if (getVerbosity() >= QUDA_VERBOSE) { printfQuda("Training finished ...\n"); }
+    logQuda(QUDA_VERBOSE, "Training finished ...\n");
     count = 0;
     for (auto &phi : B) {
-      double ind_chi2 = cost(ref, base, chi, phi);
-      double phi2 = blas::norm2(phi);
-      if (getVerbosity() >= QUDA_VERBOSE) {
-        printfQuda("chi2 %03d %% = %8.4e, phi2 = %8.4e\n", count, ind_chi2 / phi2, phi2);
-      }
+      real_t ind_chi2 = cost(ref, base, chi, phi);
+      real_t phi2 = blas::norm2(phi);
+      logQuda(QUDA_VERBOSE, "chi2 %03d %% = %8.4e, phi2 = %8.4e\n", count, double(ind_chi2 / phi2), double(phi2));
       count++;
     }
 
@@ -287,7 +281,7 @@ namespace quda
 
     std::string save_param_path(param.madwf_param_outfile);
     char cstring[512];
-    sprintf(cstring, "/madwf_trained_param_ls_%02d_%02d_mu_%.3f.dat", Ls, Ls_base, mu);
+    sprintf(cstring, "/madwf_trained_param_ls_%02d_%02d_mu_%.3f.dat", Ls, Ls_base, double(mu));
     save_param_path += std::string(cstring);
     FILE *fp = fopen(save_param_path.c_str(), "w");
     if (!fp) { errorQuda("Unable to open file %s\n", save_param_path.c_str()); }
@@ -308,7 +302,7 @@ namespace quda
 
     char param_file_name[512];
     // Note that all ranks load from the same file.
-    sprintf(param_file_name, "/madwf_trained_param_ls_%02d_%02d_mu_%.3f.dat", Ls, Ls_base, mu);
+    sprintf(param_file_name, "/madwf_trained_param_ls_%02d_%02d_mu_%.3f.dat", Ls, Ls_base, double(mu));
     std::string param_file_name_str(param_file_name);
     auto search_cache = host_training_param_cache.find(param_file_name_str);
     if (search_cache != host_training_param_cache.end()) {
diff --git a/lib/max_clover.cu b/lib/max_clover.cu
index 48e9630421..953e068239 100644
--- a/lib/max_clover.cu
+++ b/lib/max_clover.cu
@@ -12,10 +12,10 @@ namespace quda {
   };
 
   template<typename real, int Nc, QudaCloverFieldOrder order>
-  double norm(const CloverField &u, bool inverse, norm_type_ type) {
+  real_t norm(const CloverField &u, bool inverse, norm_type_ type) {
     constexpr int Ns = 4;
     typedef typename mapper<real>::type reg_type;
-    double norm_ = 0.0;
+    real_t norm_ = 0.0;
     switch(type) {
     case   NORM1: norm_ = FieldOrder<reg_type,Nc,Ns,order>(const_cast<CloverField &>(u), inverse).norm1();   break;
     case   NORM2: norm_ = FieldOrder<reg_type,Nc,Ns,order>(const_cast<CloverField &>(u), inverse).norm2();   break;
@@ -26,8 +26,8 @@ namespace quda {
   }
 
   template<typename real, int Nc>
-  double norm(const CloverField &u, bool inverse, norm_type_ type) {
-    double norm_ = 0.0;
+  real_t norm(const CloverField &u, bool inverse, norm_type_ type) {
+    real_t norm_ = 0.0;
     switch (u.Order()) {
     case QUDA_FLOAT2_CLOVER_ORDER: norm_ = norm<real,Nc,QUDA_FLOAT2_CLOVER_ORDER>(u, inverse, type); break;
     case QUDA_FLOAT4_CLOVER_ORDER: norm_ = norm<real,Nc,QUDA_FLOAT4_CLOVER_ORDER>(u, inverse, type); break;
@@ -38,8 +38,8 @@ namespace quda {
   }
 
   template<typename real>
-  double _norm(const CloverField &u, bool inverse, norm_type_ type) {
-    double norm_ = 0.0;
+  real_t _norm(const CloverField &u, bool inverse, norm_type_ type) {
+    real_t norm_ = 0.0;
     switch(u.Ncolor()) {
     case  3: norm_ = norm<real, 3>(u, inverse, type); break;
     default: errorQuda("Unsupported color %d", u.Ncolor());
@@ -48,10 +48,10 @@ namespace quda {
   }
 
 #ifdef GPU_CLOVER_DIRAC
-  double _norm(const CloverField &u, bool inverse, norm_type_ type)
+  real_t _norm(const CloverField &u, bool inverse, norm_type_ type)
   {
     if (!u.data(inverse)) errorQuda("reqeusted clover is_inverse=%d, but not allocated", inverse);
-    double nrm = 0.0;
+    real_t nrm = 0.0;
     switch(u.Precision()) {
     case QUDA_DOUBLE_PRECISION: nrm = _norm<double>(u, inverse, type); break;
     case QUDA_SINGLE_PRECISION: nrm = _norm< float>(u, inverse, type); break;
@@ -60,26 +60,26 @@ namespace quda {
     return nrm;
   }
 #else
-  double _norm(const CloverField &, bool, norm_type_)
+  real_t _norm(const CloverField &, bool, norm_type_)
   {
     errorQuda("Clover dslash has not been built");
     return 0.0;;
   }
 #endif
 
-  double CloverField::norm1(bool inverse) const {
+  real_t CloverField::norm1(bool inverse) const {
     return _norm(*this, inverse, NORM1);
   }
 
-  double CloverField::norm2(bool inverse) const {
+  real_t CloverField::norm2(bool inverse) const {
     return _norm(*this, inverse, NORM2);
   }
 
-  double CloverField::abs_max(bool inverse) const {
+  real_t CloverField::abs_max(bool inverse) const {
     return _norm(*this, inverse, ABS_MAX);
   }
 
-  double CloverField::abs_min(bool inverse) const {
+  real_t CloverField::abs_min(bool inverse) const {
     return _norm(*this, inverse, ABS_MIN);
   }
 
diff --git a/lib/momentum.cu b/lib/momentum.cu
index 7a574687ca..e273036443 100644
--- a/lib/momentum.cu
+++ b/lib/momentum.cu
@@ -107,7 +107,7 @@ namespace quda {
     const GaugeField &force;
     GaugeField &mom;
     double coeff;
-    typename Arg::reduce_t force_max;
+    array<double, 2> force_max;
 
   public:
     UpdateMom(const GaugeField &force, GaugeField &mom, double coeff, const char *fname) :
diff --git a/lib/multi_blas_quda.cu b/lib/multi_blas_quda.cu
index 5020f7b109..7f01e12745 100644
--- a/lib/multi_blas_quda.cu
+++ b/lib/multi_blas_quda.cu
@@ -308,7 +308,7 @@ namespace quda {
     }
 
     template <>
-    void axpy<double>(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void axpy<real_t>(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       // Enter a recursion.
       // Pass a, x, y. (0,0) indexes the tiles. false specifies the matrix is unstructured.
@@ -316,7 +316,7 @@ namespace quda {
     }
 
     template <>
-    void axpy_U<double>(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void axpy_U<real_t>(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       // Enter a recursion.
       // Pass a, x, y. (0,0) indexes the tiles. 1 indicates the matrix is upper-triangular,
@@ -330,7 +330,7 @@ namespace quda {
     }
 
     template <>
-    void axpy_L<double>(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void axpy_L<real_t>(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       // Enter a recursion.
       // Pass a, x, y. (0,0) indexes the tiles. -1 indicates the matrix is lower-triangular
@@ -344,20 +344,20 @@ namespace quda {
     }
 
     template <>
-    void axpy<Complex>(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void axpy<complex_t>(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       // Enter a recursion.
       // Pass a, x, y. (0,0) indexes the tiles. false specifies the matrix is unstructured.
       axpy_recurse<multicaxpy_>(a, x, y, range(0,x.size()), range(0,y.size()), 0);
     }
 
-    void caxpy(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void caxpy(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       axpy(a, std::move(x), std::move(y));
     }
 
     template <>
-    void axpy_U<Complex>(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void axpy_U<complex_t>(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       // Enter a recursion.
       // Pass a, x, y. (0,0) indexes the tiles. 1 indicates the matrix is upper-triangular,
@@ -369,13 +369,13 @@ namespace quda {
       axpy_recurse<multicaxpy_>(a, x, y, range(0,x.size()), range(0,y.size()), 1);
     }
 
-    void caxpy_U(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void caxpy_U(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       axpy_U(a, std::move(x), std::move(y));
     }
 
     template <>
-    void axpy_L<Complex>(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void axpy_L<complex_t>(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       // Enter a recursion.
       // Pass a, x, y. (0,0) indexes the tiles. -1 indicates the matrix is lower-triangular
@@ -387,7 +387,7 @@ namespace quda {
       axpy_recurse<multicaxpy_>(a, x, y, range(0,x.size()), range(0,y.size()), -1);
     }
 
-    void caxpy_L(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
+    void caxpy_L(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<ColorSpinorField> &y)
     {
       axpy_L(a, std::move(x), std::move(y));
     }
@@ -448,12 +448,12 @@ namespace quda {
       } // end if (y.size() > max_YW_size())
     }
 
-    void axpyz(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
+    void axpyz(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
     {
       axpyz_recurse<multiaxpyz_>(a, x, y, z, range(0, x.size()), range(0, y.size()), 0, 0);
     }
 
-    void axpyz_U(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
+    void axpyz_U(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
     {
       if (x.size() != y.size()) {
         errorQuda("An optimal block axpyz_U with non-square 'a' (%lu != %lu) has not yet been implemented. Use block axpyz instead",
@@ -466,7 +466,7 @@ namespace quda {
       axpyz_recurse<multiaxpyz_>(a, x, y, z, range(0, x.size()), range(0, y.size()), 1, 1);
     }
 
-    void axpyz_L(const std::vector<double> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
+    void axpyz_L(const std::vector<real_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
     {
       if (x.size() != y.size()) {
         errorQuda("An optimal block axpyz_L with non-square 'a' (%lu != %lu) has not yet been implemented. Use block axpyz instead",
@@ -479,12 +479,12 @@ namespace quda {
       axpyz_recurse<multiaxpyz_>(a, x, y, z, range(0, x.size()), range(0, y.size()), 1, -1);
     }
 
-    void caxpyz(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
+    void caxpyz(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
     {
       axpyz_recurse<multicaxpyz_>(a, x, y, z, range(0, x.size()), range(0, y.size()), 0, 0);
     }
 
-    void caxpyz_U(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
+    void caxpyz_U(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
     {
       if (x.size() != y.size()) {
         errorQuda("An optimal block caxpyz_U with non-square 'a' (%lu != %lu) has not yet been implemented. Use block caxpyz instead",
@@ -497,7 +497,7 @@ namespace quda {
       axpyz_recurse<multicaxpyz_>(a, x, y, z, range(0, x.size()), range(0, y.size()), 1, 1);
     }
 
-    void axpyz_L(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
+    void axpyz_L(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x, cvector_ref<const ColorSpinorField> &y, cvector_ref<ColorSpinorField> &z)
     {
       if (x.size() != y.size()) {
         errorQuda("An optimal block axpyz_U with non-square 'a' (%lu != %lu) has not yet been implemented. Use block axpyz instead",
@@ -510,8 +510,8 @@ namespace quda {
       axpyz_recurse<multicaxpyz_>(a, x, y, z, range(0, x.size()), range(0, y.size()), 1, -1);
     }
 
-    void axpyBzpcx(const std::vector<double> &a, cvector_ref<ColorSpinorField> &x_, cvector_ref<ColorSpinorField> &y_,
-                   const std::vector<double> &b, ColorSpinorField &z_, const std::vector<double> &c)
+    void axpyBzpcx(const std::vector<real_t> &a, cvector_ref<ColorSpinorField> &x_, cvector_ref<ColorSpinorField> &y_,
+                   const std::vector<real_t> &b, ColorSpinorField &z_, const std::vector<real_t> &c)
     {
       if (y_.size() <= (size_t)max_N_multi_1d()) {
         // swizzle order since we are writing to x_ and y_, but the
@@ -538,8 +538,8 @@ namespace quda {
       }
     }
 
-    void caxpyBxpz(const std::vector<Complex> &a, cvector_ref<const ColorSpinorField> &x_, ColorSpinorField &y_,
-                   const std::vector<Complex> &b, ColorSpinorField &z_)
+    void caxpyBxpz(const std::vector<complex_t> &a, cvector_ref<const ColorSpinorField> &x_, ColorSpinorField &y_,
+                   const std::vector<complex_t> &b, ColorSpinorField &z_)
     {
       if (x_.size() <= (size_t)max_N_multi_1d() && is_valid_NXZ(x_.size(), false, y_.Precision())) // only split if we have to.
       {
@@ -554,7 +554,7 @@ namespace quda {
         auto &x = x_;
 
         constexpr bool mixed = true;
-        instantiate<multi_caxpyBxpz_, MultiBlas, mixed>(a, b, std::vector<Complex>(), x[0], y[0], x, y, x, w);
+        instantiate<multi_caxpyBxpz_, MultiBlas, mixed>(a, b, std::vector<complex_t>(), x[0], y[0], x, y, x, w);
       } else {
         // split the problem in half and recurse
         auto a_ = bisect(a);
@@ -567,10 +567,10 @@ namespace quda {
     }
 
     // temporary wrappers
-    void axpy(const double *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
+    void axpy(const real_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
     {
-      std::vector<double> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(double));
+      std::vector<real_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(real_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<ColorSpinorField> y_;
@@ -578,10 +578,10 @@ namespace quda {
       axpy(a_, x_, y_);
     }
 
-    void axpy_U(const double *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
+    void axpy_U(const real_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
     {
-      std::vector<double> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(double));
+      std::vector<real_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(real_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<ColorSpinorField> y_;
@@ -589,10 +589,10 @@ namespace quda {
       axpy_U(a_, x_, y_);
     }
 
-    void axpy_L(const double *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
+    void axpy_L(const real_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
     {
-      std::vector<double> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(double));
+      std::vector<real_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(real_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<ColorSpinorField> y_;
@@ -600,9 +600,9 @@ namespace quda {
       axpy_L(a_, x_, y_);
     }
 
-    void caxpy(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y) {
-      std::vector<Complex> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(Complex));
+    void caxpy(const complex_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y) {
+      std::vector<complex_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(complex_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<ColorSpinorField> y_;
@@ -610,9 +610,9 @@ namespace quda {
       caxpy(a_, x_, y_);
     }
 
-    void caxpy_U(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y) {
-      std::vector<Complex> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(Complex));
+    void caxpy_U(const complex_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y) {
+      std::vector<complex_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(complex_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<ColorSpinorField> y_;
@@ -620,9 +620,9 @@ namespace quda {
       caxpy_U(a_, x_, y_);
     }
 
-    void caxpy_L(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y) {
-      std::vector<Complex> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(Complex));
+    void caxpy_L(const complex_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y) {
+      std::vector<complex_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(complex_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<ColorSpinorField> y_;
@@ -630,11 +630,11 @@ namespace quda {
       caxpy_L(a_, x_, y_);
     }
 
-    void axpyz(const double *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y,
+    void axpyz(const real_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y,
                std::vector<ColorSpinorField*> &z)
     {
-      std::vector<double> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(double));
+      std::vector<real_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(real_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<const ColorSpinorField> y_;
@@ -644,11 +644,11 @@ namespace quda {
       axpyz(a_, x_, y_, z_);
     }
 
-    void caxpyz(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y,
+    void caxpyz(const complex_t *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y,
                std::vector<ColorSpinorField*> &z)
     {
-      std::vector<Complex> a_(x.size() * y.size());
-      memcpy(a_.data(), a, x.size() * y.size() * sizeof(Complex));
+      std::vector<complex_t> a_(x.size() * y.size());
+      memcpy(a_.data(), a, x.size() * y.size() * sizeof(complex_t));
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<const ColorSpinorField> y_;
@@ -658,15 +658,15 @@ namespace quda {
       caxpyz(a_, x_, y_, z_);
     }
 
-    void axpyBzpcx(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
-                   const double *b, ColorSpinorField &z, const double *c)
+    void axpyBzpcx(const real_t *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y,
+                   const real_t *b, ColorSpinorField &z, const real_t *c)
     {
-      std::vector<double> a_(x.size());
-      memcpy(a_.data(), a, x.size() * sizeof(double));
-      std::vector<double> b_(x.size());
-      memcpy(b_.data(), b, x.size() * sizeof(double));
-      std::vector<double> c_(x.size());
-      memcpy(c_.data(), c, x.size() * sizeof(double));
+      std::vector<real_t> a_(x.size());
+      memcpy(a_.data(), a, x.size() * sizeof(real_t));
+      std::vector<real_t> b_(x.size());
+      memcpy(b_.data(), b, x.size() * sizeof(real_t));
+      std::vector<real_t> c_(x.size());
+      memcpy(c_.data(), c, x.size() * sizeof(real_t));
 
       vector_ref<ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
@@ -675,13 +675,13 @@ namespace quda {
       axpyBzpcx(a_, x_, y_, b_, z, c_);
     }
 
-    void caxpyBxpz(const Complex *a, std::vector<ColorSpinorField*> &x, ColorSpinorField &y,
-		   const Complex *b, ColorSpinorField &z)
+    void caxpyBxpz(const complex_t *a, std::vector<ColorSpinorField*> &x, ColorSpinorField &y,
+		   const complex_t *b, ColorSpinorField &z)
     {
-      std::vector<Complex> a_(x.size());
-      memcpy(a_.data(), a, x.size() * sizeof(Complex));
-      std::vector<Complex> b_(x.size());
-      memcpy(b_.data(), b, x.size() * sizeof(Complex));
+      std::vector<complex_t> a_(x.size());
+      memcpy(a_.data(), a, x.size() * sizeof(complex_t));
+      std::vector<complex_t> b_(x.size());
+      memcpy(b_.data(), b, x.size() * sizeof(complex_t));
 
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
@@ -689,20 +689,20 @@ namespace quda {
     }
 
     // Composite field version
-    void caxpy(const Complex *a, ColorSpinorField &x, ColorSpinorField &y){ caxpy(a, x.Components(), y.Components()); }
-    void caxpy_U(const Complex *a, ColorSpinorField &x, ColorSpinorField &y) { caxpy_U(a, x.Components(), y.Components()); }
-    void caxpy_L(const Complex *a, ColorSpinorField &x, ColorSpinorField &y) { caxpy_L(a, x.Components(), y.Components()); }
+    void caxpy(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y){ caxpy(a, x.Components(), y.Components()); }
+    void caxpy_U(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y) { caxpy_U(a, x.Components(), y.Components()); }
+    void caxpy_L(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y) { caxpy_L(a, x.Components(), y.Components()); }
 
-    void axpy(const double *a, ColorSpinorField &x, ColorSpinorField &y) { axpy(a, x.Components(), y.Components()); }
-    void axpy_U(const double *a, ColorSpinorField &x, ColorSpinorField &y) { axpy_U(a, x.Components(), y.Components()); }
-    void axpy_L(const double *a, ColorSpinorField &x, ColorSpinorField &y) { axpy_L(a, x.Components(), y.Components()); }
+    void axpy(const real_t *a, ColorSpinorField &x, ColorSpinorField &y) { axpy(a, x.Components(), y.Components()); }
+    void axpy_U(const real_t *a, ColorSpinorField &x, ColorSpinorField &y) { axpy_U(a, x.Components(), y.Components()); }
+    void axpy_L(const real_t *a, ColorSpinorField &x, ColorSpinorField &y) { axpy_L(a, x.Components(), y.Components()); }
 
-    void axpyz(const double *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z)
+    void axpyz(const real_t *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z)
     {
       axpyz(a, x.Components(), y.Components(), z.Components());
     }
 
-    void caxpyz(const Complex *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z)
+    void caxpyz(const complex_t *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z)
     {
       caxpyz(a, x.Components(), y.Components(), z.Components());
     }
diff --git a/lib/multi_reduce_quda.cu b/lib/multi_reduce_quda.cu
index f93ab431e4..967ac9a994 100644
--- a/lib/multi_reduce_quda.cu
+++ b/lib/multi_reduce_quda.cu
@@ -12,7 +12,7 @@ namespace quda {
     class MultiReduce : public TunableMultiReduction
     {
       using real = typename mapper<y_store_t>::type;
-      using host_reduce_t = typename Reducer<double, real>::reduce_t;
+      using host_reduce_t = typename Reducer<real_t, real>::reduce_t;
       const int NXZ;
       const int NYW;
       Reducer<device_reduce_t, real> r;
@@ -596,14 +596,14 @@ namespace quda {
       void postTune() override {} // FIXME - use write to determine what needs to be saved
     };
 
-    void reDotProduct(std::vector<double> &result, cvector_ref<const ColorSpinorField> &x,
+    void reDotProduct(std::vector<real_t> &result, cvector_ref<const ColorSpinorField> &x,
                       cvector_ref<const ColorSpinorField> &y)
     {
       auto &x0 = x[0];
       auto &y0 = y[0];
 
       if (x.size() == 0 || y.size() == 0) errorQuda("vector.size() == 0");
-      std::vector<double> result_tmp(x.size() * y.size(), 0.0);
+      std::vector<real_t> result_tmp(x.size() * y.size(), 0.0);
 
       if (x.size() == 1) {
         auto NYW_max = y0.Precision() == QUDA_DOUBLE_PRECISION ?
@@ -615,7 +615,7 @@ namespace quda {
         multiReduce_recurse<multiDot, multiDot>(result_tmp, x, y, x, x, 0, 0, false, max_tile_size);
       } else if (y.size() == 1 && x0.Precision() == y0.Precision()) {
 
-        std::vector<double> result_trans(x.size() * y.size());
+        std::vector<real_t> result_trans(x.size() * y.size());
 
         // swap (x<->y and w<-z> when doing transpose calculation)
         auto NXZ_max = x0.Precision() == QUDA_DOUBLE_PRECISION ?
@@ -633,9 +633,9 @@ namespace quda {
           for (unsigned int i = 0; i < ylen; i++) result_tmp[i * xlen + j] = result_trans[j * ylen + i];
 
       } else if (x0.Precision() == y0.Precision()) {
-        TransposeTune<multiDot, multiDot, double, decltype(x), decltype(y)>(result_tmp, x, y, false);
+        TransposeTune<multiDot, multiDot, real_t, decltype(x), decltype(y)>(result_tmp, x, y, false);
       } else {
-        TileSizeTune<multiDot, multiDot, double, decltype(x), decltype(y)>(result_tmp, x, y, x, x, false);
+        TileSizeTune<multiDot, multiDot, real_t, decltype(x), decltype(y)>(result_tmp, x, y, x, x, false);
       }
 
       // do a single multi-node reduction only once we have computed all local dot products
@@ -647,14 +647,14 @@ namespace quda {
       result = transpose(result_tmp, y.size(), x.size());
     }
 
-    void cDotProduct(std::vector<Complex> &result, cvector_ref<const ColorSpinorField> &x,
+    void cDotProduct(std::vector<complex_t> &result, cvector_ref<const ColorSpinorField> &x,
                       cvector_ref<const ColorSpinorField> &y)
     {
       auto &x0 = x[0];
       auto &y0 = y[0];
 
       if (x.size() == 0 || y.size() == 0) errorQuda("vector.size() == 0");
-      std::vector<Complex> result_tmp(x.size() * y.size(), 0.0);
+      std::vector<complex_t> result_tmp(x.size() * y.size(), real_t(0.0));
 
       if (x.size() == 1) {
         auto NYW_max = y0.Precision() == QUDA_DOUBLE_PRECISION ?
@@ -666,7 +666,7 @@ namespace quda {
         multiReduce_recurse<multiCdot, multiCdot>(result_tmp, x, y, x, x, 0, 0, false, max_tile_size);
       } else if (y.size() == 1 && x0.Precision() == y0.Precision()) {
 
-        std::vector<Complex> result_trans(x.size() * y.size());
+        std::vector<complex_t> result_trans(x.size() * y.size());
 
         // swap (x<->y and w<-z> when doing transpose calculation)
         auto NXZ_max = x0.Precision() == QUDA_DOUBLE_PRECISION ?
@@ -684,9 +684,9 @@ namespace quda {
           for (unsigned int i = 0; i < ylen; i++) result_tmp[i * xlen + j] = conj(result_trans[j * ylen + i]);
         }
       } else if (x0.Precision() == y0.Precision()) {
-        TransposeTune<multiCdot, multiCdot, Complex, decltype(x), decltype(y)>(result_tmp, x, y, false);
+        TransposeTune<multiCdot, multiCdot, complex_t, decltype(x), decltype(y)>(result_tmp, x, y, false);
       } else {
-        TileSizeTune<multiCdot, multiCdot, Complex, decltype(x), decltype(y)>(result_tmp, x, y, x, x, false);
+        TileSizeTune<multiCdot, multiCdot, complex_t, decltype(x), decltype(y)>(result_tmp, x, y, x, x, false);
       }
 
       // do a single multi-node reduction only once we have computed all local dot products
@@ -698,14 +698,14 @@ namespace quda {
       result = transpose(result_tmp, y.size(), x.size());
     }
 
-    void hDotProduct(std::vector<Complex> &result, cvector_ref<const ColorSpinorField> &x,
+    void hDotProduct(std::vector<complex_t> &result, cvector_ref<const ColorSpinorField> &x,
                      cvector_ref<const ColorSpinorField> &y)
     {
       if (x.size() == 0 || y.size() == 0) errorQuda("vector.size() == 0");
       if (x.size() != y.size()) errorQuda("Cannot call Hermitian block dot product on non-square inputs");
 
-      std::vector<Complex> result_tmp(x.size() * y.size(), 0.0);
-      TileSizeTune<multiCdot, multiCdot, Complex, decltype(x), decltype(y)>(result_tmp, x, y, x, x, true, false); // last false is b/c L2 norm
+      std::vector<complex_t> result_tmp(x.size() * y.size(), real_t(0.0));
+      TileSizeTune<multiCdot, multiCdot, complex_t, decltype(x), decltype(y)>(result_tmp, x, y, x, x, true, false); // last false is b/c L2 norm
 
       // do a single multi-node reduction only once we have computed all local dot products
       comm_allreduce_sum(result_tmp); // FIXME - could optimize this for Hermiticity as well
@@ -723,14 +723,14 @@ namespace quda {
     }
 
     // for (p, Ap) norms in CG which are Hermitian.
-    void hDotProduct_Anorm(std::vector<Complex> &result, cvector_ref<const ColorSpinorField> &x,
+    void hDotProduct_Anorm(std::vector<complex_t> &result, cvector_ref<const ColorSpinorField> &x,
                      cvector_ref<const ColorSpinorField> &y)
     {
       if (x.size() == 0 || y.size() == 0) errorQuda("vector.size() == 0");
       if (x.size() != y.size()) errorQuda("Cannot call Hermitian block A-norm dot product on non-square inputs");
 
-      std::vector<Complex> result_tmp(x.size() * y.size(), 0.0);
-      TileSizeTune<multiCdot, multiCdot, Complex, decltype(x), decltype(y)>(result_tmp, x, y, x, x, true, true); // last true is b/c A norm
+      std::vector<complex_t> result_tmp(x.size() * y.size(), real_t(0.0));
+      TileSizeTune<multiCdot, multiCdot, complex_t, decltype(x), decltype(y)>(result_tmp, x, y, x, x, true, true); // last true is b/c A norm
 
       // do a single multi-node reduction only once we have computed all local dot products
       comm_allreduce_sum(result_tmp);
@@ -747,37 +747,37 @@ namespace quda {
           result[i * y.size() + j] = conj(result[j * x.size() + i]);
     }
 
-    void reDotProduct(double *result, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
+    void reDotProduct(real_t *result, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
     {
-      std::vector<double> result_(x.size() * y.size());
+      std::vector<real_t> result_(x.size() * y.size());
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<const ColorSpinorField> y_;
       for (auto &yi : y) y_.push_back(*yi);
       reDotProduct(result_, std::move(x_), std::move(y_));
-      memcpy(result, result_.data(), x.size() * y.size() * sizeof(double));
+      memcpy(result, result_.data(), x.size() * y.size() * sizeof(real_t));
     }
 
-    void cDotProduct(Complex *result, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
+    void cDotProduct(complex_t *result, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
     {
-      std::vector<Complex> result_(x.size() * y.size());
+      std::vector<complex_t> result_(x.size() * y.size());
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<const ColorSpinorField> y_;
       for (auto &yi : y) y_.push_back(*yi);
       cDotProduct(result_, std::move(x_), std::move(y_));
-      memcpy(result, result_.data(), x.size() * y.size() * sizeof(Complex));
+      memcpy(result, result_.data(), x.size() * y.size() * sizeof(complex_t));
     }
 
-    void hDotProduct(Complex *result, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
+    void hDotProduct(complex_t *result, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y)
     {
-      std::vector<Complex> result_(x.size() * y.size());
+      std::vector<complex_t> result_(x.size() * y.size());
       vector_ref<const ColorSpinorField> x_;
       for (auto &xi : x) x_.push_back(*xi);
       vector_ref<const ColorSpinorField> y_;
       for (auto &yi : y) y_.push_back(*yi);
       hDotProduct(result_, std::move(x_), std::move(y_));
-      memcpy(result, result_.data(), x.size() * y.size() * sizeof(Complex));
+      memcpy(result, result_.data(), x.size() * y.size() * sizeof(complex_t));
     }
 
   } // namespace blas
diff --git a/lib/multigrid.cpp b/lib/multigrid.cpp
index 4defe3878f..92ba7cefed 100644
--- a/lib/multigrid.cpp
+++ b/lib/multigrid.cpp
@@ -247,7 +247,7 @@ namespace quda
 
   void MG::resetStaggeredKD(GaugeField *gauge_in, GaugeField *fat_gauge_in, GaugeField *long_gauge_in,
                             GaugeField *gauge_sloppy_in, GaugeField *fat_gauge_sloppy_in,
-                            GaugeField *long_gauge_sloppy_in, double mass)
+                            GaugeField *long_gauge_sloppy_in, real_t mass)
   {
     if (param.level != 0) errorQuda("The staggered KD operator can only be updated from level 0");
 
@@ -832,9 +832,9 @@ namespace quda
     return flops;
   }
 
-  bool check_deviation(double deviation, double tol)
+  bool check_deviation(real_t deviation, real_t tol)
   {
-    return (deviation > tol || std::isnan(deviation) || std::isinf(deviation));
+    return (deviation > tol || isnan(deviation) || isinf(deviation));
   }
 
   /**
@@ -881,11 +881,11 @@ namespace quda
 
         logQuda(
           QUDA_VERBOSE, "Vector %d: L2 norms v_k = %e P^\\dagger v_k = %e (1 - P P^\\dagger) v_k = %e; Deviations: L2 relative = %e, max = %e\n",
-          i, norm2(tmp1), norm2(*r_coarse), norm2(tmp2), l2_deviation, max_deviation[0]);
+          i, double(norm2(tmp1)), double(norm2(*r_coarse)), double(norm2(tmp2)), double(l2_deviation), double(max_deviation[0]));
         if (check_deviation(l2_deviation, tol))
-          errorQuda("k=%d orthonormality failed: L2 relative deviation %e > %e", i, l2_deviation, tol);
+          errorQuda("k=%d orthonormality failed: L2 relative deviation %e > %e", i, double(l2_deviation), double(tol));
         if (check_deviation(max_deviation[0], tol))
-          errorQuda("k=%d orthonormality failed: max deviation %e > %e", i, max_deviation[0], tol);
+          errorQuda("k=%d orthonormality failed: max deviation %e > %e", i, double(max_deviation[0]), double(tol));
       }
 
       // the oblique check
@@ -904,8 +904,8 @@ namespace quda
           transfer->P(tmp2, *x_coarse);
           (*param.matResidual)(tmp1, tmp2);
           tmp2 = *(param.B[i]);
-          logQuda(QUDA_SUMMARIZE, "Vector %d: norms %e %e\n", i, norm2(*param.B[i]), norm2(tmp1));
-          logQuda(QUDA_SUMMARIZE, "relative residual = %e\n", sqrt(xmyNorm(tmp2, tmp1) / norm2(*param.B[i])));
+          logQuda(QUDA_SUMMARIZE, "Vector %d: norms %e %e\n", i, double(norm2(*param.B[i])), double(norm2(tmp1)));
+          logQuda(QUDA_SUMMARIZE, "relative residual = %e\n", double(sqrt(xmyNorm(tmp2, tmp1) / norm2(*param.B[i]))));
         }
         sprintf(prefix, "MG level %d (%s): ", param.level + 1,
                 param.location == QUDA_CUDA_FIELD_LOCATION ? "GPU" : "CPU");
@@ -955,12 +955,12 @@ namespace quda
       auto r2 = norm2(*r_coarse);
       auto max_deviation = blas::max_deviation(*r_coarse, *x_coarse);
       auto l2_deviation = sqrt(xmyNorm(*x_coarse, *r_coarse) / norm2(*x_coarse));
-      logQuda(QUDA_VERBOSE, "L2 norms %e %e (fine tmp %e); Deviations: L2 relative = %e, max = %e\n", norm2(*x_coarse),
-              r2, norm2(tmp2), l2_deviation, max_deviation[0]);
+      logQuda(QUDA_VERBOSE, "L2 norms %e %e (fine tmp %e); Deviations: L2 relative = %e, max = %e\n", double(norm2(*x_coarse)),
+              double(r2), double(norm2(tmp2)), double(l2_deviation), double(max_deviation[0]));
       if (check_deviation(l2_deviation, tol))
-        errorQuda("coarse span failed: L2 relative deviation = %e > %e", l2_deviation, tol);
+        errorQuda("coarse span failed: L2 relative deviation = %e > %e", double(l2_deviation), double(tol));
       if (check_deviation(max_deviation[0], tol))
-        errorQuda("coarse span failed: max deviation = %e > %e", max_deviation[0], tol);
+        errorQuda("coarse span failed: max deviation = %e > %e", double(max_deviation[0]), double(tol));
     }
 
     logQuda(QUDA_SUMMARIZE, "Checking 0 = (D_c - P^\\dagger D P) (native coarse operator to emulated operator)\n");
@@ -1011,8 +1011,8 @@ namespace quda
     if (can_verify) {
 
       if (param.coarse_grid_solution_type == QUDA_MATPC_SOLUTION && param.smoother_solve_type == QUDA_DIRECT_PC_SOLVE) {
-        double kappa = diracResidual->Kappa();
-        double mass = diracResidual->Mass();
+        auto kappa = diracResidual->Kappa();
+        auto mass = diracResidual->Mass();
         if (param.level == 0) {
           if (tmp1.Nspin() == 4) {
             diracSmoother->DslashXpay(tmp2.Even(), tmp1.Odd(), QUDA_EVEN_PARITY, tmp1.Even(), -kappa);
@@ -1056,29 +1056,29 @@ namespace quda
       setOutputPrefix(prefix);
 #endif
 
-      double r_nrm = norm2(*r_coarse);
+      auto r_nrm = norm2(*r_coarse);
       auto max_deviation = blas::max_deviation(*r_coarse, *x_coarse);
       auto l2_deviation = sqrt(xmyNorm(*x_coarse, *r_coarse) / norm2(*x_coarse));
 
       if (diracResidual->Mu() != 0.0) {
         // When the mu is shifted on the coarse level; we can compute exactly the error we introduce in the check:
         //  it is given by 2*kappa*delta_mu || tmp_coarse ||; where tmp_coarse is the random vector generated for the test
-        double delta_factor = param.mg_global.mu_factor[param.level + 1] - param.mg_global.mu_factor[param.level];
+        auto delta_factor = param.mg_global.mu_factor[param.level + 1] - param.mg_global.mu_factor[param.level];
         if (fabs(delta_factor) > tol) {
-          double delta_a
+          auto delta_a
             = delta_factor * 2.0 * diracResidual->Kappa() * diracResidual->Mu() * transfer->Vectors().TwistFlavor();
-          l2_deviation -= fabs(delta_a) * sqrt(norm2(*tmp_coarse) / norm2(*x_coarse));
-          l2_deviation = fabs(l2_deviation);
-          max_deviation[0] -= fabs(delta_a);
+          l2_deviation -= abs(delta_a) * sqrt(norm2(*tmp_coarse) / norm2(*x_coarse));
+          l2_deviation = abs(l2_deviation);
+          max_deviation[0] -= abs(delta_a);
         }
       }
       logQuda(QUDA_VERBOSE, "L2 norms: Emulated = %e, Native = %e; Deviations: L2 relative = %e, max = %e\n",
-              norm2(*x_coarse), r_nrm, l2_deviation, max_deviation[0]);
+              double(norm2(*x_coarse)), double(r_nrm), double(l2_deviation), double(max_deviation[0]));
 
       if (check_deviation(l2_deviation, tol))
-        errorQuda("Coarse operator failed: L2 relative deviation = %e > %e", l2_deviation, tol);
+        errorQuda("Coarse operator failed: L2 relative deviation = %e > %e", double(l2_deviation), double(tol));
       if (check_deviation(max_deviation[0], tol))
-        warningQuda("Coarse operator failed: max deviation = %e > %e", max_deviation[0], tol);
+        warningQuda("Coarse operator failed: max deviation = %e > %e", double(max_deviation[0]), double(tol));
     }
 
     // check the preconditioned operator construction on the lower level if applicable
@@ -1090,15 +1090,15 @@ namespace quda
       static_cast<DiracCoarse *>(diracCoarseResidual)->Dslash(r_coarse->Even(), tmp_coarse->Odd(), QUDA_EVEN_PARITY);
       static_cast<DiracCoarse *>(diracCoarseResidual)->CloverInv(x_coarse->Even(), r_coarse->Even(), QUDA_EVEN_PARITY);
       static_cast<DiracCoarsePC *>(diracCoarseSmoother)->Dslash(r_coarse->Even(), tmp_coarse->Odd(), QUDA_EVEN_PARITY);
-      double r_nrm = norm2(r_coarse->Even());
+      auto r_nrm = norm2(r_coarse->Even());
       auto max_deviation = blas::max_deviation(r_coarse->Even(), x_coarse->Even());
       auto l2_deviation = sqrt(xmyNorm(x_coarse->Even(), r_coarse->Even()) / norm2(x_coarse->Even()));
       logQuda(QUDA_VERBOSE, "L2 norms: Emulated = %e, Native = %e; Deviations: L2 relative = %e, max = %e\n",
-              norm2(x_coarse->Even()), r_nrm, l2_deviation, max_deviation[0]);
+              double(norm2(x_coarse->Even())), double(r_nrm), double(l2_deviation), double(max_deviation[0]));
       if (check_deviation(l2_deviation, tol))
-        errorQuda("Preconditioned Deo failed: L2 relative deviation = %e > %e", l2_deviation, tol);
+        errorQuda("Preconditioned Deo failed: L2 relative deviation = %e > %e", double(l2_deviation), double(tol));
       if (check_deviation(max_deviation[0], tol))
-        errorQuda("Preconditioned Deo failed: max deviation = %e > %e", max_deviation[0], tol);
+        errorQuda("Preconditioned Deo failed: max deviation = %e > %e", double(max_deviation[0]), double(tol));
 
       // check Doe
       logQuda(QUDA_SUMMARIZE, "Checking Doe of preconditioned operator 0 = \\hat{D}_c - A^{-1} D_c\n");
@@ -1109,11 +1109,11 @@ namespace quda
       max_deviation = blas::max_deviation(r_coarse->Odd(), x_coarse->Odd());
       l2_deviation = sqrt(xmyNorm(x_coarse->Odd(), r_coarse->Odd()) / norm2(x_coarse->Odd()));
       logQuda(QUDA_VERBOSE, "L2 norms: Emulated = %e, Native = %e; Deviations: L2 relative = %e, max = %e\n",
-              norm2(x_coarse->Odd()), r_nrm, l2_deviation, max_deviation[0]);
+              double(norm2(x_coarse->Odd())), double(r_nrm), double(l2_deviation), double(max_deviation[0]));
       if (check_deviation(l2_deviation, tol))
-        errorQuda("Preconditioned Doe failed: L2 relative deviation = %e > %e", l2_deviation, tol);
+        errorQuda("Preconditioned Doe failed: L2 relative deviation = %e > %e", double(l2_deviation), double(tol));
       if (check_deviation(max_deviation[0], tol))
-        errorQuda("Preconditioned Doe failed: max deviation = %e > %e", max_deviation[0], tol);
+        errorQuda("Preconditioned Doe failed: max deviation = %e > %e", double(max_deviation[0]), double(tol));
     }
 
     // here we check that the Hermitian conjugate operator is working
@@ -1125,13 +1125,13 @@ namespace quda
       } else {
         diracSmoother->MdagM(tmp2.Even(), tmp1.Odd());
       }
-      Complex dot = cDotProduct(tmp2.Even(), tmp1.Odd());
-      double deviation = std::fabs(dot.imag()) / std::fabs(dot.real());
+      auto dot = cDotProduct(tmp2.Even(), tmp1.Odd());
+      auto deviation = abs(dot.imag()) / abs(dot.real());
       logQuda(QUDA_VERBOSE,
               "Smoother normal operator test (eta^dag M^dag M eta): real=%e imag=%e, relative imaginary deviation=%e\n",
-              real(dot), imag(dot), deviation);
+              double(dot.real()), double(dot.imag()), double(deviation));
       if (check_deviation(deviation, tol))
-        errorQuda("Smoother operator normality failed: deviation = %e > %e", deviation, tol);
+        errorQuda("Smoother operator normality failed: deviation = %e > %e", double(deviation), double(tol));
     }
 
     { // normal operator check for residual operator
@@ -1142,13 +1142,13 @@ namespace quda
         // staggered preconditioned op.
         diracResidual->M(tmp2, tmp1);
       }
-      Complex dot = cDotProduct(tmp1, tmp2);
-      double deviation = std::fabs(dot.imag()) / std::fabs(dot.real());
+      auto dot = cDotProduct(tmp1, tmp2);
+      auto deviation = abs(dot.imag()) / abs(dot.real());
       logQuda(QUDA_VERBOSE,
               "Normal operator test (eta^dag M^dag M eta): real=%e imag=%e, relative imaginary deviation=%e\n",
-              real(dot), imag(dot), deviation);
+              double(dot.real()), double(dot.imag()), double(deviation));
       if (check_deviation(deviation, tol))
-        errorQuda("Residual operator normality failed: deviation = %e > %e", deviation, tol);
+        errorQuda("Residual operator normality failed: deviation = %e > %e", double(deviation), double(tol));
     }
 
     // Not useful for staggered op since it's a unitary transform
@@ -1170,13 +1170,13 @@ namespace quda
           // Prolong r_coarse, place result in tmp2
           transfer->P(tmp2, *r_coarse);
 
-          printfQuda("Vector %d: norms v_k = %e P^dag v_k = %e PP^dag v_k = %e\n", i, norm2(*param.B[i]),
-                     norm2(*r_coarse), norm2(tmp2));
+          printfQuda("Vector %d: norms v_k = %e P^dag v_k = %e PP^dag v_k = %e\n", i, double(norm2(*param.B[i])),
+                     double(norm2(*r_coarse)), double(norm2(tmp2)));
 
           // Compare v_k and PP^dag v_k.
           auto max_deviation = blas::max_deviation(tmp2, *param.B[i]);
           auto l2_deviation = sqrt(xmyNorm(*param.B[i], tmp2) / norm2(*param.B[i]));
-          printfQuda("L2 relative deviation = %e max deviation = %e\n", l2_deviation, max_deviation[0]);
+          printfQuda("L2 relative deviation = %e max deviation = %e\n", double(l2_deviation), double(max_deviation[0]));
 
           if (param.mg_global.run_oblique_proj_check) {
 
@@ -1193,11 +1193,11 @@ namespace quda
             transfer->P(tmp2, *x_coarse);
             (*param.matResidual)(tmp1, tmp2);
 
-            logQuda(QUDA_SUMMARIZE, "Vector %d: norms v_k %e DP(P^dagDP)P^dag v_k %e\n", i, norm2(*param.B[i]),
-                    norm2(tmp1));
+            logQuda(QUDA_SUMMARIZE, "Vector %d: norms v_k %e DP(P^dagDP)P^dag v_k %e\n", i, double(norm2(*param.B[i])),
+                    double(norm2(tmp1)));
             max_deviation = blas::max_deviation(tmp1, *param.B[i]);
             logQuda(QUDA_SUMMARIZE, "L2 relative deviation = %e, max deviation = %e\n",
-                    sqrt(xmyNorm(*param.B[i], tmp1) / norm2(*param.B[i])), max_deviation[0]);
+                    double(sqrt(xmyNorm(*param.B[i], tmp1) / norm2(*param.B[i]))), double(max_deviation[0]));
           }
 
           sprintf(prefix, "MG level %d (%s): ", param.level + 1,
@@ -1240,13 +1240,13 @@ namespace quda
     if ( inner_solution_type == QUDA_MATPC_SOLUTION && param.smoother_solve_type != QUDA_DIRECT_PC_SOLVE)
       errorQuda("For this coarse grid solution type, a preconditioned smoother is required");
 
-    if ( debug ) printfQuda("entering V-cycle with x2=%e, r2=%e\n", norm2(x), norm2(b));
+    if ( debug ) printfQuda("entering V-cycle with x2=%e, r2=%e\n", double(norm2(x)), double(norm2(b)));
 
     if (param.level < param.Nlevel-1) {
       //transfer->setTransferGPU(false); // use this to force location of transfer (need to check if still works for multi-level)
 
       // do the pre smoothing
-      if (debug) printfQuda("pre-smoothing b2=%e site subset %d\n", norm2(b), b.SiteSubset());
+      if (debug) printfQuda("pre-smoothing b2=%e site subset %d\n", double(norm2(b)), b.SiteSubset());
 
       ColorSpinorField *out=nullptr, *in=nullptr;
 
@@ -1280,7 +1280,7 @@ namespace quda
         (*param.matResidual)(residual, x);
         axpby(1.0, b, -1.0, residual);
       }
-      double r2 = debug ? norm2(residual) : 0.0;
+      auto r2 = debug ? norm2(residual) : real_t(0.0);
 
       // We need this to ensure that the coarse level has been created.
       // e.g. in case of iterative setup with MG we use just pre- and post-smoothing at the first iteration.
@@ -1288,19 +1288,19 @@ namespace quda
 
         // restrict to the coarse grid
         transfer->R(*r_coarse, residual);
-        if ( debug ) printfQuda("after pre-smoothing x2 = %e, r2 = %e, r_coarse2 = %e\n", norm2(x), r2, norm2(*r_coarse));
+        if ( debug ) printfQuda("after pre-smoothing x2 = %e, r2 = %e, r_coarse2 = %e\n", double(norm2(x)), double(r2), double(norm2(*r_coarse)));
 
         // recurse to the next lower level
         (*coarse_solver)(*x_coarse, *r_coarse);
-        if (debug) printfQuda("after coarse solve x_coarse2 = %e r_coarse2 = %e\n", norm2(*x_coarse), norm2(*r_coarse));
+        if (debug) printfQuda("after coarse solve x_coarse2 = %e r_coarse2 = %e\n", double(norm2(*x_coarse)), double(norm2(*r_coarse)));
 
         // prolongate back to this grid
         ColorSpinorField &x_coarse_2_fine = inner_solution_type == QUDA_MAT_SOLUTION ? *r : r->Even(); // define according to inner solution type
         transfer->P(x_coarse_2_fine, *x_coarse); // repurpose residual storage
         xpy(x_coarse_2_fine, solution); // sum to solution FIXME - sum should be done inside the transfer operator
         if ( debug ) {
-          printfQuda("Prolongated coarse solution y2 = %e\n", norm2(*r));
-          printfQuda("after coarse-grid correction x2 = %e, r2 = %e\n", norm2(x), norm2(*r));
+          printfQuda("Prolongated coarse solution y2 = %e\n", double(norm2(*r)));
+          printfQuda("after coarse-grid correction x2 = %e, r2 = %e\n", double(norm2(x)), double(norm2(*r)));
         }
       }
 
@@ -1337,8 +1337,8 @@ namespace quda
     // FIXME on subset check
     if (debug && b.SiteSubset() == r->SiteSubset()) {
       (*param.matResidual)(*r, x);
-      double r2 = xmyNorm(b, *r);
-      printfQuda("leaving V-cycle with x2=%e, r2=%e\n", norm2(x), r2);
+      auto r2 = xmyNorm(b, *r);
+      printfQuda("leaving V-cycle with x2=%e, r2=%e\n", double(norm2(x)), double(r2));
     }
 
     popOutputPrefix();
@@ -1503,11 +1503,11 @@ namespace quda
       if(param.mg_global.pre_orthonormalize) {
         for(int i=0; i<(int)B.size(); i++) {
           for (int j=0; j<i; j++) {
-            Complex alpha = cDotProduct(*B[j], *B[i]);// <j,i>
+            complex_t alpha = cDotProduct(*B[j], *B[i]);// <j,i>
             caxpy(-alpha, *B[j], *B[i]); // i-<j,i>j
           }
-          double nrm2 = norm2(*B[i]);
-          if (nrm2 > 1e-16) ax(1.0 /sqrt(nrm2), *B[i]);// i/<i,i>
+          auto nrm2 = norm2(*B[i]);
+          if (nrm2 > 1e-16) ax(rsqrt(nrm2), *B[i]);// i/<i,i>
           else errorQuda("\nCannot normalize %u vector\n", i);
         }
       }
@@ -1522,15 +1522,15 @@ namespace quda
           zero(b);
         }
 
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Initial guess = %g\n", norm2(x));
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Initial rhs = %g\n", norm2(b));
+        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Initial guess = %g\n", double(norm2(x)));
+        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Initial rhs = %g\n", double(norm2(b)));
 
         ColorSpinorField *out=nullptr, *in=nullptr;
         diracSmoother->prepare(in, out, x, b, QUDA_MAT_SOLUTION);
         (*solve)(*out, *in);
         diracSmoother->reconstruct(x, b, QUDA_MAT_SOLUTION);
 
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Solution = %g\n", norm2(x));
+        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Solution = %g\n", double(norm2(x)));
         *B[i] = x;
       }
 
@@ -1538,12 +1538,12 @@ namespace quda
       if (param.mg_global.post_orthonormalize) {
         for(int i=0; i<(int)B.size(); i++) {
           for (int j=0; j<i; j++) {
-            Complex alpha = cDotProduct(*B[j], *B[i]);// <j,i>
+            complex_t alpha = cDotProduct(*B[j], *B[i]);// <j,i>
             caxpy(-alpha, *B[j], *B[i]); // i-<j,i>j
           }
-          double nrm2 = norm2(*B[i]);
-          if (sqrt(nrm2) > 1e-16) ax(1.0/sqrt(nrm2), *B[i]);// i/<i,i>
-          else errorQuda("\nCannot normalize %u vector (nrm=%e)\n", i, sqrt(nrm2));
+          auto nrm2 = norm2(*B[i]);
+          if (sqrt(nrm2) > 1e-16) ax(rsqrt(nrm2), *B[i]);// i/<i,i>
+          else errorQuda("\nCannot normalize %u vector (nrm=%e)\n", i, double(sqrt(nrm2)));
         }
       }
 
@@ -1755,8 +1755,8 @@ namespace quda
     // global orthonormalization of the generated null-space vectors
     if(param.mg_global.post_orthonormalize) {
       for(int i=0; i<(int)B.size(); i++) {
-        double nrm2 = norm2(*B[i]);
-        if (nrm2 > 1e-16) ax(1.0 /sqrt(nrm2), *B[i]);// i/<i,i>
+        auto nrm2 = norm2(*B[i]);
+        if (nrm2 > 1e-16) ax(rsqrt(nrm2), *B[i]);// i/<i,i>
         else errorQuda("\nCannot normalize %u vector\n", i);
       }
     }
@@ -1782,7 +1782,7 @@ namespace quda
     // This is the vector precision used by matResidual
     csParam.setPrecision(param.mg_global.invert_param->cuda_prec_sloppy, QUDA_INVALID_PRECISION, true);
 
-    std::vector<Complex> evals(n_conv, 0.0);
+    std::vector<complex_t> evals(n_conv, real_t(0.0));
     std::vector<ColorSpinorField> B_evecs(n_conv);
     for (auto &b : B_evecs) b = ColorSpinorField(csParam);
 
diff --git a/lib/pgauge_det_trace.cu b/lib/pgauge_det_trace.cu
index fd48ca75e3..795eea9f13 100644
--- a/lib/pgauge_det_trace.cu
+++ b/lib/pgauge_det_trace.cu
@@ -13,11 +13,11 @@ namespace quda {
   template <typename Float, int nColor, QudaReconstructType recon>
   class CalcFunc : TunableReduction2D {
     const GaugeField &u;
-    array<double, 2> &result;
+    complex_t &result;
     const compute_type type;
 
   public:
-    CalcFunc(const GaugeField &u, array<double, 2> &result, compute_type type) :
+    CalcFunc(const GaugeField &u, complex_t &result, compute_type type) :
       TunableReduction2D(u),
       u(u),
       result(result),
@@ -30,15 +30,16 @@ namespace quda {
     void apply(const qudaStream_t &stream)
     {
       TuneParam tp = tuneLaunch(*this, getTuning(), getVerbosity());
+      array<real_t, 2> det_trace = {};
       if (type == compute_type::determinant) {
         KernelArg<Float, nColor, recon, compute_type::determinant> arg(u);
-        launch<DetTrace>(result, tp, stream, arg);
+        launch<DetTrace>(det_trace, tp, stream, arg);
       } else {
         KernelArg<Float, nColor, recon, compute_type::trace> arg(u);
-        launch<DetTrace>(result, tp, stream, arg);
+        launch<DetTrace>(det_trace, tp, stream, arg);
       }
 
-      for (int i = 0; i < 2; i++) result[i] /= (double)(4*u.LocalVolume()*comm_size());
+      result = complex_t(det_trace[0], det_trace[1]) / (real_t)(4*u.LocalVolume()*comm_size());
     }
 
     long long flops() const {
@@ -50,18 +51,18 @@ namespace quda {
     long long bytes() const { return u.Bytes(); }
   };
 
-  double2 getLinkDeterminant(GaugeField& data)
+  complex_t getLinkDeterminant(GaugeField& data)
   {
-    array<double, 2> det{0.0, 0.0};
+    complex_t det{0.0, 0.0};
     instantiate<CalcFunc>(data, det, compute_type::determinant);
-    return make_double2(det[0], det[1]);
+    return det;
   }
 
-  double2 getLinkTrace(GaugeField& data)
+  complex_t getLinkTrace(GaugeField& data)
   {
-    array<double, 2> tr{0.0, 0.0};
+    complex_t tr{0.0, 0.0};
     instantiate<CalcFunc>(data, tr, compute_type::trace);
-    return make_double2(tr[0], tr[1]);
+    return tr;
   }
 
 } // namespace quda
diff --git a/lib/pgauge_heatbath.cu b/lib/pgauge_heatbath.cu
index 257b9cd3a1..4bf1e0c0f7 100644
--- a/lib/pgauge_heatbath.cu
+++ b/lib/pgauge_heatbath.cu
@@ -23,7 +23,7 @@ namespace quda {
     unsigned int minThreads() const { return U.LocalVolumeCB(); }
 
   public:
-    GaugeHB(GaugeField &U, double beta, RNG &rng, int mu, int parity, bool heatbath) :
+    GaugeHB(GaugeField &U, real_t beta, RNG &rng, int mu, int parity, bool heatbath) :
       TunableKernel1D(U),
       U(U),
       beta(static_cast<Float>(beta)),
@@ -101,7 +101,7 @@ namespace quda {
 
   template <typename Float, int nColor, QudaReconstructType recon>
   struct MonteAlg {
-    MonteAlg(GaugeField& data, RNG &rngstate, Float Beta, int nhb, int nover)
+    MonteAlg(GaugeField& data, RNG &rngstate, real_t Beta, int nhb, int nover)
     {
       host_timer_t timer;
       double hb_time = 0.0, ovr_time = 0.0;
@@ -149,9 +149,9 @@ namespace quda {
    * @param[in] nhb number of heatbath steps
    * @param[in] nover number of overrelaxation steps
    */
-  void Monte(GaugeField& data, RNG &rngstate, double Beta, int nhb, int nover)
+  void Monte(GaugeField& data, RNG &rngstate, real_t Beta, int nhb, int nover)
   {
-    instantiate<MonteAlg>(data, rngstate, (float)Beta, nhb, nover);
+    instantiate<MonteAlg>(data, rngstate, Beta, nhb, nover);
   }
 
 }
diff --git a/lib/quda_arpack_interface.cpp b/lib/quda_arpack_interface.cpp
index 5100cb0001..e542f78fcd 100644
--- a/lib/quda_arpack_interface.cpp
+++ b/lib/quda_arpack_interface.cpp
@@ -28,7 +28,7 @@ namespace quda
   void arpackErrorHelpNAUPD();
   void arpackErrorHelpNEUPD();
 
-  void arpack_solve(std::vector<ColorSpinorField> &h_evecs, std::vector<Complex> &h_evals, const DiracMatrix &mat,
+  void arpack_solve(std::vector<ColorSpinorField> &h_evecs, std::vector<complex_t> &h_evals, const DiracMatrix &mat,
                     QudaEigParam *eig_param, TimeProfile &profile)
   {
     // Create Eigensolver object for member function use
@@ -105,23 +105,23 @@ namespace quda
     double tol_ = eig_param->tol;
 
     // ARPACK workspace
-    Complex I(0.0, 1.0);
-    std::vector<Complex> resid_(ldv_);
+    complex_t I(0.0, 1.0);
+    std::vector<complex_t> resid_(ldv_);
 
     // Use initial guess?
     if (info_ > 0) {
       for (int a = 0; a < ldv_; a++) resid_[a] = drand48();
     }
 
-    Complex sigma_ = 0.0;
-    std::vector<Complex> w_workd_(3 * ldv_);
-    std::vector<Complex> w_workl_(lworkl_);
-    std::vector<Complex> w_workev_(2 * n_kr_);
+    complex_t sigma_ = 0.0;
+    std::vector<complex_t> w_workd_(3 * ldv_);
+    std::vector<complex_t> w_workl_(lworkl_);
+    std::vector<complex_t> w_workev_(2 * n_kr_);
     std::vector<double> w_rwork_(n_kr_);
     std::vector<int> select_(n_kr_);
 
-    std::vector<Complex> h_evecs_(n_kr_ * ldv_);
-    std::vector<Complex> h_evals_(n_ev_);
+    std::vector<complex_t> h_evecs_(n_kr_ * ldv_);
+    std::vector<complex_t> h_evals_(n_ev_);
 
     // create container wrapping the vectors returned from ARPACK
     ColorSpinorParam param(h_evecs[0]);
@@ -350,7 +350,7 @@ namespace quda
 
     // Sort the eigenvalues. To do this we use the QUDA EigenSolver method, which
     // requires transferring data to std::vector arrays.
-    std::vector<Complex> evals(nconv, 0.0);
+    std::vector<complex_t> evals(nconv, 0.0);
     std::vector<int> arpack_index(nconv, 0.0);
     for (int i = 0; i < nconv; i++) {
       evals[i] = h_evals_[i];
@@ -411,7 +411,7 @@ namespace quda
 	// d_v2 = M*v = lambda_measured * v
 	mat(d_v2, d_v);
 	// d_v = ||lambda_measured*v - lambda_arpack*v||
-	blas::caxpby(Complex {1.0, 0.0}, d_v2, -evals[i], d_v);
+	blas::caxpby(complex_t {1.0, 0.0}, d_v2, -evals[i], d_v);
 	double L2norm = blas::norm2(d_v);
 	profile.TPSTOP(QUDA_PROFILE_COMPUTE);
 
@@ -538,7 +538,7 @@ namespace quda
 
 #else
 
-  void arpack_solve(std::vector<ColorSpinorField> &, std::vector<Complex> &, const DiracMatrix &, QudaEigParam *,
+  void arpack_solve(std::vector<ColorSpinorField> &, std::vector<complex_t> &, const DiracMatrix &, QudaEigParam *,
                     TimeProfile &)
   {
     errorQuda("(P)ARPACK has not been enabled for this build");
diff --git a/lib/reduce_helper.cu b/lib/reduce_helper.cu
index cf95032656..1afd696044 100644
--- a/lib/reduce_helper.cu
+++ b/lib/reduce_helper.cu
@@ -28,6 +28,20 @@ namespace quda
     static int allocated_n_reduce = 0;
     static bool init_event = false;
 
+#ifdef QUDA_REDUCTION_ALGORITHM_REPRODUCIBLE
+    static bool init_rfa = false;
+    static reproducible::RFA_bins<reduction_t> bins;
+
+    reproducible::RFA_bins<reduction_t>& get_rfa_bins()
+    {
+      if (!init_rfa) {
+        bins.initialize_bins();
+        init_rfa = true;
+      }
+      return bins;
+    }
+#endif
+
     template <typename T>
     struct init_reduce : public TunableKernel1D {
       T *reduce_count;
@@ -68,7 +82,7 @@ namespace quda
         using system_atomic_t = device_reduce_t;
         size_t n_reduce = bytes / sizeof(system_atomic_t);
         auto *atomic_buf = reinterpret_cast<system_atomic_t *>(h_reduce);
-        for (size_t i = 0; i < n_reduce; i++) new (atomic_buf + i) system_atomic_t {0}; // placement new constructor
+        for (size_t i = 0; i < n_reduce; i++) new (atomic_buf + i) system_atomic_t {}; // placement new constructor
 
         allocated_bytes = bytes;
       }
diff --git a/lib/reduce_quda.cu b/lib/reduce_quda.cu
index 7b61c78b6e..f273508261 100644
--- a/lib/reduce_quda.cu
+++ b/lib/reduce_quda.cu
@@ -12,7 +12,7 @@ namespace quda {
     class Reduce : public TunableReduction2D
     {
       using real = typename mapper<y_store_t>::type;
-      using host_reduce_t = typename Reducer<double, real>::reduce_t;
+      using host_reduce_t = typename Reducer<real_t, real>::reduce_t;
       Reducer<device_reduce_t, real> r;
       const int nParity; // for composite fields this includes the number of composites
 
@@ -101,7 +101,7 @@ namespace quda {
           using host_store_t = typename host_type_mapper<store_t>::type;
           using host_y_store_t = typename host_type_mapper<y_store_t>::type;
           using host_real_t = typename mapper<host_y_store_t>::type;
-          Reducer<double, host_real_t> r_(a, b);
+          Reducer<device_reduce_t, host_real_t> r_(a, b);
 
           // redefine site_unroll with host_store types to ensure we have correct N/Ny/M values
           constexpr bool site_unroll = !std::is_same<host_store_t, host_y_store_t>::value || isFixed<host_store_t>::value || decltype(r)::site_unroll;
@@ -145,131 +145,131 @@ namespace quda {
     template <template <typename reduce_t, typename real> class Functor, bool mixed, typename... Args>
     auto instantiateReduce(Args &&... args)
     {
-      using host_reduce_t = typename Functor<double, double>::reduce_t;
-      host_reduce_t value = ::quda::zero<host_reduce_t>();
+      using host_reduce_t = typename Functor<real_t, real_t>::reduce_t;
+      host_reduce_t value = {};
       instantiate<Functor, Reduce, mixed>(args..., value);
       return value;
     }
 
-    double max(const ColorSpinorField &x)
+    real_t max(const ColorSpinorField &x)
     {
-      return instantiateReduce<Max, false>(0.0, 0.0, 0.0, x, x, x, x, x);
+      return instantiateReduce<Max, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, x, x, x, x);
     }
 
-    array<double, 2> max_deviation(const ColorSpinorField &x, const ColorSpinorField &y)
+    array<real_t, 2> max_deviation(const ColorSpinorField &x, const ColorSpinorField &y)
     {
-      auto deviation = instantiateReduce<MaxDeviation, false>(0.0, 0.0, 0.0, x, y, y, y, y);
+      auto deviation = instantiateReduce<MaxDeviation, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, y, y, y);
       // ensure that if the absolute deviation is zero, so is the relative deviation
-      return {deviation.diff, deviation.diff > 0.0 ? deviation.diff / deviation.ref : 0.0};
+      return {deviation.diff, deviation.diff > real_t(0.0) ? deviation.diff / deviation.ref : real_t(0.0)};
     }
 
-    double norm1(const ColorSpinorField &x)
+    real_t norm1(const ColorSpinorField &x)
     {
-      return instantiateReduce<Norm1, false>(0.0, 0.0, 0.0, x, x, x, x, x);
+      return instantiateReduce<Norm1, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, x, x, x, x);
     }
 
-    double norm2(const ColorSpinorField &x)
+    real_t norm2(const ColorSpinorField &x)
     {
-      return instantiateReduce<Norm2, false>(0.0, 0.0, 0.0, x, x, x, x, x);
+      return instantiateReduce<Norm2, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, x, x, x, x);
     }
 
-    double reDotProduct(const ColorSpinorField &x, const ColorSpinorField &y)
+    real_t reDotProduct(const ColorSpinorField &x, const ColorSpinorField &y)
     {
-      return instantiateReduce<Dot, false>(0.0, 0.0, 0.0, x, y, x, x, x);
+      return instantiateReduce<Dot, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, x, x, x);
     }
 
-    double axpbyzNorm(double a, const ColorSpinorField &x, double b, const ColorSpinorField &y, ColorSpinorField &z)
+    real_t axpbyzNorm(real_t a, const ColorSpinorField &x, real_t b, const ColorSpinorField &y, ColorSpinorField &z)
     {
-      return instantiateReduce<axpbyzNorm2, false>(a, b, 0.0, x, y, z, x, x);
+      return instantiateReduce<axpbyzNorm2, false>(a, b, real_t(0.0), x, y, z, x, x);
     }
 
-    double axpyReDot(double a, const ColorSpinorField &x, ColorSpinorField &y)
+    real_t axpyReDot(real_t a, const ColorSpinorField &x, ColorSpinorField &y)
     {
-      return instantiateReduce<AxpyReDot, false>(a, 0.0, 0.0, x, y, x, x, x);
+      return instantiateReduce<AxpyReDot, false>(a, real_t(0.0), real_t(0.0), x, y, x, x, x);
     }
 
-    double caxpyNorm(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y)
+    real_t caxpyNorm(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y)
     {
-      return instantiateReduce<caxpyNorm2, false>(a, Complex(0.0), Complex(0.0), x, y, x, x, x);
+      return instantiateReduce<caxpyNorm2, false>(a, complex_t(0.0), complex_t(0.0), x, y, x, x, x);
     }
 
-    double cabxpyzAxNorm(double a, const Complex &b, ColorSpinorField &x, const ColorSpinorField &y, ColorSpinorField &z)
+    real_t cabxpyzAxNorm(real_t a, const complex_t &b, ColorSpinorField &x, const ColorSpinorField &y, ColorSpinorField &z)
     {
-      return instantiateReduce<cabxpyzaxnorm, false>(Complex(a), b, Complex(0.0), x, y, z, x, x);
+      return instantiateReduce<cabxpyzaxnorm, false>(complex_t(a), b, complex_t(0.0), x, y, z, x, x);
     }
 
-    Complex cDotProduct(const ColorSpinorField &x, const ColorSpinorField &y)
+    complex_t cDotProduct(const ColorSpinorField &x, const ColorSpinorField &y)
     {
-      auto cdot = instantiateReduce<Cdot, false>(0.0, 0.0, 0.0, x, y, x, x, x);
-      return Complex(cdot[0], cdot[1]);
+      auto cdot = instantiateReduce<Cdot, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, x, x, x);
+      return complex_t(cdot[0], cdot[1]);
     }
 
-    Complex caxpyDotzy(const Complex &a, const ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z)
+    complex_t caxpyDotzy(const complex_t &a, const ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &z)
     {
-      auto cdot = instantiateReduce<caxpydotzy, false>(a, Complex(0.0), Complex(0.0), x, y, z, x, x);
-      return Complex(cdot[0], cdot[1]);
+      auto cdot = instantiateReduce<caxpydotzy, false>(a, complex_t(0.0), complex_t(0.0), x, y, z, x, x);
+      return complex_t(cdot[0], cdot[1]);
     }
 
-    double4 cDotProductNormAB(const ColorSpinorField &x, const ColorSpinorField &y)
+    array<real_t, 4> cDotProductNormAB(const ColorSpinorField &x, const ColorSpinorField &y)
     {
-      auto ab = instantiateReduce<CdotNormAB, false>(0.0, 0.0, 0.0, x, y, x, x, x);
-      return make_double4(ab[0], ab[1], ab[2], ab[3]);
+      auto ab = instantiateReduce<CdotNormAB, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, x, x, x);
+      return {ab[0], ab[1], ab[2], ab[3]};
     }
 
-    double3 caxpbypzYmbwcDotProductUYNormY(const Complex &a, const ColorSpinorField &x, const Complex &b,
+    array<real_t, 3> caxpbypzYmbwcDotProductUYNormY(const complex_t &a, const ColorSpinorField &x, const complex_t &b,
                                            ColorSpinorField &y, ColorSpinorField &z,
                                            const ColorSpinorField &w, const ColorSpinorField &v)
     {
-      auto rtn = instantiateReduce<caxpbypzYmbwcDotProductUYNormY_, true>(a, b, Complex(0.0), x, z, y, w, v);
-      return make_double3(rtn[0], rtn[1], rtn[2]);
+      auto rtn = instantiateReduce<caxpbypzYmbwcDotProductUYNormY_, true>(a, b, complex_t(0.0), x, z, y, w, v);
+      return {rtn[0], rtn[1], rtn[2]};
     }
 
-    double2 axpyCGNorm(double a, const ColorSpinorField &x, ColorSpinorField &y)
+    array<real_t, 2> axpyCGNorm(real_t a, const ColorSpinorField &x, ColorSpinorField &y)
     {
-      auto cg_norm = instantiateReduce<axpyCGNorm2, true>(a, 0.0, 0.0, x, y, x, x, x);
-      return make_double2(cg_norm[0], cg_norm[1]);
+      auto cg_norm = instantiateReduce<axpyCGNorm2, true>(a, real_t(0.0), real_t(0.0), x, y, x, x, x);
+      return {cg_norm[0], cg_norm[1]};
     }
 
-    double3 HeavyQuarkResidualNorm(const ColorSpinorField &x, const ColorSpinorField &r)
+    array<real_t, 3> HeavyQuarkResidualNorm(const ColorSpinorField &x, const ColorSpinorField &r)
     {
       // in case of x.Ncolor()!=3 (MG mainly) reduce_core do not support this function.
-      if (x.Ncolor() != 3) return make_double3(0.0, 0.0, 0.0);
-      auto rtn = instantiateReduce<HeavyQuarkResidualNorm_, false>(0.0, 0.0, 0.0, x, r, r, r, r);
+      if (x.Ncolor() != 3) return {0.0, 0.0, 0.0};
+      auto rtn = instantiateReduce<HeavyQuarkResidualNorm_, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, r, r, r, r);
       rtn[2] /= (x.Volume()*comm_size());
-      return make_double3(rtn[0], rtn[1], rtn[2]);
+      return {rtn[0], rtn[1], rtn[2]};
     }
 
-    double3 xpyHeavyQuarkResidualNorm(const ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &r)
+    array<real_t, 3> xpyHeavyQuarkResidualNorm(const ColorSpinorField &x, ColorSpinorField &y, const ColorSpinorField &r)
     {
       // in case of x.Ncolor()!=3 (MG mainly) reduce_core do not support this function.
-      if (x.Ncolor()!=3) return make_double3(0.0, 0.0, 0.0);
-      auto rtn = instantiateReduce<xpyHeavyQuarkResidualNorm_, false>(0.0, 0.0, 0.0, x, y, r, r, r);
+      if (x.Ncolor()!=3) return {0.0, 0.0, 0.0};
+      auto rtn = instantiateReduce<xpyHeavyQuarkResidualNorm_, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, r, r, r);
       rtn[2] /= (x.Volume()*comm_size());
-      return make_double3(rtn[0], rtn[1], rtn[2]);
+      return {rtn[0], rtn[1], rtn[2]};
     }
 
-    double3 tripleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z)
+    array<real_t, 3> tripleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z)
     {
-      auto rtn = instantiateReduce<tripleCGReduction_, false>(0.0, 0.0, 0.0, x, y, z, x, x);
-      return make_double3(rtn[0], rtn[1], rtn[2]);
+      auto rtn = instantiateReduce<tripleCGReduction_, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, z, x, x);
+      return {rtn[0], rtn[1], rtn[2]};
     }
 
-    double4 quadrupleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z)
+    array<real_t, 4> quadrupleCGReduction(const ColorSpinorField &x, const ColorSpinorField &y, const ColorSpinorField &z)
     {
-      auto red = instantiateReduce<quadrupleCGReduction_, false>(0.0, 0.0, 0.0, x, y, z, x, x);
-      return make_double4(red[0], red[1], red[2], red[3]);
+      auto red = instantiateReduce<quadrupleCGReduction_, false>(real_t(0.0), real_t(0.0), real_t(0.0), x, y, z, x, x);
+      return {red[0], red[1], red[2], red[3]};
     }
 
-    double quadrupleCG3InitNorm(double a, ColorSpinorField &x, ColorSpinorField &y,
+    real_t quadrupleCG3InitNorm(real_t a, ColorSpinorField &x, ColorSpinorField &y,
                                 ColorSpinorField &z, ColorSpinorField &w, const ColorSpinorField &v)
     {
-      return instantiateReduce<quadrupleCG3InitNorm_, false>(a, 0.0, 0.0, x, y, z, w, v);
+      return instantiateReduce<quadrupleCG3InitNorm_, false>(a, real_t(0.0), real_t(0.0), x, y, z, w, v);
     }
 
-    double quadrupleCG3UpdateNorm(double a, double b, ColorSpinorField &x, ColorSpinorField &y,
+    real_t quadrupleCG3UpdateNorm(real_t a, real_t b, ColorSpinorField &x, ColorSpinorField &y,
                                   ColorSpinorField &z, ColorSpinorField &w, const ColorSpinorField &v)
     {
-      return instantiateReduce<quadrupleCG3UpdateNorm_, false>(a, b, 0.0, x, y, z, w, v);
+      return instantiateReduce<quadrupleCG3UpdateNorm_, false>(a, b, real_t(0.0), x, y, z, w, v);
     }
 
   } // namespace blas
diff --git a/lib/solver.cpp b/lib/solver.cpp
index 8b734e8bc5..069d7666c6 100644
--- a/lib/solver.cpp
+++ b/lib/solver.cpp
@@ -311,7 +311,7 @@ namespace quda {
       } else {
         // Computing the deflation space, rather than transferring, so we create space.
         resize(evecs, param.eig_param.n_conv, csParam);
-        evals.resize(param.eig_param.n_conv, 0.0);
+        evals.resize(param.eig_param.n_conv, real_t(0.0));
       }
     }
 
@@ -378,13 +378,13 @@ namespace quda {
     }
   }
 
-  double Solver::stopping(double tol, double b2, QudaResidualType residual_type)
+  real_t Solver::stopping(real_t tol, real_t b2, QudaResidualType residual_type)
   {
-    double stop=0.0;
+    real_t stop=0.0;
     if ( (residual_type & QUDA_L2_ABSOLUTE_RESIDUAL) &&
 	 (residual_type & QUDA_L2_RELATIVE_RESIDUAL) ) {
       // use the most stringent stopping condition
-      double lowest = (b2 < 1.0) ? b2 : 1.0;
+      real_t lowest = (b2 < 1.0) ? b2 : 1.0;
       stop = lowest*tol*tol;
     } else if (residual_type & QUDA_L2_ABSOLUTE_RESIDUAL) {
       stop = tol*tol;
@@ -395,19 +395,19 @@ namespace quda {
     return stop;
   }
 
-  bool Solver::convergence(double r2, double hq2, double r2_tol, double hq_tol) {
+  bool Solver::convergence(real_t r2, real_t hq2, real_t r2_tol, real_t hq_tol) {
 
     // check the heavy quark residual norm if necessary
     if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-      if (std::isnan(hq2) || std::isinf(hq2))
-        errorQuda("Solver appears to have diverged with heavy quark residual %9.6e", hq2);
+      if (isnan(hq2) || isinf(hq2))
+        errorQuda("Solver appears to have diverged with heavy quark residual %9.6e", double(hq2));
 
       if (hq2 > hq_tol) return false;
     }
 
     // check the L2 relative residual norm if necessary
     if ((param.residual_type & QUDA_L2_RELATIVE_RESIDUAL) || (param.residual_type & QUDA_L2_ABSOLUTE_RESIDUAL)) {
-      if (std::isnan(r2) || std::isinf(r2)) errorQuda("Solver appears to have diverged with residual %9.6e", r2);
+      if (isnan(r2) || isinf(r2)) errorQuda("Solver appears to have diverged with residual %9.6e", double(r2));
 
       if (r2 > r2_tol) return false;
     }
@@ -415,12 +415,12 @@ namespace quda {
     return true;
   }
 
-  bool Solver::convergenceHQ(double, double hq2, double, double hq_tol)
+  bool Solver::convergenceHQ(real_t, real_t hq2, real_t, real_t hq_tol)
   {
     // check the heavy quark residual norm if necessary
     if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-      if (std::isnan(hq2) || std::isinf(hq2))
-        errorQuda("Solver appears to have diverged with heavy quark residual %9.6e", hq2);
+      if (isnan(hq2) || isinf(hq2))
+        errorQuda("Solver appears to have diverged with heavy quark residual %9.6e", double(hq2));
 
       if (hq2 > hq_tol) return false;
     }
@@ -428,11 +428,11 @@ namespace quda {
     return true;
   }
 
-  bool Solver::convergenceL2(double r2, double, double r2_tol, double)
+  bool Solver::convergenceL2(real_t r2, real_t, real_t r2_tol, real_t)
   {
     // check the L2 relative residual norm if necessary
     if ((param.residual_type & QUDA_L2_RELATIVE_RESIDUAL) || (param.residual_type & QUDA_L2_ABSOLUTE_RESIDUAL)) {
-      if (std::isnan(r2) || std::isinf(r2)) errorQuda("Solver appears to have diverged with residual %9.6e", r2);
+      if (isnan(r2) || isinf(r2)) errorQuda("Solver appears to have diverged with residual %9.6e", double(r2));
 
       if (r2 > r2_tol) return false;
     }
@@ -440,40 +440,40 @@ namespace quda {
     return true;
   }
 
-  void Solver::PrintStats(const char* name, int k, double r2, double b2, double hq2) {
+  void Solver::PrintStats(const char* name, int k, real_t r2, real_t b2, real_t hq2) {
     if (getVerbosity() >= QUDA_VERBOSE) {
       if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
-        printfQuda("%s: %5d iterations, <r,r> = %9.6e, |r|/|b| = %9.6e, heavy-quark residual = %9.6e\n", name, k, r2,
-                   sqrt(r2 / b2), hq2);
+        printfQuda("%s: %5d iterations, <r,r> = %9.6e, |r|/|b| = %9.6e, heavy-quark residual = %9.6e\n", name, k, double(r2),
+                   double(sqrt(r2 / b2)), double(hq2));
       } else {
-        printfQuda("%s: %5d iterations, <r,r> = %9.6e, |r|/|b| = %9.6e\n", name, k, r2, sqrt(r2 / b2));
+        printfQuda("%s: %5d iterations, <r,r> = %9.6e, |r|/|b| = %9.6e\n", name, k, double(r2), double(sqrt(r2 / b2)));
       }
     }
 
-    if (std::isnan(r2) || std::isinf(r2)) errorQuda("Solver appears to have diverged");
+    if (isnan(r2) || isinf(r2)) errorQuda("Solver appears to have diverged");
   }
 
-  void Solver::PrintSummary(const char *name, int k, double r2, double b2,
-                            double r2_tol, double hq_tol) {
+  void Solver::PrintSummary(const char *name, int k, real_t r2, real_t b2,
+                            real_t r2_tol, real_t hq_tol) {
     if (getVerbosity() >= QUDA_SUMMARIZE) {
       if (param.compute_true_res) {
 	if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
           printfQuda("%s: Convergence at %d iterations, L2 relative residual: iterated = %9.6e, true = %9.6e "
                      "(requested = %9.6e), heavy-quark residual = %9.6e (requested = %9.6e)\n",
-                     name, k, sqrt(r2 / b2), param.true_res, sqrt(r2_tol / b2), param.true_res_hq, hq_tol);
+                     name, k, double(sqrt(r2 / b2)), double(param.true_res), double(sqrt(r2_tol / b2)), double(param.true_res_hq), double(hq_tol));
         } else {
           printfQuda("%s: Convergence at %d iterations, L2 relative residual: iterated = %9.6e, true = %9.6e "
                      "(requested = %9.6e)\n",
-                     name, k, sqrt(r2 / b2), param.true_res, sqrt(r2_tol / b2));
+                     name, k, double(sqrt(r2 / b2)), double(param.true_res), double(sqrt(r2_tol / b2)));
         }
       } else {
 	if (param.residual_type & QUDA_HEAVY_QUARK_RESIDUAL) {
           printfQuda("%s: Convergence at %d iterations, L2 relative residual: iterated = %9.6e "
                      "(requested = %9.6e), heavy-quark residual = %9.6e (requested = %9.6e)\n",
-                     name, k, sqrt(r2 / b2), sqrt(r2_tol / b2), param.true_res_hq, hq_tol);
+                     name, k, double(sqrt(r2 / b2)), double(sqrt(r2_tol / b2)), double(param.true_res_hq), double(hq_tol));
         } else {
           printfQuda("%s: Convergence at %d iterations, L2 relative residual: iterated = %9.6e (requested = %9.6e)\n",
-                     name, k, sqrt(r2 / b2), sqrt(r2_tol / b2));
+                     name, k, double(sqrt(r2 / b2)), double(sqrt(r2_tol / b2)));
         }
       }
     }
@@ -500,13 +500,13 @@ namespace quda {
       errorQuda("Precision mismatch %d %d", checkPrecision(x[0], b), param.precision);
   }
 
-  bool MultiShiftSolver::convergence(const std::vector<double> &r2, const std::vector<double> &r2_tol, int n) const
+  bool MultiShiftSolver::convergence(const std::vector<real_t> &r2, const std::vector<real_t> &r2_tol, int n) const
   {
     // check the L2 relative residual norm if necessary
     if ((param.residual_type & QUDA_L2_RELATIVE_RESIDUAL) || (param.residual_type & QUDA_L2_ABSOLUTE_RESIDUAL)) {
       for (int i = 0; i < n; i++) {
-        if (std::isnan(r2[i]) || std::isinf(r2[i]))
-          errorQuda("Multishift solver appears to have diverged on shift %d with residual %9.6e", i, r2[i]);
+        if (isnan(r2[i]) || isinf(r2[i]))
+          errorQuda("Multishift solver appears to have diverged on shift %d with residual %9.6e", i, double(r2[i]));
 
         if (r2[i] > r2_tol[i] && r2_tol[i] != 0.0) return false;
       }
diff --git a/lib/solver.hpp b/lib/solver.hpp
index ab93451aef..911840d5a3 100644
--- a/lib/solver.hpp
+++ b/lib/solver.hpp
@@ -19,7 +19,7 @@ namespace quda
      @return Norm of final power iteration result
   */
   template <typename... Args>
-  double Solver::performPowerIterations(const DiracMatrix &diracm, const ColorSpinorField &start,
+  real_t Solver::performPowerIterations(const DiracMatrix &diracm, const ColorSpinorField &start,
                                         ColorSpinorField &tempvec1, ColorSpinorField &tempvec2, int niter,
                                         int normalize_freq, Args &&...args)
   {
@@ -29,21 +29,21 @@ namespace quda
     // Do niter iterations, normalize every normalize_freq
     for (int i = 0; i < niter; i++) {
       if (normalize_freq > 0 && i % normalize_freq == 0) {
-        double tmpnrm = sqrt(blas::norm2(tempvec1));
-        blas::ax(1.0 / tmpnrm, tempvec1);
+        auto tmpnrm = rsqrt(blas::norm2(tempvec1));
+        blas::ax(tmpnrm, tempvec1);
       }
       diracm(tempvec2, tempvec1, args...);
       if (normalize_freq > 0 && i % normalize_freq == 0) {
-        logQuda(QUDA_VERBOSE, "Current Rayleigh Quotient step %d is %e\n", i, sqrt(blas::norm2(tempvec2)));
+        logQuda(QUDA_VERBOSE, "Current Rayleigh Quotient step %d is %e\n", i, double(sqrt(blas::norm2(tempvec2))));
       }
       std::swap(tempvec1, tempvec2);
     }
     // Get Rayleigh quotient
-    double tmpnrm = sqrt(blas::norm2(tempvec1));
-    blas::ax(1.0 / tmpnrm, tempvec1);
+    auto tmpnrm = rsqrt(blas::norm2(tempvec1));
+    blas::ax(tmpnrm, tempvec1);
     diracm(tempvec2, tempvec1, args...);
-    double lambda_max = sqrt(blas::norm2(tempvec2));
-    logQuda(QUDA_VERBOSE, "Power iterations approximate max = %e\n", lambda_max);
+    auto lambda_max = sqrt(blas::norm2(tempvec2));
+    logQuda(QUDA_VERBOSE, "Power iterations approximate max = %e\n", double(lambda_max));
 
     return lambda_max;
   }
@@ -61,8 +61,8 @@ namespace quda
   */
   template <typename... Args>
   void Solver::computeCAKrylovSpace(const DiracMatrix &diracm, std::vector<ColorSpinorField> &Ap,
-                                    std::vector<ColorSpinorField> &p, int n_krylov, QudaCABasis basis, double m_map,
-                                    double b_map, Args &&...args)
+                                    std::vector<ColorSpinorField> &p, int n_krylov, QudaCABasis basis, real_t m_map,
+                                    real_t b_map, Args &&...args)
   {
     // in some cases p or Ap may be larger
     if (static_cast<int>(p.size()) < n_krylov) errorQuda("Invalid p.size() %lu < n_krylov %d", p.size(), n_krylov);
diff --git a/lib/staggered_coarse_op.in.cpp b/lib/staggered_coarse_op.in.cpp
index bab3e1ffba..8d896f8201 100644
--- a/lib/staggered_coarse_op.in.cpp
+++ b/lib/staggered_coarse_op.in.cpp
@@ -8,7 +8,7 @@ namespace quda
 
   template <int fineColor, int coarseColor, int... N>
   void StaggeredCoarseOp2(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                          const GaugeField &longGauge, const GaugeField &XinvKD, double mass, bool allow_truncation,
+                          const GaugeField &longGauge, const GaugeField &XinvKD, real_t mass, bool allow_truncation,
                           QudaDiracType dirac, QudaMatPCType matpc, IntList<coarseColor, N...>)
   {
     if (Y.Ncolor() / 2 == coarseColor) {
@@ -25,7 +25,7 @@ namespace quda
 
   template <int fineColor, int... N>
   void StaggeredCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                         const GaugeField &longGauge, const GaugeField &XinvKD, double mass, bool allow_truncation,
+                         const GaugeField &longGauge, const GaugeField &XinvKD, real_t mass, bool allow_truncation,
                          QudaDiracType dirac, QudaMatPCType matpc, IntList<fineColor, N...>)
   {
     if (gauge.Ncolor() == fineColor) {
@@ -44,7 +44,7 @@ namespace quda
   }
 
   void StaggeredCoarseOp(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                         const GaugeField &longGauge, const GaugeField &XinvKD, double mass, bool allow_truncation,
+                         const GaugeField &longGauge, const GaugeField &XinvKD, real_t mass, bool allow_truncation,
                          QudaDiracType dirac, QudaMatPCType matpc)
   {
     if constexpr (is_enabled_spin(1) && is_enabled_multigrid()) {
diff --git a/lib/staggered_coarse_op.in.cu b/lib/staggered_coarse_op.in.cu
index 3a03467d9a..828e432cfc 100644
--- a/lib/staggered_coarse_op.in.cu
+++ b/lib/staggered_coarse_op.in.cu
@@ -23,7 +23,7 @@ namespace quda {
     GaugeField& Y;
     GaugeField& X;
     const GaugeField& g;
-    double mass;
+    real_t mass;
 
     const int nDim = 4;
 
@@ -41,7 +41,7 @@ namespace quda {
     unsigned int minThreads() const { return g.VolumeCB(); }
 
   public:
-    CalculateStaggeredY(GaugeField &Y, GaugeField &X, const GaugeField &g, const double mass) :
+    CalculateStaggeredY(GaugeField &Y, GaugeField &X, const GaugeField &g, const real_t mass) :
       TunableKernel3D(g, fineColor*fineColor, 2),
       Y(Y),
       X(X),
@@ -69,9 +69,9 @@ namespace quda {
 
       // reset scales as appropriate
       if constexpr (sizeof(Float) < QUDA_SINGLE_PRECISION) {
-        double max_scale = g.abs_max();
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Global U_max = %e\n", max_scale);
-        X.Scale(max_scale > 2.0*mass ? max_scale : 2.0*mass);
+        auto max_scale = g.abs_max();
+        logQuda(QUDA_VERBOSE, "Global U_max = %e\n", double(max_scale));
+        X.Scale(max_scale > 2.0 * mass ? max_scale : 2.0 * mass);
         Y.Scale(max_scale);
       }
 
@@ -79,12 +79,10 @@ namespace quda {
 
       apply(device::get_default_stream());
 
-        if (getVerbosity() >= QUDA_VERBOSE) {
-        for (int d = 0; d < nDim; d++) printfQuda("Y2[%d] = %e\n", 4+d, Y.norm2( 4+d ));
-        for (int d = 0; d < nDim; d++) printfQuda("Y2[%d] = %e\n", d, Y.norm2( d ));
-      }
+      for (int d = 0; d < nDim; d++) logQuda(QUDA_VERBOSE, "Y2[%d] = %e\n", 4+d, double(Y.norm2( 4+d )));
+      for (int d = 0; d < nDim; d++) logQuda(QUDA_VERBOSE, "Y2[%d] = %e\n", d, double(Y.norm2( d )));
 
-      if (getVerbosity() >= QUDA_VERBOSE) printfQuda("X2 = %e\n", X.norm2(0));
+      logQuda(QUDA_VERBOSE, "X2 = %e\n", double(X.norm2(0)));
     }
 
     void apply(const qudaStream_t &stream)
@@ -108,7 +106,7 @@ namespace quda {
   template <typename Float, typename vFloat, int fineColor, int fineSpin, int coarseColor, int coarseSpin, int uvSpin>
   void aggregateStaggeredY(GaugeField &Y, GaugeField &X,
                         const Transfer &T, const GaugeField &g, const GaugeField &l, const GaugeField &XinvKD,
-                        double mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
+                        real_t mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
   {
     // Actually create the temporaries like UV, etc.
     auto location = Y.Location();
@@ -142,9 +140,9 @@ namespace quda {
 
     // Moving along to the build
 
-    const double kappa = -1.; // cancels a minus sign factor for kappa w/in the dslash application
-    const double mu_dummy = 0.; 
-    const double mu_factor_dummy = 0.;
+    const real_t kappa = -1.; // cancels a minus sign factor for kappa w/in the dslash application
+    const real_t mu_dummy = 0.; 
+    const real_t mu_factor_dummy = 0.;
     constexpr bool use_mma = false;
     
     bool need_bidirectional = false;
@@ -234,7 +232,7 @@ namespace quda {
   // template on UV spin, which can be 1 for the non-KD ops but needs to be 2 for the KD op
   template <typename Float, typename vFloat, int fineColor, int fineSpin, int coarseColor, int coarseSpin>
   void aggregateStaggeredY(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &g, const GaugeField &l,
-                           const GaugeField &XinvKD, double mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
+                           const GaugeField &XinvKD, real_t mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
   {
     if (dirac == QUDA_STAGGERED_DIRAC || dirac == QUDA_STAGGEREDPC_DIRAC || dirac == QUDA_ASQTAD_DIRAC || dirac == QUDA_ASQTADPC_DIRAC) {
       // uvSpin == 1
@@ -251,7 +249,7 @@ namespace quda {
   // and actual aggregation
   template <typename Float, typename vFloat, int fineColor, int coarseColor>
   void calculateStaggeredY(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &g, const GaugeField &l,
-                           const GaugeField &XinvKD, double mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
+                           const GaugeField &XinvKD, real_t mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
   {
     if (T.Vectors(X.Location()).Nspin() != 1) errorQuda("Unsupported number of spins %d", T.Vectors(X.Location()).Nspin());
     constexpr int fineSpin = 1;
@@ -273,7 +271,7 @@ namespace quda {
 
   template <int fineColor, int coarseColor>
   void calculateStaggeredY(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &g, const GaugeField &l,
-                           const GaugeField &XinvKD, double mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
+                           const GaugeField &XinvKD, real_t mass, bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
   {
     if constexpr (is_enabled_multigrid() && is_enabled_spin(1)) {
       logQuda(QUDA_SUMMARIZE, "Computing Y field......\n");
@@ -307,7 +305,7 @@ namespace quda {
 
   template <>
   void StaggeredCoarseOp<fineColor, coarseColor>(GaugeField &Y, GaugeField &X, const Transfer &T, const GaugeField &gauge,
-                                                 const GaugeField &longGauge, const GaugeField &XinvKD, double mass,
+                                                 const GaugeField &longGauge, const GaugeField &XinvKD, real_t mass,
                                                  bool allow_truncation, QudaDiracType dirac, QudaMatPCType matpc)
   {
     QudaPrecision precision = checkPrecision(T.Vectors(X.Location()), X, Y);
diff --git a/lib/staggered_kd_build_xinv.cu b/lib/staggered_kd_build_xinv.cu
index b1195d9f4e..b99020da4a 100644
--- a/lib/staggered_kd_build_xinv.cu
+++ b/lib/staggered_kd_build_xinv.cu
@@ -14,7 +14,7 @@ namespace quda {
 
     GaugeField &X;
     const GaugeField &g;
-    double mass;
+    real_t mass;
 
     const int nDim = 4;
 
@@ -35,7 +35,7 @@ namespace quda {
     unsigned int minThreads() const { return g.VolumeCB(); }
 
   public:
-    CalculateStaggeredKDBlock(const GaugeField &g, GaugeField &X, double mass) :
+    CalculateStaggeredKDBlock(const GaugeField &g, GaugeField &X, real_t mass) :
       TunableKernel3D(g, fineColor*fineColor, 2),
       X(X),
       g(g),
@@ -57,8 +57,8 @@ namespace quda {
 
       // reset scales as appropriate
       if constexpr (sizeof(Float) < QUDA_SINGLE_PRECISION) {
-        double max_scale = g.abs_max();
-        if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Global U_max = %e\n", max_scale);
+        auto max_scale = g.abs_max();
+        logQuda(QUDA_VERBOSE, "Global U_max = %e\n", double(max_scale));
         X.Scale(max_scale > 2.0*mass ? max_scale : 2.0*mass);
       }
 
@@ -92,14 +92,14 @@ namespace quda {
      @param g[in] fine gauge field (fat links for asqtad)
      @param mass[in] Mass of staggered fermion
    */
-  void calculateStaggeredKDBlock(GaugeField &X, const GaugeField &g, const double mass)
+  void calculateStaggeredKDBlock(GaugeField &X, const GaugeField &g, const real_t mass)
   {
     // Instantiate based on precision, number of colors
     // need to swizzle `g` to the first argument to get the right fine nColor
     instantiate<CalculateStaggeredKDBlock>(g, X, mass);
   }
 #else
-  void calculateStaggeredKDBlock(GaugeField &, const GaugeField &, const double)
+  void calculateStaggeredKDBlock(GaugeField &, const GaugeField &, const real_t)
   {
     errorQuda("Staggered fermion multigrid support has not been built");
   }
@@ -113,7 +113,7 @@ namespace quda {
      @param mass[in] Mass of staggered fermion
      @param dagger_approximation[in] Whether or not to use the dagger approximation, using the dagger of X instead of Xinv
    */
-  void BuildStaggeredKahlerDiracInverse(GaugeField &Xinv, const GaugeField &gauge, const double mass, const bool dagger_approximation)
+  void BuildStaggeredKahlerDiracInverse(GaugeField &Xinv, const GaugeField &gauge, const real_t mass, const bool dagger_approximation)
   {
     using namespace blas_lapack;
     auto invert = use_native() ? native::BatchInvertMatrix : generic::BatchInvertMatrix;
@@ -215,11 +215,11 @@ namespace quda {
     GaugeField& X = *tmp_X;
 
     // Step 4: Calculate X from U
-    if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Computing the KD block on the %s\n", location == QUDA_CUDA_FIELD_LOCATION ? "GPU" : "CPU");
+    logQuda(QUDA_VERBOSE, "Computing the KD block on the %s\n", location == QUDA_CUDA_FIELD_LOCATION ? "GPU" : "CPU");
 
     calculateStaggeredKDBlock(X, U, mass);
 
-    if (getVerbosity() >= QUDA_VERBOSE) printfQuda("X2 = %e\n", X.norm2(0));
+    logQuda(QUDA_VERBOSE, "X2 = %e\n", double(X.norm2(0)));
 
     // Step 5: Calculate Xinv
     if (dagger_approximation) {
@@ -244,7 +244,7 @@ namespace quda {
         blas::flops += invert(xInvMilcOrder->data(), X.data(), n, X.Volume(), X.Precision(), X.Location());
       }
 
-      if (getVerbosity() >= QUDA_VERBOSE) printfQuda("xInvMilcOrder = %e\n", xInvMilcOrder->norm2(0));
+      logQuda(QUDA_VERBOSE, "xInvMilcOrder = %e\n", double(xInvMilcOrder->norm2(0)));
 
     }
 
@@ -252,15 +252,13 @@ namespace quda {
     // last two parameters: dagger approximation, mass (which becomes a scale in the dagger approx)
     ReorderStaggeredKahlerDiracInverse(Xinv, *xInvMilcOrder, dagger_approximation, mass);
 
-    if (getVerbosity() >= QUDA_VERBOSE) {
-      if (dagger_approximation) printfQuda("Using the dagger approximation to Xinv\n");
-      printfQuda("xInvKdGeometry = %e\n", Xinv.norm2());
-    }
+    if (dagger_approximation) logQuda(QUDA_VERBOSE, "Using the dagger approximation to Xinv\n");
+    logQuda(QUDA_VERBOSE, "xInvKdGeometry = %e\n", double(Xinv.norm2()));
   }
 
 
   // Allocates and calculates the inverse KD block, returning Xinv
-  std::shared_ptr<GaugeField> AllocateAndBuildStaggeredKahlerDiracInverse(const GaugeField &gauge, const double mass, const bool dagger_approximation)
+  std::shared_ptr<GaugeField> AllocateAndBuildStaggeredKahlerDiracInverse(const GaugeField &gauge, const real_t mass, const bool dagger_approximation)
   {
     GaugeFieldParam gParam(gauge);
     gParam.reconstruct = QUDA_RECONSTRUCT_NO;
diff --git a/lib/staggered_kd_reorder_xinv.cu b/lib/staggered_kd_reorder_xinv.cu
index e2bc332375..f1570a2588 100644
--- a/lib/staggered_kd_reorder_xinv.cu
+++ b/lib/staggered_kd_reorder_xinv.cu
@@ -14,7 +14,7 @@ namespace quda {
 
     GaugeField &fineXinv;
     const GaugeField &coarseXinv;
-    double scale;
+    real_t scale;
 
     long long flops() const {
       if (dagger_approximation) {
@@ -36,7 +36,7 @@ namespace quda {
     unsigned int minThreads() const { return fineXinv.VolumeCB(); }
 
   public:
-    CalculateStaggeredGeometryReorder(GaugeField& fineXinv, const GaugeField& coarseXinv, const double scale) :
+    CalculateStaggeredGeometryReorder(GaugeField& fineXinv, const GaugeField& coarseXinv, const real_t scale) :
       TunableKernel3D(fineXinv, QUDA_KDINVERSE_GEOMETRY, 2),
       fineXinv(fineXinv),
       coarseXinv(coarseXinv),
@@ -78,24 +78,24 @@ namespace quda {
 
   template<typename Float, int fineColor>
   struct calculateStaggeredGeometryReorder {
-    calculateStaggeredGeometryReorder(GaugeField &fineXinv, const GaugeField &coarseXinv, const bool dagger_approximation, const double mass) {
+    calculateStaggeredGeometryReorder(GaugeField &fineXinv, const GaugeField &coarseXinv, const bool dagger_approximation, const real_t mass) {
       // template on dagger approximation
       if (dagger_approximation)  {
         // Approximate the inverse with the dagger, multiplied by a rescale factor which
         // makes the norm of the dagger max equal the norm of the inverse in the free field
-        double xinv_max_abs = coarseXinv.abs_max(0);
-        double scale = 1. / (4. * (xinv_max_abs * xinv_max_abs + mass * mass));
+        auto xinv_max_abs = coarseXinv.abs_max(0);
+        auto scale = 1. / (4. * (xinv_max_abs * xinv_max_abs + mass * mass));
 
         // reset scales as appropriate
         if constexpr (sizeof(Float) < QUDA_SINGLE_PRECISION) {
-          double max_scale = xinv_max_abs * scale;
-          if (getVerbosity() >= QUDA_VERBOSE) printfQuda("Global xInv_max = %e\n", max_scale);
+          auto max_scale = xinv_max_abs * scale;
+          logQuda(QUDA_VERBOSE, "Global xInv_max = %e\n", double(max_scale));
 
           fineXinv.Scale(max_scale);
         }
         CalculateStaggeredGeometryReorder<Float,fineColor,true>(fineXinv, coarseXinv, scale);
       } else {
-        double scale = 1.;
+        real_t scale = 1.;
         CalculateStaggeredGeometryReorder<Float,fineColor,false>(fineXinv, coarseXinv, scale);
       }
     }
@@ -110,12 +110,12 @@ namespace quda {
      @param dagger_approximation[in] Whether or not to apply the dagger approximation
      @param mass[in] Mass of staggered fermion (used for dagger approximation only)
    */
-  void ReorderStaggeredKahlerDiracInverse(GaugeField &fineXinv, const GaugeField &coarseXinv, const bool dagger_approximation, const double mass) {
+  void ReorderStaggeredKahlerDiracInverse(GaugeField &fineXinv, const GaugeField &coarseXinv, const bool dagger_approximation, const real_t mass) {
     // Instantiate based on precision, number of colors
     instantiate<calculateStaggeredGeometryReorder>(fineXinv, coarseXinv, dagger_approximation, mass);
   }
 #else
-  void ReorderStaggeredKahlerDiracInverse(GaugeField &, const GaugeField &, const bool, const double) {
+  void ReorderStaggeredKahlerDiracInverse(GaugeField &, const GaugeField &, const bool, const real_t) {
     errorQuda("Staggered fermion support has not been built");
   }
 #endif
diff --git a/lib/transform_reduce.cu b/lib/transform_reduce.cu
index 9a4ab393df..73b732a27d 100644
--- a/lib/transform_reduce.cu
+++ b/lib/transform_reduce.cu
@@ -57,7 +57,7 @@ namespace quda
   template <typename reducer, typename T, typename count_t, typename transformer>
   typename reducer::reduce_t transform_reduce(QudaFieldLocation location, const T *v, count_t n_items, transformer h)
   {
-    std::vector<typename reducer::reduce_t> result = {0.0};
+    std::vector<typename reducer::reduce_t> result = {};
     std::vector<const T *> v_ = {v};
     transform_reduce<reducer>(location, result, v_, n_items, h, identity());
     return result[0];
@@ -72,7 +72,7 @@ namespace quda
   template <typename reducer, typename T, typename count_t>
   typename reducer::reduce_t reduce(QudaFieldLocation location, const T *v, count_t n_items)
   {
-    std::vector<typename reducer::reduce_t> result = {0.0};
+    std::vector<typename reducer::reduce_t> result = {};
     std::vector<const T *> v_ = {v};
     transform_reduce<reducer>(location, result, v_, n_items, identity());
     return result[0];
@@ -80,48 +80,48 @@ namespace quda
 
   // explicit instantiation list for transform_reduce
   // abs
-  template void transform_reduce<plus<double>, complex<double>, unsigned int, abs_<double, double>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<double> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<double>, unsigned int, abs_<double, double>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<double> *> const &, unsigned int,
     abs_<double, double>, identity);
-  template void transform_reduce<plus<double>, complex<float>, unsigned int, abs_<double, float>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<float> *> const &, unsigned int, abs_<double, float>,
+  template void transform_reduce<plus<device_reduce_t>, complex<float>, unsigned int, abs_<double, float>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<float> *> const &, unsigned int, abs_<double, float>,
     identity);
-  template void transform_reduce<plus<double>, complex<int>, unsigned int, abs_<double, int>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<int> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<int>, unsigned int, abs_<double, int>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<int> *> const &, unsigned int,
     abs_<double, int>, identity);
-  template void transform_reduce<plus<double>, complex<short>, unsigned int, abs_<double, short>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<short> *> const &, unsigned int, abs_<double, short>,
+  template void transform_reduce<plus<device_reduce_t>, complex<short>, unsigned int, abs_<double, short>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<short> *> const &, unsigned int, abs_<double, short>,
     identity);
-  template void transform_reduce<plus<double>, complex<signed char>, unsigned int, abs_<double, signed char>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<signed char> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<signed char>, unsigned int, abs_<double, signed char>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<signed char> *> const &, unsigned int,
     abs_<double, signed char>, identity);
-  template double transform_reduce<plus<double>, complex<double>, unsigned long, abs_<double, double>>(
+  template device_reduce_t transform_reduce<plus<device_reduce_t>, complex<double>, unsigned long, abs_<double, double>>(
     QudaFieldLocation, complex<double> const *, unsigned long, abs_<double, double>);
-  template double transform_reduce<plus<double>, complex<float>, unsigned long, abs_<double, float>>(
+  template device_reduce_t transform_reduce<plus<device_reduce_t>, complex<float>, unsigned long, abs_<double, float>>(
     QudaFieldLocation, complex<float> const *, unsigned long, abs_<double, float>);
   // square
-  template void transform_reduce<plus<double>, complex<double>, unsigned int, square_<double, double>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<double> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<double>, unsigned int, square_<double, double>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<double> *> const &, unsigned int,
     square_<double, double>, identity);
-  template void transform_reduce<plus<double>, complex<float>, unsigned int, square_<double, float>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<float> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<float>, unsigned int, square_<double, float>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<float> *> const &, unsigned int,
     square_<double, float>, identity);
-  template void transform_reduce<plus<double>, complex<int>, unsigned int, square_<double, int>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<int> *> const &, unsigned int, square_<double, int>,
+  template void transform_reduce<plus<device_reduce_t>, complex<int>, unsigned int, square_<double, int>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<int> *> const &, unsigned int, square_<double, int>,
     identity);
-  template void transform_reduce<plus<double>, complex<signed char>, unsigned int, square_<double, signed char>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<signed char> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<signed char>, unsigned int, square_<double, signed char>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<signed char> *> const &, unsigned int,
     square_<double, signed char>, identity);
-  template void transform_reduce<plus<double>, complex<short>, unsigned int, square_<double, short>, identity>(
-    QudaFieldLocation, std::vector<double> &, std::vector<complex<short> *> const &, unsigned int,
+  template void transform_reduce<plus<device_reduce_t>, complex<short>, unsigned int, square_<double, short>, identity>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<complex<short> *> const &, unsigned int,
     square_<double, short>, identity);
-  template double transform_reduce<plus<double>, complex<double>, unsigned long, square_<double, double>>(
+  template device_reduce_t transform_reduce<plus<device_reduce_t>, complex<double>, unsigned long, square_<double, double>>(
     QudaFieldLocation, complex<double> const *, unsigned long, square_<double, double>);
-  template double transform_reduce<plus<double>, complex<float>, unsigned long, square_<double, float>>(
+  template device_reduce_t transform_reduce<plus<device_reduce_t>, complex<float>, unsigned long, square_<double, float>>(
     QudaFieldLocation, complex<float> const *, unsigned long, square_<double, float>);
-  template double transform_reduce<plus<double>, complex<float>, unsigned int, square_<double, float>>(
+  template device_reduce_t transform_reduce<plus<device_reduce_t>, complex<float>, unsigned int, square_<double, float>>(
     QudaFieldLocation, complex<float> const *, unsigned int, square_<double, float>);
-  template double transform_reduce<plus<double>, complex<short>, unsigned int, square_<double, short>>(
+  template device_reduce_t transform_reduce<plus<device_reduce_t>, complex<short>, unsigned int, square_<double, short>>(
     QudaFieldLocation, complex<short> const *, unsigned int, square_<double, short>);
   // abs_max
   template void transform_reduce<maximum<double>, complex<double>, unsigned int, abs_max_<double, double>, identity>(
@@ -174,36 +174,36 @@ namespace quda
   template float transform_reduce<minimum<float>, complex<float>, unsigned long, abs_min_<float, float>>(
     QudaFieldLocation, complex<float> const *, unsigned long, abs_min_<float, float>);
 
-  template void quda::transform_reduce<plus<double>, complex<double>, unsigned int, square_<double, double>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<double> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<double>, unsigned int, square_<double, double>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<double> *> const &, unsigned int,
     square_<double, double>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<float>, unsigned int, square_<double, float>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<float> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<float>, unsigned int, square_<double, float>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<float> *> const &, unsigned int,
     square_<double, float>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<int>, unsigned int, square_<double, int>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<int> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<int>, unsigned int, square_<double, int>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<int> *> const &, unsigned int,
     square_<double, int>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<short>, unsigned int, square_<double, short>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<short> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<short>, unsigned int, square_<double, short>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<short> *> const &, unsigned int,
     square_<double, short>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<int8_t>, unsigned int, square_<double, int8_t>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<int8_t> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<int8_t>, unsigned int, square_<double, int8_t>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<int8_t> *> const &, unsigned int,
     square_<double, int8_t>, milc_mapper);
 
-  template void quda::transform_reduce<plus<double>, complex<double>, unsigned int, abs_<double, double>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<double> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<double>, unsigned int, abs_<double, double>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<double> *> const &, unsigned int,
     abs_<double, double>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<float>, unsigned int, abs_<double, float>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<float> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<float>, unsigned int, abs_<double, float>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<float> *> const &, unsigned int,
     abs_<double, float>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<int>, unsigned int, abs_<double, int>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<int> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<int>, unsigned int, abs_<double, int>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<int> *> const &, unsigned int,
     abs_<double, int>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<short>, unsigned int, abs_<double, short>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<short> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<short>, unsigned int, abs_<double, short>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<short> *> const &, unsigned int,
     abs_<double, short>, milc_mapper);
-  template void quda::transform_reduce<plus<double>, complex<int8_t>, unsigned int, abs_<double, int8_t>, milc_mapper>(
-    QudaFieldLocation, std::vector<double> &, std::vector<quda::complex<int8_t> *> const &, unsigned int,
+  template void quda::transform_reduce<plus<device_reduce_t>, complex<int8_t>, unsigned int, abs_<double, int8_t>, milc_mapper>(
+    QudaFieldLocation, std::vector<device_reduce_t> &, std::vector<quda::complex<int8_t> *> const &, unsigned int,
     abs_<double, int8_t>, milc_mapper);
 
   template void
diff --git a/lib/unitarize_links_quda.cu b/lib/unitarize_links_quda.cu
index 83ea615c48..155a96cf98 100644
--- a/lib/unitarize_links_quda.cu
+++ b/lib/unitarize_links_quda.cu
@@ -73,7 +73,7 @@ namespace quda {
   }
 
   // CPU function which checks that the gauge field is unitary
-  bool isUnitary(const GaugeField& field, double max_error)
+  bool isUnitary(const GaugeField& field, real_t max_error)
   {
     if (field.Location() != QUDA_CPU_FIELD_LOCATION) errorQuda("Location must be CPU");
     Matrix<complex<double>,3> link, identity;
@@ -87,7 +87,7 @@ namespace quda {
         } else {
 	  errorQuda("Unsupported precision\n");
 	}
-	if (link.isUnitary(max_error) == false) {
+	if (link.isUnitary(double(max_error)) == false) {
 	  printf("Unitarity failure\n");
 	  printf("site index = %u,\t direction = %d\n", i, dir);
 	  printLink(link);
@@ -157,7 +157,7 @@ namespace quda {
     unsigned int minThreads() const { return u.VolumeCB(); }
 
   public:
-    ProjectSU3(GaugeField &u, double tol, int *fails) :
+    ProjectSU3(GaugeField &u, real_t tol, int *fails) :
       TunableKernel3D(u, 2, 4),
       u(u),
       tol(tol),
@@ -182,7 +182,7 @@ namespace quda {
     long long bytes() const { return 2 * u.Bytes(); }
   };
 
-  void projectSU3(GaugeField &u, double tol, int *fails)
+  void projectSU3(GaugeField &u, real_t tol, int *fails)
   {
     getProfile().TPSTART(QUDA_PROFILE_COMPUTE);
     // check the the field doesn't have staggered phases applied
diff --git a/tests/blas_test.cpp b/tests/blas_test.cpp
index 713ffb5d0a..a23158e6aa 100644
--- a/tests/blas_test.cpp
+++ b/tests/blas_test.cpp
@@ -298,7 +298,6 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
     for (int i = 0; i < Msrc; i++) { ymH[i].Source(QUDA_RANDOM_SOURCE, 0, 0, 0); }
     // Now set the parameters for the device fields
 
-    if (param.nSpin == 4) param.gammaBasis = QUDA_UKQCD_GAMMA_BASIS;
     param.create = QUDA_ZERO_FIELD_CREATE;
 
     QudaPrecision prec = prec_pair.first;
@@ -346,17 +345,17 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
 protected:
   double benchmark(Kernel kernel, const int niter)
   {
-    double a = 1.0, b = 2.0, c = 3.0;
-    quda::Complex a2, b2;
-    std::vector<quda::Complex> A(Nsrc * Msrc);
-    std::vector<quda::Complex> B(Nsrc * Msrc);
-    std::vector<quda::Complex> C(Nsrc * Msrc);
-    std::vector<quda::Complex> A2(Nsrc * Nsrc); // for the block cDotProductNorm test
-    std::vector<double> Ar(Nsrc * Msrc);
-    std::vector<double> A2r(Nsrc * Nsrc);
-    std::vector<double> A1r(Nsrc);
-    std::vector<double> B1r(Nsrc);
-    std::vector<double> C1r(Nsrc);
+    quda::real_t a = 1.0, b = 2.0, c = 3.0;
+    quda::complex_t a2, b2;
+    std::vector<quda::complex_t> A(Nsrc * Msrc);
+    std::vector<quda::complex_t> B(Nsrc * Msrc);
+    std::vector<quda::complex_t> C(Nsrc * Msrc);
+    std::vector<quda::complex_t> A2(Nsrc * Nsrc); // for the block cDotProductNorm test
+    std::vector<quda::real_t> Ar(Nsrc * Msrc);
+    std::vector<quda::real_t> A2r(Nsrc * Nsrc);
+    std::vector<quda::real_t> A1r(Nsrc);
+    std::vector<quda::real_t> B1r(Nsrc);
+    std::vector<quda::real_t> C1r(Nsrc);
 
     device_timer_t timer;
     timer.start();
@@ -538,39 +537,39 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
     return timer.last();
   }
 
-#define ERROR(a) fabs(blas::norm2(a##D) - blas::norm2(a##H)) / blas::norm2(a##H)
+#define ERROR(a) abs(blas::norm2(a##D) - blas::norm2(a##H)) / blas::norm2(a##H)
 
-  double test(Kernel kernel)
+  quda::real_t test(Kernel kernel)
   {
     // all host fields are double precision, so the "other" fields just alias the regular fields
     ColorSpinorField &yoH = yH;
     ColorSpinorField &zoH = zH;
 
-    double a = M_PI, b = M_PI * exp(1.0), c = sqrt(M_PI);
-    quda::Complex a2(a, b), b2(b, -c), c2(a + b, c * a);
-    double error = 0;
-    std::vector<quda::Complex> A(Nsrc * Msrc);
-    std::vector<quda::Complex> B(Nsrc * Msrc);
-    std::vector<quda::Complex> C(Nsrc * Msrc);
-    std::vector<double> Ar(Nsrc * Msrc);
-    std::vector<double> Br(Nsrc * Msrc);
-    std::vector<double> Cr(Nsrc * Msrc);
+    quda::real_t  a = M_PI, b = M_PI * exp(1.0), c = sqrt(M_PI);
+    quda::complex_t a2(a, b), b2(b, -c), c2(a + b, c * a);
+    quda::real_t error = 0;
+    std::vector<quda::complex_t> A(Nsrc * Msrc);
+    std::vector<quda::complex_t> B(Nsrc * Msrc);
+    std::vector<quda::complex_t> C(Nsrc * Msrc);
+    std::vector<quda::real_t> Ar(Nsrc * Msrc);
+    std::vector<quda::real_t> Br(Nsrc * Msrc);
+    std::vector<quda::real_t> Cr(Nsrc * Msrc);
 
     // for norm multi-reduce tests
-    std::vector<quda::Complex> A2(Nsrc * Nsrc);
-    std::vector<quda::Complex> B2(Nsrc * Nsrc);
-    std::vector<double> A2r(Nsrc * Nsrc);
-    std::vector<double> B2r(Nsrc * Nsrc);
+    std::vector<quda::complex_t> A2(Nsrc * Nsrc);
+    std::vector<quda::complex_t> B2(Nsrc * Nsrc);
+    std::vector<quda::real_t> A2r(Nsrc * Nsrc);
+    std::vector<quda::real_t> B2r(Nsrc * Nsrc);
 
     // for 1-d multi-blas
-    std::vector<double> A1r(Nsrc);
-    std::vector<double> B1r(Nsrc);
-    std::vector<double> C1r(Nsrc);
+    std::vector<quda::real_t> A1r(Nsrc);
+    std::vector<quda::real_t> B1r(Nsrc);
+    std::vector<quda::real_t> C1r(Nsrc);
 
     for (int i = 0; i < Nsrc * Msrc; i++) {
-      A[i] = a2 * (1.0 * ((i / (double)Nsrc) + i)) + b2 * (1.0 * i) + c2 * (1.0 * (0.5 * Nsrc * Msrc - i));
-      B[i] = a2 * (1.0 * ((i / (double)Nsrc) + i)) - b2 * (M_PI * i) + c2 * (1.0 * (0.5 * Nsrc * Msrc - i));
-      C[i] = a2 * (1.0 * ((M_PI / (double)Nsrc) + i)) + b2 * (1.0 * i) + c2 * (1.0 * (0.5 * Nsrc * Msrc - i));
+      A[i] = a2 * complex_t(1.0 * ((i / (double)Nsrc) + i)) + b2 * complex_t(1.0 * i) + c2 * complex_t(1.0 * (0.5 * Nsrc * Msrc - i));
+      B[i] = a2 * complex_t(1.0 * ((i / (double)Nsrc) + i)) - b2 * complex_t(M_PI * i) + c2 * complex_t(1.0 * (0.5 * Nsrc * Msrc - i));
+      C[i] = a2 * complex_t(1.0 * ((M_PI / (double)Nsrc) + i)) + b2 * complex_t(1.0 * i) + c2 * complex_t(1.0 * (0.5 * Nsrc * Msrc - i));
       Ar[i] = A[i].real();
       Br[i] = B[i].real();
       Cr[i] = C[i].real();
@@ -653,7 +652,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       zD = zH;
       blas::axpyBzpcx(a, xD, yoD, b, zD, c);
       blas::axpyBzpcx(a, xH, yH, b, zH, c);
-      error = ERROR(x) + ERROR(yo);
+      error = std::max(ERROR(x), ERROR(yo));
       break;
 
     case Kernel::axpyZpbx:
@@ -662,7 +661,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       zD = zH;
       blas::axpyZpbx(a, xD, yoD, zD, b);
       blas::axpyZpbx(a, xH, yH, zH, b);
-      error = ERROR(x) + ERROR(yo);
+      error = std::max(ERROR(x), ERROR(yo));
       break;
 
     case Kernel::caxpbypzYmbw:
@@ -672,7 +671,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       wD = wH;
       blas::caxpbypzYmbw(a2, xD, b2, yD, zD, wD);
       blas::caxpbypzYmbw(a2, xH, b2, yH, zH, wH);
-      error = ERROR(z) + ERROR(y);
+      error = std::max(ERROR(z), ERROR(y));
       break;
 
     case Kernel::cabxpyAx:
@@ -680,7 +679,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       yD = yH;
       blas::cabxpyAx(a, b2, xD, yD);
       blas::cabxpyAx(a, b2, xH, yH);
-      error = ERROR(y) + ERROR(x);
+      error = std::max(ERROR(y), ERROR(x));
       break;
 
     case Kernel::caxpyXmaz:
@@ -690,28 +689,28 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       {
         blas::caxpyXmaz(a, xD, yD, zD);
         blas::caxpyXmaz(a, xH, yH, zH);
-        error = ERROR(y) + ERROR(x);
+        error = std::max(ERROR(y), ERROR(x));
       }
       break;
 
     case Kernel::norm2:
       xD = xH;
-      error = fabs(blas::norm2(xD) - blas::norm2(xH)) / blas::norm2(xH);
+      error = abs(blas::norm2(xD) - blas::norm2(xH)) / blas::norm2(xH);
       break;
 
     case Kernel::reDotProduct:
       xD = xH;
       yD = yH;
-      error = fabs(blas::reDotProduct(xD, yD) - blas::reDotProduct(xH, yH)) / fabs(blas::reDotProduct(xH, yH));
+      error = abs(blas::reDotProduct(xD, yD) - blas::reDotProduct(xH, yH)) / abs(blas::reDotProduct(xH, yH));
       break;
 
     case Kernel::axpbyzNorm:
       xD = xH;
       yD = yH;
       {
-        double d = blas::axpbyzNorm(a, xD, b, yD, zD);
-        double h = blas::axpbyzNorm(a, xH, b, yH, zH);
-        error = ERROR(z) + fabs(d - h) / fabs(h);
+        auto d = blas::axpbyzNorm(a, xD, b, yD, zD);
+        auto h = blas::axpbyzNorm(a, xH, b, yH, zH);
+        error = std::max(ERROR(z), abs(d - h) / abs(h));
       }
       break;
 
@@ -719,9 +718,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       xD = xH;
       yoD = yH;
       {
-        double2 d = blas::axpyCGNorm(a, xD, yoD);
-        double2 h = blas::axpyCGNorm(a, xH, yH);
-        error = ERROR(yo) + fabs(d.x - h.x) / fabs(h.x) + fabs(d.y - h.y) / fabs(h.y);
+        auto d = blas::axpyCGNorm(a, xD, yoD);
+        auto h = blas::axpyCGNorm(a, xH, yH);
+        error = std::max({ERROR(yo), abs(d[0] - h[0]) / abs(h[0]), abs(d[1] - h[1]) / abs(h[1])});
       }
       break;
 
@@ -729,9 +728,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       xD = xH;
       yD = yH;
       {
-        double d = blas::caxpyNorm(a, xD, yD);
-        double h = blas::caxpyNorm(a, xH, yH);
-        error = ERROR(y) + fabs(d - h) / fabs(h);
+        auto d = blas::caxpyNorm(a, xD, yD);
+        auto h = blas::caxpyNorm(a, xH, yH);
+        error = std::max(ERROR(y), abs(d - h) / abs(h));
       }
       break;
 
@@ -739,9 +738,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       xD = xH;
       yD = yH;
       {
-        double d = blas::cabxpyzAxNorm(a, b2, xD, yD, yD);
-        double h = blas::cabxpyzAxNorm(a, b2, xH, yH, yH);
-        error = ERROR(x) + ERROR(y) + fabs(d - h) / fabs(h);
+        auto d = blas::cabxpyzAxNorm(a, b2, xD, yD, yD);
+        auto h = blas::cabxpyzAxNorm(a, b2, xH, yH, yH);
+        error = std::max({ERROR(x), ERROR(y), abs(d - h) / abs(h)});
       }
       break;
 
@@ -756,9 +755,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       yD = yH;
       zD = zH;
       {
-        quda::Complex d = blas::caxpyDotzy(a, xD, yD, zD);
-        quda::Complex h = blas::caxpyDotzy(a, xH, yH, zH);
-        error = ERROR(y) + abs(d - h) / abs(h);
+        quda::complex_t d = blas::caxpyDotzy(a, xD, yD, zD);
+        quda::complex_t h = blas::caxpyDotzy(a, xH, yH, zH);
+        error = std::max(ERROR(y), abs(d - h) / abs(h));
       }
       break;
 
@@ -770,8 +769,8 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
         auto dot = blas::cDotProduct(xH, yH);
         auto x2 = blas::norm2(xH);
         auto y2 = blas::norm2(yH);
-        error = abs(Complex(d.x - dot.real(), d.y - dot.imag())) / abs(dot) + fabs(d.z - x2) / fabs(x2)
-          + fabs(d.w - y2) / fabs(y2);
+        error = std::max({abs(complex_t(d[0] - dot.real(), d[1] - dot.imag())) / abs(dot),
+            abs(d[2] - x2) / abs(x2), abs(d[3] - y2) / abs(y2)});
       }
       break;
 
@@ -782,10 +781,10 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       wD = wH;
       vD = vH;
       {
-        double3 d = blas::caxpbypzYmbwcDotProductUYNormY(a2, xD, b2, yD, zD, wD, vD);
-        double3 h = blas::caxpbypzYmbwcDotProductUYNormY(a2, xH, b2, yH, zH, wH, vH);
-        error = ERROR(z) + ERROR(y) + abs(Complex(d.x - h.x, d.y - h.y)) / abs(Complex(h.x, h.y))
-          + fabs(d.z - h.z) / fabs(h.z);
+        auto d = blas::caxpbypzYmbwcDotProductUYNormY(a2, xD, b2, yD, zD, wD, vD);
+        auto h = blas::caxpbypzYmbwcDotProductUYNormY(a2, xH, b2, yH, zH, wH, vH);
+        error = std::max({ERROR(z), ERROR(y), abs(complex_t(d[0] - h[0], d[1] - h[1])) / abs(complex_t(h[0], h[1])),
+            abs(d[2] - h[2]) / abs(h[2])});
       }
       break;
 
@@ -793,9 +792,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       xD = xH;
       yD = yH;
       {
-        double3 d = blas::HeavyQuarkResidualNorm(xD, yD);
-        double3 h = blas::HeavyQuarkResidualNorm(xH, yH);
-        error = fabs(d.x - h.x) / fabs(h.x) + fabs(d.y - h.y) / fabs(h.y) + fabs(d.z - h.z) / fabs(h.z);
+        auto d = blas::HeavyQuarkResidualNorm(xD, yD);
+        auto h = blas::HeavyQuarkResidualNorm(xH, yH);
+        error = std::max({abs(d[0] - h[0]) / abs(h[0]), abs(d[1] - h[1]) / abs(h[1]), abs(d[2] - h[2]) / abs(h[2])});
       }
       break;
 
@@ -804,9 +803,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       yD = yH;
       zD = zH;
       {
-        double3 d = blas::xpyHeavyQuarkResidualNorm(xD, yD, zD);
-        double3 h = blas::xpyHeavyQuarkResidualNorm(xH, yH, zH);
-        error = ERROR(y) + fabs(d.x - h.x) / fabs(h.x) + fabs(d.y - h.y) / fabs(h.y) + fabs(d.z - h.z) / fabs(h.z);
+        auto d = blas::xpyHeavyQuarkResidualNorm(xD, yD, zD);
+        auto h = blas::xpyHeavyQuarkResidualNorm(xH, yH, zH);
+        error = std::max({ERROR(y), abs(d[0] - h[0]) / abs(h[0]), abs(d[1] - h[1]) / abs(h[1]), abs(d[2] - h[2]) / abs(h[2])});
       }
       break;
 
@@ -815,9 +814,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       yD = yH;
       zD = zH;
       {
-        double3 d = blas::tripleCGReduction(xD, yD, zD);
-        double3 h = make_double3(blas::norm2(xH), blas::norm2(yH), blas::reDotProduct(yH, zH));
-        error = fabs(d.x - h.x) / fabs(h.x) + fabs(d.y - h.y) / fabs(h.y) + fabs(d.z - h.z) / fabs(h.z);
+        auto d = blas::tripleCGReduction(xD, yD, zD);
+        auto h = array<quda::real_t, 3>{blas::norm2(xH), blas::norm2(yH), blas::reDotProduct(yH, zH)};
+        error = std::max({abs(d[0] - h[0]) / abs(h[0]), abs(d[1] - h[1]) / abs(h[1]), abs(d[2] - h[2]) / abs(h[2])});
       }
       break;
 
@@ -829,7 +828,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       {
         blas::tripleCGUpdate(a, b, xD, yD, zD, wD);
         blas::tripleCGUpdate(a, b, xH, yH, zH, wH);
-        error = ERROR(y) + ERROR(z) + ERROR(w);
+        error = std::max({ERROR(y), ERROR(z), ERROR(w)});
       }
       break;
 
@@ -837,9 +836,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       xD = xH;
       yD = yH;
       {
-        double d = blas::axpyReDot(a, xD, yD);
-        double h = blas::axpyReDot(a, xH, yH);
-        error = ERROR(y) + fabs(d - h) / fabs(h);
+        auto d = blas::axpyReDot(a, xD, yD);
+        auto h = blas::axpyReDot(a, xH, yH);
+        error = std::max(ERROR(y), abs(d - h) / abs(h));
       }
       break;
 
@@ -850,7 +849,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       {
         blas::caxpyBxpz(a, xD, yD, b2, zD);
         blas::caxpyBxpz(a, xH, yH, b2, zH);
-        error = ERROR(x) + ERROR(z);
+        error = std::max(ERROR(x), ERROR(z));
       }
       break;
 
@@ -861,7 +860,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       {
         blas::caxpyBzpx(a, xD, yD, b2, zD);
         blas::caxpyBzpx(a, xH, yH, b2, zH);
-        error = ERROR(x) + ERROR(z);
+        error = std::max(ERROR(x), ERROR(z));
       }
       break;
 
@@ -876,9 +875,8 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
 
       error = 0;
       for (int i = 0; i < Msrc; i++) {
-        error += fabs(blas::norm2(ymoD[i]) - blas::norm2(ymH[i])) / blas::norm2(ymH[i]);
+        error = std::max(error, abs(blas::norm2(ymoD[i]) - blas::norm2(ymH[i])) / blas::norm2(ymH[i]));
       }
-      error /= Msrc;
       break;
 
     case Kernel::caxpy_block:
@@ -891,9 +889,8 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       }
       error = 0;
       for (int i = 0; i < Msrc; i++) {
-        error += fabs(blas::norm2((ymoD[i])) - blas::norm2(ymH[i])) / blas::norm2(ymH[i]);
+        error = std::max(error, abs(blas::norm2(ymoD[i]) - blas::norm2(ymH[i])) / blas::norm2(ymH[i]));
       }
-      error /= Msrc;
       break;
 
     case Kernel::axpyz_block:
@@ -907,9 +904,8 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       }
       error = 0;
       for (int i = 0; i < Msrc; i++) {
-        error += fabs(blas::norm2((wmD[i])) - blas::norm2(wmH[i])) / blas::norm2(wmH[i]);
+        error = std::max(error, abs(blas::norm2(wmD[i]) - blas::norm2(wmH[i])) / blas::norm2(wmH[i]));
       }
-      error /= Msrc;
       break;
 
     case Kernel::caxpyz_block:
@@ -923,9 +919,8 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       }
       error = 0;
       for (int i = 0; i < Msrc; i++) {
-        error += fabs(blas::norm2((wmD[i])) - blas::norm2(wmH[i])) / blas::norm2(wmH[i]);
+        error = std::max(error, abs(blas::norm2(wmD[i]) - blas::norm2(wmH[i])) / blas::norm2(wmH[i]));
       }
-      error /= Msrc;
       break;
 
     case Kernel::axpyBzpcx_block:
@@ -941,10 +936,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
 
       error = 0;
       for (int i = 0; i < Nsrc; i++) {
-        error += fabs(blas::norm2((xmD[i])) - blas::norm2(xmH[i])) / blas::norm2(xmH[i]);
-        error += fabs(blas::norm2((zmoD[i])) - blas::norm2(zmH[i])) / blas::norm2(zmH[i]);
+        error = std::max(error, abs(blas::norm2((xmD[i])) - blas::norm2(xmH[i])) / blas::norm2(xmH[i]));
+        error = std::max(error, abs(blas::norm2((zmoD[i])) - blas::norm2(zmH[i])) / blas::norm2(zmH[i]));
       }
-      error /= Nsrc;
       break;
 
     case Kernel::reDotProductNorm_block:
@@ -954,10 +948,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       for (int i = 0; i < Nsrc; i++) {
         for (int j = 0; j < Nsrc; j++) {
           B2r[i * Nsrc + j] = blas::reDotProduct(xmD[i], xmD[j]);
-          error += std::abs(A2[i * Nsrc + j] - B2[i * Nsrc + j]) / std::abs(B2r[i * Nsrc + j]);
+          error = std::max(error, abs(A2[i * Nsrc + j] - B2[i * Nsrc + j]) / abs(B2r[i * Nsrc + j]));
         }
       }
-      error /= Nsrc * Nsrc;
       break;
 
     case Kernel::reDotProduct_block:
@@ -969,10 +962,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       for (int i = 0; i < Nsrc; i++) {
         for (int j = 0; j < Msrc; j++) {
           Br[i * Msrc + j] = blas::reDotProduct(xmD[i], ymD[j]);
-          error += std::abs(Ar[i * Msrc + j] - Br[i * Msrc + j]) / std::abs(Br[i * Msrc + j]);
+          error = std::max(error, abs(Ar[i * Msrc + j] - Br[i * Msrc + j]) / abs(Br[i * Msrc + j]));
         }
       }
-      error /= Nsrc * Msrc;
       break;
 
     case Kernel::cDotProductNorm_block:
@@ -982,10 +974,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       for (int i = 0; i < Nsrc; i++) {
         for (int j = 0; j < Nsrc; j++) {
           B2[i * Nsrc + j] = blas::cDotProduct(xmD[i], xmD[j]);
-          error += std::abs(A2[i * Nsrc + j] - B2[i * Nsrc + j]) / std::abs(B2[i * Nsrc + j]);
+          error = std::max(error, abs(A2[i * Nsrc + j] - B2[i * Nsrc + j]) / abs(B2[i * Nsrc + j]));
         }
       }
-      error /= Nsrc * Nsrc;
       break;
 
     case Kernel::cDotProduct_block:
@@ -997,10 +988,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       for (int i = 0; i < Nsrc; i++) {
         for (int j = 0; j < Msrc; j++) {
           B[i * Msrc + j] = blas::cDotProduct(xmD[i], ymD[j]);
-          error += std::abs(A[i * Msrc + j] - B[i * Msrc + j]) / std::abs(B[i * Msrc + j]);
+          error = std::max(error, abs(A[i * Msrc + j] - B[i * Msrc + j]) / abs(B[i * Msrc + j]));
         }
       }
-      error /= Nsrc * Msrc;
       break;
 
     case Kernel::hDotProduct_block:
@@ -1010,10 +1000,9 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       error = 0.0;
       for (int i = 0; i < Nsrc; i++) {
         for (int j = 0; j < Nsrc; j++) {
-          error += std::abs(A2[i * Nsrc + j] - B2[i * Nsrc + j]) / std::abs(B2[i * Nsrc + j]);
+          error = std::max(error, abs(A2[i * Nsrc + j] - B2[i * Nsrc + j]) / abs(B2[i * Nsrc + j]));
         }
       }
-      error /= Nsrc * Nsrc;
       break;
 
     case Kernel::caxpyXmazMR:
@@ -1032,8 +1021,8 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
       wD = yH;
       zD = zH;
       {
-        double3 Ar3 = blas::cDotProductNormA(zD, vD);
-        auto alpha = Complex(Ar3.x, Ar3.y) / Ar3.z;
+        auto Ar3 = blas::cDotProductNormA(zD, vD);
+        auto alpha = complex_t(Ar3[0], Ar3[1]) / Ar3[2];
         blas::caxpyXmaz(a * alpha, vD, wD, zD);
       }
       xH = vD;
@@ -1041,7 +1030,7 @@ class BlasTest : public ::testing::TestWithParam<::testing::tuple<int, int>>
 
       commGlobalReductionPop(); // restore global reductions
 
-      error = ERROR(x) + ERROR(y);
+      error = std::max(ERROR(x), ERROR(y));
       break;
 
     default: errorQuda("Undefined blas kernel %s\n", kernel_map.at(kernel).c_str());
@@ -1126,20 +1115,20 @@ TEST_P(BlasTest, verify)
 
   // certain tests will fail to run for coarse grids so mark these as
   // failed without running
-  double deviation = test(kernel);
-  // printfQuda("%-35s error = %e\n", names[kernel], deviation);
-  double tol_x
+  auto deviation = test(kernel);
+  logQuda(QUDA_VERBOSE, "%-35s error = %e\n", kernel_map.at(kernel).c_str(), double(deviation));
+  auto tol_x
     = (prec_pair.first == QUDA_DOUBLE_PRECISION ?
          1e-12 :
          (prec_pair.first == QUDA_SINGLE_PRECISION ? 1e-6 : (prec_pair.first == QUDA_HALF_PRECISION ? 1e-4 : 1e-2)));
-  double tol_y
+  auto tol_y
     = (prec_pair.second == QUDA_DOUBLE_PRECISION ?
          1e-12 :
          (prec_pair.second == QUDA_SINGLE_PRECISION ? 1e-6 : (prec_pair.second == QUDA_HALF_PRECISION ? 1e-4 : 1e-2)));
-  double tol = std::max(tol_x, tol_y);
+  auto tol = std::max(tol_x, tol_y);
   tol = is_copy(kernel) ? 5e-2 : tol; // use different tolerance for copy
   EXPECT_LE(deviation, tol) << "CPU and CUDA implementations do not agree";
-  EXPECT_EQ(false, std::isnan(deviation)) << "Nan has propagated into the result";
+  EXPECT_EQ(false, isnan(deviation)) << "Nan has propagated into the result";
 }
 
 TEST_P(BlasTest, benchmark)
@@ -1156,10 +1145,10 @@ TEST_P(BlasTest, benchmark)
   quda::blas::flops = 0;
   quda::blas::bytes = 0;
 
-  double secs = benchmark(kernel, niter);
+  auto secs = benchmark(kernel, niter);
 
-  double gflops = (quda::blas::flops * 1e-9) / (secs);
-  double gbytes = quda::blas::bytes / (secs * 1e9);
+  auto gflops = (quda::blas::flops * 1e-9) / (secs);
+  auto gbytes = quda::blas::bytes / (secs * 1e9);
   RecordProperty("Gflops", std::to_string(gflops));
   RecordProperty("GBs", std::to_string(gbytes));
   printfQuda("%-31s: Gflop/s = %6.1f, GB/s = %6.1f\n", kernel_map.at(kernel).c_str(), gflops, gbytes);
diff --git a/tests/covdev_test.cpp b/tests/covdev_test.cpp
index d296a553af..525b7fffd0 100644
--- a/tests/covdev_test.cpp
+++ b/tests/covdev_test.cpp
@@ -115,9 +115,9 @@ void init(int argc, char **argv)
   printfQuda("Sending spinor field to GPU\n");
   *cudaSpinor = *spinor;
 
-  double spinor_norm2 = blas::norm2(*spinor);
-  double cuda_spinor_norm2 = blas::norm2(*cudaSpinor);
-  printfQuda("Source CPU = %f, CUDA=%f\n", spinor_norm2, cuda_spinor_norm2);
+  auto spinor_norm2 = blas::norm2(*spinor);
+  auto cuda_spinor_norm2 = blas::norm2(*cudaSpinor);
+  printfQuda("Source CPU = %f, CUDA=%f\n", double(spinor_norm2), double(cuda_spinor_norm2));
 
   csParam.siteSubset = QUDA_FULL_SITE_SUBSET;
   tmp = std::make_unique<ColorSpinorField>(csParam);
@@ -243,12 +243,12 @@ int main(int argc, char **argv)
           = niter * cudaSpinor->Nspin() * (8 * nColor - 2) * nColor * (long long)cudaSpinor->Volume();
         printfQuda("GFLOPS = %f\n", 1.0e-9 * flops / secs);
 
-        double spinor_ref_norm2 = blas::norm2(*spinorRef);
-        double spinor_out_norm2 = blas::norm2(*spinorOut);
+        auto spinor_ref_norm2 = blas::norm2(*spinorRef);
+        auto spinor_out_norm2 = blas::norm2(*spinorOut);
 
-        double cuda_spinor_out_norm2 = blas::norm2(*cudaSpinorOut);
-        printfQuda("Results mu = %d: CPU=%f, CUDA=%f, CPU-CUDA=%f\n", muCuda, spinor_ref_norm2, cuda_spinor_out_norm2,
-                   spinor_out_norm2);
+        auto cuda_spinor_out_norm2 = blas::norm2(*cudaSpinorOut);
+        printfQuda("Results mu = %d: CPU=%f, CUDA=%f, CPU-CUDA=%f\n", muCuda, double(spinor_ref_norm2), double(cuda_spinor_out_norm2),
+                   double(spinor_out_norm2));
 
         if (verify_results) {
           ::testing::TestEventListeners &listeners = ::testing::UnitTest::GetInstance()->listeners();
diff --git a/tests/dilution_test.cpp b/tests/dilution_test.cpp
index 9d7475d114..106f448fbe 100644
--- a/tests/dilution_test.cpp
+++ b/tests/dilution_test.cpp
@@ -67,7 +67,7 @@ TEST_P(DilutionTest, verify)
 
     param.create = QUDA_ZERO_FIELD_CREATE;
     ColorSpinorField sum(param);
-    blas::axpy(std::vector<double>(v.size(), 1.0), v, sum); // reassemble the vector
+    blas::axpy(std::vector<real_t>(v.size(), 1.0), v, sum); // reassemble the vector
 
     { // check its norm matches the original
       auto src2 = blas::norm2(src);
diff --git a/tests/dslash_test_utils.h b/tests/dslash_test_utils.h
index 8f01594579..76970ec500 100644
--- a/tests/dslash_test_utils.h
+++ b/tests/dslash_test_utils.h
@@ -304,9 +304,9 @@ struct DslashTestWrapper {
       printfQuda("Sending spinor field to GPU\n");
       cudaSpinor = spinor;
 
-      double cpu_norm = blas::norm2(spinor);
-      double cuda_norm = blas::norm2(cudaSpinor);
-      printfQuda("Source: CPU = %e, CUDA = %e\n", cpu_norm, cuda_norm);
+      auto cpu_norm = blas::norm2(spinor);
+      auto cuda_norm = blas::norm2(cudaSpinor);
+      printfQuda("Source: CPU = %e, CUDA = %e\n", double(cpu_norm), double(cuda_norm));
 
       bool pc = (dtest_type != dslash_test_type::Mat && dtest_type != dslash_test_type::MatDagMat);
 
@@ -316,8 +316,8 @@ struct DslashTestWrapper {
       dirac = Dirac::create(diracParam);
 
     } else {
-      double cpu_norm = blas::norm2(spinor);
-      printfQuda("Source: CPU = %e\n", cpu_norm);
+      auto cpu_norm = blas::norm2(spinor);
+      printfQuda("Source: CPU = %e\n", double(cpu_norm));
     }
   }
 
@@ -1040,8 +1040,8 @@ struct DslashTestWrapper {
         auto norm_cpu_quda = blas::norm2(vp_spinorOut[n]);
         auto max_deviation = blas::max_deviation(spinorRef, vp_spinorOut[n]);
 
-        printfQuda("Results: reference = %f, QUDA = %f, L2 relative deviation = %e, max deviation = %e\n", norm_cpu,
-                   norm_cpu_quda, 1.0 - sqrt(norm_cpu_quda / norm_cpu), max_deviation[0]);
+        printfQuda("Results: reference = %f, QUDA = %f, L2 relative deviation = %e, max deviation = %e\n", double(norm_cpu),
+                   double(norm_cpu_quda), double(real_t(1.0) - sqrt(norm_cpu_quda / norm_cpu)), double(max_deviation[0]));
         deviation = std::max(deviation, std::pow(10, -(double)(ColorSpinorField::Compare(spinorRef, vp_spinorOut[n]))));
       }
     } else {
@@ -1049,8 +1049,8 @@ struct DslashTestWrapper {
       auto norm_cpu_quda = blas::norm2(spinorOut);
       auto max_deviation = blas::max_deviation(spinorRef, spinorOut);
 
-      printfQuda("Results: reference = %f, QUDA = %f, L2 relative deviation = %e, max deviation = %e\n", norm_cpu,
-                 norm_cpu_quda, 1.0 - sqrt(norm_cpu_quda / norm_cpu), max_deviation[0]);
+      printfQuda("Results: reference = %f, QUDA = %f, L2 relative deviation = %e, max deviation = %e\n", double(norm_cpu),
+                 double(norm_cpu_quda), double(real_t(1.0) - sqrt(norm_cpu_quda / norm_cpu)), double(max_deviation[0]));
       deviation = std::pow(10, -(double)(ColorSpinorField::Compare(spinorRef, spinorOut)));
     }
     return deviation;
diff --git a/tests/gauge_alg_test.cpp b/tests/gauge_alg_test.cpp
index 00ba1f3689..c0a8da9bdd 100644
--- a/tests/gauge_alg_test.cpp
+++ b/tests/gauge_alg_test.cpp
@@ -40,7 +40,7 @@ class GaugeAlgTest : public ::testing::Test
   QudaGaugeParam param;
   Timer<false> a0, a1;
   GaugeField *U;
-  double3 plaq;
+  array<real_t, 3> plaq;
 
   void SetReunitarizationConsts()
   {
@@ -53,21 +53,21 @@ class GaugeAlgTest : public ::testing::Test
     setUnitarizeLinksConstants(unitarize_eps, max_error, reunit_allow_svd, reunit_svd_only, svd_rel_error, svd_abs_error);
   }
 
-  bool comparePlaquette(double3 a, double3 b)
+  bool comparePlaquette(array<real_t, 3> &a, array<real_t, 3> &b)
   {
-    auto a0 = std::abs(a.x - b.x);
-    auto a1 = std::abs(a.y - b.y);
-    auto a2 = std::abs(a.z - b.z);
-    double prec_val = 1.0e-5;
+    auto a0 = abs(a[0] - b[0]);
+    auto a1 = abs(a[1] - b[1]);
+    auto a2 = abs(a[2] - b[2]);
+    real_t prec_val = 1.0e-5;
     if (prec == QUDA_DOUBLE_PRECISION) prec_val = gf_tolerance * 1e2;
     return ((a0 < prec_val) && (a1 < prec_val) && (a2 < prec_val));
   }
 
-  bool CheckDeterminant(double2 detu)
+  bool CheckDeterminant(complex_t &detu)
   {
-    double prec_val = 5e-8;
+    real_t prec_val = 5e-8;
     if (prec == QUDA_DOUBLE_PRECISION) prec_val = gf_tolerance * 1e2;
-    return (std::abs(1.0 - detu.x) < prec_val && std::abs(detu.y) < prec_val);
+    return (abs(real_t(1.0) - detu.real()) < prec_val && abs(detu.imag()) < prec_val);
   }
 
   virtual void SetUp()
@@ -116,7 +116,7 @@ class GaugeAlgTest : public ::testing::Test
         int nhbsteps = heatbath_num_heatbath_per_step;
         int novrsteps = heatbath_num_overrelax_per_step;
         bool coldstart = heatbath_coldstart;
-        double beta_value = heatbath_beta_value;
+        real_t beta_value = heatbath_beta_value;
         a1.start();
 
         if (coldstart)
@@ -134,7 +134,7 @@ class GaugeAlgTest : public ::testing::Test
           qudaDeviceSynchronize();
           if (*num_failures_h > 0) errorQuda("Error in the unitarization (%d errors)", *num_failures_h);
           plaq = plaquette(*U);
-          printfQuda("Plaq: %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
+          printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
         }
 
         a1.stop();
@@ -178,7 +178,7 @@ class GaugeAlgTest : public ::testing::Test
         if (*num_failures_h > 0) errorQuda("Error in the unitarization (%d errors)", *num_failures_h);
 
         plaq = plaquette(*U);
-        printfQuda("Plaq: %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
+        printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
       }
 
       // If a specific test type is requested, perfrom it now and then
@@ -201,8 +201,8 @@ class GaugeAlgTest : public ::testing::Test
     if (execute) {
       auto detu = getLinkDeterminant(*U);
       auto tru = getLinkTrace(*U);
-      printfQuda("Det: %.16e:%.16e\n", detu.x, detu.y);
-      printfQuda("Tr: %.16e:%.16e\n", tru.x / 3.0, tru.y / 3.0);
+      printfQuda("Det: %.16e:%.16e\n", double(detu.real()), double(detu.imag()));
+      printfQuda("Tr: %.16e:%.16e\n", double(tru.real()) / 3.0, double(tru.imag()) / 3.0);
 
       delete U;
       // Release all temporary memory used for data exchange between GPUs in multi-GPU mode
@@ -221,8 +221,8 @@ class GaugeAlgTest : public ::testing::Test
       gaugeFixingOVR(*U, gf_gauge_dir, gf_maxiter, gf_verbosity_interval, gf_ovr_relaxation_boost, gf_tolerance,
                      gf_reunit_interval, gf_theta_condition);
       auto plaq_gf = plaquette(*U);
-      printfQuda("Plaq:    %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
-      printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", plaq_gf.x, plaq_gf.y, plaq_gf.z);
+      printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
+      printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", double(plaq_gf[0]), double(plaq_gf[1]), double(plaq_gf[2]));
       ASSERT_TRUE(comparePlaquette(plaq, plaq_gf));
       // Save if output string is specified
       if (gauge_store) save_gauge();
@@ -237,8 +237,8 @@ class GaugeAlgTest : public ::testing::Test
                        gf_theta_condition);
 
         auto plaq_gf = plaquette(*U);
-        printfQuda("Plaq:    %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
-        printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", plaq_gf.x, plaq_gf.y, plaq_gf.z);
+        printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
+        printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", double(plaq_gf[0]), double(plaq_gf[1]), double(plaq_gf[2]));
         ASSERT_TRUE(comparePlaquette(plaq, plaq_gf));
         // Save if output string is specified
         if (gauge_store) save_gauge();
@@ -295,8 +295,8 @@ TEST_F(GaugeAlgTest, Landau_Overrelaxation)
     gaugeFixingOVR(*U, 4, gf_maxiter, gf_verbosity_interval, gf_ovr_relaxation_boost, gf_tolerance, gf_reunit_interval,
                    gf_theta_condition);
     auto plaq_gf = plaquette(*U);
-    printfQuda("Plaq:    %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
-    printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", plaq_gf.x, plaq_gf.y, plaq_gf.z);
+    printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
+    printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", double(plaq_gf[0]), double(plaq_gf[1]), double(plaq_gf[2]));
     ASSERT_TRUE(comparePlaquette(plaq, plaq_gf));
   }
 }
@@ -308,8 +308,8 @@ TEST_F(GaugeAlgTest, Coulomb_Overrelaxation)
     gaugeFixingOVR(*U, 3, gf_maxiter, gf_verbosity_interval, gf_ovr_relaxation_boost, gf_tolerance, gf_reunit_interval,
                    gf_theta_condition);
     auto plaq_gf = plaquette(*U);
-    printfQuda("Plaq:    %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
-    printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", plaq_gf.x, plaq_gf.y, plaq_gf.z);
+    printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
+    printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", double(plaq_gf[0]), double(plaq_gf[1]), double(plaq_gf[2]));
     ASSERT_TRUE(comparePlaquette(plaq, plaq_gf));
   }
 }
@@ -322,8 +322,8 @@ TEST_F(GaugeAlgTest, Landau_FFT)
       gaugeFixingFFT(*U, 4, gf_maxiter, gf_verbosity_interval, gf_fft_alpha, gf_fft_autotune, gf_tolerance,
                      gf_theta_condition);
       auto plaq_gf = plaquette(*U);
-      printfQuda("Plaq:    %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
-      printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", plaq_gf.x, plaq_gf.y, plaq_gf.z);
+      printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
+      printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", double(plaq_gf[0]), double(plaq_gf[1]), double(plaq_gf[2]));
       ASSERT_TRUE(comparePlaquette(plaq, plaq_gf));
     }
   }
@@ -337,8 +337,8 @@ TEST_F(GaugeAlgTest, Coulomb_FFT)
       gaugeFixingFFT(*U, 4, gf_maxiter, gf_verbosity_interval, gf_fft_alpha, gf_fft_autotune, gf_tolerance,
                      gf_theta_condition);
       auto plaq_gf = plaquette(*U);
-      printfQuda("Plaq:    %.16e, %.16e, %.16e\n", plaq.x, plaq.y, plaq.z);
-      printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", plaq_gf.x, plaq_gf.y, plaq_gf.z);
+      printfQuda("Plaq:    %.16e, %.16e, %.16e\n", double(plaq[0]), double(plaq[1]), double(plaq[2]));
+      printfQuda("Plaq GF: %.16e, %.16e, %.16e\n", double(plaq_gf[0]), double(plaq_gf[1]), double(plaq_gf[2]));
       ASSERT_TRUE(comparePlaquette(plaq, plaq_gf));
     }
   }
diff --git a/tests/gauge_path_test.cpp b/tests/gauge_path_test.cpp
index 7d37c9faad..367158688d 100644
--- a/tests/gauge_path_test.cpp
+++ b/tests/gauge_path_test.cpp
@@ -77,9 +77,9 @@ int trace_path[][6] {{0, 1, 7, 6},       {0, 2, 7, 5},       {0, 3, 7, 4},
 
 static int force_check;
 static int path_check;
-static double force_deviation;
-static double loop_deviation;
-static double plaq_deviation;
+static quda::real_t force_deviation;
+static quda::real_t loop_deviation;
+static quda::real_t plaq_deviation;
 
 // The same function is used to test computePath.
 // If compute_force is false then a path is computed
@@ -215,9 +215,9 @@ void gauge_force_test(bool compute_force = true)
     logQuda(QUDA_VERBOSE, "\nComputing momentum action\n");
     auto action_quda = momActionQuda(mom, &gauge_param);
     auto action_ref = mom_action(refmom, gauge_param.cpu_prec, 4 * V);
-    force_deviation = std::abs(action_quda - action_ref) / std::abs(action_ref);
-    logQuda(QUDA_VERBOSE, "QUDA action = %e, reference = %e relative deviation = %e\n", action_quda, action_ref,
-            force_deviation);
+    force_deviation = abs(action_quda - action_ref) / abs(action_ref);
+    logQuda(QUDA_VERBOSE, "QUDA action = %e, reference = %e relative deviation = %e\n",
+            action_quda, action_ref, double(force_deviation));
   }
 
   double perf = 1.0 * niter * flops * V / (time_sec * 1e+9);
@@ -285,8 +285,7 @@ void gauge_loop_test()
   loadGaugeQuda(sitelink, &gauge_param);
 
   // storage for traces
-  using double_complex = double _Complex;
-  std::vector<double_complex> traces(num_paths);
+  std::vector<double _Complex> traces(num_paths);
   double scale_factor = 2.0;
 
   // compute various observables
@@ -315,7 +314,7 @@ void gauge_loop_test()
   // 6 loops of length 4, 12 loops of length 6 + 18 paths worth of traces and rescales
   int flops = (4 * 6 + 6 * 12) * 198 + 18 * 8;
 
-  std::vector<quda::Complex> traces_ref(num_paths);
+  std::vector<quda::complex_t> traces_ref(num_paths);
 
   if (verify_results) {
     gauge_loop_trace_reference(U_qdp, traces_ref, scale_factor, trace_path_p,
@@ -323,32 +322,32 @@ void gauge_loop_test()
 
     loop_deviation = 0;
     for (int i = 0; i < num_paths; i++) {
-      double *t_ptr = (double *)(&traces[i]);
-      std::complex<double> traces_(t_ptr[0], t_ptr[1]);
-      auto diff = std::abs(traces_ref[i] - traces_);
-      auto norm = std::abs(traces_ref[i]);
+      quda::complex_t traces_(static_cast<std::complex<double>>(traces[i]).real(), static_cast<std::complex<double>>(traces[i]).imag());
+      auto diff = abs(traces_ref[i] - traces_);
+      auto norm = abs(traces_ref[i]);
       loop_deviation += diff / norm;
-      logQuda(QUDA_VERBOSE, "Loop %d QUDA trace %e + I %e Reference trace %e + I %e Deviation %e\n", i, traces_.real(),
-              traces_.imag(), traces_ref[i].real(), traces_ref[i].imag(), diff / norm);
+      logQuda(QUDA_VERBOSE, "Loop %d QUDA trace %e + I %e Reference trace %e + I %e Deviation %e\n", i,
+              double(traces_.real()), double(traces_.imag()), double(traces_ref[i].real()),
+              double(traces_ref[i].imag()), double(diff / norm));
     }
 
     // Second check: we can reconstruct the plaquette from the first six loops we calculated
     double plaq_factor = 1. / (V * U_qdp.Ncolor() * quda::comm_size());
-    std::vector<quda::Complex> plaq_components(6);
-    for (int i = 0; i < 6; i++) plaq_components[i] = traces_ref[i] / trace_loop_coeff_d[i] / scale_factor * plaq_factor;
+    std::vector<quda::complex_t> plaq_components(6);
+    for (int i = 0; i < 6; i++) plaq_components[i] = traces_ref[i] / quda::real_t(trace_loop_coeff_d[i]) / quda::real_t(scale_factor) * quda::real_t(plaq_factor);
 
-    double plaq_loop[3];
+    quda::real_t plaq_loop[3];
     // spatial: xy, xz, yz
-    plaq_loop[1] = ((plaq_components[0] + plaq_components[1] + plaq_components[3]) / 3.).real();
+    plaq_loop[1] = ((plaq_components[0] + plaq_components[1] + plaq_components[3]) / quda::real_t(3.)).real();
     // temporal: xt, yt, zt
-    plaq_loop[2] = ((plaq_components[2] + plaq_components[4] + plaq_components[5]) / 3.).real();
+    plaq_loop[2] = ((plaq_components[2] + plaq_components[4] + plaq_components[5]) / quda::real_t(3.)).real();
     plaq_loop[0] = 0.5 * (plaq_loop[1] + plaq_loop[2]);
 
-    plaq_deviation = std::abs(obsParam.plaquette[0] - plaq_loop[0]) / std::abs(obsParam.plaquette[0]);
+    plaq_deviation = abs(obsParam.plaquette[0] - plaq_loop[0]) / abs(obsParam.plaquette[0]);
     logQuda(QUDA_VERBOSE,
             "Plaquette loop space %e time %e total %e ; plaqQuda space %e time %e total %e ; deviation %e\n",
-            plaq_loop[0], plaq_loop[1], plaq_loop[2], obsParam.plaquette[0], obsParam.plaquette[1],
-            obsParam.plaquette[2], plaq_deviation);
+            double(plaq_loop[0]), double(plaq_loop[1]), double(plaq_loop[2]), obsParam.plaquette[0], obsParam.plaquette[1],
+            obsParam.plaquette[2], double(plaq_deviation));
   }
 
   double perf = 1.0 * niter * flops * V / (host_timer.last() * 1e+9);
diff --git a/tests/host_reference/domain_wall_dslash_reference.cpp b/tests/host_reference/domain_wall_dslash_reference.cpp
index 29edd18a44..744aa62d34 100644
--- a/tests/host_reference/domain_wall_dslash_reference.cpp
+++ b/tests/host_reference/domain_wall_dslash_reference.cpp
@@ -551,10 +551,10 @@ void dslashReference_5th_inv(sFloat *res, sFloat *spinorField, int, int daggerBi
 
 template <typename sComplex> sComplex cpow(const sComplex &x, int y)
 {
-  static_assert(sizeof(sComplex) == sizeof(Complex), "C and C++ complex type sizes do not match");
+  static_assert(sizeof(sComplex) == sizeof(std::complex<double>), "C and C++ complex type sizes do not match");
   // note that C++ standard explicitly calls out that casting between C and C++ complex is legal
-  const Complex x_ = reinterpret_cast<const Complex &>(x);
-  Complex z_ = std::pow(x_, y);
+  auto x_ = reinterpret_cast<const std::complex<double> &>(x);
+  auto z_ = std::pow(x_, y);
   sComplex z = reinterpret_cast<sComplex &>(z_);
   return z;
 }
diff --git a/tests/host_reference/dslash_reference.cpp b/tests/host_reference/dslash_reference.cpp
index 3ed0c9aa5f..d47c39c320 100644
--- a/tests/host_reference/dslash_reference.cpp
+++ b/tests/host_reference/dslash_reference.cpp
@@ -795,18 +795,18 @@ double verifyStaggeredInversion(quda::ColorSpinorField &tmp, quda::ColorSpinorFi
   mxpy(in.data(), ref.data(), len * stag_spinor_site_size, inv_param.cpu_prec);
   double nrm2 = norm_2(ref.data(), len * stag_spinor_site_size, inv_param.cpu_prec);
   double src2 = norm_2(in.data(), len * stag_spinor_site_size, inv_param.cpu_prec);
-  double hqr = sqrt(quda::blas::HeavyQuarkResidualNorm(out, ref).z);
+  auto hqr = sqrt(quda::blas::HeavyQuarkResidualNorm(out, ref)[2]);
   double l2r = sqrt(nrm2 / src2);
 
   if (multishift == 1) {
     printfQuda("Residuals: (L2 relative) tol %9.6e, QUDA = %9.6e, host = %9.6e; (heavy-quark) tol %9.6e, QUDA = %9.6e, "
                "host = %9.6e\n",
-               inv_param.tol, inv_param.true_res, l2r, inv_param.tol_hq, inv_param.true_res_hq, hqr);
+               inv_param.tol, inv_param.true_res, l2r, inv_param.tol_hq, inv_param.true_res_hq, double(hqr));
   } else {
     printfQuda("Shift %2d residuals: (L2 relative) tol %9.6e, QUDA = %9.6e, host = %9.6e; (heavy-quark) tol %9.6e, "
                "QUDA = %9.6e, host = %9.6e\n",
                shift, inv_param.tol_offset[shift], inv_param.true_res_offset[shift], l2r,
-               inv_param.tol_hq_offset[shift], inv_param.true_res_hq_offset[shift], hqr);
+               inv_param.tol_hq_offset[shift], inv_param.true_res_hq_offset[shift], double(hqr));
     // Empirical: if the cpu residue is more than 1 order the target accuracy, then it fails to converge
     if (sqrt(nrm2 / src2) > 10 * inv_param.tol_offset[shift]) {
       printfQuda("Shift %2d has empirically failed to converge\n", shift);
diff --git a/tests/host_reference/dslash_test_helpers.cpp b/tests/host_reference/dslash_test_helpers.cpp
index be2a7cac18..0815996670 100644
--- a/tests/host_reference/dslash_test_helpers.cpp
+++ b/tests/host_reference/dslash_test_helpers.cpp
@@ -29,7 +29,7 @@ void dslashQuda_4dpc(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaPa
   ColorSpinorField in(cudaParam);
   in = in_h;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", blas::norm2(in), blas::norm2(in_h));
+  logQuda(QUDA_DEBUG_VERBOSE, "In CPU %e CUDA %e\n", double(blas::norm2(in)), double(blas::norm2(in_h)));
 
   ColorSpinorField out(cudaParam);
 
@@ -60,7 +60,7 @@ void dslashQuda_4dpc(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaPa
   ColorSpinorField out_h(cpuParam);
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", blas::norm2(out_h), blas::norm2(out));
+  logQuda(QUDA_DEBUG_VERBOSE, "Out CPU %e CUDA %e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
 
   popVerbosity();
 }
@@ -83,7 +83,7 @@ void dslashQuda_mdwf(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaPa
   ColorSpinorField in(cudaParam);
   in = in_h;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("In CPU %e CUDA %e\n", blas::norm2(in_h), blas::norm2(in));
+  logQuda(QUDA_DEBUG_VERBOSE, "In CPU %e CUDA %e\n", double(blas::norm2(in_h)), double(blas::norm2(in)));
 
   ColorSpinorField out(cudaParam);
 
@@ -110,7 +110,7 @@ void dslashQuda_mdwf(void *h_out, void *h_in, QudaInvertParam *inv_param, QudaPa
   ColorSpinorField out_h(cpuParam);
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE) printfQuda("Out CPU %e CUDA %e\n", blas::norm2(out_h), blas::norm2(out));
+  logQuda(QUDA_DEBUG_VERBOSE, "Out CPU %e CUDA %e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
   popVerbosity();
 }
 
@@ -133,8 +133,7 @@ void dslashQuda_mobius_eofa(void *h_out, void *h_in, QudaInvertParam *inv_param,
   ColorSpinorField in(cudaParam);
   in = in_h;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
-    printfQuda("In CPU %16.12e CUDA %12.12e\n", blas::norm2(in_h), blas::norm2(in));
+  logQuda(QUDA_DEBUG_VERBOSE, "In CPU %16.12e CUDA %12.12e\n", double(blas::norm2(in_h)), double(blas::norm2(in)));
 
   ColorSpinorField out(cudaParam);
 
@@ -160,7 +159,6 @@ void dslashQuda_mobius_eofa(void *h_out, void *h_in, QudaInvertParam *inv_param,
   ColorSpinorField out_h(cpuParam);
   out_h = out;
 
-  if (getVerbosity() >= QUDA_DEBUG_VERBOSE)
-    printfQuda("In CPU %16.12e CUDA %12.12e\n", blas::norm2(out_h), blas::norm2(out));
+  logQuda(QUDA_DEBUG_VERBOSE, "In CPU %16.12e CUDA %12.12e\n", double(blas::norm2(out_h)), double(blas::norm2(out)));
   popVerbosity();
 }
diff --git a/tests/host_reference/gauge_force_reference.cpp b/tests/host_reference/gauge_force_reference.cpp
index eb18f10568..e5ed23fe11 100644
--- a/tests/host_reference/gauge_force_reference.cpp
+++ b/tests/host_reference/gauge_force_reference.cpp
@@ -503,7 +503,7 @@ void gauge_force_reference(void *refMom, double eb3, quda::GaugeField &u, int **
   delete qdp_ex;
 }
 
-void gauge_loop_trace_reference(quda::GaugeField &u, std::vector<quda::Complex> &loop_traces,
+void gauge_loop_trace_reference(quda::GaugeField &u, std::vector<quda::complex_t> &loop_traces,
                                 double factor, int **input_path, int *length, double *path_coeff, int num_paths)
 {
   void *sitelink[] = {u.data(0), u.data(1), u.data(2), u.data(3)};
@@ -520,7 +520,7 @@ void gauge_loop_trace_reference(quda::GaugeField &u, std::vector<quda::Complex>
   lattice_t lat(*qdp_ex);
   void *sitelink_ex[] = {qdp_ex->data(0), qdp_ex->data(1), qdp_ex->data(2), qdp_ex->data(3)};
 
-  std::vector<double> loop_tr_dbl(2 * num_paths);
+  std::vector<quda::real_t> loop_tr_dbl(2 * num_paths);
 
   for (int i = 0; i < num_paths; i++) {
     if (u.Precision() == QUDA_DOUBLE_PRECISION) {
@@ -536,7 +536,7 @@ void gauge_loop_trace_reference(quda::GaugeField &u, std::vector<quda::Complex>
 
   quda::comm_allreduce_sum(loop_tr_dbl);
 
-  for (int i = 0; i < num_paths; i++) loop_traces[i] = quda::Complex(loop_tr_dbl[2 * i], loop_tr_dbl[2 * i + 1]);
+  for (int i = 0; i < num_paths; i++) loop_traces[i] = quda::complex_t(loop_tr_dbl[2 * i], loop_tr_dbl[2 * i + 1]);
 
   delete qdp_ex;
 }
diff --git a/tests/host_reference/gauge_force_reference.h b/tests/host_reference/gauge_force_reference.h
index 5d65ecc82b..a2d7dde929 100644
--- a/tests/host_reference/gauge_force_reference.h
+++ b/tests/host_reference/gauge_force_reference.h
@@ -5,5 +5,5 @@
 void gauge_force_reference(void *refMom, double eb3, quda::GaugeField &u, int ***path_dir,
                            int *length,  void *loop_coeff, int num_paths, bool compute_force);
 
-void gauge_loop_trace_reference(quda::GaugeField &u, std::vector<quda::Complex> &loop_traces,
+void gauge_loop_trace_reference(quda::GaugeField &u, std::vector<quda::complex_t> &loop_traces,
                                 double factor, int **input_path, int *length, double *path_coeff, int num_paths);
diff --git a/tests/io_test.cpp b/tests/io_test.cpp
index af708baf3b..001ae61602 100644
--- a/tests/io_test.cpp
+++ b/tests/io_test.cpp
@@ -25,6 +25,9 @@ class GaugeIOTest : public ::testing::TestWithParam<gauge_test_t>
 // test write/read of a gauge field yields identical lattice
 TEST_P(GaugeIOTest, verify)
 {
+  using namespace quda;
+  if (!is_enabled(prec)) GTEST_SKIP();
+
   QudaGaugeParam gauge_param = newQudaGaugeParam();
   setWilsonGaugeParam(gauge_param);
 
diff --git a/tests/pack_test.cpp b/tests/pack_test.cpp
index fe68c2645c..a46a690d07 100644
--- a/tests/pack_test.cpp
+++ b/tests/pack_test.cpp
@@ -161,11 +161,11 @@ void packTest()
   host_timer.stop();
   printfQuda("Spinor receive time = %e seconds\n", host_timer.last());
 
-  double spinor_norm = blas::norm2(*spinor);
-  double cuda_spinor_norm = blas::norm2(*cudaSpinor);
-  double spinor2_norm = blas::norm2(*spinor2);
+  auto spinor_norm = blas::norm2(*spinor);
+  auto cuda_spinor_norm = blas::norm2(*cudaSpinor);
+  auto spinor2_norm = blas::norm2(*spinor2);
 
-  printfQuda("Norm check: CPU = %e, CUDA = %e, CPU = %e\n", spinor_norm, cuda_spinor_norm, spinor2_norm);
+  printfQuda("Norm check: CPU = %e, CUDA = %e, CPU = %e\n", double(spinor_norm), double(cuda_spinor_norm), double(spinor2_norm));
 
   ColorSpinorField::Compare(*spinor, *spinor2, 1);
 }
diff --git a/tests/staggered_dslash_test_utils.h b/tests/staggered_dslash_test_utils.h
index 5cae0d80c2..aa8b63a997 100644
--- a/tests/staggered_dslash_test_utils.h
+++ b/tests/staggered_dslash_test_utils.h
@@ -450,11 +450,11 @@ struct StaggeredDslashTestWrapper {
 
         bool failed = false;
         // Catching nans is weird.
-        if (std::isnan(spinor_ref_norm)) { failed = true; }
-        if (std::isnan(spinor_out_norm)) { failed = true; }
+        if (isnan(spinor_ref_norm)) { failed = true; }
+        if (isnan(spinor_out_norm)) { failed = true; }
 
         printfQuda("Results: reference = %f, QUDA = %f, L2 relative deviation = %e, max deviation = %e\n",
-                   spinor_ref_norm, spinor_out_norm, 1.0 - sqrt(spinor_out_norm / spinor_ref_norm), max_deviation[0]);
+                   double(spinor_ref_norm), double(spinor_out_norm), double(real_t(1.0) - sqrt(spinor_out_norm / spinor_ref_norm)), double(max_deviation[0]));
         deviation = std::max(deviation, pow(10.0, -(double)(ColorSpinorField::Compare(spinorRef, vp_spinor_out[n]))));
         if (failed) { deviation = 1.0; }
       }
@@ -465,11 +465,12 @@ struct StaggeredDslashTestWrapper {
 
       bool failed = false;
       // Catching nans is weird.
-      if (std::isnan(spinor_ref_norm)) { failed = true; }
-      if (std::isnan(spinor_out_norm)) { failed = true; }
+      if (isnan(spinor_ref_norm)) { failed = true; }
+      if (isnan(spinor_out_norm)) { failed = true; }
 
       printfQuda("Results: reference = %f, QUDA = %f, L2 relative deviation = %e, max deviation = %e\n",
-                 spinor_ref_norm, spinor_out_norm, 1.0 - sqrt(spinor_out_norm / spinor_ref_norm), max_deviation[0]);
+                 double(spinor_ref_norm), double(spinor_out_norm),
+                 double(real_t(1.0) - sqrt(spinor_out_norm / spinor_ref_norm)), double(max_deviation[0]));
       deviation = pow(10, -(double)(ColorSpinorField::Compare(spinorRef, spinorOut)));
       if (failed) { deviation = 1.0; }
     }