diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h
index 89ebb2da7..429e02fd5 100644
--- a/renderdoc/driver/gl/gl_common.h
+++ b/renderdoc/driver/gl/gl_common.h
@@ -64,6 +64,7 @@ struct GLWindowingData
 
 #include "replay/renderdoc.h"
 
+// similar to RDCUNIMPLEMENTED but for things that are hit often so we don't want to fire the debugbreak.
 #define GLNOTIMP(...) RDCDEBUG("OpenGL not implemented - " __VA_ARGS__)
 
 #define IMPLEMENT_FUNCTION_SERIALISED(ret, func) ret func; bool CONCAT(Serialise_, func);
diff --git a/renderdoc/driver/gl/gl_replay.cpp b/renderdoc/driver/gl/gl_replay.cpp
index 936bc4863..98b0c742b 100644
--- a/renderdoc/driver/gl/gl_replay.cpp
+++ b/renderdoc/driver/gl/gl_replay.cpp
@@ -1192,13 +1192,13 @@ void GLReplay::FillCBufferVariables(ResourceId shader, uint32_t cbufSlot, vector
 
 bool GLReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, float *minval, float *maxval)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("GetMinMax");
 	return false;
 }
 
 bool GLReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t mip, float minval, float maxval, bool channels[4], vector<uint32_t> &histogram)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("GetHistogram");
 	return false;
 }
 
@@ -1215,17 +1215,17 @@ vector<EventUsage> GLReplay::GetUsage(ResourceId id)
 
 void GLReplay::SetContextFilter(ResourceId id, uint32_t firstDefEv, uint32_t lastDefEv)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("SetContextFilter");
 }
 
 void GLReplay::FreeTargetResource(ResourceId id)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("FreeTargetResource");
 }
 
 void GLReplay::FreeCustomShader(ResourceId id)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("FreeCustomShader");
 }
 
 PostVSMeshData GLReplay::GetPostVSBuffers(uint32_t frameID, uint32_t eventID, MeshDataStage stage)
@@ -1240,74 +1240,74 @@ PostVSMeshData GLReplay::GetPostVSBuffers(uint32_t frameID, uint32_t eventID, Me
 
 byte *GLReplay::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip, size_t &dataSize)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("GetTextureData");
 	return NULL;
 }
 
 void GLReplay::ReplaceResource(ResourceId from, ResourceId to)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("ReplaceResource");
 }
 
 void GLReplay::RemoveReplacement(ResourceId id)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("RemoveReplacement");
 }
 
 void GLReplay::TimeDrawcalls(rdctype::array<FetchDrawcall> &arr)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("TimeDrawcalls");
 }
 
 bool GLReplay::SaveTexture(ResourceId tex, uint32_t saveMip, wstring path)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("SaveTexture");
 	return false;
 }
 
 void GLReplay::BuildTargetShader(string source, string entry, const uint32_t compileFlags, ShaderStageType type, ResourceId *id, string *errors)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("BuildTargetShader");
 }
 
 void GLReplay::BuildCustomShader(string source, string entry, const uint32_t compileFlags, ShaderStageType type, ResourceId *id, string *errors)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("BuildCustomShader");
 }
 
 ShaderDebugTrace GLReplay::DebugVertex(uint32_t frameID, uint32_t eventID, uint32_t vertid, uint32_t instid, uint32_t idx, uint32_t instOffset, uint32_t vertOffset)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("DebugVertex");
 	return ShaderDebugTrace();
 }
 
 ShaderDebugTrace GLReplay::DebugPixel(uint32_t frameID, uint32_t eventID, uint32_t x, uint32_t y)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("DebugPixel");
 	return ShaderDebugTrace();
 }
 
 ShaderDebugTrace GLReplay::DebugThread(uint32_t frameID, uint32_t eventID, uint32_t groupid[3], uint32_t threadid[3])
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("DebugThread");
 	return ShaderDebugTrace();
 }
 
 ResourceId GLReplay::ApplyCustomShader(ResourceId shader, ResourceId texid, uint32_t mip)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("ApplyCustomShader");
 	return ResourceId();
 }
 
 ResourceId GLReplay::CreateProxyTexture( FetchTexture templateTex )
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("CreateProxyTexture");
 	return ResourceId();
 }
 
 void GLReplay::SetProxyTextureData(ResourceId texid, uint32_t arrayIdx, uint32_t mip, byte *data, size_t dataSize)
 {
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("SetProxyTextureData");
 }
 
 const GLHookSet &GetRealFunctions();
diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
index 471aa03ac..1a570cfea 100644
--- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
+++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
@@ -298,13 +298,11 @@ void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr
 {
 	if(m_State >= WRITING)
 	{
-		// haven't implemented non-invalidating write maps
 		if((access & (GL_MAP_INVALIDATE_BUFFER_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_READ_BIT)) == 0)
-			RDCUNIMPLEMENTED();
+			RDCUNIMPLEMENTED("haven't implemented non-invalidating glMap WRITE");
 		
-		// haven't implemented coherent/persistent bits
 		if((access & (GL_MAP_COHERENT_BIT|GL_MAP_PERSISTENT_BIT)) != 0)
-			RDCUNIMPLEMENTED();
+			RDCUNIMPLEMENTED("haven't implemented coherent/persistant glMap calls");
 
 		m_BufferRecord[BufferIdx(target)]->Map.offset = offset;
 		m_BufferRecord[BufferIdx(target)]->Map.length = length;
diff --git a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp
index 09e9afd2f..7706006cc 100644
--- a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp
+++ b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp
@@ -44,14 +44,7 @@ bool WrappedOpenGL::Serialise_glCreateShader(GLuint shader, GLenum type)
 
 		m_Shaders[liveId].type = Type;
 
-		if(m_State >= WRITING)
-		{
-			RDCUNIMPLEMENTED();
-		}
-		else
-		{
-			GetResourceManager()->AddLiveResource(id, res);
-		}
+		GetResourceManager()->AddLiveResource(id, res);
 	}
 
 	return true;
diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp
index e0fd965a9..ceea09d76 100644
--- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp
+++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp
@@ -409,42 +409,42 @@ void WrappedOpenGL::glTexImage1D(GLenum target, GLint level, GLint internalforma
 {
 	m_Real.glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
 
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("Old glTexImage1D API not implemented");
 }
 
 void WrappedOpenGL::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
 	m_Real.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("Old glTexImage2D API not implemented");
 }
 
 void WrappedOpenGL::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
 	m_Real.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("Old glTexImage3D API not implemented");
 }
 
 void WrappedOpenGL::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels)
 {
 	m_Real.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, pixels);
 
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("Old glCompressedTexImage1D API not implemented");
 }
 
 void WrappedOpenGL::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels)
 {
 	m_Real.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels);
 
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("Old glCompressedTexImage2D API not implemented");
 }
 
 void WrappedOpenGL::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels)
 {
 	m_Real.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, pixels);
 
-	RDCUNIMPLEMENTED();
+	RDCUNIMPLEMENTED("Old glCompressedTexImage3D API not implemented");
 }
 
 bool WrappedOpenGL::Serialise_glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)