diff --git a/demo/index.html b/demo/index.html
index d5f41d20..52cdbe64 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -227,6 +227,7 @@ <h1 class="text-center m-3 mb-5">GCode Preview
         </div>
       </div>
       <div>
+        <button class="bulma-button bulma-is-light bulma-is-small bulma-is-outlined" @click="exportScene">Export STL</button>
         <footer class="is-size-7 p-0 has-text-grey-light">
          
           
diff --git a/demo/js/STLExporter.js b/demo/js/STLExporter.js
new file mode 100644
index 00000000..a97b4082
--- /dev/null
+++ b/demo/js/STLExporter.js
@@ -0,0 +1,199 @@
+import { Vector3 } from 'three';
+
+/**
+ * Usage:
+ *  const exporter = new STLExporter();
+ *
+ *  // second argument is a list of options
+ *  const data = exporter.parse( mesh, { binary: true } );
+ *
+ */
+
+class STLExporter {
+
+	parse( scene, options = {} ) {
+
+		options = Object.assign( {
+			binary: false
+		}, options );
+
+		const binary = options.binary;
+
+		//
+
+		const objects = [];
+		let triangles = 0;
+
+		scene.traverse( function ( object ) {
+
+			if ( object.isMesh ) {
+
+				const geometry = object.geometry;
+
+				const index = geometry.index;
+				const positionAttribute = geometry.getAttribute( 'position' );
+
+				triangles += ( index !== null ) ? ( index.count / 3 ) : ( positionAttribute.count / 3 );
+
+				objects.push( {
+					object3d: object,
+					geometry: geometry
+				} );
+
+			}
+
+		} );
+
+		let output;
+		let offset = 80; // skip header
+
+		if ( binary === true ) {
+
+			const bufferLength = triangles * 2 + triangles * 3 * 4 * 4 + 80 + 4;
+			const arrayBuffer = new ArrayBuffer( bufferLength );
+			output = new DataView( arrayBuffer );
+			output.setUint32( offset, triangles, true ); offset += 4;
+
+		} else {
+
+			output = '';
+			output += 'solid exported\n';
+
+		}
+
+		const vA = new Vector3();
+		const vB = new Vector3();
+		const vC = new Vector3();
+		const cb = new Vector3();
+		const ab = new Vector3();
+		const normal = new Vector3();
+
+		for ( let i = 0, il = objects.length; i < il; i ++ ) {
+
+			const object = objects[ i ].object3d;
+			const geometry = objects[ i ].geometry;
+
+			const index = geometry.index;
+			const positionAttribute = geometry.getAttribute( 'position' );
+
+			if ( index !== null ) {
+
+				// indexed geometry
+
+				for ( let j = 0; j < index.count; j += 3 ) {
+
+					const a = index.getX( j + 0 );
+					const b = index.getX( j + 1 );
+					const c = index.getX( j + 2 );
+
+					writeFace( a, b, c, positionAttribute, object );
+
+				}
+
+			} else {
+
+				// non-indexed geometry
+
+				for ( let j = 0; j < positionAttribute.count; j += 3 ) {
+
+					const a = j + 0;
+					const b = j + 1;
+					const c = j + 2;
+
+					writeFace( a, b, c, positionAttribute, object );
+
+				}
+
+			}
+
+		}
+
+		if ( binary === false ) {
+
+			output += 'endsolid exported\n';
+
+		}
+
+		return output;
+
+		function writeFace( a, b, c, positionAttribute, object ) {
+
+			vA.fromBufferAttribute( positionAttribute, a );
+			vB.fromBufferAttribute( positionAttribute, b );
+			vC.fromBufferAttribute( positionAttribute, c );
+
+			if ( object.isSkinnedMesh === true ) {
+
+				object.applyBoneTransform( a, vA );
+				object.applyBoneTransform( b, vB );
+				object.applyBoneTransform( c, vC );
+
+			}
+
+			vA.applyMatrix4( object.matrixWorld );
+			vB.applyMatrix4( object.matrixWorld );
+			vC.applyMatrix4( object.matrixWorld );
+
+			writeNormal( vA, vB, vC );
+
+			writeVertex( vA );
+			writeVertex( vB );
+			writeVertex( vC );
+
+			if ( binary === true ) {
+
+				output.setUint16( offset, 0, true ); offset += 2;
+
+			} else {
+
+				output += '\t\tendloop\n';
+				output += '\tendfacet\n';
+
+			}
+
+		}
+
+		function writeNormal( vA, vB, vC ) {
+
+			cb.subVectors( vC, vB );
+			ab.subVectors( vA, vB );
+			cb.cross( ab ).normalize();
+
+			normal.copy( cb ).normalize();
+
+			if ( binary === true ) {
+
+				output.setFloat32( offset, normal.x, true ); offset += 4;
+				output.setFloat32( offset, normal.y, true ); offset += 4;
+				output.setFloat32( offset, normal.z, true ); offset += 4;
+
+			} else {
+
+				output += '\tfacet normal ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
+				output += '\t\touter loop\n';
+
+			}
+
+		}
+
+		function writeVertex( vertex ) {
+
+			if ( binary === true ) {
+
+				output.setFloat32( offset, vertex.x, true ); offset += 4;
+				output.setFloat32( offset, vertex.y, true ); offset += 4;
+				output.setFloat32( offset, vertex.z, true ); offset += 4;
+
+			} else {
+
+				output += '\t\t\tvertex ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+
+			}
+
+		}
+
+	}
+
+}
+
+export { STLExporter };
diff --git a/demo/js/app.js b/demo/js/app.js
index fa70b34b..e50b8f0d 100644
--- a/demo/js/app.js
+++ b/demo/js/app.js
@@ -3,6 +3,7 @@ import { presets } from './presets.js';
 import * as GCodePreview from 'gcode-preview';
 import { defaultSettings } from './default-settings.js';
 import { debounce, humanFileSize, readFile } from './utils.js';
