diff --git a/src/components/tools/SelectTool.vue b/src/components/tools/SelectTool.vue
index 8f9ebd4ef..97b5939ad 100644
--- a/src/components/tools/SelectTool.vue
+++ b/src/components/tools/SelectTool.vue
@@ -45,6 +45,8 @@ onVTKEvent(
     // position or, mid capture, nothing at all.
     const { x, y } = event.position;
     const selectedData = await view.widgetManager.getSelectedDataForXY(x, y);
+    // the pick spans a capture, which the view teardown can outrun
+    if (view.widgetManager.isDeleted()) return;
     if ('widget' in selectedData) {
       const widget =
         selectedData.widget as Partial<vtkAnnotationToolWidget> | null;
diff --git a/src/components/vtk/VtkRenderWindowParent.vue b/src/components/vtk/VtkRenderWindowParent.vue
index c4629c69d..ea64ef36d 100644
--- a/src/components/vtk/VtkRenderWindowParent.vue
+++ b/src/components/vtk/VtkRenderWindowParent.vue
@@ -1,8 +1,9 @@
 <script setup lang="ts">
 import { VtkRenderWindowParentContext } from '@/src/components/vtk/context';
+import { releaseOpenGLRenderWindow } from '@/src/core/vtk/releaseRenderWindow';
 import vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
 import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
-import { effectScope, onUnmounted, provide } from 'vue';
+import { effectScope, onScopeDispose, onUnmounted, provide } from 'vue';
 
 const scope = effectScope(true);
 
@@ -12,6 +13,14 @@ const api = scope.run(() => {
   renderWindow.addView(rwView);
   rwView.initialize();
 
+  // Child views unmount before this hook runs, so their nodes are already off
+  // the scene graph by the time the WebGL context they draw through goes away.
+  onScopeDispose(() => {
+    renderWindow.removeView(rwView);
+    releaseOpenGLRenderWindow(rwView as vtkOpenGLRenderWindow);
+    renderWindow.delete();
+  });
+
   return {
     renderWindow,
     renderWindowView: rwView as vtkOpenGLRenderWindow,
diff --git a/src/composables/__tests__/useVolumeThumbnailing.spec.ts b/src/composables/__tests__/useVolumeThumbnailing.spec.ts
new file mode 100644
index 000000000..27df935ef
--- /dev/null
+++ b/src/composables/__tests__/useVolumeThumbnailing.spec.ts
@@ -0,0 +1,139 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { createPinia, setActivePinia } from 'pinia';
+import { defineComponent, h, ref, type Ref } from 'vue';
+import { flushPromises, mount } from '@vue/test-utils';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import { useVolumeThumbnailing } from '@/src/composables/useVolumeThumbnailing';
+import { CurrentImageInjectionKey } from '@/src/composables/useCurrentImage';
+import { useImageCacheStore } from '@/src/store/image-cache';
+import { NOOP } from '@/src/constants';
+import type { createVolumeThumbnailer } from '@/src/core/thumbnailers/volume-thumbnailer';
+
+type Thumbnailer = ReturnType<typeof createVolumeThumbnailer>;
+
+const IMAGE_ID = 'img-1';
+const OTHER_IMAGE_ID = 'img-2';
+
+// the real thumbnailer needs a WebGL context the test DOM cannot provide, so
+// this stands in for the surface the composable touches
+function createStubThumbnailer(capture?: Promise<string>) {
+  let deleted = false;
+  let captureCount = 0;
+  const noopProxy = {
+    setDataRange: NOOP,
+    setMode: NOOP,
+    setPoints: NOOP,
+    setGaussians: NOOP,
+    setPresetName: NOOP,
+  };
+  const renderWindow = {
+    render: NOOP,
+    captureImages: () => {
+      captureCount += 1;
+      return [capture ?? Promise.resolve('')];
+    },
+  };
+  const thumbnailer = {
+    scene: { getRenderWindow: () => renderWindow },
+    opacityFuncProxy: noopProxy,
+    colorTransferFuncProxy: noopProxy,
+    setInputImage: NOOP,
+    resetCameraWithOrientation: NOOP,
+    delete() {
+      deleted = true;
+    },
+  };
+  return {
+    thumbnailer: thumbnailer as unknown as Thumbnailer,
+    isDeleted: () => deleted,
+    getCaptureCount: () => captureCount,
+  };
+}
+
+function addImageToCache(id = IMAGE_ID) {
+  const image = vtkImageData.newInstance();
+  image.setDimensions([2, 2, 2]);
+  image
+    .getPointData()
+    .setScalars(vtkDataArray.newInstance({ values: new Uint8Array(8) }));
+  useImageCacheStore().addVTKImageData(image, 'CT', { id });
+}
+
+function mountThumbnailing(
+  thumbnailer: Thumbnailer,
+  imageID: Ref<string | null>
+) {
+  const component = defineComponent({
+    setup() {
+      useVolumeThumbnailing(64, () => thumbnailer);
+      return () => h('div');
+    },
+  });
+  return mount(component, {
+    global: {
+      provide: {
+        [CurrentImageInjectionKey as symbol]: { imageID },
+      },
+    },
+  });
+}
+
+describe('useVolumeThumbnailing', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  it('disposes the thumbnailer when the component unmounts', async () => {
+    const stub = createStubThumbnailer();
+    const wrapper = mountThumbnailing(stub.thumbnailer, ref(null));
+    expect(stub.isDeleted()).toBe(false);
+
+    wrapper.unmount();
+    await flushPromises();
+
+    expect(stub.isDeleted()).toBe(true);
+  });
+
+  it('holds off deletion until an in-flight capture settles', async () => {
+    let resolveCapture!: (uri: string) => void;
+    const capture = new Promise<string>((resolve) => {
+      resolveCapture = resolve;
+    });
+    const stub = createStubThumbnailer(capture);
+    addImageToCache();
+
+    const wrapper = mountThumbnailing(stub.thumbnailer, ref(IMAGE_ID));
+    await flushPromises();
+    expect(stub.getCaptureCount()).toBe(1);
+
+    // captureImages() finishes its render on a timer, so deleting the render
+    // window while the capture is pending would crash that callback.
+    wrapper.unmount();
+    await flushPromises();
+    expect(stub.isDeleted()).toBe(false);
+
+    resolveCapture('data:image/png;base64,');
+    await flushPromises();
+    expect(stub.isDeleted()).toBe(true);
+
+    // the unmount sentinel keeps the remaining presets from capturing
+    expect(stub.getCaptureCount()).toBe(1);
+  });
+
+  it('starts a new cycle even while an earlier capture never settles', async () => {
+    const stub = createStubThumbnailer(new Promise<string>(() => {}));
+    addImageToCache();
+    addImageToCache(OTHER_IMAGE_ID);
+    const imageID = ref<string | null>(IMAGE_ID);
+
+    mountThumbnailing(stub.thumbnailer, imageID);
+    await flushPromises();
+    expect(stub.getCaptureCount()).toBe(1);
+
+    imageID.value = OTHER_IMAGE_ID;
+    await flushPromises();
+
+    expect(stub.getCaptureCount()).toBeGreaterThan(1);
+  });
+});
diff --git a/src/composables/useVolumeThumbnailing.ts b/src/composables/useVolumeThumbnailing.ts
index f3b5ba307..6dacf8221 100644
--- a/src/composables/useVolumeThumbnailing.ts
+++ b/src/composables/useVolumeThumbnailing.ts
@@ -13,6 +13,7 @@ import {
   getOpacityRangeFromPreset,
 } from '../utils/vtk-helpers';
 import { PresetNameList } from '../vtk/ColorMaps';
+import { logError } from '../utils/loggers';
 
 function resetOpacityFunction(
   pwfProxy: vtkPiecewiseFunctionProxy,
@@ -42,9 +43,12 @@ function resetOpacityFunction(
   }
 }
 
-export function useVolumeThumbnailing(thumbnailSize: number) {
+export function useVolumeThumbnailing(
+  thumbnailSize: number,
+  createThumbnailer = createVolumeThumbnailer
+) {
   const thumbnails = reactive<Record<string, Record<string, string>>>({});
-  const thumbnailer = createVolumeThumbnailer(thumbnailSize);
+  const thumbnailer = createThumbnailer(thumbnailSize);
   const currentThumbnails = ref<Record<string, string>>({});
 
   const { currentImageMetadata, currentImageID, currentImageData } =
@@ -59,9 +63,15 @@ export function useVolumeThumbnailing(thumbnailSize: number) {
 
   // used to interrupt a thumbnailing cycle if
   // doThumbnailing is called again
+  const UNMOUNTED = Symbol('unmount');
   let interruptSentinel = Symbol('interrupt');
 
+  // captures finish on a timer, so deletion waits for the in-flight ones
+  const inFlightCaptures = new Set<Promise<string>>();
+
   async function doThumbnailing(imageID: string, image: vtkImageData) {
+    if (interruptSentinel === UNMOUNTED) return;
+
     const localSentinel = Symbol('interrupt');
     interruptSentinel = localSentinel;
 
@@ -108,7 +118,16 @@ export function useVolumeThumbnailing(thumbnailSize: number) {
 
       const renWin = thumbnailer.scene.getRenderWindow();
       renWin.render();
-      const imageURL = await renWin.captureImages()[0];
+      const capture = renWin.captureImages()[0];
+      inFlightCaptures.add(capture);
+      const imageURL = await capture.finally(() => {
+        inFlightCaptures.delete(capture);
+      });
+
+      // the capture spans a render, so the cycle may have been superseded
+      if (interruptSentinel !== localSentinel) return;
+      if (imageID !== currentImageID.value) return;
+
       if (imageURL) {
         thumbnails[imageID][presetName] = imageURL;
       }
@@ -117,7 +136,7 @@ export function useVolumeThumbnailing(thumbnailSize: number) {
     PresetNameList.reduce(
       (promise, presetName) => promise.then(() => helper(presetName)),
       Promise.resolve()
-    );
+    ).catch(logError);
   }
 
   // workaround for computed not properly working on deeply reactive objects
@@ -134,7 +153,10 @@ export function useVolumeThumbnailing(thumbnailSize: number) {
 
   // force thumbnailing to stop
   onBeforeUnmount(() => {
-    interruptSentinel = Symbol('unmount');
+    interruptSentinel = UNMOUNTED;
+    Promise.allSettled([...inFlightCaptures])
+      .then(() => thumbnailer.delete())
+      .catch(logError);
   });
 
   // trigger thumbnailing
diff --git a/src/core/thumbnailers/volume-thumbnailer.ts b/src/core/thumbnailers/volume-thumbnailer.ts
index 8bec0742b..aa6a12836 100644
--- a/src/core/thumbnailers/volume-thumbnailer.ts
+++ b/src/core/thumbnailers/volume-thumbnailer.ts
@@ -9,7 +9,10 @@ import vtkLookupTableProxy from '@kitware/vtk.js/Proxy/Core/LookupTableProxy';
 import { vec3 } from 'gl-matrix';
 import type { Vector3 } from '@kitware/vtk.js/types';
 import vtkVolumeProperty from '@kitware/vtk.js/Rendering/Core/VolumeProperty';
+import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
 import { getDiagonalLength } from '@kitware/vtk.js/Common/DataModel/BoundingBox';
+import { beginContextRelease } from '@/src/core/vtk/releaseRenderWindow';
+import { deleteInteractor } from '@/src/core/vtk/deleteInteractor';
 
 export function createRenderingPipeline() {
   const actor = vtkVolume.newInstance();
@@ -127,5 +130,32 @@ export function createVolumeThumbnailer(size: number) {
         renderer.updateLightsGeometryToFollowCamera();
       }
     },
+    delete() {
+      renderer.removeVolume(actor);
+      // scene.delete() deletes the API specific render window, so the context
+      // can only be handed back afterwards
+      const apiRenderWindow =
+        scene.getApiSpecificRenderWindow() as vtkOpenGLRenderWindow;
+      const loseContext = beginContextRelease(apiRenderWindow);
+      const interactor = scene.getInteractor();
+      const renderWindow = scene.getRenderWindow();
+      try {
+        // nothing that walks the render window's view list should reach the
+        // deleted view
+        renderWindow.removeView(apiRenderWindow);
+        scene.delete();
+        deleteInteractor(interactor);
+      } finally {
+        loseContext();
+      }
+      renderWindow.delete();
+      renderer.delete();
+      actor.delete();
+      mapper.delete();
+      opacityFuncProxy.delete();
+      colorTransferFuncProxy.delete();
+      pipeline.cfun.delete();
+      pipeline.ofun.delete();
+    },
   };
 }
diff --git a/src/core/vtk/__tests__/useVtkView.spec.ts b/src/core/vtk/__tests__/useVtkView.spec.ts
new file mode 100644
index 000000000..844129b1e
--- /dev/null
+++ b/src/core/vtk/__tests__/useVtkView.spec.ts
@@ -0,0 +1,167 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { defineComponent, effectScope, h, ref } from 'vue';
+import { mount } from '@vue/test-utils';
+import vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
+import vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
+import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
+import vtkWidgetManager from '@kitware/vtk.js/Widgets/Core/WidgetManager';
+import { VtkRenderWindowParentContext } from '@/src/components/vtk/context';
+import { VtkRenderWindowParentApi } from '@/src/types/vtk-types';
+import { releaseWidgetManager } from '@/src/core/vtk/releaseWidgetManager';
+import { useVtkView, useWebGLRenderWindow } from '@/src/core/vtk/useVtkView';
+
+function createParent() {
+  const renderWindow = vtkRenderWindow.newInstance();
+  const renderWindowView = renderWindow.newAPISpecificView(
+    'WebGL'
+  ) as vtkOpenGLRenderWindow;
+  renderWindow.addView(renderWindowView);
+  return { renderWindow, renderWindowView };
+}
+
+function createRecordingParent(calls: Array<string>) {
+  const { renderWindow, renderWindowView } = createParent();
+  // an uninitialized interactor keeps the parent's renders inert: the test DOM
+  // has no WebGL context to traverse
+  renderWindow.setInteractor(vtkRenderWindowInteractor.newInstance());
+
+  return {
+    renderWindow: {
+      ...renderWindow,
+      removeRenderWindow: (child: vtkRenderWindow) => {
+        calls.push('removeRenderWindow');
+        return renderWindow.removeRenderWindow(child);
+      },
+    },
+    renderWindowView: {
+      ...renderWindowView,
+      removeNode: (node: vtkOpenGLRenderWindow) => {
+        calls.push('removeNode');
+        return renderWindowView.removeNode(node);
+      },
+    },
+  } as unknown as VtkRenderWindowParentApi;
+}
+
+function mountViewUnder(parent: VtkRenderWindowParentApi) {
+  const component = defineComponent({
+    setup() {
+      // no container: attaching one kicks off renders the test DOM cannot
+      // service without a WebGL context
+      useVtkView(ref(null));
+      return () => h('div');
+    },
+  });
+  return mount(component, {
+    global: {
+      provide: { [VtkRenderWindowParentContext as symbol]: parent },
+    },
+  });
+}
+
+describe('useVtkView teardown', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('queues no render work once the view scope is disposed', () => {
+    const container = document.createElement('div');
+    const scope = effectScope(true);
+    const view = scope.run(() => useVtkView(container))!;
+
+    scope.stop();
+
+    view.requestRender();
+    view.requestRender({ immediate: true });
+
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('takes its view node off the parent scene graph on dispose', () => {
+    const parent = createParent();
+    const renderWindow = vtkRenderWindow.newInstance();
+    const container = document.createElement('div');
+    const scope = effectScope(true);
+
+    const renderWindowView = scope.run(() =>
+      useWebGLRenderWindow(renderWindow, container, parent)
+    )!;
+    expect(parent.renderWindowView.getChildren()).toHaveLength(1);
+
+    scope.stop();
+
+    expect(parent.renderWindowView.getChildren()).toHaveLength(0);
+    expect(renderWindowView.isDeleted()).toBe(true);
+  });
+
+  it('unregisters from the parent render window before dropping its view node', () => {
+    const calls: Array<string> = [];
+    const wrapper = mountViewUnder(createRecordingParent(calls));
+
+    wrapper.unmount();
+
+    expect(calls).toEqual(['removeRenderWindow', 'removeNode']);
+  });
+
+  function createSelectorStubs(released: Array<string>) {
+    const depthTexture = {} as WebGLRenderbuffer;
+    const context = {
+      deleteRenderbuffer: (renderbuffer: WebGLRenderbuffer) => {
+        released.push(
+          renderbuffer === depthTexture ? 'depthRenderbuffer' : 'unexpected'
+        );
+      },
+    } as unknown as WebGLRenderingContext;
+    const framebuffer = {
+      isDeleted: () => false,
+      releaseGraphicsResources: () => {
+        released.push('framebuffer');
+      },
+      getColorTexture: () => ({
+        releaseGraphicsResources: () => {
+          released.push('colorTexture');
+        },
+      }),
+      get: () => ({ context, depthTexture }),
+    };
+    return {
+      get: () => ({
+        _selector: { isDeleted: () => false, get: () => ({ framebuffer }) },
+      }),
+      delete: () => {
+        released.push('managerDeleted');
+      },
+    } as unknown as vtkWidgetManager;
+  }
+
+  it('hands back the selector framebuffer, color texture and depth renderbuffer', () => {
+    const released: Array<string> = [];
+    const rootView = {
+      isDeleted: () => false,
+    } as unknown as vtkOpenGLRenderWindow;
+
+    releaseWidgetManager(createSelectorStubs(released), rootView);
+
+    expect(released).toEqual([
+      'colorTexture',
+      'depthRenderbuffer',
+      'framebuffer',
+      'managerDeleted',
+    ]);
+  });
+
+  it('still deletes the manager when the root view is already gone', () => {
+    const released: Array<string> = [];
+    const rootView = {
+      isDeleted: () => true,
+    } as unknown as vtkOpenGLRenderWindow;
+
+    releaseWidgetManager(createSelectorStubs(released), rootView);
+
+    expect(released).toEqual(['managerDeleted']);
+  });
+});
diff --git a/src/core/vtk/deleteInteractor.ts b/src/core/vtk/deleteInteractor.ts
new file mode 100644
index 000000000..7fc9ef68d
--- /dev/null
+++ b/src/core/vtk/deleteInteractor.ts
@@ -0,0 +1,21 @@
+import type vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
+
+// vtk.js' public cancelAnimation() is a no-op while the post-wheel extension
+// window is still open (model._animationExtendedEnd), so a pending rAF can
+// survive dispose and fire against a deleted interactor.
+function cancelPendingAnimationFrame(interactor: vtkRenderWindowInteractor) {
+  const model = (
+    interactor as unknown as { get(): { animationRequest?: number | null } }
+  ).get();
+  if (model.animationRequest == null) return;
+
+  cancelAnimationFrame(model.animationRequest);
+  model.animationRequest = null;
+}
+
+// interactor.delete() cancels outstanding animations by rendering, through a
+// view its callers have already deleted, so the pending frame has to go first.
+export function deleteInteractor(interactor: vtkRenderWindowInteractor) {
+  cancelPendingAnimationFrame(interactor);
+  interactor.delete();
+}
diff --git a/src/core/vtk/releaseRenderWindow.ts b/src/core/vtk/releaseRenderWindow.ts
new file mode 100644
index 000000000..29f470ec4
--- /dev/null
+++ b/src/core/vtk/releaseRenderWindow.ts
@@ -0,0 +1,55 @@
+import type vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
+import { NOOP } from '@/src/constants';
+import { Maybe } from '@/src/types';
+
+export type WebGLContext = WebGLRenderingContext | WebGL2RenderingContext;
+
+// releaseGraphicsResources is not in vtk.js' typings for vtkOpenGLRenderWindow,
+// and neither is the shape of its model.
+type ReleasableRenderWindow = vtkOpenGLRenderWindow & {
+  releaseGraphicsResources(): void;
+};
+
+type RenderWindowModel = {
+  get(): {
+    context?: Maybe<WebGLContext>;
+    rootOpenGLRenderWindow?: Maybe<vtkOpenGLRenderWindow>;
+  };
+};
+
+/**
+ * Releases a WebGL render window along with the browser context behind it.
+ *
+ * delete() alone leaves the context live until the canvas is collected, and
+ * browsers force-lose the oldest context past their per page cap. loseContext()
+ * runs after delete() because delete() removes the webglcontextlost handler
+ * that would ask the browser to restore what we are giving up.
+ */
+export function releaseOpenGLRenderWindow(view: vtkOpenGLRenderWindow) {
+  if (view.isDeleted()) return;
+  const loseContext = beginContextRelease(view);
+  try {
+    view.delete();
+  } finally {
+    loseContext();
+  }
+}
+
+/**
+ * Frees a render window's GPU resources and returns the step that gives the
+ * browser context back, for owners whose own teardown chain deletes the view
+ * for them.
+ *
+ * Only a root render window holds a context; a child proxies getContext() and
+ * releaseGraphicsResources() to the root, so releasing through one would take
+ * out the resources its siblings are still drawing with.
+ */
+export function beginContextRelease(view: vtkOpenGLRenderWindow) {
+  const releasable = view as ReleasableRenderWindow;
+  const model = (view as unknown as RenderWindowModel).get();
+  if (model.rootOpenGLRenderWindow) return NOOP;
+
+  const context = model.context;
+  if (context) releasable.releaseGraphicsResources();
+  return () => context?.getExtension('WEBGL_lose_context')?.loseContext();
+}
diff --git a/src/core/vtk/releaseWidgetManager.ts b/src/core/vtk/releaseWidgetManager.ts
new file mode 100644
index 000000000..ba94459f5
--- /dev/null
+++ b/src/core/vtk/releaseWidgetManager.ts
@@ -0,0 +1,55 @@
+import type vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
+import type vtkWidgetManager from '@kitware/vtk.js/Widgets/Core/WidgetManager';
+import { WebGLContext } from '@/src/core/vtk/releaseRenderWindow';
+import { Maybe } from '@/src/types';
+
+type SelectorFramebuffer = {
+  isDeleted(): boolean;
+  releaseGraphicsResources(): void;
+  getColorTexture(): Maybe<{
+    releaseGraphicsResources(view: vtkOpenGLRenderWindow): void;
+  }>;
+  get(): {
+    context?: Maybe<WebGLContext>;
+    depthTexture?: Maybe<WebGLRenderbuffer>;
+  };
+};
+
+type HardwareSelector = {
+  isDeleted(): boolean;
+  get(): { framebuffer?: Maybe<SelectorFramebuffer> };
+};
+
+/**
+ * Deletes a widget manager and frees the picking resources vtk.js leaves behind.
+ *
+ * vtkWidgetManager.delete() drops only its own subscriptions, so the hardware
+ * selector's framebuffer, color texture and depth renderbuffer pile up on the
+ * shared context one set per view; the framebuffer's releaseGraphicsResources()
+ * covers itself alone, hence the explicit renderbuffer handback.
+ *
+ * rootView owns that context, so there is nothing to hand back once it is gone.
+ */
+export function releaseWidgetManager(
+  manager: vtkWidgetManager,
+  rootView: vtkOpenGLRenderWindow
+) {
+  const selector = (
+    manager as unknown as { get(): { _selector?: Maybe<HardwareSelector> } }
+  ).get()._selector;
+  const framebuffer =
+    selector && !selector.isDeleted() ? selector.get().framebuffer : null;
+
+  try {
+    if (framebuffer && !framebuffer.isDeleted() && !rootView.isDeleted()) {
+      framebuffer.getColorTexture()?.releaseGraphicsResources(rootView);
+      const { context, depthTexture } = framebuffer.get();
+      if (context && depthTexture) {
+        context.deleteRenderbuffer(depthTexture);
+      }
+      framebuffer.releaseGraphicsResources();
+    }
+  } finally {
+    manager.delete();
+  }
+}
diff --git a/src/core/vtk/useVtkView.ts b/src/core/vtk/useVtkView.ts
index 3ff4e6aea..92858c0de 100644
--- a/src/core/vtk/useVtkView.ts
+++ b/src/core/vtk/useVtkView.ts
@@ -3,6 +3,10 @@ import { onVTKEvent } from '@/src/composables/onVTKEvent';
 import { View } from '@/src/core/vtk/types';
 import { Maybe } from '@/src/types';
 import { VtkRenderWindowParentApi } from '@/src/types/vtk-types';
+import { releaseOpenGLRenderWindow } from '@/src/core/vtk/releaseRenderWindow';
+import { releaseWidgetManager } from '@/src/core/vtk/releaseWidgetManager';
+import { deleteInteractor } from '@/src/core/vtk/deleteInteractor';
+import { NOOP } from '@/src/constants';
 import { batchForNextTask } from '@/src/utils/batchForNextTask';
 import vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
 import vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
@@ -19,23 +23,6 @@ import {
   watchPostEffect,
 } from 'vue';
 
-// vtk.js' public interactor.cancelAnimation() is a no-op while the
-// post-wheel extension window is still open (model._animationExtendedEnd),
-// so on dispose during that window a pending rAF survives and fires against
-// the deleted interactor. Reach into the private animationRequest field to
-// cancel it directly.
-function cancelPendingInteractorAnimationFrame(
-  interactor: vtkRenderWindowInteractor
-) {
-  const model = (
-    interactor as unknown as { get(): { animationRequest?: number | null } }
-  ).get();
-  if (model.animationRequest == null) return;
-
-  cancelAnimationFrame(model.animationRequest);
-  model.animationRequest = null;
-}
-
 export function useWebGLRenderWindow(
   renderWindow: vtkRenderWindow,
   container: MaybeRef<Maybe<HTMLElement>>,
@@ -57,10 +44,12 @@ export function useWebGLRenderWindow(
   });
 
   onScopeDispose(() => {
+    // a child node draws through its parent's context, so only the standalone
+    // case has one of its own to release
     if (parent?.renderWindowView) {
       parent.renderWindowView.removeNode(renderWindowView);
     } else {
-      renderWindowView.delete();
+      releaseOpenGLRenderWindow(renderWindowView);
     }
   });
 
@@ -99,6 +88,18 @@ export function useVtkView(container: MaybeRef<Maybe<HTMLElement>>): View {
   const renderWindow = vtkRenderWindow.newInstance();
   renderWindow.addRenderer(renderer);
 
+  let disposed = false;
+  let releaseWidgets = NOOP;
+
+  // registered first so it runs before the teardown below: picking resources go
+  // back through the root view, and the parent rebuilds its scene graph from
+  // its own child render window list
+  onScopeDispose(() => {
+    disposed = true;
+    releaseWidgets();
+    parent?.renderWindow.removeRenderWindow(renderWindow);
+  });
+
   parent?.renderWindow.addRenderWindow(renderWindow);
 
   // the render window view
@@ -126,6 +127,11 @@ export function useVtkView(container: MaybeRef<Maybe<HTMLElement>>): View {
 
   // widget manager
   const widgetManager = useWidgetManager(renderer);
+  releaseWidgets = () =>
+    releaseWidgetManager(
+      widgetManager,
+      parent?.renderWindowView ?? renderWindowView
+    );
 
   // render API
   const deferredRender = batchForNextTask(() => {
@@ -141,7 +147,10 @@ export function useVtkView(container: MaybeRef<Maybe<HTMLElement>>): View {
     renderWindow.render();
   };
 
+  // requests outlive the view: vtk event handlers and promises that settle
+  // after dispose has deleted the scene graph nodes a render would traverse
   const requestRender = ({ immediate } = { immediate: false }) => {
+    if (disposed) return;
     if (immediate) {
       immediateRender();
     }
@@ -176,12 +185,10 @@ export function useVtkView(container: MaybeRef<Maybe<HTMLElement>>): View {
     deferredRender.cancel();
 
     renderWindow.removeRenderer(renderer);
-    parent?.renderWindow.removeRenderWindow(renderWindow);
 
     renderer.delete();
     renderWindow.delete();
-    cancelPendingInteractorAnimationFrame(interactor);
-    interactor.delete();
+    deleteInteractor(interactor);
   });
 
   return {