diff --git a/CMakeLists.txt b/CMakeLists.txt
index ab7064b..ae486e9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1538,16 +1538,17 @@
     )
 
     set(SUBZERO_REACTOR_LIST
-        ${SOURCE_DIR}/Reactor/Reactor.cpp
-        ${SOURCE_DIR}/Reactor/Reactor.hpp
-        ${SOURCE_DIR}/Reactor/SubzeroReactor.cpp
-        ${SOURCE_DIR}/Reactor/Optimizer.cpp
-        ${SOURCE_DIR}/Reactor/Nucleus.hpp
-        ${SOURCE_DIR}/Reactor/Routine.hpp
         ${SOURCE_DIR}/Reactor/Debug.cpp
         ${SOURCE_DIR}/Reactor/Debug.hpp
         ${SOURCE_DIR}/Reactor/ExecutableMemory.cpp
         ${SOURCE_DIR}/Reactor/ExecutableMemory.hpp
+        ${SOURCE_DIR}/Reactor/Nucleus.hpp
+        ${SOURCE_DIR}/Reactor/Optimizer.cpp
+        ${SOURCE_DIR}/Reactor/Print.hpp
+        ${SOURCE_DIR}/Reactor/Reactor.cpp
+        ${SOURCE_DIR}/Reactor/Reactor.hpp
+        ${SOURCE_DIR}/Reactor/Routine.hpp
+        ${SOURCE_DIR}/Reactor/SubzeroReactor.cpp
     )
 
     set(SUBZERO_INCLUDE_DIR
@@ -1670,20 +1671,21 @@
 endif(REACTOR_EMIT_DEBUG_INFO)
 
 set(REACTOR_LLVM_LIST
-    ${SOURCE_DIR}/Reactor/Reactor.cpp
-    ${SOURCE_DIR}/Reactor/Reactor.hpp
-    ${SOURCE_DIR}/Reactor/LLVMReactor.cpp
-    ${SOURCE_DIR}/Reactor/LLVMReactor.hpp
-    ${SOURCE_DIR}/Reactor/LLVMReactorDebugInfo.cpp
-    ${SOURCE_DIR}/Reactor/LLVMReactorDebugInfo.hpp
-    ${SOURCE_DIR}/Reactor/Nucleus.hpp
-    ${SOURCE_DIR}/Reactor/Routine.hpp
     ${SOURCE_DIR}/Reactor/CPUID.cpp
     ${SOURCE_DIR}/Reactor/CPUID.hpp
     ${SOURCE_DIR}/Reactor/Debug.cpp
     ${SOURCE_DIR}/Reactor/Debug.hpp
     ${SOURCE_DIR}/Reactor/ExecutableMemory.cpp
     ${SOURCE_DIR}/Reactor/ExecutableMemory.hpp
+    ${SOURCE_DIR}/Reactor/LLVMReactor.cpp
+    ${SOURCE_DIR}/Reactor/LLVMReactor.hpp
+    ${SOURCE_DIR}/Reactor/LLVMReactorDebugInfo.cpp
+    ${SOURCE_DIR}/Reactor/LLVMReactorDebugInfo.hpp
+    ${SOURCE_DIR}/Reactor/Nucleus.hpp
+    ${SOURCE_DIR}/Reactor/Print.hpp
+    ${SOURCE_DIR}/Reactor/Reactor.cpp
+    ${SOURCE_DIR}/Reactor/Reactor.hpp
+    ${SOURCE_DIR}/Reactor/Routine.hpp
 )
 
 file(GLOB_RECURSE EGL_LIST
diff --git a/src/Pipeline/SamplerCore.hpp b/src/Pipeline/SamplerCore.hpp
index b733710..e5ab898 100644
--- a/src/Pipeline/SamplerCore.hpp
+++ b/src/Pipeline/SamplerCore.hpp
@@ -17,6 +17,7 @@
 
 #include "ShaderCore.hpp"
 #include "Device/Sampler.hpp"
+#include "Reactor/Print.hpp"
 #include "Reactor/Reactor.hpp"
 
 #ifdef None
diff --git a/src/Pipeline/ShaderCore.hpp b/src/Pipeline/ShaderCore.hpp
index fd51000..aa707d5 100644
--- a/src/Pipeline/ShaderCore.hpp
+++ b/src/Pipeline/ShaderCore.hpp
@@ -15,6 +15,7 @@
 #ifndef sw_ShaderCore_hpp
 #define sw_ShaderCore_hpp
 
+#include "Reactor/Print.hpp"
 #include "Reactor/Reactor.hpp"
 #include "Vulkan/VkDebug.hpp"
 
diff --git a/src/Reactor/Print.hpp b/src/Reactor/Print.hpp
new file mode 100644
index 0000000..252e621
--- /dev/null
+++ b/src/Reactor/Print.hpp
@@ -0,0 +1,371 @@
+// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef rr_Print_hpp
+#define rr_Print_hpp
+
+#if !defined(NDEBUG)
+#define ENABLE_RR_PRINT 1 // Enables RR_PRINT(), RR_WATCH()
+#endif // !defined(NDEBUG)
+
+#ifdef ENABLE_RR_PRINT
+
+#include "Reactor.hpp"
+
+#include <string>
+#include <vector>
+
+namespace rr {
+
+	// PrintValue holds the printf format and value(s) for a single argument
+	// to Print(). A single argument can be expanded into multiple printf
+	// values - for example a Float4 will expand to "%f %f %f %f" and four
+	// scalar values.
+	// The PrintValue constructor accepts the following:
+	//   * Reactor LValues, RValues, Pointers.
+	//   * Standard Plain-Old-Value types (int, float, bool, etc)
+	//   * Custom types that specialize the PrintValue::Ty template struct.
+	//   * Static arrays in the form T[N] where T can be any of the above.
+	class PrintValue
+	{
+		// Ty is a template that can be specialized for printing type T.
+		// Each specialization must expose:
+		//  * A 'static std::string fmt(const T& v)' method that provides the
+		//    printf format specifier.
+		//  * A 'static std::vector<rr::Value*> val(const T& v)' method that
+		//    returns all the printf format values.
+		template <typename T> struct Ty
+		{
+			// static std::string fmt(const T& v);
+			// static std::vector<rr::Value*> val(const T& v);
+		};
+
+		// returns the printf values for all the values in the given array.
+		template <typename T>
+		static std::vector<Value*> val(const T* list, int count) {
+			std::vector<Value*> values;
+			values.reserve(count);
+			for (int i = 0; i < count; i++)
+			{
+				auto v = val(list[i]);
+				values.insert(values.end(), v.begin(), v.end());
+			}
+			return values;
+		}
+
+		// fmt returns the comma-delimited list of printf format strings for
+		// every element in the provided list, all enclosed in square brackets.
+		template <typename T>
+		static std::string fmt(const T* list, int count)
+		{
+			std::string out = "[";
+			for (int i = 0; i < count; i++)
+			{
+				if (i > 0) { out += ", "; }
+				out += fmt(list[i]);
+			}
+			return out + "]";
+		}
+
+		static std::string addr(const void* ptr)
+		{
+			char buf[32];
+			snprintf(buf, sizeof(buf), "%p", ptr);
+			return buf;
+		}
+
+	public:
+		const std::string format;
+		const std::vector<Value*> values;
+
+		// Constructs a PrintValue for the given value.
+		template <typename T>
+		PrintValue(const T& v) : format(fmt(v)), values(val(v)) {}
+
+		// Constructs a PrintValue for the given static array.
+		template <typename T, int N>
+		PrintValue(const T (&v)[N]) : format(fmt(&v[0], N)), values(val(&v[0], N)) {}
+
+		// Constructs a PrintValue for the given array starting at arr of length
+		// len.
+		template <typename T>
+		PrintValue(const T* arr, int len) : format(fmt(arr, len)), values(val(arr, len)) {}
+
+		// PrintValue constructors for plain-old-data values.
+		PrintValue(bool v) : format(v ? "true" : "false") {}
+		PrintValue(int8_t v) : format(std::to_string(v)) {}
+		PrintValue(uint8_t v) : format(std::to_string(v)) {}
+		PrintValue(int16_t v) : format(std::to_string(v)) {}
+		PrintValue(uint16_t v) : format(std::to_string(v)) {}
+		PrintValue(int32_t v) : format(std::to_string(v)) {}
+		PrintValue(uint32_t v) : format(std::to_string(v)) {}
+		PrintValue(int64_t v) : format(std::to_string(v)) {}
+		PrintValue(uint64_t v) : format(std::to_string(v)) {}
+		PrintValue(float v) : format(std::to_string(v)) {}
+		PrintValue(double v) : format(std::to_string(v)) {}
+
+		template <typename T>
+		PrintValue(const T* v) : format(addr(v)) {}
+
+		// vals is a helper to build composite value lists.
+		// vals returns the full, sequential list of printf argument values used
+		// to print all the provided variadic values.
+		// vals() is intended to be used by implementations of
+		// PrintValue::Ty<>::vals() to help declare aggregate types.
+		// For example, if you were declaring a PrintValue::Ty<> specialization
+		// for a custom Mat4x4 matrix formed from four Vector4 values, you'd
+		// write:
+		//
+		// namespace rr
+		// {
+		//		template <> struct PrintValue::Ty<Mat4x4>
+		//		{
+		//			static std::string fmt(const Mat4x4& v)
+		//			{
+		//				return	"[a: <%f, %f, %f, %f>,"
+		//				        " b: <%f, %f, %f, %f>,"
+		//				        " c: <%f, %f, %f, %f>,"
+		//				        " d: <%f, %f, %f, %f>]";
+		//			}
+		//			static std::vector<rr::Value*> val(const Mat4x4& v)
+		//			{
+		//				return PrintValue::vals(v.a, v.b, v.c, v.d);
+		//			}
+		//		};
+		//	}
+		template<typename ... ARGS>
+		static std::vector<Value*> vals(ARGS... v)
+		{
+			std::vector< std::vector<Value*> > lists = {val(v)...};
+			std::vector<Value*> joined;
+			for (const auto& list : lists)
+			{
+				joined.insert(joined.end(), list.begin(), list.end());
+			}
+			return joined;
+		}
+
+		// returns the printf format specifier for the given type via the
+		// PrintValue::Ty<T> specialization.
+		template <typename T>
+		static std::string fmt(const T& v) { return Ty<T>::fmt(v); }
+
+		// returns the printf value for the given type with a
+		// PrintValue::Ty<T> specialization.
+		template <typename T>
+		static std::vector<Value*> val(const T& v) { return Ty<T>::val(v); }
+	};
+
+	// PrintValue::Ty<T> specializations for basic types.
+	template <> struct PrintValue::Ty<const char*>
+	{
+		static std::string fmt(const char* v) { return "%s"; }
+		static std::vector<Value*> val(const char* v);
+	};
+	template <> struct PrintValue::Ty<std::string>
+	{
+		static std::string fmt(const std::string& v) { return PrintValue::Ty<const char*>::fmt(v.c_str()); }
+		static std::vector<Value*> val(const std::string& v) { return PrintValue::Ty<const char*>::val(v.c_str()); }
+	};
+
+	// PrintValue::Ty<T> specializations for standard Reactor types.
+	template <> struct PrintValue::Ty<Bool>
+	{
+		static std::string fmt(const RValue<Bool>& v) { return "%d"; }
+		static std::vector<Value*> val(const RValue<Bool>& v) { return {v.value}; }
+	};
+	template <> struct PrintValue::Ty<Byte>
+	{
+		static std::string fmt(const RValue<Byte>& v) { return "%d"; }
+		static std::vector<Value*> val(const RValue<Byte>& v);
+	};
+	template <> struct PrintValue::Ty<Byte4>
+	{
+		static std::string fmt(const RValue<Byte4>& v) { return "[%d, %d, %d, %d]"; }
+		static std::vector<Value*> val(const RValue<Byte4>& v);
+	};
+	template <> struct PrintValue::Ty<Int>
+	{
+		static std::string fmt(const RValue<Int>& v) { return "%d"; }
+		static std::vector<Value*> val(const RValue<Int>& v);
+	};
+	template <> struct PrintValue::Ty<Int2>
+	{
+		static std::string fmt(const RValue<Int>& v) { return "[%d, %d]"; }
+		static std::vector<Value*> val(const RValue<Int2>& v);
+	};
+	template <> struct PrintValue::Ty<Int4>
+	{
+		static std::string fmt(const RValue<Int4>& v) { return "[%d, %d, %d, %d]"; }
+		static std::vector<Value*> val(const RValue<Int4>& v);
+	};
+	template <> struct PrintValue::Ty<UInt>
+	{
+		static std::string fmt(const RValue<UInt>& v) { return "%u"; }
+		static std::vector<Value*> val(const RValue<UInt>& v);
+	};
+	template <> struct PrintValue::Ty<UInt2>
+	{
+		static std::string fmt(const RValue<UInt>& v) { return "[%u, %u]"; }
+		static std::vector<Value*> val(const RValue<UInt2>& v);
+	};
+	template <> struct PrintValue::Ty<UInt4>
+	{
+		static std::string fmt(const RValue<UInt4>& v) { return "[%u, %u, %u, %u]"; }
+		static std::vector<Value*> val(const RValue<UInt4>& v);
+	};
+	template <> struct PrintValue::Ty<Short>
+	{
+		static std::string fmt(const RValue<Short>& v) { return "%d"; }
+		static std::vector<Value*> val(const RValue<Short>& v);
+	};
+	template <> struct PrintValue::Ty<Short4>
+	{
+		static std::string fmt(const RValue<Short4>& v) { return "[%d, %d, %d, %d]"; }
+		static std::vector<Value*> val(const RValue<Short4>& v);
+	};
+	template <> struct PrintValue::Ty<UShort>
+	{
+		static std::string fmt(const RValue<UShort>& v) { return "%u"; }
+		static std::vector<Value*> val(const RValue<UShort>& v);
+	};
+	template <> struct PrintValue::Ty<UShort4>
+	{
+		static std::string fmt(const RValue<UShort4>& v) { return "[%u, %u, %u, %u]"; }
+		static std::vector<Value*> val(const RValue<UShort4>& v);
+	};
+	template <> struct PrintValue::Ty<Float>
+	{
+		static std::string fmt(const RValue<Float>& v) { return "[%f]"; }
+		static std::vector<Value*> val(const RValue<Float>& v);
+	};
+	template <> struct PrintValue::Ty<Float4>
+	{
+		static std::string fmt(const RValue<Float4>& v) { return "[%f, %f, %f, %f]"; }
+		static std::vector<Value*> val(const RValue<Float4>& v);
+	};
+	template <> struct PrintValue::Ty<Long>
+	{
+		static std::string fmt(const RValue<Long>& v) { return "%lld"; }
+		static std::vector<Value*> val(const RValue<Long>& v) { return {v.value}; }
+	};
+	template <typename T> struct PrintValue::Ty< Pointer<T> >
+	{
+		static std::string fmt(const RValue<Pointer<T>>& v) { return "%p"; }
+		static std::vector<Value*> val(const RValue<Pointer<T>>& v) { return {v.value}; }
+	};
+	template <typename T> struct PrintValue::Ty< Reference<T> >
+	{
+		static std::string fmt(const Reference<T>& v) { return PrintValue::Ty<T>::fmt(v); }
+		static std::vector<Value*> val(const Reference<T>& v) { return PrintValue::Ty<T>::val(v); }
+	};
+	template <typename T> struct PrintValue::Ty< RValue<T> >
+	{
+		static std::string fmt(const RValue<T>& v) { return PrintValue::Ty<T>::fmt(v); }
+		static std::vector<Value*> val(const RValue<T>& v) { return PrintValue::Ty<T>::val(v); }
+	};
+
+	// Printv emits a call to printf() using the function, file and line,
+	// message and optional values.
+	// See Printv below.
+	void Printv(const char* function, const char* file, int line, const char* msg, std::initializer_list<PrintValue> vals);
+
+	// Printv emits a call to printf() using the provided message and optional
+	// values.
+	// Printf replaces any bracketed indices in the message with string
+	// representations of the corresponding value in vals.
+	// For example:
+	//   Printv("{0} and {1}", "red", "green");
+	// Would print the string:
+	//   "red and green"
+	// Arguments can be indexed in any order.
+	// Invalid indices are not substituted.
+	inline void Printv(const char* msg, std::initializer_list<PrintValue> vals)
+	{
+		Printv(nullptr, nullptr, 0, msg, vals);
+	}
+
+	// Print is a wrapper over Printv that wraps the variadic arguments into an
+	// initializer_list before calling Printv.
+	template <typename ... ARGS>
+	void Print(const char* msg, const ARGS& ... vals) { Printv(msg, {vals...}); }
+
+	// Print is a wrapper over Printv that wraps the variadic arguments into an
+	// initializer_list before calling Printv.
+	template <typename ... ARGS>
+	void Print(const char* function, const char* file, int line, const char* msg, const ARGS& ... vals)
+	{
+		Printv(function, file, line, msg, {vals...});
+	}
+
+	// RR_LOG is a macro that calls Print(), automatically populating the
+	// function, file and line parameters and appending a newline to the string.
+	//
+	// RR_LOG() is intended to be used for debugging JIT compiled code, and is
+	// not intended for production use.
+	#if defined(_WIN32)
+		#define RR_LOG(msg, ...) Print(__FUNCSIG__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
+	#else
+		#define RR_LOG(msg, ...) Print(__PRETTY_FUNCTION__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
+	#endif
+
+	// Macro magic to perform variadic dispatch.
+	// See: https://renenyffenegger.ch/notes/development/languages/C-C-plus-plus/preprocessor/macros/__VA_ARGS__/count-arguments
+	// Note, this doesn't attempt to use the ##__VA_ARGS__ trick to handle 0
+	#define RR_MSVC_EXPAND_BUG(X) X // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler.
+	#define RR_GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
+	#define RR_COUNT_ARGUMENTS(...) RR_MSVC_EXPAND_BUG(RR_GET_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+	static_assert(1 == RR_COUNT_ARGUMENTS(a), "RR_COUNT_ARGUMENTS broken"); // Sanity checks.
+	static_assert(2 == RR_COUNT_ARGUMENTS(a, b), "RR_COUNT_ARGUMENTS broken");
+	static_assert(3 == RR_COUNT_ARGUMENTS(a, b, c), "RR_COUNT_ARGUMENTS broken");
+
+	// RR_WATCH_FMT(...) resolves to a string literal that lists all the
+	// arguments by name. This string can be passed to LOG() to print each of
+	// the arguments with their name and value.
+	//
+	// RR_WATCH_FMT(...) uses the RR_COUNT_ARGUMENTS helper macro to delegate to a
+	// corresponding RR_WATCH_FMT_n specialization macro below.
+	#define RR_WATCH_CONCAT(a, b) a ## b
+	#define RR_WATCH_CONCAT2(a, b) RR_WATCH_CONCAT(a, b)
+	#define RR_WATCH_FMT(...) RR_MSVC_EXPAND_BUG(RR_WATCH_CONCAT2(RR_WATCH_FMT_, RR_COUNT_ARGUMENTS(__VA_ARGS__))(__VA_ARGS__))
+	#define RR_WATCH_FMT_1(_1) "\n  " #_1 ": {0}"
+	#define RR_WATCH_FMT_2(_1, _2)                                             RR_WATCH_FMT_1(_1) "\n  " #_2 ": {1}"
+	#define RR_WATCH_FMT_3(_1, _2, _3)                                         RR_WATCH_FMT_2(_1, _2) "\n  " #_3 ": {2}"
+	#define RR_WATCH_FMT_4(_1, _2, _3, _4)                                     RR_WATCH_FMT_3(_1, _2, _3) "\n  " #_4 ": {3}"
+	#define RR_WATCH_FMT_5(_1, _2, _3, _4, _5)                                 RR_WATCH_FMT_4(_1, _2, _3, _4) "\n  " #_5 ": {4}"
+	#define RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6)                             RR_WATCH_FMT_5(_1, _2, _3, _4, _5) "\n  " #_6 ": {5}"
+	#define RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7)                         RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) "\n  " #_7 ": {6}"
+	#define RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8)                     RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) "\n  " #_8 ": {7}"
+	#define RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9)                 RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) "\n  " #_9 ": {8}"
+	#define RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)           RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) "\n  " #_10 ": {9}"
+	#define RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)      RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) "\n  " #_11 ": {10}"
+	#define RR_WATCH_FMT_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) "\n  " #_12 ": {11}"
+
+	// RR_WATCH() is a helper that prints the name and value of all the supplied
+	// arguments.
+	// For example, if you had the Int and bool variables 'foo' and 'bar' that
+	// you want to print, you can simply write:
+	//    RR_WATCH(foo, bar)
+	// When this JIT compiled code is executed, it will print the string
+	// "foo: 1, bar: true" to stdout.
+	//
+	// RR_WATCH() is intended to be used for debugging JIT compiled code, and
+	// is not intended for production use.
+	#define RR_WATCH(...) RR_LOG(RR_WATCH_FMT(__VA_ARGS__), __VA_ARGS__)
+
+}  // namespace rr
+
+#endif  // ENABLE_RR_PRINT
+
+#endif  // rr_Print_hpp
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index 5997132..e4b6be0 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -23,16 +23,11 @@
 #include <cstddef>
 #include <cstdio>
 
-#include <string>
 #include <tuple>
 #include <unordered_set>
 
 #undef Bool // b/127920555
 
-#if !defined(NDEBUG)
-#define ENABLE_RR_PRINT 1 // Enables RR_PRINT(), RR_WATCH()
-#endif // !defined(NDEBUG)
-
 #ifdef ENABLE_RR_DEBUG_INFO
 	// Functions used for generating JIT debug info.
 	// See docs/ReactorDebugInfo.md for more information.
@@ -3324,344 +3319,6 @@
 	// This can be used to stop an attached debugger at the given call.
 	void Breakpoint();
 
-#ifdef ENABLE_RR_PRINT
-	// PrintValue holds the printf format and value(s) for a single argument
-	// to Print(). A single argument can be expanded into multiple printf
-	// values - for example a Float4 will expand to "%f %f %f %f" and four
-	// scalar values.
-	// The PrintValue constructor accepts the following:
-	//   * Reactor LValues, RValues, Pointers.
-	//   * Standard Plain-Old-Value types (int, float, bool, etc)
-	//   * Custom types that specialize the PrintValue::Ty template struct.
-	//   * Static arrays in the form T[N] where T can be any of the above.
-	class PrintValue
-	{
-		// Ty is a template that can be specialized for printing type T.
-		// Each specialization must expose:
-		//  * A 'static std::string fmt(const T& v)' method that provides the
-		//    printf format specifier.
-		//  * A 'static std::vector<rr::Value*> val(const T& v)' method that
-		//    returns all the printf format values.
-		template <typename T> struct Ty
-		{
-			// static std::string fmt(const T& v);
-			// static std::vector<rr::Value*> val(const T& v);
-		};
-
-		// returns the printf values for all the values in the given array.
-		template <typename T>
-		static std::vector<Value*> val(const T* list, int count) {
-			std::vector<Value*> values;
-			values.reserve(count);
-			for (int i = 0; i < count; i++)
-			{
-				auto v = val(list[i]);
-				values.insert(values.end(), v.begin(), v.end());
-			}
-			return values;
-		}
-
-		// fmt returns the comma-delimited list of printf format strings for
-		// every element in the provided list, all enclosed in square brackets.
-		template <typename T>
-		static std::string fmt(const T* list, int count)
-		{
-			std::string out = "[";
-			for (int i = 0; i < count; i++)
-			{
-				if (i > 0) { out += ", "; }
-				out += fmt(list[i]);
-			}
-			return out + "]";
-		}
-
-		static std::string addr(const void* ptr)
-		{
-			char buf[32];
-			snprintf(buf, sizeof(buf), "%p", ptr);
-			return buf;
-		}
-
-	public:
-		const std::string format;
-		const std::vector<Value*> values;
-
-		// Constructs a PrintValue for the given value.
-		template <typename T>
-		PrintValue(const T& v) : format(fmt(v)), values(val(v)) {}
-
-		// Constructs a PrintValue for the given static array.
-		template <typename T, int N>
-		PrintValue(const T (&v)[N]) : format(fmt(&v[0], N)), values(val(&v[0], N)) {}
-
-		// Constructs a PrintValue for the given array starting at arr of length
-		// len.
-		template <typename T>
-		PrintValue(const T* arr, int len) : format(fmt(arr, len)), values(val(arr, len)) {}
-
-		// PrintValue constructors for plain-old-data values.
-		PrintValue(bool v) : format(v ? "true" : "false") {}
-		PrintValue(int8_t v) : format(std::to_string(v)) {}
-		PrintValue(uint8_t v) : format(std::to_string(v)) {}
-		PrintValue(int16_t v) : format(std::to_string(v)) {}
-		PrintValue(uint16_t v) : format(std::to_string(v)) {}
-		PrintValue(int32_t v) : format(std::to_string(v)) {}
-		PrintValue(uint32_t v) : format(std::to_string(v)) {}
-		PrintValue(int64_t v) : format(std::to_string(v)) {}
-		PrintValue(uint64_t v) : format(std::to_string(v)) {}
-		PrintValue(float v) : format(std::to_string(v)) {}
-		PrintValue(double v) : format(std::to_string(v)) {}
-
-		template <typename T>
-		PrintValue(const T* v) : format(addr(v)) {}
-
-		// vals is a helper to build composite value lists.
-		// vals returns the full, sequential list of printf argument values used
-		// to print all the provided variadic values.
-		// vals() is intended to be used by implementations of
-		// PrintValue::Ty<>::vals() to help declare aggregate types.
-		// For example, if you were declaring a PrintValue::Ty<> specialization
-		// for a custom Mat4x4 matrix formed from four Vector4 values, you'd
-		// write:
-		//
-		// namespace rr
-		// {
-		//		template <> struct PrintValue::Ty<Mat4x4>
-		//		{
-		//			static std::string fmt(const Mat4x4& v)
-		//			{
-		//				return	"[a: <%f, %f, %f, %f>,"
-		//				        " b: <%f, %f, %f, %f>,"
-		//				        " c: <%f, %f, %f, %f>,"
-		//				        " d: <%f, %f, %f, %f>]";
-		//			}
-		//			static std::vector<rr::Value*> val(const Mat4x4& v)
-		//			{
-		//				return PrintValue::vals(v.a, v.b, v.c, v.d);
-		//			}
-		//		};
-		//	}
-		template<typename ... ARGS>
-		static std::vector<Value*> vals(ARGS... v)
-		{
-			std::vector< std::vector<Value*> > lists = {val(v)...};
-			std::vector<Value*> joined;
-			for (const auto& list : lists)
-			{
-				joined.insert(joined.end(), list.begin(), list.end());
-			}
-			return joined;
-		}
-
-		// returns the printf format specifier for the given type via the
-		// PrintValue::Ty<T> specialization.
-		template <typename T>
-		static std::string fmt(const T& v) { return Ty<T>::fmt(v); }
-
-		// returns the printf value for the given type with a
-		// PrintValue::Ty<T> specialization.
-		template <typename T>
-		static std::vector<Value*> val(const T& v) { return Ty<T>::val(v); }
-	};
-
-	// PrintValue::Ty<T> specializations for basic types.
-	template <> struct PrintValue::Ty<const char*>
-	{
-		static std::string fmt(const char* v) { return "%s"; }
-		static std::vector<Value*> val(const char* v);
-	};
-	template <> struct PrintValue::Ty<std::string>
-	{
-		static std::string fmt(const std::string& v) { return PrintValue::Ty<const char*>::fmt(v.c_str()); }
-		static std::vector<Value*> val(const std::string& v) { return PrintValue::Ty<const char*>::val(v.c_str()); }
-	};
-
-	// PrintValue::Ty<T> specializations for standard Reactor types.
-	template <> struct PrintValue::Ty<Bool>
-	{
-		static std::string fmt(const RValue<Bool>& v) { return "%d"; }
-		static std::vector<Value*> val(const RValue<Bool>& v) { return {v.value}; }
-	};
-	template <> struct PrintValue::Ty<Byte>
-	{
-		static std::string fmt(const RValue<Byte>& v) { return "%d"; }
-		static std::vector<Value*> val(const RValue<Byte>& v);
-	};
-	template <> struct PrintValue::Ty<Byte4>
-	{
-		static std::string fmt(const RValue<Byte4>& v) { return "[%d, %d, %d, %d]"; }
-		static std::vector<Value*> val(const RValue<Byte4>& v);
-	};
-	template <> struct PrintValue::Ty<Int>
-	{
-		static std::string fmt(const RValue<Int>& v) { return "%d"; }
-		static std::vector<Value*> val(const RValue<Int>& v);
-	};
-	template <> struct PrintValue::Ty<Int2>
-	{
-		static std::string fmt(const RValue<Int>& v) { return "[%d, %d]"; }
-		static std::vector<Value*> val(const RValue<Int2>& v);
-	};
-	template <> struct PrintValue::Ty<Int4>
-	{
-		static std::string fmt(const RValue<Int4>& v) { return "[%d, %d, %d, %d]"; }
-		static std::vector<Value*> val(const RValue<Int4>& v);
-	};
-	template <> struct PrintValue::Ty<UInt>
-	{
-		static std::string fmt(const RValue<UInt>& v) { return "%u"; }
-		static std::vector<Value*> val(const RValue<UInt>& v);
-	};
-	template <> struct PrintValue::Ty<UInt2>
-	{
-		static std::string fmt(const RValue<UInt>& v) { return "[%u, %u]"; }
-		static std::vector<Value*> val(const RValue<UInt2>& v);
-	};
-	template <> struct PrintValue::Ty<UInt4>
-	{
-		static std::string fmt(const RValue<UInt4>& v) { return "[%u, %u, %u, %u]"; }
-		static std::vector<Value*> val(const RValue<UInt4>& v);
-	};
-	template <> struct PrintValue::Ty<Short>
-	{
-		static std::string fmt(const RValue<Short>& v) { return "%d"; }
-		static std::vector<Value*> val(const RValue<Short>& v);
-	};
-	template <> struct PrintValue::Ty<Short4>
-	{
-		static std::string fmt(const RValue<Short4>& v) { return "[%d, %d, %d, %d]"; }
-		static std::vector<Value*> val(const RValue<Short4>& v);
-	};
-	template <> struct PrintValue::Ty<UShort>
-	{
-		static std::string fmt(const RValue<UShort>& v) { return "%u"; }
-		static std::vector<Value*> val(const RValue<UShort>& v);
-	};
-	template <> struct PrintValue::Ty<UShort4>
-	{
-		static std::string fmt(const RValue<UShort4>& v) { return "[%u, %u, %u, %u]"; }
-		static std::vector<Value*> val(const RValue<UShort4>& v);
-	};
-	template <> struct PrintValue::Ty<Float>
-	{
-		static std::string fmt(const RValue<Float>& v) { return "[%f]"; }
-		static std::vector<Value*> val(const RValue<Float>& v);
-	};
-	template <> struct PrintValue::Ty<Float4>
-	{
-		static std::string fmt(const RValue<Float4>& v) { return "[%f, %f, %f, %f]"; }
-		static std::vector<Value*> val(const RValue<Float4>& v);
-	};
-	template <> struct PrintValue::Ty<Long>
-	{
-		static std::string fmt(const RValue<Long>& v) { return "%lld"; }
-		static std::vector<Value*> val(const RValue<Long>& v) { return {v.value}; }
-	};
-	template <typename T> struct PrintValue::Ty< Pointer<T> >
-	{
-		static std::string fmt(const RValue<Pointer<T>>& v) { return "%p"; }
-		static std::vector<Value*> val(const RValue<Pointer<T>>& v) { return {v.value}; }
-	};
-	template <typename T> struct PrintValue::Ty< Reference<T> >
-	{
-		static std::string fmt(const Reference<T>& v) { return PrintValue::Ty<T>::fmt(v); }
-		static std::vector<Value*> val(const Reference<T>& v) { return PrintValue::Ty<T>::val(v); }
-	};
-	template <typename T> struct PrintValue::Ty< RValue<T> >
-	{
-		static std::string fmt(const RValue<T>& v) { return PrintValue::Ty<T>::fmt(v); }
-		static std::vector<Value*> val(const RValue<T>& v) { return PrintValue::Ty<T>::val(v); }
-	};
-
-	// Printv emits a call to printf() using the function, file and line,
-	// message and optional values.
-	// See Printv below.
-	void Printv(const char* function, const char* file, int line, const char* msg, std::initializer_list<PrintValue> vals);
-
-	// Printv emits a call to printf() using the provided message and optional
-	// values.
-	// Printf replaces any bracketed indices in the message with string
-	// representations of the corresponding value in vals.
-	// For example:
-	//   Printv("{0} and {1}", "red", "green");
-	// Would print the string:
-	//   "red and green"
-	// Arguments can be indexed in any order.
-	// Invalid indices are not substituted.
-	inline void Printv(const char* msg, std::initializer_list<PrintValue> vals)
-	{
-		Printv(nullptr, nullptr, 0, msg, vals);
-	}
-
-	// Print is a wrapper over Printv that wraps the variadic arguments into an
-	// initializer_list before calling Printv.
-	template <typename ... ARGS>
-	void Print(const char* msg, const ARGS& ... vals) { Printv(msg, {vals...}); }
-
-	// Print is a wrapper over Printv that wraps the variadic arguments into an
-	// initializer_list before calling Printv.
-	template <typename ... ARGS>
-	void Print(const char* function, const char* file, int line, const char* msg, const ARGS& ... vals)
-	{
-		Printv(function, file, line, msg, {vals...});
-	}
-
-	// RR_LOG is a macro that calls Print(), automatically populating the
-	// function, file and line parameters and appending a newline to the string.
-	//
-	// RR_LOG() is intended to be used for debugging JIT compiled code, and is
-	// not intended for production use.
-	#if defined(_WIN32)
-		#define RR_LOG(msg, ...) Print(__FUNCSIG__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
-	#else
-		#define RR_LOG(msg, ...) Print(__PRETTY_FUNCTION__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
-	#endif
-
-	// Macro magic to perform variadic dispatch.
-	// See: https://renenyffenegger.ch/notes/development/languages/C-C-plus-plus/preprocessor/macros/__VA_ARGS__/count-arguments
-	// Note, this doesn't attempt to use the ##__VA_ARGS__ trick to handle 0
-	#define RR_MSVC_EXPAND_BUG(X) X // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler.
-	#define RR_GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
-	#define RR_COUNT_ARGUMENTS(...) RR_MSVC_EXPAND_BUG(RR_GET_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
-	static_assert(1 == RR_COUNT_ARGUMENTS(a), "RR_COUNT_ARGUMENTS broken"); // Sanity checks.
-	static_assert(2 == RR_COUNT_ARGUMENTS(a, b), "RR_COUNT_ARGUMENTS broken");
-	static_assert(3 == RR_COUNT_ARGUMENTS(a, b, c), "RR_COUNT_ARGUMENTS broken");
-
-	// RR_WATCH_FMT(...) resolves to a string literal that lists all the
-	// arguments by name. This string can be passed to LOG() to print each of
-	// the arguments with their name and value.
-	//
-	// RR_WATCH_FMT(...) uses the RR_COUNT_ARGUMENTS helper macro to delegate to a
-	// corresponding RR_WATCH_FMT_n specialization macro below.
-	#define RR_WATCH_CONCAT(a, b) a ## b
-	#define RR_WATCH_CONCAT2(a, b) RR_WATCH_CONCAT(a, b)
-	#define RR_WATCH_FMT(...) RR_MSVC_EXPAND_BUG(RR_WATCH_CONCAT2(RR_WATCH_FMT_, RR_COUNT_ARGUMENTS(__VA_ARGS__))(__VA_ARGS__))
-	#define RR_WATCH_FMT_1(_1) "\n  " #_1 ": {0}"
-	#define RR_WATCH_FMT_2(_1, _2)                                             RR_WATCH_FMT_1(_1) "\n  " #_2 ": {1}"
-	#define RR_WATCH_FMT_3(_1, _2, _3)                                         RR_WATCH_FMT_2(_1, _2) "\n  " #_3 ": {2}"
-	#define RR_WATCH_FMT_4(_1, _2, _3, _4)                                     RR_WATCH_FMT_3(_1, _2, _3) "\n  " #_4 ": {3}"
-	#define RR_WATCH_FMT_5(_1, _2, _3, _4, _5)                                 RR_WATCH_FMT_4(_1, _2, _3, _4) "\n  " #_5 ": {4}"
-	#define RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6)                             RR_WATCH_FMT_5(_1, _2, _3, _4, _5) "\n  " #_6 ": {5}"
-	#define RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7)                         RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) "\n  " #_7 ": {6}"
-	#define RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8)                     RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) "\n  " #_8 ": {7}"
-	#define RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9)                 RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) "\n  " #_9 ": {8}"
-	#define RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)           RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) "\n  " #_10 ": {9}"
-	#define RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)      RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) "\n  " #_11 ": {10}"
-	#define RR_WATCH_FMT_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) "\n  " #_12 ": {11}"
-
-	// RR_WATCH() is a helper that prints the name and value of all the supplied
-	// arguments.
-	// For example, if you had the Int and bool variables 'foo' and 'bar' that
-	// you want to print, you can simply write:
-	//    RR_WATCH(foo, bar)
-	// When this JIT compiled code is executed, it will print the string
-	// "foo: 1, bar: true" to stdout.
-	//
-	// RR_WATCH() is intended to be used for debugging JIT compiled code, and
-	// is not intended for production use.
-	#define RR_WATCH(...) RR_LOG(RR_WATCH_FMT(__VA_ARGS__), __VA_ARGS__)
-#endif // ENABLE_RR_PRINT
-
 	class ForData
 	{
 	public:
diff --git a/src/Reactor/Reactor.vcxproj b/src/Reactor/Reactor.vcxproj
index 9859409..4f6ef61 100644
--- a/src/Reactor/Reactor.vcxproj
+++ b/src/Reactor/Reactor.vcxproj
@@ -300,6 +300,7 @@
     <ClInclude Include="ExecutableMemory.hpp" />
     <ClInclude Include="MutexLock.hpp" />
     <ClInclude Include="Nucleus.hpp" />
+    <ClInclude Include="Print.hpp" />
     <ClInclude Include="Reactor.hpp" />
     <ClInclude Include="Routine.hpp" />
     <ClInclude Include="Thread.hpp" />
diff --git a/src/Reactor/Reactor.vcxproj.filters b/src/Reactor/Reactor.vcxproj.filters
index 32900aa..22c1a6b 100644
--- a/src/Reactor/Reactor.vcxproj.filters
+++ b/src/Reactor/Reactor.vcxproj.filters
@@ -41,6 +41,9 @@
     <ClInclude Include="Nucleus.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Print.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="Reactor.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>