diff --git a/examples/OpenGL/main.cpp b/examples/OpenGL/main.cpp
index 7e2451e1..27b0ac6b 100644
--- a/examples/OpenGL/main.cpp
+++ b/examples/OpenGL/main.cpp
@@ -90,86 +90,86 @@ int main(int argc, char *argv[])
 
 	QSharedPointer<QGLShaderProgram> shader(new QGLShaderProgram);
 
-	if (!shader->addShaderFromSourceCode(QGLShader::Vertex, R"(
-		#version 140
+	if (!shader->addShaderFromSourceCode(QGLShader::Vertex,
+		"#version 140\n"
 		
-		in vec4 position; // This will be the position of the vertex in model-space
-		in vec4 normal; // The normal data may not have been set
-		in ivec2 material;
+		"in vec4 position; // This will be the position of the vertex in model-space\n"
+		"in vec4 normal; // The normal data may not have been set\n"
+		"in ivec2 material;\n"
 		
-		uniform mat4 cameraToClipMatrix;
-		uniform mat4 worldToCameraMatrix;
-		uniform mat4 modelToWorldMatrix;
+		"uniform mat4 cameraToClipMatrix;\n"
+		"uniform mat4 worldToCameraMatrix;\n"
+		"uniform mat4 modelToWorldMatrix;\n"
 		
-		out vec4 worldPosition; //This is being passed to the fragment shader to calculate the normals
-		out vec3 normalFromVS;
-		flat out ivec2 materialFromVS;
+		"out vec4 worldPosition; //This is being passed to the fragment shader to calculate the normals\n"
+		"out vec3 normalFromVS;\n"
+		"flat out ivec2 materialFromVS;\n"
 		
-		void main()
-		{
-			// Compute the usual OpenGL transformation to clip space.
-			gl_Position = cameraToClipMatrix * worldToCameraMatrix * modelToWorldMatrix * position;
+		"void main()\n"
+		"{\n"
+		"	// Compute the usual OpenGL transformation to clip space.\n"
+		"	gl_Position = cameraToClipMatrix * worldToCameraMatrix * modelToWorldMatrix * position;\n"
 
-			// This example is demonstrating the marching cubes mesh, which does have per-vertex normals. We can 
-			// just pass them through, though real code might want to deal with transforming normals appropriatly.
-			normalFromVS = normal.xyz;
+		"	// This example is demonstrating the marching cubes mesh, which does have per-vertex normals. We can \n"
+		"	// just pass them through, though real code might want to deal with transforming normals appropriatly.\n"
+		"	normalFromVS = normal.xyz;\n"
 
-			// Nothing special here, we just pass the material through to the fragment shader.
-			materialFromVS = material;
-		}
-	)"))
+		"	// Nothing special here, we just pass the material through to the fragment shader.\n"
+		"	materialFromVS = material;\n"
+		"}\n"
+	))
 	{
 		std::cerr << shader->log().toStdString() << std::endl;
 		exit(EXIT_FAILURE);
 	}
 
-	if (!shader->addShaderFromSourceCode(QGLShader::Fragment, R"(
-		#version 130
+	if (!shader->addShaderFromSourceCode(QGLShader::Fragment,
+		"#version 130\n"
 		
-		in vec4 worldPosition; //Passed in from the vertex shader
-		in vec3 normalFromVS;
-		flat in ivec2 materialFromVS;
+		"in vec4 worldPosition; //Passed in from the vertex shader\n"
+		"in vec3 normalFromVS;\n"
+		"flat in ivec2 materialFromVS;\n"
 		
-		out vec4 outputColor;
+		"out vec4 outputColor;\n"
 		
-		void main()
-		{
-			// The first byte of our voxel data is the material.
-			// We use this to decide how to color the fragment.
-			vec4 surfaceColor;
-			switch(materialFromVS.x)
-			{
-			case 1:
-				surfaceColor = vec4(1.0, 0.0, 0.0, 1.0);
-				break;
-			case 2:
-				surfaceColor = vec4(0.0, 1.0, 0.0, 1.0);
-				break;
-			case 3:
-				surfaceColor = vec4(0.0, 0.0, 1.0, 1.0);
-				break;
-			case 4:
-				surfaceColor = vec4(1.0, 1.0, 0.0, 1.0);
-				break;
-			case 5:
-				surfaceColor = vec4(1.0, 0.0, 1.0, 1.0);
-				break;
-			default:
-				surfaceColor = vec4(1.0, 1.0, 1.0, 1.0);
-				break;
-			}
+		"void main()\n"
+		"{\n"
+		"	// The first byte of our voxel data is the material.\n"
+		"	// We use this to decide how to color the fragment.\n"
+		"	vec4 surfaceColor;\n"
+		"	switch(materialFromVS.x)\n"
+		"	{\n"
+		"	case 1:\n"
+		"		surfaceColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
+		"		break;\n"
+		"	case 2:\n"
+		"		surfaceColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
+		"		break;\n"
+		"	case 3:\n"
+		"		surfaceColor = vec4(0.0, 0.0, 1.0, 1.0);\n"
+		"		break;\n"
+		"	case 4:\n"
+		"		surfaceColor = vec4(1.0, 1.0, 0.0, 1.0);\n"
+		"		break;\n"
+		"	case 5:\n"
+		"		surfaceColor = vec4(1.0, 0.0, 1.0, 1.0);\n"
+		"		break;\n"
+		"	default:\n"
+		"		surfaceColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
+		"		break;\n"
+		"	}\n"
 
-			// Quick and dirty lighting, obviously a real implementation
-			// should pass light properties as shader parameters, etc.
-			vec3 lightDir = vec3(0.0, 0.0, 1.0);
-			float diffuse = clamp(dot(lightDir, normalFromVS), 0.0, 1.0);
-			diffuse *= 0.7; // Dim the diffuse a bit
-			float ambient = 0.3; // Add some ambient
-			float lightIntensity = diffuse + ambient; // Compute the final light intensity
+		"	// Quick and dirty lighting, obviously a real implementation\n"
+		"	// should pass light properties as shader parameters, etc.\n"
+		"	vec3 lightDir = vec3(0.0, 0.0, 1.0);\n"
+		"	float diffuse = clamp(dot(lightDir, normalFromVS), 0.0, 1.0);\n"
+		"	diffuse *= 0.7; // Dim the diffuse a bit\n"
+		"	float ambient = 0.3; // Add some ambient\n"
+		"	float lightIntensity = diffuse + ambient; // Compute the final light intensity\n"
 
-			outputColor = surfaceColor * lightIntensity; //Compute final rendered color
-		}
-	)"))
+		"	outputColor = surfaceColor * lightIntensity; //Compute final rendered color\n"
+		"}\n"
+	))
 	{
 		std::cerr << shader->log().toStdString() << std::endl;
 		exit(EXIT_FAILURE);
diff --git a/examples/common/OpenGLWidget.cpp b/examples/common/OpenGLWidget.cpp
index e0ea7de4..96cbe1ce 100644
--- a/examples/common/OpenGLWidget.cpp
+++ b/examples/common/OpenGLWidget.cpp
@@ -91,28 +91,28 @@ void OpenGLWidget::initializeGL()
 	
 	// This is basically a simple fallback vertex shader which does the most basic rendering possible.  
 	// PolyVox examples are able to provide their own shaders to demonstrate certain effects if desired. 
-	if (!mShader->addShaderFromSourceCode(QGLShader::Vertex, R"(
-		#version 140
+	if (!mShader->addShaderFromSourceCode(QGLShader::Vertex,
+		"#version 140\n"
 		
-		in vec4 position; // This will be the position of the vertex in model-space
+		"in vec4 position; // This will be the position of the vertex in model-space\n"
 		
-		// The usual matrices are provided
-		uniform mat4 cameraToClipMatrix;
-		uniform mat4 worldToCameraMatrix;
-		uniform mat4 modelToWorldMatrix;
+		"// The usual matrices are provided\n"
+		"uniform mat4 cameraToClipMatrix;\n"
+		"uniform mat4 worldToCameraMatrix;\n"
+		"uniform mat4 modelToWorldMatrix;\n"
 		
-		// This will be used by the fragment shader to calculate flat-shaded normals. This is an unconventional approach
-		// but we use it in this example framework because not all surface extractor generate surface normals.
-		out vec4 worldPosition;
+		"// This will be used by the fragment shader to calculate flat-shaded normals. This is an unconventional approach\n"
+		"// but we use it in this example framework because not all surface extractor generate surface normals.\n"
+		"out vec4 worldPosition;\n"
 		
-		void main()
-		{
-			// Standard sequence of OpenGL transformations.
-			worldPosition = modelToWorldMatrix * position;
-			vec4 cameraPosition = worldToCameraMatrix * worldPosition;
-			gl_Position = cameraToClipMatrix * cameraPosition;
-		}
-	)"))
+		"void main()\n"
+		"{\n"
+		"	// Standard sequence of OpenGL transformations.\n"
+		"	worldPosition = modelToWorldMatrix * position;\n"
+		"	vec4 cameraPosition = worldToCameraMatrix * worldPosition;\n"
+		"	gl_Position = cameraToClipMatrix * cameraPosition;\n"
+		"}\n"
+	))
 	{
 		std::cerr << mShader->log().toStdString() << std::endl;
 		exit(EXIT_FAILURE);
@@ -120,27 +120,27 @@ void OpenGLWidget::initializeGL()
 	
 	// This is basically a simple fallback fragment shader which does the most basic rendering possible.  
 	// PolyVox examples are able to provide their own shaders to demonstrate certain effects if desired. 
-	if (!mShader->addShaderFromSourceCode(QGLShader::Fragment, R"(
-		#version 130
+	if (!mShader->addShaderFromSourceCode(QGLShader::Fragment,
+		"#version 130\n"
 		
-		// Passed in from the vertex shader
-		in vec4 worldPosition;
-		in vec4 worldNormal;
+		"// Passed in from the vertex shader\n"
+		"in vec4 worldPosition;\n"
+		"in vec4 worldNormal;\n"
 		
-		// the color that gets written to the display
-		out vec4 outputColor;
+		"// the color that gets written to the display\n"
+		"out vec4 outputColor;\n"
 		
-		void main()
-		{
-			// Again, for the purposes of these examples we cannot be sure that per-vertex normals are provided. A sensible fallback 
-			// is to use this little trick to compute per-fragment flat-shaded normals from the world positions using derivative operations.
-			vec3 normal = normalize(cross(dFdy(worldPosition.xyz), dFdx(worldPosition.xyz)));
+		"void main()\n"
+		"{\n"
+		"	// Again, for the purposes of these examples we cannot be sure that per-vertex normals are provided. A sensible fallback \n"
+		"	// is to use this little trick to compute per-fragment flat-shaded normals from the world positions using derivative operations.\n"
+		"	vec3 normal = normalize(cross(dFdy(worldPosition.xyz), dFdx(worldPosition.xyz)));\n"
 			
-			// We are just using the normal as the output color, and making it lighter so it looks a bit nicer. 
-			// Obviously a real shader would also do texuring, lighting, or whatever is required for the application.
-			outputColor = vec4(abs(normal) * 0.5 + vec3(0.5, 0.5, 0.5), 1.0);
-		}
-	)"))
+		"	// We are just using the normal as the output color, and making it lighter so it looks a bit nicer. \n"
+		"	// Obviously a real shader would also do texuring, lighting, or whatever is required for the application.\n"
+		"	outputColor = vec4(abs(normal) * 0.5 + vec3(0.5, 0.5, 0.5), 1.0);\n"
+		"}\n"
+	))
 	{
 		std::cerr << mShader->log().toStdString() << std::endl;
 		exit(EXIT_FAILURE);