diff --git a/src/api/graphics.c b/src/api/graphics.c
index d872eb14..455e40ed 100644
--- a/src/api/graphics.c
+++ b/src/api/graphics.c
@@ -256,7 +256,7 @@ int l_lovrGraphicsInit(lua_State* L) {
   luax_registertype(L, "Shader", lovrShader);
   luax_registertype(L, "ShaderBlock", lovrShaderBlock);
   luax_registertype(L, "Texture", lovrTexture);
-  luax_extendtype(L, "Texture", "Canvas", lovrTexture, lovrCanvas);
+  luax_registertype(L, "Canvas", lovrCanvas);
 
   luax_pushconf(L);
 
@@ -436,22 +436,10 @@ int l_lovrGraphicsSetBlendMode(lua_State* L) {
 }
 
 int l_lovrGraphicsGetCanvas(lua_State* L) {
-  Canvas* canvas[MAX_CANVASES];
-  int count;
-  lovrGraphicsGetCanvas(canvas, &count);
-  for (int i = 0; i < count; i++) {
-    luax_pushobject(L, canvas[i]);
-  }
-  return count;
+  return 0;
 }
 
 int l_lovrGraphicsSetCanvas(lua_State* L) {
-  Canvas* canvas[MAX_CANVASES];
-  int count = MIN(lua_gettop(L), MAX_CANVASES);
-  for (int i = 0; i < count; i++) {
-    canvas[i] = luax_checktype(L, i + 1, Canvas);
-  }
-  lovrGraphicsSetCanvas(canvas, count);
   return 0;
 }
 
@@ -949,37 +937,7 @@ int l_lovrGraphicsNewShaderBlock(lua_State* L) {
 }
 
 int l_lovrGraphicsNewCanvas(lua_State* L) {
-  int width = luaL_checkinteger(L, 1);
-  int height = luaL_checkinteger(L, 2);
-  luaL_argcheck(L, width > 0, 1, "width must be positive");
-  luaL_argcheck(L, height > 0, 2, "height must be positive");
-
-  TextureFormat format = FORMAT_RGBA;
-  CanvasFlags flags = { .msaa = 0, .depth = true, .stencil = false, .mipmaps = true };
-
-  if (lua_istable(L, 3)) {
-    lua_getfield(L, 3, "format");
-    format = luaL_checkoption(L, -1, "rgba", TextureFormats);
-    lua_pop(L, 1);
-
-    lua_getfield(L, 3, "msaa");
-    flags.msaa = luaL_optinteger(L, -1, 0);
-    lua_pop(L, 1);
-
-    lua_getfield(L, 3, "depth");
-    flags.depth = lua_toboolean(L, -1);
-    lua_pop(L, 1);
-
-    lua_getfield(L, 3, "stencil");
-    flags.stencil = lua_toboolean(L, -1);
-    lua_pop(L, 1);
-
-    lua_getfield(L, 3, "mipmaps");
-    flags.mipmaps = lua_toboolean(L, -1);
-    lua_pop(L, 1);
-  }
-
-  Canvas* canvas = lovrCanvasCreate(width, height, format, flags);
+  Canvas* canvas = lovrCanvasCreate();
   luax_pushobject(L, canvas);
   lovrRelease(canvas);
   return 1;
diff --git a/src/api/types/canvas.c b/src/api/types/canvas.c
index 253aa9e5..11345bdd 100644
--- a/src/api/types/canvas.c
+++ b/src/api/types/canvas.c
@@ -1,46 +1,6 @@
 #include "api.h"
-#include "graphics/graphics.h"
 #include "graphics/canvas.h"
 
-int l_lovrCanvasRenderTo(lua_State* L) {
-  Canvas* canvas = luax_checktype(L, 1, Canvas);
-  luaL_checktype(L, 2, LUA_TFUNCTION);
-  int nargs = lua_gettop(L) - 2;
-
-  Canvas* old[MAX_CANVASES];
-  int count;
-  lovrGraphicsGetCanvas(old, &count);
-  lovrGraphicsSetCanvas(&canvas, 1);
-  lua_call(L, nargs, 0);
-  lovrGraphicsSetCanvas(old, count);
-  return 0;
-}
-
-int l_lovrCanvasGetFormat(lua_State* L) {
-  Canvas* canvas = luax_checktype(L, 1, Canvas);
-  TextureFormat format = lovrCanvasGetFormat(canvas);
-  lua_pushstring(L, TextureFormats[format]);
-  return 1;
-}
-
-int l_lovrCanvasGetMSAA(lua_State* L) {
-  Canvas* canvas = luax_checktype(L, 1, Canvas);
-  lua_pushinteger(L, lovrCanvasGetMSAA(canvas));
-  return 1;
-}
-
-int l_lovrCanvasNewTextureData(lua_State* L) {
-  Canvas* canvas = luax_checktype(L, 1, Canvas);
-  TextureData* textureData = lovrCanvasNewTextureData(canvas);
-  luax_pushobject(L, textureData);
-  lovrRelease(textureData);
-  return 1;
-}
-
 const luaL_Reg lovrCanvas[] = {
-  { "renderTo", l_lovrCanvasRenderTo },
-  { "getFormat", l_lovrCanvasGetFormat },
-  { "getMSAA", l_lovrCanvasGetMSAA },
-  { "newTextureData", l_lovrCanvasNewTextureData },
   { NULL, NULL }
 };
diff --git a/src/graphics/canvas.h b/src/graphics/canvas.h
index f68ee969..70722694 100644
--- a/src/graphics/canvas.h
+++ b/src/graphics/canvas.h
@@ -1,25 +1,6 @@
-#include "graphics/texture.h"
-#include "data/textureData.h"
-#include <stdbool.h>
-
 #pragma once
 
-#define MAX_CANVASES 4
-
-typedef struct {
-  int msaa;
-  bool depth;
-  bool stencil;
-  bool mipmaps;
-} CanvasFlags;
-
 typedef struct Canvas Canvas;
 
-bool lovrCanvasSupportsFormat(TextureFormat format);
-
-Canvas* lovrCanvasCreate(int width, int height, TextureFormat format, CanvasFlags flags);
+Canvas* lovrCanvasCreate();
 void lovrCanvasDestroy(void* ref);
-void lovrCanvasResolve(Canvas* canvas);
-TextureFormat lovrCanvasGetFormat(Canvas* canvas);
-int lovrCanvasGetMSAA(Canvas* canvas);
-TextureData* lovrCanvasNewTextureData(Canvas* canvas);
diff --git a/src/graphics/graphics.c b/src/graphics/graphics.c
index 117a13f4..4458f1d1 100644
--- a/src/graphics/graphics.c
+++ b/src/graphics/graphics.c
@@ -34,7 +34,6 @@ void lovrGraphicsDestroy() {
   }
   lovrGraphicsSetShader(NULL);
   lovrGraphicsSetFont(NULL);
-  lovrGraphicsSetCanvas(NULL, 0);
   for (int i = 0; i < MAX_DEFAULT_SHADERS; i++) {
     lovrRelease(state.defaultShaders[i]);
   }
@@ -142,9 +141,8 @@ void lovrGraphicsSetCamera(Camera* camera, bool clear) {
   }
 
   if (clear) {
-    int canvasCount = state.camera.canvas != NULL;
     Color backgroundColor = lovrGraphicsGetBackgroundColor();
-    lovrGpuClear(&state.camera.canvas, canvasCount, &backgroundColor, &(float) { 1. }, &(int) { 0 });
+    lovrGpuClear(state.camera.canvas, &backgroundColor, &(float) { 1. }, &(int) { 0 });
   }
 }
 
@@ -158,7 +156,6 @@ void lovrGraphicsReset() {
   lovrGraphicsSetCamera(NULL, false);
   lovrGraphicsSetBackgroundColor((Color) { 0, 0, 0, 1 });
   lovrGraphicsSetBlendMode(BLEND_ALPHA, BLEND_ALPHA_MULTIPLY);
-  lovrGraphicsSetCanvas(NULL, 0);
   lovrGraphicsSetColor((Color) { 1, 1, 1, 1 });
   lovrGraphicsSetCullingEnabled(false);
   lovrGraphicsSetDefaultFilter((TextureFilter) { .mode = FILTER_TRILINEAR });
@@ -176,17 +173,11 @@ void lovrGraphicsReset() {
 void lovrGraphicsPushPipeline() {
   lovrAssert(++state.pipeline < MAX_PIPELINES, "Unbalanced pipeline stack (more pushes than pops?)");
   memcpy(&state.pipelines[state.pipeline], &state.pipelines[state.pipeline - 1], sizeof(Pipeline));
-  for (int i = 0; i < state.pipelines[state.pipeline].canvasCount; i++) {
-    lovrRetain(state.pipelines[state.pipeline].canvas[i]);
-  }
   lovrRetain(state.pipelines[state.pipeline].font);
   lovrRetain(state.pipelines[state.pipeline].shader);
 }
 
 void lovrGraphicsPopPipeline() {
-  for (int i = 0; i < state.pipelines[state.pipeline].canvasCount; i++) {
-    lovrRelease(state.pipelines[state.pipeline].canvas[i]);
-  }
   lovrRelease(state.pipelines[state.pipeline].font);
   lovrRelease(state.pipelines[state.pipeline].shader);
   lovrAssert(--state.pipeline >= 0, "Unbalanced pipeline stack (more pops than pushes?)");
@@ -210,24 +201,6 @@ void lovrGraphicsSetBlendMode(BlendMode mode, BlendAlphaMode alphaMode) {
   state.pipelines[state.pipeline].blendAlphaMode = alphaMode;
 }
 
-void lovrGraphicsGetCanvas(Canvas** canvas, int* count) {
-  *count = state.pipelines[state.pipeline].canvasCount;
-  memcpy(canvas, state.pipelines[state.pipeline].canvas, *count);
-}
-
-void lovrGraphicsSetCanvas(Canvas** canvas, int count) {
-  for (int i = 0; i < count; i++) {
-    lovrRetain(canvas[i]);
-  }
-
-  for (int i = 0; i < state.pipelines[state.pipeline].canvasCount; i++) {
-    lovrRelease(state.pipelines[state.pipeline].canvas[i]);
-  }
-
-  memcpy(state.pipelines[state.pipeline].canvas, canvas, count * sizeof(Canvas*));
-  state.pipelines[state.pipeline].canvasCount = count;
-}
-
 Color lovrGraphicsGetColor() {
   return state.pipelines[state.pipeline].color;
 }
@@ -381,11 +354,7 @@ VertexPointer lovrGraphicsGetVertexPointer(uint32_t count) {
 
 void lovrGraphicsClear(Color* color, float* depth, int* stencil) {
   Pipeline* pipeline = &state.pipelines[state.pipeline];
-  if (pipeline->canvasCount > 0) {
-    lovrGpuClear(pipeline->canvas, pipeline->canvasCount, color, depth, stencil);
-  } else {
-    lovrGpuClear(&state.camera.canvas, state.camera.canvas != NULL, color, depth, stencil);
-  }
+  lovrGpuClear(state.camera.canvas, color, depth, stencil);
 }
 
 void lovrGraphicsDraw(DrawOptions* draw) {
diff --git a/src/graphics/graphics.h b/src/graphics/graphics.h
index 29bd3075..dd3969d4 100644
--- a/src/graphics/graphics.h
+++ b/src/graphics/graphics.h
@@ -106,8 +106,6 @@ typedef struct {
   Color backgroundColor;
   BlendMode blendMode;
   BlendAlphaMode blendAlphaMode;
-  Canvas* canvas[MAX_CANVASES];
-  int canvasCount;
   Color color;
   bool culling;
   CompareMode depthTest;
@@ -192,8 +190,6 @@ Color lovrGraphicsGetBackgroundColor();
 void lovrGraphicsSetBackgroundColor(Color color);
 void lovrGraphicsGetBlendMode(BlendMode* mode, BlendAlphaMode* alphaMode);
 void lovrGraphicsSetBlendMode(BlendMode mode, BlendAlphaMode alphaMode);
-void lovrGraphicsGetCanvas(Canvas** canvas, int* count);
-void lovrGraphicsSetCanvas(Canvas** canvas, int count);
 Color lovrGraphicsGetColor();
 void lovrGraphicsSetColor(Color color);
 bool lovrGraphicsIsCullingEnabled();
@@ -252,7 +248,7 @@ typedef void (*gpuProc)(void);
 
 void lovrGpuInit(bool srgb, bool singlepass, gpuProc (*getProcAddress)(const char*));
 void lovrGpuDestroy();
-void lovrGpuClear(Canvas** canvas, int canvasCount, Color* color, float* depth, int* stencil);
+void lovrGpuClear(Canvas* canvas, Color* color, float* depth, int* stencil);
 void lovrGpuDraw(DrawCommand* command);
 void lovrGpuCompute(Shader* shader, int x, int y, int z);
 void lovrGpuWait(uint8_t flags);
diff --git a/src/graphics/opengl.c b/src/graphics/opengl.c
index c6a9b1e9..1dc09bb5 100644
--- a/src/graphics/opengl.c
+++ b/src/graphics/opengl.c
@@ -49,8 +49,6 @@ static struct {
   bool stencilWriting;
   Winding winding;
   bool wireframe;
-  Canvas* canvas[MAX_CANVASES];
-  int canvasCount;
   uint32_t framebuffer;
   uint32_t indexBuffer;
   uint32_t program;
@@ -111,13 +109,8 @@ struct Texture {
 };
 
 struct Canvas {
-  Texture texture;
-  GLuint framebuffer;
-  GLuint resolveFramebuffer;
-  GLuint depthStencilBuffer;
-  GLuint msaaTexture;
-  CanvasFlags flags;
-  Canvas** attachments[MAX_CANVASES];
+  Ref ref;
+  uint32_t framebuffer;
 };
 
 typedef struct {
@@ -286,16 +279,6 @@ static GLenum convertMeshDrawMode(MeshDrawMode mode) {
   }
 }
 
-static bool isCanvasFormatSupported(TextureFormat format) {
-  switch (format) {
-    case FORMAT_DXT1:
-    case FORMAT_DXT3:
-    case FORMAT_DXT5:
-      return false;
-    default: return true;
-  }
-}
-
 static UniformType getUniformType(GLenum type, const char* debug) {
   switch (type) {
     case GL_FLOAT:
@@ -448,13 +431,6 @@ static void lovrGpuCleanupIncoherentResource(void* resource, uint8_t incoherent)
 
 // GPU
 
-static void lovrGpuBindFramebuffer(uint32_t framebuffer) {
-  if (state.framebuffer != framebuffer) {
-    state.framebuffer = framebuffer;
-    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-  }
-}
-
 static void lovrGpuBindIndexBuffer(uint32_t indexBuffer) {
   if (state.indexBuffer != indexBuffer) {
     state.indexBuffer = indexBuffer;
@@ -529,13 +505,6 @@ static void lovrGpuBindVertexBuffer(uint32_t vertexBuffer) {
   }
 }
 
-static void lovrGpuSetViewport(float viewport[4]) {
-  if (memcmp(state.viewport, viewport, 4 * sizeof(float))) {
-    memcpy(state.viewport, viewport, 4 * sizeof(float));
-    glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
-  }
-}
-
 static void lovrGpuUseProgram(uint32_t program) {
   if (state.program != program) {
     state.program = program;
@@ -590,34 +559,7 @@ void lovrGpuDestroy() {
   }
 }
 
-void lovrGpuClear(Canvas** canvas, int canvasCount, Color* color, float* depth, int* stencil) {
-  lovrGpuBindFramebuffer(canvasCount > 0 ? canvas[0]->framebuffer : 0);
-
-  if (color) {
-    gammaCorrectColor(color);
-    float c[4] = { color->r, color->g, color->b, color->a };
-    glClearBufferfv(GL_COLOR, 0, c);
-    for (int i = 1; i < canvasCount; i++) {
-      glClearBufferfv(GL_COLOR, i, c);
-    }
-  }
-
-  if (depth) {
-    if (!state.depthWrite) {
-      state.depthWrite = true;
-      glDepthMask(state.depthWrite);
-    }
-
-    glClearBufferfv(GL_DEPTH, 0, depth);
-  }
-
-  if (stencil) {
-    glClearBufferiv(GL_STENCIL, 0, stencil);
-  }
-
-  if (canvasCount > 0) {
-    lovrCanvasResolve(canvas[0]);
-  }
+void lovrGpuClear(Canvas* canvas, Color* color, float* depth, int* stencil) {
 }
 
 void lovrGraphicsStencil(StencilAction action, int replaceValue, StencilCallback callback, void* userdata) {
@@ -864,65 +806,14 @@ void lovrGpuDraw(DrawCommand* command) {
 
   lovrShaderSetMatrices(shader, "lovrMaterialTransform", material->transform, 0, 9);
 
-  // Canvas
-  Canvas** canvas = pipeline->canvasCount > 0 ? pipeline->canvas : &command->camera.canvas;
-  int canvasCount = pipeline->canvasCount > 0 ? pipeline->canvasCount : (command->camera.canvas != NULL);
-  if (canvasCount != state.canvasCount || memcmp(state.canvas, canvas, canvasCount * sizeof(Canvas*))) {
-    if (state.canvasCount > 0) {
-      lovrCanvasResolve(state.canvas[0]);
-    }
-
-    state.canvasCount = canvasCount;
-
-    if (canvasCount > 0) {
-      memcpy(state.canvas, canvas, canvasCount * sizeof(Canvas*));
-      lovrGpuBindFramebuffer(canvas[0]->framebuffer);
-
-      GLenum buffers[MAX_CANVASES];
-      for (int i = 0; i < canvasCount; i++) {
-        buffers[i] = GL_COLOR_ATTACHMENT0 + i;
-        if (canvas[i]->flags.msaa > 0) {
-          glFramebufferRenderbuffer(GL_FRAMEBUFFER, buffers[i], GL_RENDERBUFFER, canvas[i]->msaaTexture);
-        } else {
-          glFramebufferTexture2D(GL_FRAMEBUFFER, buffers[i], GL_TEXTURE_2D, lovrTextureGetId((Texture*) canvas[i]), 0);
-        }
-      }
-      glDrawBuffers(canvasCount, buffers);
-
-      GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-      lovrAssert(status == GL_FRAMEBUFFER_COMPLETE, "Unable to bind framebuffer");
-    } else {
-      lovrGpuBindFramebuffer(0);
-    }
-  }
-
-  // We need to synchronize if any attached textures have pending writes
-  for (int i = 0; i < canvasCount; i++) {
-    if ((canvas[i]->texture.incoherent >> BARRIER_CANVAS) & 1) {
-      lovrGpuWait(1 << BARRIER_CANVAS);
-      break;
-    }
-  }
-
   // Bind attributes
   lovrMeshBind(mesh, shader);
 
-  bool stereo = pipeline->canvasCount == 0 && command->camera.stereo == true;
+  bool stereo = false;
   int drawCount = 1 + (stereo == true && !state.singlepass);
 
   // Draw (TODEW)
   for (int i = 0; i < drawCount; i++) {
-    if (pipeline->canvasCount > 0) {
-      int width = lovrTextureGetWidth((Texture*) pipeline->canvas[0], 0);
-      int height = lovrTextureGetHeight((Texture*) pipeline->canvas[0], 0);
-      lovrGpuSetViewport((float[4]) { 0, 0, width, height });
-#ifndef EMSCRIPTEN
-    } else if (state.singlepass) {
-      glViewportArrayv(0, 2, command->camera.viewport[0]);
-#endif
-    } else  {
-      lovrGpuSetViewport(command->camera.viewport[i]);
-    }
 
     // Bind uniforms
     lovrShaderSetInts(shader, "lovrIsStereo", &(int) { stereo && state.singlepass }, 0, 1);
@@ -1295,125 +1186,16 @@ void lovrTextureSetWrap(Texture* texture, TextureWrap wrap) {
 
 // Canvas
 
-Canvas* lovrCanvasCreate(int width, int height, TextureFormat format, CanvasFlags flags) {
-  lovrAssert(isCanvasFormatSupported(format), "Unsupported texture format for Canvas");
+Canvas* lovrCanvasCreate() {
   Canvas* canvas = lovrAlloc(Canvas, lovrCanvasDestroy);
-  Texture* texture = lovrTextureCreate(TEXTURE_2D, NULL, 0, true, flags.mipmaps);
-
-  if (!canvas || !texture) {
-    lovrRelease(canvas);
-    lovrRelease(texture);
-    return NULL;
-  }
-
-  lovrTextureAllocate(texture, width, height, 1, format);
-
-  Ref ref = canvas->texture.ref;
-  canvas->texture = *texture;
-  canvas->texture.ref = ref;
-  canvas->flags = flags;
-
-  // Framebuffer
-  glGenFramebuffers(1, &canvas->framebuffer);
-  lovrGpuBindFramebuffer(canvas->framebuffer);
-
-  // Color attachment
-  if (flags.msaa > 0) {
-    GLenum internalFormat = convertTextureFormatInternal(format, lovrGraphicsIsGammaCorrect());
-    glGenRenderbuffers(1, &canvas->msaaTexture);
-    glBindRenderbuffer(GL_RENDERBUFFER, canvas->msaaTexture);
-    glRenderbufferStorageMultisample(GL_RENDERBUFFER, flags.msaa, internalFormat, width, height);
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, canvas->msaaTexture);
-  } else {
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, canvas->texture.id, 0);
-  }
-
-  // Depth/Stencil
-  if (flags.depth || flags.stencil) {
-    GLenum depthStencilFormat = flags.stencil ? GL_DEPTH24_STENCIL8 : GL_DEPTH_COMPONENT24;
-    glGenRenderbuffers(1, &canvas->depthStencilBuffer);
-    glBindRenderbuffer(GL_RENDERBUFFER, canvas->depthStencilBuffer);
-    if (flags.msaa > 0) {
-      glRenderbufferStorageMultisample(GL_RENDERBUFFER, flags.msaa, depthStencilFormat, width, height);
-    } else {
-      glRenderbufferStorage(GL_RENDERBUFFER, depthStencilFormat, width, height);
-    }
-
-    if (flags.depth) {
-      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, canvas->depthStencilBuffer);
-    }
-
-    if (flags.stencil) {
-      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, canvas->depthStencilBuffer);
-    }
-  }
-
-  // Resolve framebuffer
-  if (flags.msaa > 0) {
-    glGenFramebuffers(1, &canvas->resolveFramebuffer);
-    lovrGpuBindFramebuffer(canvas->resolveFramebuffer);
-    glBindTexture(GL_TEXTURE_2D, canvas->texture.id);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, canvas->texture.id, 0);
-    lovrGpuBindFramebuffer(canvas->framebuffer);
-  }
-
-  lovrAssert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE, "Error creating Canvas");
-  lovrGpuClear(&canvas, 1, &(Color) { 0, 0, 0, 0 }, &(float) { 1. }, &(int) { 0 });
+  if (!canvas) return NULL;
 
   return canvas;
 }
 
 void lovrCanvasDestroy(void* ref) {
   Canvas* canvas = ref;
-  glDeleteFramebuffers(1, &canvas->framebuffer);
-  if (canvas->resolveFramebuffer) {
-    glDeleteFramebuffers(1, &canvas->resolveFramebuffer);
-  }
-  if (canvas->depthStencilBuffer) {
-    glDeleteRenderbuffers(1, &canvas->depthStencilBuffer);
-  }
-  if (canvas->msaaTexture) {
-    glDeleteTextures(1, &canvas->msaaTexture);
-  }
-  lovrTextureDestroy(ref);
-}
-
-void lovrCanvasResolve(Canvas* canvas) {
-  if (canvas->flags.msaa > 0) {
-    int width = canvas->texture.width;
-    int height = canvas->texture.height;
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, canvas->framebuffer);
-    lovrGpuBindFramebuffer(canvas->resolveFramebuffer);
-    glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-  }
-
-  if (canvas->flags.mipmaps) {
-    lovrGpuBindTexture(&canvas->texture, 0);
-    glGenerateMipmap(canvas->texture.target);
-  }
-}
-
-TextureFormat lovrCanvasGetFormat(Canvas* canvas) {
-  return canvas->texture.format;
-}
-
-int lovrCanvasGetMSAA(Canvas* canvas) {
-  return canvas->flags.msaa;
-}
-
-TextureData* lovrCanvasNewTextureData(Canvas* canvas) {
-  TextureData* textureData = lovrTextureDataGetBlank(canvas->texture.width, canvas->texture.height, 0, FORMAT_RGBA);
-  if (!textureData) return NULL;
-
-  if ((canvas->texture.incoherent >> BARRIER_TEXTURE) & 1) {
-    lovrGpuWait(1 << BARRIER_TEXTURE);
-  }
-
-  lovrGpuBindFramebuffer(canvas->framebuffer);
-  glReadPixels(0, 0, canvas->texture.width, canvas->texture.height, GL_RGBA, GL_UNSIGNED_BYTE, textureData->blob.data);
-
-  return textureData;
+  free(ref);
 }
 
 // Shader
diff --git a/src/headset/openvr.c b/src/headset/openvr.c
index dd445f34..b6c146d8 100644
--- a/src/headset/openvr.c
+++ b/src/headset/openvr.c
@@ -240,11 +240,7 @@ static void ensureCanvas() {
     return;
   }
 
-  int maxMSAA = lovrGraphicsGetLimits().textureMSAA;
-  int msaa = state.msaa == -1 ? maxMSAA : MIN(state.msaa, maxMSAA);
-  state.system->GetRecommendedRenderTargetSize(&state.renderWidth, &state.renderHeight);
-  CanvasFlags flags = { .msaa = msaa, .depth = true, .stencil = true, .mipmaps = false };
-  state.canvas = lovrCanvasCreate(state.renderWidth * 2, state.renderHeight, FORMAT_RGB, flags);
+  state.canvas = lovrCanvasCreate();
 }
 
 static bool openvrInit(float offset, int msaa) {
@@ -685,12 +681,10 @@ static void openvrRenderTo(void (*callback)(void*), void* userdata) {
   lovrGraphicsSetCamera(&camera, true);
   callback(userdata);
   lovrGraphicsSetCamera(NULL, false);
-  lovrGraphicsSetCanvas(NULL, 0);
-  lovrCanvasResolve(state.canvas);
   state.isRendering = false;
 
   // Submit
-  uintptr_t texture = (uintptr_t) lovrTextureGetId((Texture*) state.canvas);
+  uintptr_t texture = (uintptr_t) 0; // TODO
   EColorSpace colorSpace = lovrGraphicsIsGammaCorrect() ? EColorSpace_ColorSpace_Linear : EColorSpace_ColorSpace_Gamma;
   Texture_t eyeTexture = { (void*) texture, ETextureType_TextureType_OpenGL, colorSpace };
   VRTextureBounds_t left = { 0, 0, .5, 1. };
@@ -703,7 +697,7 @@ static void openvrRenderTo(void (*callback)(void*), void* userdata) {
     lovrGraphicsPushPipeline();
     lovrGraphicsSetColor((Color) { 1, 1, 1, 1 });
     lovrGraphicsSetShader(NULL);
-    lovrGraphicsFill((Texture*) state.canvas);
+    // TODO
     lovrGraphicsPopPipeline();
   }
 }