diff --git a/README.md b/README.md
index daec5b22..601316a0 100644
--- a/README.md
+++ b/README.md
@@ -10,3 +10,13 @@ WARNING! This is not ready for use and is under heavy development of basic featu
 5. Once all dependencies have been installed, run ```npm run start```
 6. Navigate to localhost:3000 in the browser to open the frontend
 7. Make sure any python backends are running on your PC.
+
+## Known Issues
+1. Mechanisms aren't limited to init
+2. Mechanisms aren't limited to only Robot or Mechanism class
+3. There is no default Robot class
+4. No way to specify whether an opmode is auto or teleop
+5. Workspace can have blocks
+6. No Robot workspace yet
+7. No Mechanism workspace yet
+8. Something weird is going on with currentModule getting unset
\ No newline at end of file
diff --git a/src/App.tsx b/src/App.tsx
index 00ba1e78..41f38d9f 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -19,14 +19,16 @@ import {
 import type { InputRef } from 'antd';
 import type { TreeDataNode, TreeProps } from 'antd';
 import {
+  AppstoreAddOutlined as MechanismAddOutlined,
+  AppstoreOutlined as MechanismOutlined,
   CopyOutlined,
   DeleteOutlined,
   DownloadOutlined,
   EditOutlined,
-  FileAddOutlined,
-  FileOutlined,
-  FolderAddOutlined,
-  FolderOutlined,
+  FileAddOutlined as OpModeAddOutlined,
+  FileOutlined as OpModeOutlined,
+  FolderAddOutlined as WorkspaceAddOutlined,
+  FolderOutlined as WorkspaceOutlined,
   SaveOutlined,
   SettingOutlined,
   UploadOutlined,
@@ -59,15 +61,17 @@ import {mutatorOpenListener}  from './blocks/mrc_class_method_def'
 
 
 type NewWorkspaceNameModalProps = {
+  title: string;
   isOpen: boolean;
   initialValue: string;
   getWorkspaceNames: () => string[];
-  onOk: (w: string) => void;
+  onOk: (newName: string) => void;
   onCancel: () => void;
 }
 
-const NewWorkspaceNameModal: React.FC<NewWorkspaceNameModalProps> = ({ isOpen, initialValue, getWorkspaceNames, onOk, onCancel }) => {
+const NewWorkspaceNameModal: React.FC<NewWorkspaceNameModalProps> = ({ title, isOpen, initialValue, getWorkspaceNames, onOk, onCancel }) => {
   const inputRef = useRef<InputRef>(null);
+  const [message, setMessage] = useState('');
   const [value, setValue] = useState('');
   const [workspaceNames, setWorkspaceNames] = useState<string[]>([]);
   const [alertErrorMessage, setAlertErrorMessage] = useState('');
@@ -76,12 +80,17 @@ const NewWorkspaceNameModal: React.FC<NewWorkspaceNameModalProps> = ({ isOpen, i
   const afterOpenChange = (open: boolean) => {
     if (open) {
       setValue(initialValue);
-      setWorkspaceNames(getWorkspaceNames());
+      const w = getWorkspaceNames();
+      if (w.length === 0) {
+        setMessage('Let\'s create your first workspace. You just need to give it a name.');
+      }
+      setWorkspaceNames(w);
       if (inputRef.current) {
         inputRef.current.focus();
       }
     } else {
       setValue('');
+      setMessage('');
     }
   };
 
@@ -101,7 +110,7 @@ const NewWorkspaceNameModal: React.FC<NewWorkspaceNameModalProps> = ({ isOpen, i
 
   return (
     <Modal
-      title={workspaceNames.length === 0 ? "Welcome to WPILib Blocks!" : "New Workspace" }
+      title={title}
       open={isOpen}
       afterOpenChange={afterOpenChange}
       onCancel={onCancel}
@@ -112,10 +121,8 @@ const NewWorkspaceNameModal: React.FC<NewWorkspaceNameModalProps> = ({ isOpen, i
     >
       <Flex vertical gap="small">
         <Typography.Paragraph
-          style={workspaceNames.length === 0 ? { } : { display: 'none' }}
-        >
-        Let's create your first workspace. You just need to give it a name.
-        </Typography.Paragraph>
+          style={message.length === 0 ? { display: 'none' } : { }}
+        >{message}</Typography.Paragraph>
         <Typography.Paragraph> Workspace Name </Typography.Paragraph>
         <Input
           ref={inputRef}
@@ -137,20 +144,21 @@ const NewWorkspaceNameModal: React.FC<NewWorkspaceNameModalProps> = ({ isOpen, i
 };
 
 
-type NewOpModeNameModalProps = {
+type NewModuleNameModalProps = {
+  title: string;
   isOpen: boolean;
   initialValue: string;
   getCurrentWorkspaceName: () => string;
-  getOpModeNames: (workspaceName: string) => string[];
-  onOk: (w: string, o: string) => void;
+  getModuleNames: (workspaceName: string) => string[];
+  onOk: (newName: string) => void;
   onCancel: () => void;
 }
 
-const NewOpModeNameModal: React.FC<NewOpModeNameModalProps> = ({ isOpen, initialValue, getCurrentWorkspaceName, getOpModeNames, onOk, onCancel }) => {
+const NewModuleNameModal: React.FC<NewModuleNameModalProps> = ({ title, isOpen, initialValue, getCurrentWorkspaceName, getModuleNames, onOk, onCancel }) => {
   const inputRef = useRef<InputRef>(null);
   const [value, setValue] = useState('');
   const [workspaceName, setWorkspaceName] = useState('');
-  const [opModeNames, setOpModeNames] = useState<string[]>([]);
+  const [moduleNames, setModuleNames] = useState<string[]>([]);
   const [alertErrorMessage, setAlertErrorMessage] = useState('');
   const [alertErrorVisible, setAlertErrorVisible] = useState(false);
 
@@ -159,7 +167,7 @@ const NewOpModeNameModal: React.FC<NewOpModeNameModalProps> = ({ isOpen, initial
       setValue(initialValue);
       const currentWorkspaceName = getCurrentWorkspaceName();
       setWorkspaceName(currentWorkspaceName);
-      setOpModeNames(getOpModeNames(currentWorkspaceName));
+      setModuleNames(getModuleNames(currentWorkspaceName));
       if (inputRef.current) {
         inputRef.current.focus();
       }
@@ -175,21 +183,21 @@ const NewOpModeNameModal: React.FC<NewOpModeNameModalProps> = ({ isOpen, initial
       return;
     }
     if (workspaceName === value) {
-      setAlertErrorMessage('An OpMode cannot have the same name as its workspace.');
+      setAlertErrorMessage('The workspace is already named ' + value);
       setAlertErrorVisible(true);
       return;
     }
-    if (opModeNames.includes(value)) {
-      setAlertErrorMessage('There is already an OpMode named ' +  value);
+    if (moduleNames.includes(value)) {
+      setAlertErrorMessage('Another module is already named ' +  value);
       setAlertErrorVisible(true);
       return;
     }
-    onOk(workspaceName, value);
+    onOk(value);
   };
 
   return (
     <Modal
-      title="New OpMode"
+      title={title}
       open={isOpen}
       afterOpenChange={afterOpenChange}
       onCancel={onCancel}
@@ -199,7 +207,7 @@ const NewOpModeNameModal: React.FC<NewOpModeNameModalProps> = ({ isOpen, initial
       ]}
     >
       <Flex vertical gap="small">
-        <Typography.Paragraph> OpMode Name </Typography.Paragraph>
+        <Typography.Paragraph> Name </Typography.Paragraph>
         <Input
           ref={inputRef}
           value={value}
@@ -242,14 +250,17 @@ const App: React.FC = () => {
   const [copyTooltip, setCopyTooltip] = useState('Copy');
   const [deleteTooltip, setDeleteTooltip] = useState('Delete');
   const blocklyComponent = useRef<BlocklyComponentType | null>(null);
+  const [triggerPythonRegeneration, setTriggerPythonRegeneration] = useState(false);
   const blocksEditor = useRef<editor.Editor | null>(null);
   const [generatedCode, setGeneratedCode] = useState('');
   const [newWorkspaceNameModalPurpose, setNewWorkspaceNameModalPurpose] = useState('');
   const [newWorkspaceNameModalInitialValue, setNewWorkspaceNameModalInitialValue] = useState('');
+  const [newWorkspaceNameModalTitle, setNewWorkspaceNameModalTitle] = useState('');
   const [newWorkspaceNameModalIsOpen, setNewWorkspaceNameModalIsOpen] = useState(false);
-  const [newOpModeNameModalPurpose, setNewOpModeNameModalPurpose] = useState('');
-  const [newOpModeNameModalInitialValue, setNewOpModeNameModalInitialValue] = useState('');
-  const [newOpModeNameModalIsOpen, setNewOpModeNameModalIsOpen] = useState(false);
+  const [newModuleNameModalPurpose, setNewModuleNameModalPurpose] = useState('');
+  const [newModuleNameModalInitialValue, setNewModuleNameModalInitialValue] = useState('');
+  const [newModuleNameModalTitle, setNewModuleNameModalTitle] = useState('');
+  const [newModuleNameModalIsOpen, setNewModuleNameModalIsOpen] = useState(false);
   const [toolboxSettingsModalIsOpen, setToolboxSettingsModalIsOpen] = useState(false);
   const [popconfirmTitle, setPopconfirmTitle] = useState('');
   const [popconfirmDescription, setPopconfirmDescription] = useState('');
@@ -257,6 +268,14 @@ const App: React.FC = () => {
   const afterPopconfirmOk = useRef<() => void>(() => {});
   const [popconfirmLoading, setPopconfirmLoading] = useState(false);
 
+  const PURPOSE_NEW_WORKSPACE = 'NewWorkspace';
+  const PURPOSE_NEW_MECHANISM = 'NewMechanism';
+  const PURPOSE_NEW_OPMODE = 'NewOpMode';
+  const PURPOSE_RENAME_WORKSPACE = 'RenameWorkspace';
+  const PURPOSE_COPY_WORKSPACE = 'CopyWorkspace';
+  const PURPOSE_RENAME_MODULE = 'RenameModule';
+  const PURPOSE_COPY_MODULE = 'CopyModule';
+
   const ignoreEffect = () => {
     if (!import.meta.env.MODE || import.meta.env.MODE === 'development') {
       // Development mode.
@@ -338,8 +357,9 @@ const App: React.FC = () => {
         callback();
 
         if (array.length === 0) {
-          setNewWorkspaceNameModalPurpose('NewWorkspace');
+          setNewWorkspaceNameModalPurpose(PURPOSE_NEW_WORKSPACE);
           setNewWorkspaceNameModalInitialValue('');
+          setNewWorkspaceNameModalTitle('Welcome to WPILib Blocks!');
           setNewWorkspaceNameModalIsOpen(true);
         }
       }
@@ -366,6 +386,20 @@ const App: React.FC = () => {
         foundMostRecentModulePath = true;
       }
       const children: TreeDataNode[] = [];
+      workspace.mechanisms.forEach((mechanism) => {
+        if (mechanism.modulePath === currentModulePath) {
+          foundCurrentModulePath = true;
+        }
+        if (mechanism.modulePath === mostRecentModulePath) {
+          foundMostRecentModulePath = true;
+        }
+        const child: TreeDataNode = {
+          key: mechanism.modulePath,
+          title: mechanism.moduleName,
+          icon: <MechanismOutlined />,
+        };
+        children.push(child);
+      });
       workspace.opModes.forEach((opMode) => {
         if (opMode.modulePath === currentModulePath) {
           foundCurrentModulePath = true;
@@ -376,7 +410,7 @@ const App: React.FC = () => {
         const child: TreeDataNode = {
           key: opMode.modulePath,
           title: opMode.moduleName,
-          icon: <FileOutlined />,
+          icon: <OpModeOutlined />,
         };
         children.push(child);
       });
@@ -384,7 +418,7 @@ const App: React.FC = () => {
         key: workspace.modulePath,
         title: workspace.workspaceName,
         children: children,
-        icon: <FolderOutlined />,
+        icon: <WorkspaceOutlined />,
       };
       data.push(parent);
       expandedKeys.push(parent.key);
@@ -411,7 +445,6 @@ const App: React.FC = () => {
     if (ignoreEffect()) {
       return;
     }
-
     const module = (modules.length > 0 && currentModulePath)
         ? commonStorage.findModule(modules, currentModulePath)
         : null;
@@ -422,14 +455,14 @@ const App: React.FC = () => {
         setRenameTooltip('Rename Workspace');
         setCopyTooltip('Copy Workspace');
         setDeleteTooltip('Delete Workspace');
-      } else if (module.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
-        setRenameTooltip('Rename OpMode');
-        setCopyTooltip('Copy OpMode');
-        setDeleteTooltip('Delete OpMode');
       } else if (module.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
         setRenameTooltip('Rename Mechanism');
         setCopyTooltip('Copy Mechanism');
         setDeleteTooltip('Delete Mechanism');
+      } else if (module.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
+        setRenameTooltip('Rename OpMode');
+        setCopyTooltip('Copy OpMode');
+        setDeleteTooltip('Delete OpMode');
       }
 
       storage.saveEntry('mostRecentModulePath', currentModulePath);
@@ -437,7 +470,6 @@ const App: React.FC = () => {
         blocksEditor.current.loadModuleBlocks(module);
       }
     } else {
-      setCurrentModule(null);
 
       setRenameTooltip('Rename');
       setCopyTooltip('Copy');
@@ -450,6 +482,17 @@ const App: React.FC = () => {
     }
   }, [currentModulePath]);
 
+  useEffect(() => {
+    if (ignoreEffect()) {
+      return;
+    }
+    if (blocklyComponent.current) {
+      const blocklyWorkspace = blocklyComponent.current.getBlocklyWorkspace();
+      extendedPythonGenerator.setCurrentModule(currentModule);
+      setGeneratedCode(extendedPythonGenerator.workspaceToCode(blocklyWorkspace));
+    }
+  }, [currentModule, triggerPythonRegeneration, blocklyComponent]);
+
   useEffect(() => {
     if (ignoreEffect()) {
       return;
@@ -494,8 +537,7 @@ const App: React.FC = () => {
       // Don't regenerate python code mid-drag.
       return;
     }
-    const code = extendedPythonGenerator.workspaceToCode(blocklyWorkspace);
-    setGeneratedCode(code);
+    setTriggerPythonRegeneration(!triggerPythonRegeneration);
   };
 
   const handlePopconfirmOk = () => {
@@ -535,8 +577,9 @@ const App: React.FC = () => {
 
   const handleNewWorkspaceClicked = () => {
     checkIfBlocksWereModified(() => {
-      setNewWorkspaceNameModalPurpose('NewWorkspace');
+      setNewWorkspaceNameModalPurpose(PURPOSE_NEW_WORKSPACE);
       setNewWorkspaceNameModalInitialValue('');
+      setNewWorkspaceNameModalTitle('New Workspace');
       setNewWorkspaceNameModalIsOpen(true);
     });
   };
@@ -551,7 +594,7 @@ const App: React.FC = () => {
 
   const handleNewWorkspaceNameOk = (newWorkspaceName: string) => {
     const newWorkspacePath = commonStorage.makeWorkspacePath(newWorkspaceName);
-    if (newWorkspaceNameModalPurpose === 'NewWorkspace') {
+    if (newWorkspaceNameModalPurpose === PURPOSE_NEW_WORKSPACE) {
       const workspaceContent = commonStorage.newWorkspaceContent(newWorkspaceName);
       storage.createModule(
           commonStorage.MODULE_TYPE_WORKSPACE, newWorkspacePath, workspaceContent,
@@ -566,9 +609,10 @@ const App: React.FC = () => {
               setAlertErrorVisible(true);
             }
           });
-    } else if (newWorkspaceNameModalPurpose === 'RenameWorkspace') {
-      const oldWorkspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      storage.renameWorkspace(oldWorkspaceName, newWorkspaceName,
+    } else if (newWorkspaceNameModalPurpose === PURPOSE_RENAME_WORKSPACE) {
+      storage.renameModule(
+          currentModule.moduleType, currentModule.workspaceName,
+          currentModule.moduleName, newWorkspaceName,
           (success: boolean, errorMessage: string) => {
             if (success) {
               afterListModulesSuccess.current = () => {
@@ -580,9 +624,10 @@ const App: React.FC = () => {
               setAlertErrorVisible(true);
             }
           });
-    } else if (newWorkspaceNameModalPurpose === 'CopyWorkspace') {
-      const oldWorkspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      storage.copyWorkspace(oldWorkspaceName, newWorkspaceName,
+    } else if (newWorkspaceNameModalPurpose === PURPOSE_COPY_WORKSPACE) {
+      storage.copyModule(
+          currentModule.moduleType, currentModule.workspaceName,
+          currentModule.moduleName, newWorkspaceName,
           (success: boolean, errorMessage: string) => {
             if (success) {
               afterListModulesSuccess.current = () => {
@@ -597,45 +642,73 @@ const App: React.FC = () => {
     }
   };
 
+  const handleNewMechanismClicked = () => {
+    checkIfBlocksWereModified(() => {
+      setNewModuleNameModalPurpose(PURPOSE_NEW_MECHANISM);
+      setNewModuleNameModalInitialValue('');
+      setNewModuleNameModalTitle('New Mechanism');
+      setNewModuleNameModalIsOpen(true);
+    });
+  };
+
   const handleNewOpModeClicked = () => {
     checkIfBlocksWereModified(() => {
-      setNewOpModeNameModalPurpose('NewOpMode');
-      setNewOpModeNameModalInitialValue('');
-      setNewOpModeNameModalIsOpen(true);
+      setNewModuleNameModalPurpose(PURPOSE_NEW_OPMODE);
+      setNewModuleNameModalInitialValue('');
+      setNewModuleNameModalTitle('New OpMode');
+      setNewModuleNameModalIsOpen(true);
     });
   };
 
-  // Provide a callback so the NewOpModeNameModal will know what the current
+  // Provide a callback so the NewModuleNameModal will know what the current
   // workspace name is.
   const getCurrentWorkspaceName = (): string => {
     return currentModule ? currentModule.workspaceName : '';
   };
 
-  // Provide a callback so the NewOpModeNameModal will know what the existing
-  // OpMode names are in the current workspace.
-  const getOpModeNames = (workspaceName: string): string[] => {
-    const opModeNames: string[] = [];
+  // Provide a callback so the NewModuleNameModal will know what the existing
+  // module names are in the current workspace.
+  const getModuleNames = (workspaceName: string): string[] => {
+    const moduleNames: string[] = [];
     for (const workspace of modules) {
       if (workspace.workspaceName === workspaceName) {
+        workspace.mechanisms.forEach((mechanism) => {
+          moduleNames.push(mechanism.moduleName);
+        });
         workspace.opModes.forEach((opMode) => {
-          opModeNames.push(opMode.moduleName);
+          moduleNames.push(opMode.moduleName);
         });
         break;
       }
     }
-    return opModeNames;
+    return moduleNames;
   };
 
-  const handleNewOpModeNameOk = (workspaceName: string, newOpModeName: string) => {
-    const newOpModePath = commonStorage.makeModulePath(workspaceName, newOpModeName);
-    if (newOpModeNameModalPurpose === 'NewOpMode') {
-      const opModeContent = commonStorage.newOpModeContent(workspaceName, newOpModeName);
+  const handleNewModuleNameOk = (newModuleName: string) => {
+    const newModulePath = commonStorage.makeModulePath(currentModule.workspaceName, newModuleName);
+    if (newModuleNameModalPurpose === PURPOSE_NEW_MECHANISM) {
+      const mechanismContent = commonStorage.newMechanismContent(currentModule.workspaceName, newModuleName);
       storage.createModule(
-          commonStorage.MODULE_TYPE_OPMODE, newOpModePath, opModeContent,
+          commonStorage.MODULE_TYPE_MECHANISM, newModulePath, mechanismContent,
           (success: boolean, errorMessage: string) => {
             if (success) {
               afterListModulesSuccess.current = () => {
-                setCurrentModulePath(newOpModePath);
+                setCurrentModulePath(newModulePath);
+              };
+              setTriggerListModules(!triggerListModules);
+            } else if (errorMessage) {
+              setAlertErrorMessage('Failed to create a new Mechanism: ' + errorMessage);
+              setAlertErrorVisible(true);
+            }
+          });
+    } else if (newModuleNameModalPurpose === PURPOSE_NEW_OPMODE) {
+      const opModeContent = commonStorage.newOpModeContent(currentModule.workspaceName, newModuleName);
+      storage.createModule(
+          commonStorage.MODULE_TYPE_OPMODE, newModulePath, opModeContent,
+          (success: boolean, errorMessage: string) => {
+            if (success) {
+              afterListModulesSuccess.current = () => {
+                setCurrentModulePath(newModulePath);
               };
               setTriggerListModules(!triggerListModules);
             } else if (errorMessage) {
@@ -643,33 +716,33 @@ const App: React.FC = () => {
               setAlertErrorVisible(true);
             }
           });
-    } else if (newOpModeNameModalPurpose === 'RenameOpMode') {
-      const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      const oldOpModeName = commonStorage.getModuleName(currentModulePath);
-      storage.renameOpMode(workspaceName, oldOpModeName, newOpModeName,
+    } else if (newModuleNameModalPurpose === PURPOSE_RENAME_MODULE) {
+      storage.renameModule(
+          currentModule.moduleType, currentModule.workspaceName,
+          currentModule.moduleName, newModuleName,
           (success: boolean, errorMessage: string) => {
             if (success) {
               afterListModulesSuccess.current = () => {
-                setCurrentModulePath(newOpModePath);
+                setCurrentModulePath(newModulePath);
               };
               setTriggerListModules(!triggerListModules);
             } else if (errorMessage) {
-              setAlertErrorMessage('Failed to rename the OpMode: ' + errorMessage);
+              setAlertErrorMessage('Failed to rename the module: ' + errorMessage);
               setAlertErrorVisible(true);
             }
           });
-    } else if (newOpModeNameModalPurpose === 'CopyOpMode') {
-      const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
-      const oldOpModeName = commonStorage.getModuleName(currentModulePath);
-      storage.copyOpMode(workspaceName, oldOpModeName, newOpModeName,
+    } else if (newModuleNameModalPurpose === PURPOSE_COPY_MODULE) {
+      storage.copyModule(
+          currentModule.moduleType, currentModule.workspaceName,
+          currentModule.moduleName, newModuleName,
           (success: boolean, errorMessage: string) => {
             if (success) {
               afterListModulesSuccess.current = () => {
-                setCurrentModulePath(newOpModePath);
+                setCurrentModulePath(newModulePath);
               };
               setTriggerListModules(!triggerListModules);
             } else if (errorMessage) {
-              setAlertErrorMessage('Failed to copy the OpMode: ' + errorMessage);
+              setAlertErrorMessage('Failed to copy the module: ' + errorMessage);
               setAlertErrorVisible(true);
             }
           });
@@ -703,15 +776,23 @@ const App: React.FC = () => {
         return;
       }
       if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
-        // This is a workspace.
-        setNewWorkspaceNameModalPurpose('RenameWorkspace');
+        // This is a Workspace.
+        setNewWorkspaceNameModalPurpose(PURPOSE_RENAME_WORKSPACE);
         setNewWorkspaceNameModalInitialValue(currentModule.workspaceName);
+        setNewWorkspaceNameModalTitle('Rename Workspace');
         setNewWorkspaceNameModalIsOpen(true);
+      } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
+        // This is a Mechanism.
+        setNewModuleNameModalPurpose(PURPOSE_RENAME_MODULE);
+        setNewModuleNameModalInitialValue(currentModule.moduleName);
+        setNewModuleNameModalTitle('Rename Mechanism');
+        setNewModuleNameModalIsOpen(true);
       } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
         // This is an OpMode.
-        setNewOpModeNameModalPurpose('RenameOpMode');
-        setNewOpModeNameModalInitialValue(currentModule.moduleName);
-        setNewOpModeNameModalIsOpen(true);
+        setNewModuleNameModalPurpose(PURPOSE_RENAME_MODULE);
+        setNewModuleNameModalInitialValue(currentModule.moduleName);
+        setNewModuleNameModalTitle('Rename OpMode');
+        setNewModuleNameModalIsOpen(true);
       }
     });
   };
@@ -722,15 +803,23 @@ const App: React.FC = () => {
         return;
       }
       if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
-        // This is a workspace.
-        setNewWorkspaceNameModalPurpose('CopyWorkspace');
+        // This is a Workspace.
+        setNewWorkspaceNameModalPurpose(PURPOSE_COPY_WORKSPACE);
         setNewWorkspaceNameModalInitialValue(currentModule.workspaceName + '_copy');
+        setNewWorkspaceNameModalTitle('Copy Workspace');
         setNewWorkspaceNameModalIsOpen(true);
+      } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
+        // This is a Mechanism.
+        setNewModuleNameModalPurpose(PURPOSE_COPY_MODULE);
+        setNewModuleNameModalInitialValue(currentModule.moduleName + '_copy');
+        setNewModuleNameModalTitle('Copy Mechanism');
+        setNewModuleNameModalIsOpen(true);
       } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
         // This is an OpMode.
-        setNewOpModeNameModalPurpose('CopyOpMode');
-        setNewOpModeNameModalInitialValue(currentModule.moduleName + '_copy');
-        setNewOpModeNameModalIsOpen(true);
+        setNewModuleNameModalPurpose(PURPOSE_COPY_MODULE);
+        setNewModuleNameModalInitialValue(currentModule.moduleName + '_copy');
+        setNewModuleNameModalTitle('Copy OpMode');
+        setNewModuleNameModalIsOpen(true);
       }
     });
   };
@@ -743,11 +832,10 @@ const App: React.FC = () => {
     setPopconfirmTitle('Are you sure?');
     if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
       setPopconfirmDescription('Press ok to delete this Workspace');
+    } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
+      setPopconfirmDescription('Press ok to delete this Mechanism');
     } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
       setPopconfirmDescription('Press ok to delete this OpMode');
-    } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_MECHANISM) {
-      // TODO: delete the mechanism.
-      return;
     }
     // Set the function to be executed if the user clicks 'ok'.
     afterPopconfirmOk.current = () => {
@@ -757,12 +845,14 @@ const App: React.FC = () => {
           return;
         }
         if (currentModule.moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
-          // This is a workspace.
+          // This is a Workspace.
           // Before deleting it, select another workspace, if there is one.
-          const workspaceNameToDelete = currentModule.workspaceName;
+          // Put the module type and path into local variables before we select another workspace.
+          const moduleTypeToDelete = currentModule.moduleType;
+          const modulePathToDelete = currentModulePath;
           let foundAnotherWorkspace = false;
           for (const workspace of modules) {
-            if (workspace.workspaceName !== workspaceNameToDelete) {
+            if (workspace.modulePath !== modulePathToDelete) {
               setCurrentModulePath(workspace.modulePath);
               foundAnotherWorkspace = true;
               break;
@@ -771,7 +861,7 @@ const App: React.FC = () => {
           if (!foundAnotherWorkspace) {
             setCurrentModulePath('');
           }
-          storage.deleteWorkspace(workspaceNameToDelete,
+          storage.deleteModule(moduleTypeToDelete, modulePathToDelete,
             (success: boolean, errorMessage: string) => {
               if (success) {
                 setTriggerListModules(!triggerListModules);
@@ -780,17 +870,21 @@ const App: React.FC = () => {
                 setAlertErrorVisible(true);
               }
             });
-        } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
-          // This is an OpMode.
+        } else if (currentModule.moduleType == commonStorage.MODULE_TYPE_MECHANISM
+            || currentModule.moduleType == commonStorage.MODULE_TYPE_OPMODE) {
+          // This is a Mechanism or an OpMode.
+          // Before deleting it, select its workspace.
+          // Put the module type and path into local variables before we select its workspace.
+          const moduleTypeToDelete = currentModule.moduleType;
           const modulePathToDelete = currentModulePath;
           const workspacePath = commonStorage.makeWorkspacePath(currentModule.workspaceName);
           setCurrentModulePath(workspacePath);
-          storage.deleteOpMode(modulePathToDelete,
+          storage.deleteModule(moduleTypeToDelete, modulePathToDelete,
             (success: boolean, errorMessage: string) => {
               if (success) {
                 setTriggerListModules(!triggerListModules);
               } else if (errorMessage) {
-                setAlertErrorMessage('Failed to delete the OpMode: ' + errorMessage);
+                setAlertErrorMessage('Failed to delete the module: ' + errorMessage);
                 setAlertErrorVisible(true);
               }
             });
@@ -918,16 +1012,26 @@ const App: React.FC = () => {
                       placement="bottomRight"
                   >
                     <Button
-                      icon={<FolderAddOutlined />}
+                      icon={<WorkspaceAddOutlined />}
                       size="small"
                       onClick={handleNewWorkspaceClicked}
                       style={{ color: 'white' }}
                     >
                     </Button>
                   </Tooltip>
+                  <Tooltip title="New Mechanism">
+                    <Button
+                      icon={<MechanismAddOutlined />}
+                      size="small"
+                      disabled={!currentModulePath}
+                      onClick={handleNewMechanismClicked}
+                      style={{ color: 'white' }}
+                    >
+                    </Button>
+                  </Tooltip>
                   <Tooltip title="New OpMode">
                     <Button
-                      icon={<FileAddOutlined />}
+                      icon={<OpModeAddOutlined />}
                       size="small"
                       disabled={!currentModulePath}
                       onClick={handleNewOpModeClicked}
@@ -1079,25 +1183,27 @@ const App: React.FC = () => {
       </Flex>
 
       <NewWorkspaceNameModal
+        title={newWorkspaceNameModalTitle}
         isOpen={newWorkspaceNameModalIsOpen}
         initialValue={newWorkspaceNameModalInitialValue}
         getWorkspaceNames={getWorkspaceNames}
-        onOk={(w) => {
+        onOk={(newName) => {
           setNewWorkspaceNameModalIsOpen(false);
-          handleNewWorkspaceNameOk(w);
+          handleNewWorkspaceNameOk(newName);
         }}
         onCancel={() => setNewWorkspaceNameModalIsOpen(false)}
       />
-      <NewOpModeNameModal
-        isOpen={newOpModeNameModalIsOpen}
-        initialValue={newOpModeNameModalInitialValue}
+      <NewModuleNameModal
+        title={newModuleNameModalTitle}
+        isOpen={newModuleNameModalIsOpen}
+        initialValue={newModuleNameModalInitialValue}
         getCurrentWorkspaceName={getCurrentWorkspaceName}
-        getOpModeNames={getOpModeNames}
-        onOk={(w, o) => {
-          setNewOpModeNameModalIsOpen(false);
-          handleNewOpModeNameOk(w, o);
+        getModuleNames={getModuleNames}
+        onOk={(newName) => {
+          setNewModuleNameModalIsOpen(false);
+          handleNewModuleNameOk(newName);
         }}
-        onCancel={() => setNewOpModeNameModalIsOpen(false)}
+        onCancel={() => setNewModuleNameModalIsOpen(false)}
       />
       <ToolboxSettingsModal
         isOpen={toolboxSettingsModalIsOpen}
diff --git a/src/blocks/mrc_class_method_def.ts b/src/blocks/mrc_class_method_def.ts
index e08d119b..0e5fabcc 100644
--- a/src/blocks/mrc_class_method_def.ts
+++ b/src/blocks/mrc_class_method_def.ts
@@ -45,7 +45,6 @@ export type Parameter = {
 type ClassMethodDefBlock = Blockly.Block & ClassMethodDefMixin & Blockly.BlockSvg;
 interface ClassMethodDefMixin extends ClassMethodDefMixinType {
     mrcCanChangeSignature: boolean,
-    mrcCanDelete: boolean,
     mrcReturnType: string,
     mrcParameters: Parameter[],
     mrcPythonMethodName: string,
@@ -58,10 +57,6 @@ type ClassMethodDefExtraState = {
      * Can change name and parameters and return type
      */
     canChangeSignature: boolean,
-    /**
-     * Can delete from class
-     */
-    canDelete: boolean,
     /**
      * The return type of the function.
      * Use 'None' for no return value.
@@ -100,7 +95,6 @@ const CLASS_METHOD_DEF = {
         this: ClassMethodDefBlock): ClassMethodDefExtraState {
         const extraState: ClassMethodDefExtraState = {
             canChangeSignature: this.mrcCanChangeSignature,
-            canDelete: this.mrcCanDelete,
             returnType: this.mrcReturnType,
             params: [],
         };
@@ -124,7 +118,6 @@ const CLASS_METHOD_DEF = {
         extraState: ClassMethodDefExtraState
     ): void {
         this.mrcCanChangeSignature = extraState.canChangeSignature;
-        this.mrcCanDelete = extraState.canDelete;
         this.mrcPythonMethodName = extraState.pythonMethodName ? extraState.pythonMethodName : '';
         this.mrcReturnType = extraState.returnType;
         this.mrcParameters = [];
@@ -157,7 +150,6 @@ const CLASS_METHOD_DEF = {
             //Case because a current bug in blockly where it won't allow passing null to Blockly.Block.setMutator makes it necessary.
             (this as Blockly.BlockSvg).setMutator( null );
         }
-        this.setDeletable(this.mrcCanDelete);
         this.mrcUpdateParams();
     },
     compose: function (this: ClassMethodDefBlock, containerBlock: any) {
@@ -347,6 +339,7 @@ export const setup = function() {
 
 import { Order, PythonGenerator } from 'blockly/python';
 
+
 export const pythonFromBlock = function (
     block: ClassMethodDefBlock,
     generator: PythonGenerator,
@@ -404,6 +397,11 @@ export const pythonFromBlock = function (
         '(' +
         paramString +
         '):\n';
+    
+    if(block.mrcPythonMethodName == '__init__'){
+        code +=  generator.INDENT + "self.mechanisms = [];\n"
+
+    }    
 
     code +=
         xfix1 +
diff --git a/src/blocks/mrc_mechanism.ts b/src/blocks/mrc_mechanism.ts
new file mode 100644
index 00000000..8738fa48
--- /dev/null
+++ b/src/blocks/mrc_mechanism.ts
@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2025 Porpoiseful LLC
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Create a mechanism with a name of a certain type
+ * @author alan@porpoiseful.com (Alan Smith)
+ */
+import * as Blockly from 'blockly';
+import { Order, PythonGenerator } from 'blockly/python';
+
+import { MRC_STYLE_FUNCTIONS } from '../themes/styles'
+import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
+import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
+import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
+
+export const BLOCK_NAME = 'mrc_mechanism';
+export const OUTPUT_NAME = 'mrc_mechansim';
+
+export type ConstructorArg = {
+  name: string,
+  type: string,
+};
+
+type MechanismExtraState = {
+  importModule?: string,
+  params?: ConstructorArg[],
+}
+
+type MechanismBlock = Blockly.Block & MechanismMixin;
+interface MechanismMixin extends MechanismMixinType {
+  mrcArgs: ConstructorArg[],
+  mrcImportModule: string,
+
+}
+type MechanismMixinType = typeof MECHANISM_FUNCTION;
+
+const MECHANISM_FUNCTION = {
+  /**
+    * Block initialization.
+    */
+  init: function (this: MechanismBlock): void {
+    this.setStyle(MRC_STYLE_FUNCTIONS);
+    this.appendDummyInput()
+      .appendField(new Blockly.FieldTextInput('my_mech'), 'NAME')
+      .appendField('of type')
+      .appendField(createFieldNonEditableText(''), 'TYPE');
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+  },
+
+  /**
+    * Returns the state of this block as a JSON serializable object.
+    */
+  saveExtraState: function (this: MechanismBlock): MechanismExtraState {
+    const extraState: MechanismExtraState = {
+    };
+    extraState.params = [];
+    this.mrcArgs.forEach((arg) => {
+      extraState.params!.push({
+        'name': arg.name,
+        'type': arg.type,
+      });
+    });    
+    if (this.mrcImportModule) {
+      extraState.importModule = this.mrcImportModule;
+    }
+    return extraState;
+  },
+  /**
+  * Applies the given state to this block.
+  */
+  loadExtraState: function (this: MechanismBlock, extraState: MechanismExtraState): void {
+    this.mrcImportModule = extraState.importModule ? extraState.importModule : '';
+    this.mrcArgs = [];
+
+    if(extraState.params){
+      extraState.params.forEach((arg) => {
+        this.mrcArgs.push({
+          'name': arg.name,
+          'type': arg.type,
+        });
+      });
+    }
+    this.mrcArgs = extraState.params ? extraState.params : [];
+    this.updateBlock_();
+  },
+  /**
+     * Update the block to reflect the newly loaded extra state.
+     */
+    updateBlock_: function(this: MechanismBlock): void {
+      // Add input sockets for the arguments.
+      for (let i = 0; i < this.mrcArgs.length; i++) {
+        const input = this.appendValueInput('ARG' + i)
+            .setAlign(Blockly.inputs.Align.RIGHT)
+            .appendField(this.mrcArgs[i].name);
+        if (this.mrcArgs[i].type) {
+          input.setCheck(getAllowedTypesForSetCheck(this.mrcArgs[i].type));
+        }
+      }
+    }
+}
+
+export const setup = function () {
+  Blockly.Blocks[BLOCK_NAME] = MECHANISM_FUNCTION;
+}
+
+//TODO: This needs to cause our own init to create the mechanisms line
+export const pythonFromBlock = function (
+  mechanismBlock: MechanismBlock,
+  generator: ExtendedPythonGenerator,
+) {
+  if (mechanismBlock.mrcImportModule) {
+    generator.addImport(mechanismBlock.mrcImportModule);
+  }
+  let code = 'self.mechanisms["' + mechanismBlock.getFieldValue('NAME') + '"] = '
+    + mechanismBlock.getFieldValue('TYPE') + '('
+
+  for (let i = 0; i < mechanismBlock.mrcArgs.length; i++) {
+      const fieldName = 'ARG' + i;
+      if(i != 0){
+        code += ', '
+      }
+      code += mechanismBlock.mrcArgs[i].name + ' = ' + generator.valueToCode(mechanismBlock, fieldName, Order.NONE);
+    }
+  
+  code += ')' + "\n";
+
+  return code
+}
diff --git a/src/blocks/setup_custom_blocks.ts b/src/blocks/setup_custom_blocks.ts
index 6362dac6..e460689f 100644
--- a/src/blocks/setup_custom_blocks.ts
+++ b/src/blocks/setup_custom_blocks.ts
@@ -9,6 +9,7 @@ import * as MiscComment from './mrc_misc_comment';
 import * as MiscEvaluateButIgnoreResult from './mrc_misc_evaluate_but_ignore_result';
 import * as SetPythonVariable from './mrc_set_python_variable';
 import * as ClassMethodDef from './mrc_class_method_def';
+import * as Mechanism from './mrc_mechanism';
 
 const customBlocks = [
   CallPythonFunction,
@@ -20,6 +21,7 @@ const customBlocks = [
   MiscComment,
   MiscEvaluateButIgnoreResult,
   SetPythonVariable,
+  Mechanism,
 ];
 
 export const setup = function(forBlock: any) {
diff --git a/src/editor/editor.ts b/src/editor/editor.ts
index 8ab5bdbf..edf5c66b 100644
--- a/src/editor/editor.ts
+++ b/src/editor/editor.ts
@@ -129,8 +129,8 @@ export class Editor {
               this.workspaceContent = moduleContent
             }
 
-            // If both the workspace and the module have been loaded, load the
-            // blocks into the blockly workspace.
+            // If both the workspace content and the module content have been
+            // loaded, load the blocks into the blockly workspace.
             if (this.workspaceContent) {
               this.loadBlocksIntoBlocklyWorkspace();
             }
@@ -164,6 +164,7 @@ export class Editor {
     if (this.bindedOnChange) {
       this.blocklyWorkspace.removeChangeListener(this.bindedOnChange);
     }
+    this.blocklyWorkspace.hideChaff();
     this.blocklyWorkspace.clear();
     this.blocklyWorkspace.scroll(0, 0);
     this.setToolbox(EMPTY_TOOLBOX);
@@ -217,7 +218,7 @@ export class Editor {
     const pythonCode = extendedPythonGenerator.workspaceToCode(this.blocklyWorkspace);
     const exportedBlocks = JSON.stringify(extendedPythonGenerator.getExportedBlocks(this.blocklyWorkspace));
     const blocksContent = JSON.stringify(Blockly.serialization.workspaces.save(this.blocklyWorkspace));
-    return commonStorage.makeModuleContent(pythonCode, exportedBlocks, blocksContent);
+    return commonStorage.makeModuleContent(this.currentModule, pythonCode, exportedBlocks, blocksContent);
   }
 
   public saveModule(callback: storage.BooleanCallback): void {
diff --git a/src/editor/extended_python_generator.ts b/src/editor/extended_python_generator.ts
index 0d93faff..3c67be97 100644
--- a/src/editor/extended_python_generator.ts
+++ b/src/editor/extended_python_generator.ts
@@ -159,30 +159,55 @@ export class ExtendedPythonGenerator extends PythonGenerator {
     this.definitions_['import_' + importModule] = 'import ' + importModule;
   }
 
-  workspaceToCode(workspace?: Blockly.Workspace): string {
-    let code = super.workspaceToCode(workspace);
-    if (!this.currentModule) {
-      return code;
+  classParentFromModuleType(moduleType : string) : string{
+    if(moduleType == commonStorage.MODULE_TYPE_WORKSPACE){
+      return "Robot";
     }
-
-    let className = this.currentModule.moduleName;
-    let classType = this.currentModule.moduleType;
-
-    this.addImport(classType);
-
-    let prefix = "";
-    for (let key in this.definitions_) {
-      prefix += this.definitions_[key] + "\n";
+    if(moduleType == commonStorage.MODULE_TYPE_OPMODE){
+      return "OpMode";
     }
-    if (prefix) {
-      prefix += "\n";
+    if(moduleType == commonStorage.MODULE_TYPE_MECHANISM){
+      return "OpMode";
     }
+    return "";
+  }
 
-    let class_def = "class " + className + "(" + classType + "):\n";
+  finish(code: string): string {
+    if (!this.currentModule) {
+      return super.finish(code);
+    }    
+    let className = this.currentModule.moduleName;
+    let classParent = this.classParentFromModuleType(this.currentModule.moduleType);
+    this.addImport(classParent);
+
+    // Convert the definitions dictionary into a list.
+    const imports = [];
+    const definitions = [];
+    for (let name in this.definitions_) {
+      const def = this.definitions_[name];
+      if (def.match(/^(from\s+\S+\s+)?import\s+\S+/)) {
+        imports.push(def);
+      } else {
+        definitions.push(def);
+      }
+    }
+    // Call Blockly.CodeGenerator's finish.  This is required to be done this way
+    // because we derive from PythonGenerator which dervies from CodeGenerator
+    // This section except for the class_def part is all copied from Blockly's
+    // PythonGenerator.  It can't be derived because it needs the class insertion
+    // in the middle.
+    code = Blockly.CodeGenerator.prototype.finish(code);
+    this.isInitialized = false;
+
+    let class_def = "class " + className + "(" + classParent + "):\n";
     if (!code) {
       code = "pass";
     }
-    return prefix + class_def + this.prefixLines(code, this.INDENT);
+
+    this.nameDB_!.reset();
+    const allDefs = imports.join('\n') + '\n\n' + definitions.join('\n\n');
+    return allDefs.replace(/\n\n+/g, '\n\n').replace(/\n*$/, '\n\n\n') + class_def + 
+            this.prefixLines(code, this.INDENT);
   }
 }
 
diff --git a/src/modules/mrc_module_opmode.ts b/src/modules/mrc_module_opmode.ts
deleted file mode 100644
index ebb79d43..00000000
--- a/src/modules/mrc_module_opmode.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import * as Blockly from 'blockly';
-import { BLOCK_NAME as MRC_CLASS_METHOD_DEF } from '../blocks/mrc_class_method_def'
-
-export function create(workspace : Blockly.Workspace, render: boolean) {
-    let initBlock = workspace.newBlock(MRC_CLASS_METHOD_DEF);
-    initBlock.setFieldValue('init', 'NAME');
-    const extra = {
-        canChangeSignature: false,
-        canDelete: false,
-        returnType: 'None',
-        pythonMethodName: '__init__',
-        params: []
-    };  
-    if (initBlock.loadExtraState){
-        initBlock.loadExtraState(extra);
-    }
-    if (render) {
-        (initBlock as Blockly.BlockSvg).initSvg();
-        (initBlock as Blockly.BlockSvg).render();
-    }
-}
diff --git a/src/modules/opmode_start.json b/src/modules/opmode_start.json
new file mode 100644
index 00000000..6abbebfd
--- /dev/null
+++ b/src/modules/opmode_start.json
@@ -0,0 +1,38 @@
+{
+    "blocks": {
+        "languageVersion": 0,
+        "blocks": [
+            {
+                "type": "mrc_class_method_def",
+                "id": "ElbONc{)s(,UprTW(|1C",
+                "x": 10,
+                "y": 10,
+                "deletable": false,
+                "extraState": {
+                    "canChangeSignature": false,
+                    "returnType": "None",
+                    "params": [],
+                    "pythonMethodName": "__init__"
+                },
+                "fields": {
+                    "NAME": "init"
+                }
+            },
+            {
+                "type": "mrc_class_method_def",
+                "id": "wxFAh6eaR1|3fTuV:UAd",
+                "x": 10,
+                "y": 200,
+                "deletable": false,
+                "extraState": {
+                    "canChangeSignature": false,
+                    "returnType": "None",
+                    "params": []
+                },
+                "fields": {
+                    "NAME": "loop"
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/src/storage/client_side_storage.ts b/src/storage/client_side_storage.ts
index 11e9ee7c..f497adae 100644
--- a/src/storage/client_side_storage.ts
+++ b/src/storage/client_side_storage.ts
@@ -31,7 +31,7 @@ export type ModulesCallback = (modules: commonStorage.Workspace[] | null, error:
 const databaseName = 'systemcore-blocks-interface';
 let db: IDBDatabase | null = null;
 
-function openDatabase(callback: BooleanCallback): void {
+function _openDatabase(callback: BooleanCallback): void {
   const openRequest = window.indexedDB.open(databaseName, 1);
   openRequest.onerror = (event: Event) => {
     console.log('IndexedDB open request failed:');
@@ -63,7 +63,7 @@ export function saveEntry(
     entryKey: string, entryValue: string,
     callback: BooleanCallback | null = null): void {
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         saveEntry(entryKey, entryValue, callback);
       } else {
@@ -111,7 +111,7 @@ export function saveEntry(
 
 export function fetchEntry(entryKey: string, defaultValue: string, callback: StringCallback): void {
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         fetchEntry(entryKey, defaultValue, callback);
       } else {
@@ -140,7 +140,7 @@ export function fetchEntry(entryKey: string, defaultValue: string, callback: Str
 
 export function listModules(callback: ModulesCallback): void {
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         listModules(callback);
       } else {
@@ -150,6 +150,9 @@ export function listModules(callback: ModulesCallback): void {
     return;
   }
   const workspaces: {[key: string]: commonStorage.Workspace} = {}; // key is workspace name, value is Workspace
+  // The mechanisms and opModes variables hold any Mechanisms and OpModes that
+  // are read before the Workspace to which they belong is read.
+  const mechanisms: {[key: string]: commonStorage.Mechanism[]} = {}; // key is workspace name, value is list of Mechanisms
   const opModes: {[key: string]: commonStorage.OpMode[]} = {}; // key is workspace name, value is list of OpModes
   const openCursorRequest = db.transaction(['modules'], 'readonly')
       .objectStore('modules')
@@ -174,30 +177,58 @@ export function listModules(callback: ModulesCallback): void {
       if (value.type === commonStorage.MODULE_TYPE_WORKSPACE) {
         const workspace: commonStorage.Workspace = {
           ...module,
+          mechanisms: [],
           opModes: [],
-          mechanisms: []
         };
         workspaces[workspace.workspaceName] = workspace;
+        // Add any Mechanisms that belong to this workspace that have already
+        // been read.
+        if (workspace.workspaceName in mechanisms) {
+          workspace.mechanisms = mechanisms[workspace.workspaceName];
+          delete mechanisms[workspace.workspaceName];
+        }
+        // Add any OpModes that belong to this workspace that have already been
+        // read.
         if (workspace.workspaceName in opModes) {
           workspace.opModes = opModes[workspace.workspaceName];
           delete opModes[workspace.workspaceName];
+        }
+      } else if (value.type === commonStorage.MODULE_TYPE_MECHANISM) {
+        const mechanism: commonStorage.Mechanism = {
+          ...module,
+        };
+        if (mechanism.workspaceName in workspaces) {
+          // If the Workspace to which this Mechanism belongs has already been read,
+          // add this Mechanism to it.
+          workspaces[mechanism.workspaceName].mechanisms.push(mechanism);
         } else {
-          workspace.opModes = [];
+          // Otherwise, add this Mechanism to the mechanisms local variable.
+          if (mechanism.workspaceName in mechanisms) {
+            mechanisms[mechanism.workspaceName].push(mechanism);
+          } else {
+            mechanisms[mechanism.workspaceName] = [mechanism];
+          }
         }
       } else if (value.type === commonStorage.MODULE_TYPE_OPMODE) {
         const opMode: commonStorage.OpMode = {
           ...module,
         };
         if (opMode.workspaceName in workspaces) {
+          // If the Workspace to which this OpMode belongs has already been read,
+          // add this OpMode to it.
           workspaces[opMode.workspaceName].opModes.push(opMode);
-        } else if (opMode.workspaceName in opModes) {
-          opModes[opMode.workspaceName].push(opMode);
         } else {
-          opModes[opMode.workspaceName] = [opMode];
+          // Otherwise, add this OpMode to the opModes local variable.
+          if (opMode.workspaceName in opModes) {
+            opModes[opMode.workspaceName].push(opMode);
+          } else {
+            opModes[opMode.workspaceName] = [opMode];
+          }
         }
       }
       cursor.continue();
     } else {
+      // The cursor is done. We have finished reading all the modules.
       const modules: commonStorage.Workspace[] = [];
       const sortedWorkspaceNames = Object.keys(workspaces).sort();
       sortedWorkspaceNames.forEach((workspaceName) => {
@@ -212,7 +243,7 @@ export function fetchModuleContent(
     modulePath: string,
     callback : (content: string | null, error: string) => void): void {
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         fetchModuleContent(modulePath, callback);
       } else {
@@ -257,7 +288,7 @@ function _saveModule(
   // When creating a new module, moduleType must be truthy.
   // When saving an existing module, the moduleType must be falsy.
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         _saveModule(moduleType, modulePath, moduleContent, callback);
       } else {
@@ -307,26 +338,14 @@ function _saveModule(
   };
 }
 
-export function renameWorkspace(
-    oldWorkspaceName: string, newWorkspaceName: string,
-    callback: BooleanCallback): void {
-  _renameOrCopyWorkspace(oldWorkspaceName, newWorkspaceName, callback, false);
-}
-
-export function copyWorkspace(
-    oldWorkspaceName: string, newWorkspaceName: string,
-    callback: BooleanCallback): void {
-  _renameOrCopyWorkspace(oldWorkspaceName, newWorkspaceName, callback, true);
-}
-
-export function _renameOrCopyWorkspace(
+function _renameOrCopyWorkspace(
     oldWorkspaceName: string, newWorkspaceName: string,
     callback: BooleanCallback, copy: boolean): void {
   const errorMessage = copy
       ? 'Copy Workspace failed.'
       : 'Rename Workspace failed.'
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         _renameOrCopyWorkspace(oldWorkspaceName, newWorkspaceName, callback, copy);
       } else {
@@ -406,30 +425,44 @@ export function _renameOrCopyWorkspace(
   };
 }
 
-export function renameOpMode(
-    workspaceName: string, oldOpModeName: string, newOpModeName: string,
+export function renameModule(
+    moduleType: string, workspaceName: string,
+    oldModuleName: string, newModuleName: string,
     callback: BooleanCallback): void {
-  _renameOrCopyOpMode(
-      workspaceName, oldOpModeName, newOpModeName, callback, false);
+  _renameOrCopyModule(
+      moduleType, workspaceName, oldModuleName, newModuleName,
+      callback, false);
 }
 
-export function copyOpMode(
-    workspaceName: string, oldOpModeName: string, newOpModeName: string,
+export function copyModule(
+    moduleType: string, workspaceName: string,
+    oldModuleName: string, newModuleName: string,
     callback: BooleanCallback): void {
-  _renameOrCopyOpMode(
-      workspaceName, oldOpModeName, newOpModeName, callback, true);
+  _renameOrCopyModule(
+      moduleType, workspaceName, oldModuleName, newModuleName,
+      callback, true);
 }
 
-export function _renameOrCopyOpMode(
-    workspaceName: string, oldOpModeName: string, newOpModeName: string,
+function _renameOrCopyModule(
+    moduleType: string, workspaceName: string,
+    oldModuleName: string, newModuleName: string,
     callback: BooleanCallback, copy: boolean): void {
+
+  if (moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
+    _renameOrCopyWorkspace(oldModuleName, newModuleName, callback, copy);
+    return;
+  }
+
   const errorMessage = copy
-      ? 'Copy OpMode failed.'
-      : 'Rename OpMode failed.'
+      ? 'Copy module failed.'
+      : 'Rename module failed.'
+
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
-        _renameOrCopyOpMode(workspaceName, oldOpModeName, newOpModeName, callback, copy);
+        _renameOrCopyModule(
+            moduleType, workspaceName, oldModuleName, newModuleName,
+            callback, copy);
       } else {
         callback(false, errorMessage + '(' + errorReason + ')');
       }
@@ -442,8 +475,8 @@ export function _renameOrCopyOpMode(
     callback(true, '');
   };
   const modulesObjectStore = transaction.objectStore('modules');
-  const oldModulePath = commonStorage.makeModulePath(workspaceName, oldOpModeName);
-  const newModulePath = commonStorage.makeModulePath(workspaceName, newOpModeName);
+  const oldModulePath = commonStorage.makeModulePath(workspaceName, oldModuleName);
+  const newModulePath = commonStorage.makeModulePath(workspaceName, newModuleName);
   const getRequest = modulesObjectStore.get(oldModulePath);
   getRequest.onerror = (event: Event) => {
     console.log('IndexedDB get request failed:');
@@ -452,7 +485,7 @@ export function _renameOrCopyOpMode(
   };
   getRequest.onsuccess = (event: Event) => {
     if (getRequest.result === undefined) {
-      callback(false, errorMessage + ' (OpMode not found)');
+      callback(false, errorMessage + ' (module not found)');
       return;
     }
     const value = getRequest.result;
@@ -479,11 +512,10 @@ export function _renameOrCopyOpMode(
   };
 }
 
-export function deleteWorkspace(
-    workspaceName: string,
-    callback: BooleanCallback): void {
+function _deleteWorkspace(
+    workspaceName: string, callback: BooleanCallback): void {
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
         deleteWorkspace(workspaceName, callback);
       } else {
@@ -531,15 +563,22 @@ export function deleteWorkspace(
   };
 }
 
-export function deleteOpMode(
-    opModePath: string,
+export function deleteModule(
+    moduleType: string, modulePath: string,
     callback: BooleanCallback): void {
+
+  if (moduleType == commonStorage.MODULE_TYPE_WORKSPACE) {
+    const workspaceName = commonStorage.getWorkspaceName(modulePath);
+    _deleteWorkspace(workspaceName, callback);
+    return;
+  }
+
   if (!db) {
-    openDatabase((success: boolean, errorReason: string) => {
+    _openDatabase((success: boolean, errorReason: string) => {
       if (success) {
-        deleteOpMode(opModePath, callback);
+        deleteModule(modulePath, callback);
       } else {
-        callback(false, 'Delete OpMode failed. (' + errorReason + ')');
+        callback(false, 'Delete module failed. (' + errorReason + ')');
       }
     });
     return;
@@ -550,11 +589,11 @@ export function deleteOpMode(
     callback(true, '');
   };
   const modulesObjectStore = transaction.objectStore('modules');
-  const deleteRequest = modulesObjectStore.delete(opModePath);
+  const deleteRequest = modulesObjectStore.delete(modulePath);
   deleteRequest.onerror = (event: Event) => {
     console.log('IndexedDB delete request failed:');
     console.log(deleteRequest.error);
-    callback(false, 'Delete OpMode failed. (deleteRequest error)');
+    callback(false, 'Delete module failed. (deleteRequest error)');
   };
   deleteRequest.onsuccess = (event: Event) => {
   };
diff --git a/src/storage/common_storage.ts b/src/storage/common_storage.ts
index 1749de3e..28851cab 100644
--- a/src/storage/common_storage.ts
+++ b/src/storage/common_storage.ts
@@ -22,7 +22,8 @@
 import * as Blockly from 'blockly/core';
 
 import {Block} from "../toolbox/items";
-import {create as createOpMode} from '../modules/mrc_module_opmode'
+import startingOpModeBlocks from '../modules/opmode_start.json'; 
+
 import {extendedPythonGenerator} from '../editor/extended_python_generator';
 
 // Types, constants, and functions related to modules, regardless of where the modules are stored.
@@ -35,20 +36,30 @@ export type Module = {
   dateModifiedMillis: number,
 };
 
-export type OpMode = Module;
 export type Mechanism = Module;
+export type OpMode = Module;
 
 export type Workspace = Module & {
-  opModes: OpMode[],
   mechanisms: Mechanism[]
+  opModes: OpMode[],
 };
 
+export const MODULE_TYPE_UNKNOWN = 'unknown';
 export const MODULE_TYPE_WORKSPACE = 'workspace';
-export const MODULE_TYPE_OPMODE = 'opmode';
 export const MODULE_TYPE_MECHANISM = 'mechanism';
+export const MODULE_TYPE_OPMODE = 'opmode';
 
 export const MODULE_NAME_PLACEHOLDER = '%module_name%';
 
+const DELIMITER_PREFIX = 'BlocksContent';
+const MARKER_MODULE_TYPE = 'moduleType: ';
+const MARKER_EXPORTED_BLOCKS = 'exportedBlocks: ';
+const MARKER_BLOCKS_CONTENT = 'blocksContent: ';
+const PARTS_INDEX_BLOCKS_CONTENT = 0;
+const PARTS_INDEX_EXPORTED_BLOCKS = 1;
+const PARTS_INDEX_MODULE_TYPE = 2;
+const NUMBER_OF_PARTS = 3;
+
 /**
  * Returns the module with the given module path, or null if it is not found.
  */
@@ -57,6 +68,11 @@ export function findModule(modules: Workspace[], modulePath: string): Module | n
     if (workspace.modulePath === modulePath) {
       return workspace;
     }
+    for (const mechanism of workspace.mechanisms) {
+      if (mechanism.modulePath === modulePath) {
+        return mechanism;
+      }
+    }
     for (const opMode of workspace.opModes) {
       if (opMode.modulePath === modulePath) {
         return opMode;
@@ -136,10 +152,42 @@ export function makeUploadWorkspaceName(uploadFileName: string): string {
  * Returns the module content for a new Workspace.
  */
 export function newWorkspaceContent(workspaceName: string): string {
+  const module: Module = {
+    modulePath: makeWorkspacePath(workspaceName),
+    moduleType: MODULE_TYPE_WORKSPACE,
+    workspaceName: workspaceName,
+    moduleName: workspaceName,
+    dateModifiedMillis: 0,
+  };
+
   const pythonCode = '';
   const exportedBlocks = '[]';
   const blocksContent = '{}';
-  return makeModuleContent(pythonCode, exportedBlocks, blocksContent);
+  return makeModuleContent(module, pythonCode, exportedBlocks, blocksContent);
+}
+
+/**
+ * Returns the module content for a new Mechanism.
+ */
+export function newMechanismContent(workspaceName: string, mechanismName: string): string {
+  const module: Module = {
+    modulePath: makeModulePath(workspaceName, mechanismName),
+    moduleType: MODULE_TYPE_MECHANISM,
+    workspaceName: workspaceName,
+    moduleName: mechanismName,
+    dateModifiedMillis: 0,
+  };
+
+  // Create a headless blockly workspace.
+  const headlessBlocklyWorkspace = new Blockly.Workspace();
+  headlessBlocklyWorkspace.options.oneBasedIndex = false;
+  // TODO: Create the blocks for a new mechanism.
+
+  extendedPythonGenerator.setCurrentModule(module);
+  const pythonCode = extendedPythonGenerator.workspaceToCode(headlessBlocklyWorkspace);
+  const exportedBlocks = JSON.stringify(extendedPythonGenerator.getExportedBlocks(headlessBlocklyWorkspace));
+  const blocksContent = JSON.stringify(Blockly.serialization.workspaces.save(headlessBlocklyWorkspace));
+  return makeModuleContent(module, pythonCode, exportedBlocks, blocksContent);
 }
 
 /**
@@ -157,21 +205,21 @@ export function newOpModeContent(workspaceName: string, opModeName: string): str
   // Create a headless blockly workspace.
   const headlessBlocklyWorkspace = new Blockly.Workspace();
   headlessBlocklyWorkspace.options.oneBasedIndex = false;
-  createOpMode(headlessBlocklyWorkspace, false);
-
+  Blockly.serialization.workspaces.load(startingOpModeBlocks, headlessBlocklyWorkspace);
+  
   extendedPythonGenerator.setCurrentModule(module);
   const pythonCode = extendedPythonGenerator.workspaceToCode(headlessBlocklyWorkspace);
   const exportedBlocks = JSON.stringify(extendedPythonGenerator.getExportedBlocks(headlessBlocklyWorkspace));
   const blocksContent = JSON.stringify(Blockly.serialization.workspaces.save(headlessBlocklyWorkspace));
-  return makeModuleContent(pythonCode, exportedBlocks, blocksContent);
+  return makeModuleContent(module, pythonCode, exportedBlocks, blocksContent);
 }
 
 /**
  * Make the module content from the given python code and blocks content.
  */
-export function makeModuleContent(pythonCode: string, exportedBlocks: string, blocksContent: string): string {
-  let delimiter = 'BlocksContent';
-  while (blocksContent.includes(delimiter) || exportedBlocks.includes(delimiter)) {
+export function makeModuleContent(module: Module, pythonCode: string, exportedBlocks: string, blocksContent: string): string {
+  let delimiter = DELIMITER_PREFIX;
+  while (blocksContent.includes(delimiter) || exportedBlocks.includes(delimiter) || module.moduleType.includes(delimiter)) {
     delimiter += '.';
   }
   return (
@@ -179,72 +227,72 @@ export function makeModuleContent(pythonCode: string, exportedBlocks: string, bl
       pythonCode + '\n\n\n' +
       '"""\n' +
       delimiter + '\n' +
-      exportedBlocks + '\n' +
+      MARKER_MODULE_TYPE + module.moduleType + '\n' +
       delimiter + '\n' +
-      blocksContent + '\n' +
+      MARKER_EXPORTED_BLOCKS + exportedBlocks + '\n' +
+      delimiter + '\n' +
+      MARKER_BLOCKS_CONTENT + blocksContent + '\n' +
       delimiter + '\n' +
       '"""\n');
 }
 
-/**
- * Extract the blocks content from the given module content.
- */
-export function extractBlocksContent(moduleContent: string): string {
+function getParts(moduleContent: string): string {
   // The last line is """.
   const lastChars = '\n"""\n';
   if (!moduleContent.endsWith(lastChars) || moduleContent.length <= lastChars.length) {
-    throw new Error('Unable to extract the blocks content.');
+    throw new Error('Unable to parse the module content.');
   }
   // The line before that is the delimiter.
   const iEndOfDelimiter = moduleContent.length - lastChars.length;
   const iPreviousNewLine = moduleContent.lastIndexOf('\n', iEndOfDelimiter - 1);
   if (iPreviousNewLine === -1) {
-    throw new Error('Unable to extract the blocks content.');
+    throw new Error('Unable to parse the module content.');
   }
-  const iEndOfBlocksContent = iPreviousNewLine;
   const iStartOfDelimiter = iPreviousNewLine + 1;
   const delimiter = moduleContent.substring(iStartOfDelimiter, iEndOfDelimiter);
-  // Now, find the previous delimiter.
-  const iStartOfPreviousDelimiter = moduleContent.lastIndexOf(delimiter, iPreviousNewLine - 1);
-  if (iStartOfPreviousDelimiter === -1) {
-    throw new Error('Unable to extract the blocks content.');
+  const split = moduleContent.split(delimiter);
+  split.pop(); // The last element is the """ that closes the python comment.
+  const parts = [];
+  // Pop the elements off of the split array and push them onto the parts array
+  // so they end up in the reverse order that they were in the module content.
+  // Ignore the first (index 0) element of the split array, which is the python
+  // code.
+  while (split.length > 1 && parts.length < NUMBER_OF_PARTS) {
+    parts.push(split.pop().trim());
+  }
+  if (parts.length < 2) {
+    throw new Error('Unable to parse the module content.');
+  }
+  if (parts.length == 2) {
+    // This module was saved without the module type, which was added to the module content when we introduced mechanisms.
+    // This module is either a Workspace or an OpMode, but we don't know which from just the content.
+    parts.push(MODULE_TYPE_UNKNOWN);
+  }
+  return parts;
+}
+
+/**
+ * Extract the blocks content from the given module content.
+ */
+export function extractBlocksContent(moduleContent: string): string {
+  const parts = getParts(moduleContent);
+  let blocksContent = parts[PARTS_INDEX_BLOCKS_CONTENT];
+  if (blocksContent.startsWith(MARKER_BLOCKS_CONTENT)) {
+    blocksContent = blocksContent.substring(MARKER_BLOCKS_CONTENT.length);
   }
-  // The blocks content is between the two delimiters.
-  const iStartOfBlocksContent = iStartOfPreviousDelimiter + delimiter.length + 1;
-  return moduleContent.substring(iStartOfBlocksContent, iEndOfBlocksContent);
+  return blocksContent;
 }
 
 /**
  * Extract the exportedBlocks from the given module content.
  */
 export function extractExportedBlocks(moduleName: string, moduleContent: string): Block[] {
-  // The last line is """.
-  const lastChars = '\n"""\n';
-  if (!moduleContent.endsWith(lastChars) || moduleContent.length <= lastChars.length) {
-    throw new Error('Unable to extract the exportedBlocks.');
-  }
-  // The line before that is the delimiter.
-  const iEndOfDelimiter = moduleContent.length - lastChars.length;
-  const iPreviousNewLine = moduleContent.lastIndexOf('\n', iEndOfDelimiter - 1);
-  if (iPreviousNewLine === -1) {
-    throw new Error('Unable to extract the exportedBlocks.');
-  }
-  const iStartOfDelimiter = iPreviousNewLine + 1;
-  const delimiter = moduleContent.substring(iStartOfDelimiter, iEndOfDelimiter);
-  // Now, find the previous delimiter.
-  let iStartOfPreviousDelimiter = moduleContent.lastIndexOf(delimiter, iPreviousNewLine - 1);
-  if (iStartOfPreviousDelimiter === -1) {
-    throw new Error('Unable to extract the exportedBlocks.');
-  }
-  const iEndOfExportedBlocks = iStartOfPreviousDelimiter - 1;
-  // Now, find the previous delimiter before that.
-  iStartOfPreviousDelimiter = moduleContent.lastIndexOf(delimiter, iStartOfPreviousDelimiter - 1);
-  if (iStartOfPreviousDelimiter === -1) {
-    throw new Error('Unable to extract the exportedBlocks.');
+  const parts = getParts(moduleContent);
+  let exportedBlocksContent = parts[PARTS_INDEX_EXPORTED_BLOCKS];
+  if (exportedBlocksContent.startsWith(MARKER_EXPORTED_BLOCKS)) {
+    exportedBlocksContent = exportedBlocksContent.substring(MARKER_EXPORTED_BLOCKS.length);
   }
-  // The exportedBlocks content is between the two delimiters.
-  const iStartOfExportedBlocks = iStartOfPreviousDelimiter + delimiter.length + 1;
-  const exportedBlocksContent = moduleContent.substring(iStartOfExportedBlocks, iEndOfExportedBlocks);
+
   const exportedBlocks: Block[] = JSON.parse(exportedBlocksContent);
   exportedBlocks.forEach((block) => {
     if (block.extraState?.importModule === MODULE_NAME_PLACEHOLDER) {
@@ -256,3 +304,15 @@ export function extractExportedBlocks(moduleName: string, moduleContent: string)
   });
   return exportedBlocks;
 }
+
+/**
+ * Extract the moduleType from the given module content.
+ */
+export function extractModuleType(moduleName: string, moduleContent: string): Block[] {
+  const parts = getParts(moduleContent);
+  let moduleType = parts[PARTS_INDEX_MODULE_TYPE];
+  if (moduleType.startsWith(MARKER_MODULE_TYPE)) {
+    moduleType = moduleType.substring(MARKER_MODULE_TYPE.length);
+  }
+  return moduleType;
+}
diff --git a/src/toolbox/mechanism_category.ts b/src/toolbox/mechanism_category.ts
new file mode 100644
index 00000000..c87d184b
--- /dev/null
+++ b/src/toolbox/mechanism_category.ts
@@ -0,0 +1,51 @@
+export const category =
+{
+    kind: 'category',
+    name: 'Mechanisms',
+    contents: [
+        {
+            kind: 'block',
+            type: 'mrc_mechanism',
+            fields: {
+                NAME: 'my_servo',
+                TYPE: 'Servo'
+            },
+            extraState: {
+                importModule : 'Servo',
+                params: [{name:'port',type:'int'}]
+            },              
+            inputs: {
+                ARG0: {
+                  shadow: {
+                    type: 'math_number',
+                    fields: {
+                      NUM: 1,
+                    },
+                  },
+                },  
+            } 
+        },
+        {
+            kind: 'block',
+            type: 'mrc_mechanism',
+            fields: {
+                NAME: 'my_motor',
+                TYPE: 'DcMotor'
+            },
+            extraState: {
+                importModule : 'DcMotor',
+                params: [{name:'port',type:'int'}]
+            },    
+            inputs: {
+                ARG0: {
+                  shadow: {
+                    type: 'math_number',
+                    fields: {
+                      NUM: 1,
+                    },
+                  },
+                },  
+            } 
+        },
+    ],
+}
\ No newline at end of file
diff --git a/src/toolbox/opmode_methods_category.ts b/src/toolbox/opmode_methods_category.ts
index 91668e4d..57d117d9 100644
--- a/src/toolbox/opmode_methods_category.ts
+++ b/src/toolbox/opmode_methods_category.ts
@@ -4,19 +4,7 @@ export const category =
     kind: 'category',
     style: MRC_STYLE_CLASS_BLOCKS,
     name: 'Methods',
-    contents: [
-        {
-            kind: 'block',
-            type: 'mrc_class_method_def',    
-            fields: {NAME: "init"},
-            extraState: {
-                canChangeSignature: false,
-                canDelete: false,
-                returnType: 'None',
-                pythonMethodName: '__init__',
-                params: []
-            },   
-        },    
+    contents: [ 
         {
             kind: 'block',
             type: 'mrc_class_method_def',    
@@ -27,18 +15,7 @@ export const category =
                 returnType: 'None',
                 params: []
             },    
-        },        
-        {
-            kind: 'block',
-            type: 'mrc_class_method_def',    
-            fields: {NAME: "loop"},
-            extraState: {
-                canChangeSignature: false,
-                canDelete: false,
-                returnType: 'None',
-                params: []
-            },    
-        },    
+        },          
         {
             kind: 'block',
             type: 'mrc_class_method_def',    
diff --git a/src/toolbox/toolbox.ts b/src/toolbox/toolbox.ts
index 8c22a0a4..49536c75 100644
--- a/src/toolbox/toolbox.ts
+++ b/src/toolbox/toolbox.ts
@@ -27,6 +27,7 @@ import {category as mathCategory} from './math_category';
 import {category as textCategory} from './text_category';
 import {category as listsCategory} from './lists_category';
 import {category as miscCategory} from './misc_category';
+import {category as mechanismCategory } from './mechanism_category';
 import {category as methodsCategory} from './opmode_methods_category';
 
 export function getToolboxJSON(
@@ -70,6 +71,7 @@ export function getToolboxJSON(
         categorystyle: 'variable_category',
         custom: 'VARIABLE',
       },
+      mechanismCategory,
       methodsCategory
     ]);
 
diff --git a/tsconfig.json b/tsconfig.json
index 5f65c78e..a487f6ce 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -11,7 +11,9 @@
     "jsx": "react",
     "allowJs": true,
     "strict": true,
-    "noImplicitAny": true
+    "noImplicitAny": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
   }
 }
 */