diff --git a/src/gpu/raster-worker.js b/src/gpu/raster-worker.js
index 3abe7863..5b532b07 120000
--- a/src/gpu/raster-worker.js
+++ b/src/gpu/raster-worker.js
@@ -1 +1 @@
-../../node_modules/@gridspace/raster-path/src/web/webgpu-worker.js
\ No newline at end of file
+../../../gs-raster-path/build/webgpu-worker.js
\ No newline at end of file
diff --git a/src/gpu/raster.js b/src/gpu/raster.js
index 5ebcfa64..107e9b6f 120000
--- a/src/gpu/raster.js
+++ b/src/gpu/raster.js
@@ -1 +1 @@
-../../node_modules/@gridspace/raster-path/src/index.js
\ No newline at end of file
+../../../gs-raster-path/build/raster-path.js
\ No newline at end of file
diff --git a/src/kiri/mode/cam/topo3.js b/src/kiri/mode/cam/topo3.js
index 980bdfdf..262fa309 100644
--- a/src/kiri/mode/cam/topo3.js
+++ b/src/kiri/mode/cam/topo3.js
@@ -108,11 +108,15 @@ export class Topo {
         }
 
         if (webGPU) {
+            console.log({ tool });
             // invert tool Z offset for gpu code
-            let gputool = toolOffset.slice();
-            for (let i=0; i<gputool.length; i+= 3) {
-                gputool[i+2] *= -1;
+            let toolBounds = new THREE.Box3();
+            let toolPos = tool.profile.slice();
+            for (let i=0; i<toolPos.length; i+= 3) {
+                toolPos[i+2] *= -1;
+                toolBounds.expandByPoint({ x: toolPos[i], y: toolPos[i+1], z: toolPos[i+2] });
             }
+            let toolData = { positions: toolPos, bounds: toolBounds };
 
             const vertices = widget.getGeoVertices({ unroll: true, translate: true });
             const wbounds = widget.getBoundingBox();
@@ -131,24 +135,25 @@ export class Topo {
                 console.timeEnd('swap XY vertices');
             }
 
-            let gpu = await self.get_raster_gpu();
+            let gpu = await self.get_raster_gpu({
+                mode: "planar",
+                resolution
+            });
             let xStep = density;
             let yStep = Math.round(toolStep / resolution);
             let epsilon = 10e-5;
-            let terrain = await gpu.rasterizeMesh(vertices, resolution, 0, wbounds);
-            let { positions } = terrain;
-            let output = await gpu.generatePlanarToolpath(
-                positions,
-                gputool,
+            let terrainData = await gpu.rasterizeModel({
+                triangles: vertices,
+                boundsOverride: wbounds
+            });
+            let output = await gpu.generateToolpaths({
+                terrainData,
+                toolData,
                 xStep,
                 yStep,
-                zBottom - 1,
-                resolution,
-                {
-                    terrainBounds: wbounds,
-                    onProgress(pct) { console.log({ pct }); onupdate(pct/100, 100) }
-                }
-            );
+                zFloor: zBottom - 1,
+                onProgress(pct) { console.log({ pct }); onupdate(pct/100, 100) }
+            });
             let { numScanlines, pointsPerLine, pathData } = output;
             let xmult = xStep * resolution;
             let ymult = yStep * resolution;
diff --git a/src/kiri/mode/cam/topo4.js b/src/kiri/mode/cam/topo4.js
index af58f74e..f4e9f6c2 100644
--- a/src/kiri/mode/cam/topo4.js
+++ b/src/kiri/mode/cam/topo4.js
@@ -163,10 +163,13 @@ export class Topo {
         const { angle, linear, offStart, offEnd, resolution, tool, unit, vertices, zBottom } = this;
 
         // invert tool Z offset for gpu code
-        let gputool = tool.slice();
-        for (let i=0; i<gputool.length; i+= 3) {
-            gputool[i+2] *= -1;
+        let toolBounds = new THREE.Box3();
+        let toolPos = tool.slice();
+        for (let i=0; i<toolPos.length; i+= 3) {
+            toolPos[i+2] *= -1;
+            toolBounds.expandByPoint({ x: toolPos[i], y: toolPos[i+1], z: toolPos[i+2] });
         }
+        let toolData = { positions: toolPos, bounds: toolBounds };
 
         console.time('swap XZ vertices');
         // swap XZ vertices for gpu code
@@ -176,30 +179,40 @@ export class Topo {
             vertices[i+0] = tmp;
         }
         console.timeEnd('swap XZ vertices');
+        // let bbox = new THREE.Box3().setFromArray(vertices);
+        // console.log({ bbox, bounds });
 
-        let gpu = await self.get_raster_gpu();
-        let tickperstep = Math.round(this.step / resolution);
-        let bounds = this.bounds.clone();
-        bounds.min.x += offStart * unit;
-        bounds.max.x -= offEnd * unit;
-        let output = await gpu.generateRadialToolpath(
-            vertices,
-            gputool,
-            angle,
-            tickperstep,
-            zBottom,
+        let gpu = await self.get_raster_gpu({
+            mode: "radial",
             resolution,
-            bounds,
-            { onProgress(pct) { onupdate(pct/100) } }
-        );
+            rotationStep: angle
+        });
+        let tickperstep = Math.round(this.step / resolution);
+        let boundsOverride = this.bounds.clone();
+        boundsOverride.min.x += offStart * unit;
+        boundsOverride.max.x -= offEnd * unit;
+        let terrainData = await gpu.rasterizeModel({
+            triangles: vertices,
+            boundsOverride
+        });
+        console.log({ terrainData });
+        let output = await gpu.generateToolpaths({
+            terrainData,
+            toolData,
+            xStep: 1,
+            yStep: this.step,
+            zFloor: zBottom,
+            onProgress(pct) { onupdate(pct/100) }
+        });
+        console.log({ output });
 
-        let { numRotations, pointsPerLine, pathData } = output;
-        let degPerRow = 360 / numRotations;
+        let { numScanlines, pointsPerLine, pathData } = output;
+        let degPerRow = 360 / numScanlines;
         let slices = this.gpu_slices = [];
         let xmult = tickperstep * resolution;
-        let xoff = bounds.min.x;
+        let xoff = toolData.bounds.min.x;
         let rows = [];
-        for (let i=0; i<numRotations; i++) {
+        for (let i=0; i<numScanlines; i++) {
             let lineData = pathData.slice(i * pointsPerLine, i * pointsPerLine + pointsPerLine);
             let points = Array.from(lineData).map((v,j) => newPoint(j * xmult + xoff, 0, v).setA(-i * degPerRow));
             rows.push(points);
diff --git a/src/kiri/run/worker.js b/src/kiri/run/worker.js
index 23958136..27e8b570 100644
--- a/src/kiri/run/worker.js
+++ b/src/kiri/run/worker.js
@@ -68,16 +68,18 @@ self.uuid = ((Math.random() * Date.now()) | 0).toString(36);
 /**
  * @returns {RasterPath}
  */
-self.get_raster_gpu = async function() {
-    let gpu = self.raster_gpu;
-    if (!gpu) {
-        gpu = self.raster_gpu = new RasterPath({
-            workerName: "/lib/gpu/raster-worker.js",
-            quiet: true
-        });
-        await gpu.init();
-        await gpu.initWorkerPool();
-    }
+self.get_raster_gpu = async function({ mode, resolution, rotationStep }) {
+    console.log({ mode, resolution, rotationStep });
+    let gpu = new RasterPath({
+        mode,
+        resolution,
+        rotationStep,
+        workerName: "/lib/gpu/raster-worker.js",
+        maxWorkers: 20,
+        quiet: false,
+        debug: true,
+    });
+    await gpu.init();
     return gpu;
 };