+import { exportSTL } from './export-stl.js';
 
 const defaultPreset = 'arcs';
 const preferDarkMode = window.matchMedia('(prefers-color-scheme: dark)');
@@ -238,6 +239,11 @@ export const app = (window.app = createApp({
       });
     });
 
+    function exportScene() {
+      console.log(preview.scene);
+      exportSTL(preview.scene , 'preview.stl', true);
+    }
+
     return {
       presets,
       activeTab,
@@ -260,7 +266,8 @@ export const app = (window.app = createApp({
       loadGCodeFromServer,
       startLoadingProgressive,
       loadDroppedFile,
-      selectPreset
+      selectPreset,
+      exportScene
     };
   }
 }).mount('#app'));
diff --git a/demo/js/export-stl.js b/demo/js/export-stl.js
new file mode 100644
index 00000000..ef419083
--- /dev/null
+++ b/demo/js/export-stl.js
@@ -0,0 +1,43 @@
+import { STLExporter } from './STLExporter.js';
+
+let link;
+
+export function setup() {
+  link = document.createElement( 'a' );
+  link.style.display = 'none';
+  document.body.appendChild( link );
+}
+
+export function exportSTL(mesh, file, binary) {
+  console.log('exporting...');
+
+  // Instantiate an exporter
+  const exporter = new STLExporter();
+
+  // Configure export options
+  const options = { binary: !!binary }
+
+  // Parse the input and generate the STL encoded output
+  const result = exporter.parse(mesh, options );
+
+  if (options.binary) {
+    saveArrayBuffer(result, file )
+  }
+  else {
+    saveString(result, file)
+  }
+}
+
+function save( blob, filename ) {
+  link.href = URL.createObjectURL( blob );
+  link.download = filename;
+  link.click();
+}
+
+function saveString( text, filename ) {
+  save( new Blob( [ text ], { type: 'text/plain' } ), filename );
+}
+
+function saveArrayBuffer( buffer, filename ) {
+  save( new Blob( [ buffer ], { type: 'application/octet-stream' } ), filename );
+}