diff --git a/example_graphs/events.json b/example_graphs/events.json
new file mode 100644
index 00000000..47c11737
--- /dev/null
+++ b/example_graphs/events.json
@@ -0,0 +1,140 @@
+{
+  "nodes": [
+    {
+      "id": "0",
+      "type": "constant",
+      "position": {
+        "x": 443.74999237060547,
+        "y": 132.24999809265137
+      },
+      "data": {
+        "label": "source",
+        "value": ""
+      },
+      "measured": {
+        "width": 205,
+        "height": 53
+      },
+      "selected": true
+    },
+    {
+      "id": "1",
+      "type": "integrator",
+      "position": {
+        "x": 688.7499923706055,
+        "y": 251.24999809265137
+      },
+      "data": {
+        "label": "integrator",
+        "initial_value": "",
+        "reset_times": ""
+      },
+      "measured": {
+        "width": 200,
+        "height": 48
+      },
+      "selected": false,
+      "dragging": false
+    },
+    {
+      "id": "2",
+      "type": "scope",
+      "position": {
+        "x": 1022.2499923706055,
+        "y": 252.24999809265137
+      },
+      "data": {
+        "label": "scope 2",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
+      },
+      "measured": {
+        "width": 120,
+        "height": 140
+      }
+    }
+  ],
+  "edges": [
+    {
+      "id": "e0-1",
+      "source": "0",
+      "target": "1",
+      "sourceHandle": null,
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e0-2",
+      "source": "0",
+      "target": "2",
+      "sourceHandle": null,
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e1-2",
+      "source": "1",
+      "target": "2",
+      "sourceHandle": null,
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    }
+  ],
+  "nodeCounter": 3,
+  "solverParams": {
+    "dt": "0.01",
+    "dt_min": "1e-6",
+    "dt_max": "1.0",
+    "Solver": "SSPRK22",
+    "tolerance_fpi": "1e-6",
+    "iterations_max": "100",
+    "log": "true",
+    "simulation_duration": "50.0",
+    "extra_params": "{}"
+  },
+  "globalVariables": [],
+  "events": [
+    {
+      "name": "my_event",
+      "type": "ZeroCrossingDown",
+      "func_evt": "def func_evt(t):\n    *_, x = integrator_1()\n    return 10 - x",
+      "func_act": "def func_act(t):\n    source_0.off()",
+      "tolerance": "1e-8",
+      "id": 1754342253698
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/App.jsx b/src/App.jsx
index b2bb8671..0bbba41d 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -18,6 +18,7 @@ import Sidebar from './Sidebar';
 import NodeSidebar from './NodeSidebar';
 import { DnDProvider, useDnD } from './DnDContext.jsx';
 import ContextMenu from './ContextMenu.jsx';
+import EventsTab from './EventsTab.jsx';
 import { isValidPythonIdentifier } from './utils.js';
 import { makeEdge } from './CustomEdge';
 import { nodeTypes } from './nodeConfig.js';
@@ -78,6 +79,7 @@ const DnDFlow = () => {
 
   // Global variables state
   const [globalVariables, setGlobalVariables] = useState([]);
+  const [events, setEvents] = useState([]);
   const [defaultValues, setDefaultValues] = useState({});
   const [isEditingLabel, setIsEditingLabel] = useState(false);
   const [tempLabel, setTempLabel] = useState('');
@@ -219,7 +221,8 @@ const DnDFlow = () => {
       edges,
       nodeCounter,
       solverParams,
-      globalVariables
+      globalVariables,
+      events
     };
 
     // Check if File System Access API is supported
@@ -299,7 +302,7 @@ const DnDFlow = () => {
           }
 
           // Load the graph data
-          const { nodes: loadedNodes, edges: loadedEdges, nodeCounter: loadedNodeCounter, solverParams: loadedSolverParams, globalVariables: loadedGlobalVariables } = graphData;
+          const { nodes: loadedNodes, edges: loadedEdges, nodeCounter: loadedNodeCounter, solverParams: loadedSolverParams, globalVariables: loadedGlobalVariables, events: loadedEvents } = graphData;
           setNodes(loadedNodes || []);
           setEdges(loadedEdges || []);
           setSelectedNode(null);
@@ -316,6 +319,7 @@ const DnDFlow = () => {
             extra_params: '{}'
           });
           setGlobalVariables(loadedGlobalVariables ?? []);
+          setEvents(loadedEvents ?? []);
 
           alert('Graph loaded successfully!');
         } catch (error) {
@@ -350,7 +354,7 @@ const DnDFlow = () => {
               return;
             }
 
-            const { nodes: loadedNodes, edges: loadedEdges, nodeCounter: loadedNodeCounter, solverParams: loadedSolverParams, globalVariables: loadedGlobalVariables } = graphData;
+            const { nodes: loadedNodes, edges: loadedEdges, nodeCounter: loadedNodeCounter, solverParams: loadedSolverParams, globalVariables: loadedGlobalVariables, events: loadedEvents } = graphData;
             setNodes(loadedNodes || []);
             setEdges(loadedEdges || []);
             setSelectedNode(null);
@@ -367,6 +371,7 @@ const DnDFlow = () => {
               extra_params: '{}'
             });
             setGlobalVariables(loadedGlobalVariables ?? []);
+            setEvents(loadedEvents ?? []);
 
             alert('Graph loaded successfully!');
           } catch (error) {
@@ -463,7 +468,8 @@ const DnDFlow = () => {
         edges,
         nodeCounter,
         solverParams,
-        globalVariables
+        globalVariables,
+        events
       };
 
       const response = await fetch(getApiEndpoint('/convert-to-python'), {
@@ -533,7 +539,8 @@ const DnDFlow = () => {
         nodes,
         edges,
         solverParams,
-        globalVariables
+        globalVariables,
+        events
       };
 
       const response = await fetch(getApiEndpoint('/run-pathsim'), {
@@ -923,6 +930,20 @@ const DnDFlow = () => {
         >
           Graph Editor
         </button>
+        <button
+          style={{
+            padding: '10px 20px',
+            margin: '5px',
+            backgroundColor: activeTab === 'events' ? '#78A083' : '#444',
+            color: 'white',
+            border: 'none',
+            borderRadius: 5,
+            cursor: 'pointer',
+          }}
+          onClick={() => setActiveTab('events')}
+        >
+          Events
+        </button>
         <button
           style={{
             padding: '10px 20px',
@@ -1272,6 +1293,9 @@ const DnDFlow = () => {
         </div>
       )}
 
+      {/* Events tab */}
+      {activeTab === 'events' && <EventsTab events={events} setEvents={setEvents} />}
+
       {/* Solver Parameters Tab */}
       {activeTab === 'solver' && (
         <div style={{
diff --git a/src/EventsTab.jsx b/src/EventsTab.jsx
new file mode 100644
index 00000000..247a66c8
--- /dev/null
+++ b/src/EventsTab.jsx
@@ -0,0 +1,486 @@
+import { useState } from 'react';
+
+// Define default parameters for each event type
+const eventDefaults = {
+  'Schedule': {
+    t_start: '0',
+    t_end: 'None',
+    t_period: '1',
+    func_act: '',
+    tolerance: '1e-16'
+  },
+  'ZeroCrossingDown': {
+    func_evt: '',
+    func_act: '',
+    tolerance: '1e-8'
+  },
+  'ZeroCrossingUp': {
+    func_evt: '',
+    func_act: '',
+    tolerance: '1e-8'
+  },
+  'ZeroCrossing': {
+    func_evt: '',
+    func_act: '',
+    tolerance: '1e-8'
+  },
+  'Condition': {
+    func_evt: '',
+    func_act: '',
+    tolerance: '1e-8'
+  }
+};
+
+const EventsTab = ({ events, setEvents }) => {
+  // Initialize with defaults for the initial event type
+  const initialEventType = 'ZeroCrossingDown';
+  const [currentEvent, setCurrentEvent] = useState(() => {
+    return {
+      name: '',
+      type: initialEventType,
+      ...eventDefaults[initialEventType]
+    };
+  });
+  
+  // State to track if we're editing an existing event
+  const [editingEventId, setEditingEventId] = useState(null);
+
+  const eventTypes = [
+    'Condition',
+    'Schedule', 
+    'ZeroCrossing',
+    'ZeroCrossingUp',
+    'ZeroCrossingDown'
+  ];
+
+  const handleInputChange = (field, value) => {
+    setCurrentEvent(prev => ({
+      ...prev,
+      [field]: value
+    }));
+  };
+
+  const handleTypeChange = (newType) => {
+    // When type changes, reset the event to defaults for that type
+    const defaults = eventDefaults[newType] || {};
+    setCurrentEvent({
+      name: currentEvent.name, // Keep the name
+      type: newType,
+      ...defaults
+    });
+  };
+
+  const addEvent = () => {
+    if (currentEvent.name) {
+      // Validate required fields based on event type
+      
+      // For Schedule, func_act is required
+      if (currentEvent.type === 'Schedule' && !currentEvent.func_act) {
+        alert('func_act is required for Schedule events');
+        return;
+      }
+      
+      // For other event types, both func_evt and func_act are typically required
+      if (currentEvent.type !== 'Schedule' && (!currentEvent.func_evt || !currentEvent.func_act)) {
+        alert('Both func_evt and func_act are required for this event type');
+        return;
+      }
+
+      setEvents(prev => [...prev, { ...currentEvent, id: Date.now() }]);
+      
+      // Reset to defaults for current type
+      const resetDefaults = eventDefaults[currentEvent.type] || {};
+      setCurrentEvent({
+        name: '',
+        type: currentEvent.type,
+        ...resetDefaults
+      });
+    }
+  };
+
+  const editEvent = (event) => {
+    setCurrentEvent({ ...event });
+    setEditingEventId(event.id);
+  };
+
+  const saveEditedEvent = () => {
+    if (currentEvent.name) {
+      
+      // For Schedule, func_act is required
+      if (currentEvent.type === 'Schedule' && !currentEvent.func_act) {
+        alert('func_act is required for Schedule events');
+        return;
+      }
+      
+      // For other event types, both func_evt and func_act are typically required
+      if (currentEvent.type !== 'Schedule' && (!currentEvent.func_evt || !currentEvent.func_act)) {
+        alert('Both func_evt and func_act are required for this event type');
+        return;
+      }
+
+      setEvents(prev => prev.map(event => 
+        event.id === editingEventId ? { ...currentEvent } : event
+      ));
+      
+      // Reset form and exit edit mode
+      cancelEdit();
+    }
+  };
+
+  const cancelEdit = () => {
+    setEditingEventId(null);
+    // Reset to defaults for current type
+    const resetDefaults = eventDefaults[currentEvent.type] || {};
+    setCurrentEvent({
+      name: '',
+      type: currentEvent.type,
+      ...resetDefaults
+    });
+  };
+
+  const deleteEvent = (id) => {
+    setEvents(prev => prev.filter(event => event.id !== id));
+  };
+
+  return (
+    <div style={{
+      width: '100%',
+      height: 'calc(100vh - 50px)',
+      paddingTop: '0px',
+      backgroundColor: '#1e1e2f',
+      overflow: 'auto',
+    }}>
+      <div style={{
+        padding: '10px',
+        maxWidth: '1200px',
+        margin: '0 auto',
+      }}>
+        <h1 style={{ color: '#ffffff', marginBottom: '20px', textAlign: 'center' }}>
+          Events
+        </h1>
+
+        {/* Add New Event Form */}
+        <div style={{
+          backgroundColor: '#2a2a3f',
+          width: '100%',
+          maxWidth: '400px',
+          margin: '0 auto',
+          borderRadius: '8px',
+          padding: '24px',
+          marginBottom: '30px',
+          border: '1px solid #444'
+        }}>
+          <h2 style={{ color: '#ffffff', marginBottom: '20px' }}>
+            {editingEventId ? 'Edit Event' : 'Add New Event'}
+          </h2>
+          
+          <div style={{ display: 'flex', flexDirection: 'column', gap: '20px' }}>
+            <div style={{ width: '100%', maxWidth: '400px' }}>
+              <label style={{ color: '#ffffff', display: 'block', marginBottom: '8px' }}>
+                Event Name:
+              </label>
+              <input
+                type="text"
+                value={currentEvent.name}
+                onChange={(e) => handleInputChange('name', e.target.value)}
+                placeholder="e.g., E1, shutdown_event"
+                style={{
+                  width: '80%',
+                  padding: '10px',
+                  backgroundColor: '#1e1e2f',
+                  border: '1px solid #555',
+                  borderRadius: '4px',
+                  color: '#ffffff',
+                  fontSize: '14px',
+                }}
+              />
+            </div>
+
+            <div style={{ width: '100%', maxWidth: '400px' }}>
+              <label style={{ color: '#ffffff', display: 'block', marginBottom: '8px'}}>
+                Event Type:
+              </label>
+              <select
+                value={currentEvent.type}
+                onChange={(e) => handleTypeChange(e.target.value)}
+                style={{
+                  width: '85%',
+                  padding: '10px',
+                  backgroundColor: '#1e1e2f',
+                  border: '1px solid #555',
+                  borderRadius: '4px',
+                  color: '#ffffff',
+                  fontSize: '14px',
+                }}
+              >
+                {eventTypes.map(type => (
+                  <option key={type} value={type}>{type}</option>
+                ))}
+              </select>
+            </div>
+          </div>
+
+          {/* Dynamic parameter fields based on event type */}
+          <div style={{ gap: '20px', marginTop: '20px' }}>
+            {(() => {
+              const typeDefaults = eventDefaults[currentEvent.type] || {};
+              const allParams = new Set([
+                // don't include 'name', 'type', since included above + 'id' cannot be edited
+                ...Object.keys(currentEvent).filter(key => key !== 'name' && key !== 'type' && key !== 'id'),
+                ...Object.keys(typeDefaults)
+              ]);
+
+              return Array.from(allParams).map(key => {
+                const currentValue = currentEvent[key] || '';
+                const defaultValue = typeDefaults[key];
+                const placeholder = defaultValue !== undefined && defaultValue !== null ?
+                  String(defaultValue) : '';
+                
+                // Check if this is a function parameter (contains 'func' in the name)
+                const isFunctionParam = key.toLowerCase().includes('func');
+
+                return (
+                  <div key={key} style={{ width: '100%', maxWidth: isFunctionParam ? '600px' : '400px' }}>
+                    <label style={{ 
+                      color: '#ffffff', 
+                      display: 'block', 
+                      marginBottom: '8px',
+                      fontSize: '14px',
+                      fontWeight: '500',
+                    }}>
+                      {key}:
+                    </label>
+                    {isFunctionParam ? (
+                      <textarea
+                        value={currentValue}
+                        onChange={(e) => handleInputChange(key, e.target.value)}
+                        placeholder={placeholder || `eg. def ${key}(t):\n    # Your code here\n    return result`}
+                        style={{
+                          width: '80%',
+                          minHeight: '100px',
+                          padding: '10px',
+                          backgroundColor: '#1e1e2f',
+                          border: '1px solid #555',
+                          borderRadius: '4px',
+                          color: '#ffffff',
+                          fontSize: '12px',
+                          fontFamily: 'monospace',
+                          resize: 'vertical'
+                        }}
+                      />
+                    ) : (
+                      <input
+                        type="text"
+                        value={currentValue}
+                        onChange={(e) => handleInputChange(key, e.target.value)}
+                        placeholder={placeholder}
+                        style={{
+                          width: '50%',
+                          padding: '10px',
+                          backgroundColor: '#1e1e2f',
+                          border: '1px solid #555',
+                          borderRadius: '4px',
+                          color: '#ffffff',
+                          fontSize: '14px',
+                        }}
+                      />
+                    )}
+                  </div>
+                );
+              });
+            })()}
+          </div>
+
+          <div style={{ display: 'flex', justifyContent: 'center', gap: '12px', marginTop: '20px' }}>
+            {editingEventId ? (
+              <>
+                <button
+                  onClick={saveEditedEvent}
+                  style={{
+                    backgroundColor: '#78A083',
+                    color: '#ffffff',
+                    border: 'none',
+                    borderRadius: '4px',
+                    padding: '12px 24px',
+                    fontSize: '14px',
+                    cursor: 'pointer',
+                    fontWeight: 'bold'
+                  }}
+                >
+                  Save Changes
+                </button>
+                <button
+                  onClick={cancelEdit}
+                  style={{
+                    backgroundColor: '#6c757d',
+                    color: '#ffffff',
+                    border: 'none',
+                    borderRadius: '4px',
+                    padding: '12px 24px',
+                    fontSize: '14px',
+                    cursor: 'pointer',
+                    fontWeight: 'bold'
+                  }}
+                >
+                  Cancel
+                </button>
+              </>
+            ) : (
+              <button
+                onClick={addEvent}
+                style={{
+                  backgroundColor: '#78A083',
+                  color: '#ffffff',
+                  border: 'none',
+                  borderRadius: '4px',
+                  padding: '12px 24px',
+                  fontSize: '14px',
+                  cursor: 'pointer',
+                  fontWeight: 'bold'
+                }}
+              >
+                Add Event
+              </button>
+            )}
+          </div>
+        </div>
+
+        {/* Events List */}
+        <div style={{ maxWidth: '800px', margin: '0 auto' }}>
+          <h2 style={{ color: '#ffffff', marginBottom: '20px', textAlign: 'center' }}>Defined Events ({events.length})</h2>
+          
+          {events.length === 0 ? (
+            <div style={{
+              backgroundColor: '#2a2a3f',
+              borderRadius: '8px',
+              padding: '24px',
+              textAlign: 'center',
+              color: '#888',
+              border: '1px solid #444'
+            }}>
+              No events defined yet. Add an event above to get started.
+            </div>
+          ) : (
+            <div style={{ display: 'flex', flexDirection: 'column', gap: '16px' }}>
+              {events.map((event, index) => (
+                <div
+                  key={event.id}
+                  style={{
+                    backgroundColor: '#2a2a3f',
+                    borderRadius: '8px',
+                    padding: '20px',
+                    border: editingEventId === event.id ? '2px solid #007bff' : '1px solid #444',
+                    boxShadow: editingEventId === event.id ? '0 0 10px rgba(0, 123, 255, 0.3)' : 'none'
+                  }}
+                >
+                  <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '16px' }}>
+                    <div>
+                      <h3 style={{ color: '#ffffff', margin: 0 }}>
+                        {event.name} ({event.type})
+                      </h3>
+                      {editingEventId === event.id && (
+                        <span style={{ 
+                          color: '#007bff', 
+                          fontSize: '12px', 
+                          fontStyle: 'italic',
+                          marginTop: '4px',
+                          display: 'block'
+                        }}>
+                          Currently editing this event
+                        </span>
+                      )}
+                    </div>
+                    <div style={{ display: 'flex', gap: '8px' }}>
+                      <button
+                        onClick={() => editEvent(event)}
+                        style={{
+                          backgroundColor: '#007bff',
+                          color: '#ffffff',
+                          border: 'none',
+                          borderRadius: '4px',
+                          padding: '6px 12px',
+                          fontSize: '12px',
+                          cursor: 'pointer'
+                        }}
+                      >
+                        Edit
+                      </button>
+                      <button
+                        onClick={() => deleteEvent(event.id)}
+                        style={{
+                          backgroundColor: '#dc3545',
+                          color: '#ffffff',
+                          border: 'none',
+                          borderRadius: '4px',
+                          padding: '6px 12px',
+                          fontSize: '12px',
+                          cursor: 'pointer'
+                        }}
+                      >
+                        Delete
+                      </button>
+                    </div>
+                  </div>
+
+                  {/* Display parameters dynamically */}
+                  <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))', gap: '16px' }}>
+                    {Object.entries(event)
+                      .filter(([key]) => key !== 'id' && key !== 'name' && key !== 'type')
+                      .map(([key, value]) => {
+                        const isFunctionParam = key.toLowerCase().includes('func');
+                        
+                        return (
+                          <div key={key}>
+                            <h4 style={{ 
+                              color: '#ccc', 
+                              margin: '0 0 8px 0', 
+                              fontSize: '14px',
+                              textTransform: 'capitalize'
+                            }}>
+                              {key.replace(/_/g, ' ')}:
+                            </h4>
+                            {isFunctionParam ? (
+                              <pre style={{
+                                backgroundColor: '#1e1e2f',
+                                padding: '12px',
+                                borderRadius: '4px',
+                                color: '#ffffff',
+                                fontSize: '12px',
+                                fontFamily: 'monospace',
+                                margin: 0,
+                                overflow: 'auto',
+                                border: '1px solid #555',
+                                whiteSpace: 'pre-wrap'
+                              }}>
+                                {value || '(not defined)'}
+                              </pre>
+                            ) : (
+                              <code style={{
+                                backgroundColor: '#1e1e2f',
+                                padding: '8px 12px',
+                                borderRadius: '4px',
+                                color: '#78A083',
+                                fontSize: '14px',
+                                fontFamily: 'monospace',
+                                border: '1px solid #555',
+                                display: 'block'
+                              }}>
+                                {value || '(not set)'}
+                              </code>
+                            )}
+                          </div>
+                        );
+                      })
+                    }
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default EventsTab;
\ No newline at end of file
diff --git a/src/convert_to_python.py b/src/convert_to_python.py
index 4f039d61..fda816bc 100644
--- a/src/convert_to_python.py
+++ b/src/convert_to_python.py
@@ -4,12 +4,14 @@
 
 from .pathsim_utils import (
     map_str_to_object,
+    map_str_to_event,
     make_blocks,
     make_global_variables,
     get_input_index,
     get_output_index,
     find_block_by_id,
     find_node_by_id,
+    make_var_name,
 )
 
 
@@ -29,35 +31,6 @@ def convert_graph_to_python(graph_data: dict) -> str:
     return template.render(context)
 
 
-def make_var_name(node: dict) -> str:
-    """
-    Create a variable name from the node label, ensuring it is a valid Python identifier.
-    If the label contains invalid characters, they are replaced with underscores.
-    If the variable name is not unique, a number is appended to make it unique.
-
-    This is supposed to match the logic in NodeSidebar.jsx makeVarName function.
-    """
-    # Make a variable name from the label
-    invalid_chars = set("!@#$%^&*()+=[]{}|;:'\",.-<>?/\\`~")
-    base_var_name = node["data"]["label"].lower().replace(" ", "_")
-    for char in invalid_chars:
-        base_var_name = base_var_name.replace(char, "")
-
-    # Make the variable name unique by appending a number if needed
-    var_name = base_var_name
-    var_name = f"{base_var_name}_{node['id']}"
-
-    # Ensure the base variable name is a valid identifier
-    if not var_name.isidentifier():
-        var_name = f"var_{var_name}"
-        if not var_name.isidentifier():
-            raise ValueError(
-                f"Variable name must be a valid identifier. {node['data']['label']} to {var_name}"
-            )
-
-    return var_name
-
-
 def process_node_data(nodes: list[dict]) -> list[dict]:
     """
     Given a list of node and edge data as dictionaries, process the nodes to create
@@ -144,6 +117,44 @@ def make_edge_data(data: dict) -> list[dict]:
     return data["edges"]
 
 
+def make_events_data(data: dict) -> list[dict]:
+    """
+    Process events data from the graph data.
+
+    This function extracts event definitions from the graph data and prepares them
+    for use in the simulation.
+
+    Args:
+        data: The graph data containing "events".
+
+    Returns:
+        A list of processed events.
+    """
+    for event in data["events"]:
+        # Add pathsim class name
+        event_class = map_str_to_event.get(event["type"])
+        event["class_name"] = event_class.__name__
+        event["module_name"] = event_class.__module__
+
+        # Add expected arguments
+        event["expected_arguments"] = signature(event_class).parameters
+
+        if "func_evt" in event:
+            # replace the name of the function by something unique
+            func_evt = event["func_evt"]
+            func_evt = func_evt.replace("def func_evt", f"def {event['name']}_func_evt")
+            event["func_evt"] = f"{event['name']}_func_evt"
+            event["func_evt_desc"] = func_evt
+        if "func_act" in event:
+            # replace the name of the function by something unique
+            func_act = event["func_act"]
+            func_act = func_act.replace("def func_act", f"def {event['name']}_func_act")
+            event["func_act"] = f"{event['name']}_func_act"
+            event["func_act_desc"] = func_act
+
+    return data["events"]
+
+
 def process_graph_data_from_dict(data: dict) -> dict:
     """
     Process graph data from a dictionary.
@@ -161,4 +172,6 @@ def process_graph_data_from_dict(data: dict) -> dict:
     # Process to add source/target variable names to edges + ports
     data["edges"] = make_edge_data(data)
 
+    data["events"] = make_events_data(data)
+
     return data
diff --git a/src/pathsim_utils.py b/src/pathsim_utils.py
index 3c5ccfbd..6bb583f7 100644
--- a/src/pathsim_utils.py
+++ b/src/pathsim_utils.py
@@ -22,6 +22,7 @@
     Schedule,
 )
 import pathsim.blocks
+import pathsim.events
 from pathsim.blocks.noise import WhiteNoise, PinkNoise
 from .custom_pathsim_blocks import (
     Process,
@@ -86,6 +87,14 @@
     "fir": pathsim.blocks.FIR,
 }
 
+map_str_to_event = {
+    "ZeroCrossingDown": pathsim.events.ZeroCrossingDown,
+    "ZeroCrossingUp": pathsim.events.ZeroCrossingUp,
+    "ZeroCrossing": pathsim.events.ZeroCrossing,
+    "Schedule": pathsim.events.Schedule,
+    "Condition": pathsim.events.Condition,
+}
+
 
 def find_node_by_id(node_id: str, nodes: list[dict]) -> dict:
     return next((node for node in nodes if node["id"] == node_id), None)
@@ -205,6 +214,78 @@ def auto_block_construction(node: dict, eval_namespace: dict = None) -> Block:
     return block_class(**parameters)
 
 
+def auto_event_construction(event_data: dict, eval_namespace: dict = None) -> Event:
+    """
+    Automatically constructs an event object from an event data dictionary.
+
+    Args:
+        event_data: The event data dictionary containing event information.
+        eval_namespace: A namespace for evaluating expressions. Defaults to None.
+
+    Raises:
+        ValueError: If the event type is unknown or if there are issues with evaluation.
+
+    Returns:
+        The constructed event object.
+    """
+
+    if event_data["type"] not in map_str_to_event:
+        raise ValueError(f"Unknown event type: {event_data['type']}")
+
+    event_class = map_str_to_event[event_data["type"]]
+
+    parameters = get_parameters_for_event_class(
+        event_class, event_data, eval_namespace=eval_namespace
+    )
+
+    return event_class(**parameters)
+
+
+def get_parameters_for_event_class(
+    event_class: type, event_data: dict, eval_namespace: dict = None
+):
+    parameters_for_class = inspect.signature(event_class.__init__).parameters
+
+    # Create a local namespace for executing the event functions
+    # we make a copy so that event functions aren't overwritten
+    event_namespace = eval_namespace.copy()
+
+    parameters = {}
+    for k, value in parameters_for_class.items():
+        if k == "self":
+            continue
+
+        user_input = event_data[k]
+        if user_input == "":
+            if value.default is inspect._empty:
+                raise ValueError(
+                    f"expected parameter for {k} in {event_data['type']} ({event_data['name']})"
+                )
+
+            # make a copy of the default value
+            if isinstance(value.default, (list, dict)):
+                parameters[k] = value.default.copy()
+            else:
+                parameters[k] = value.default
+        else:
+            if k in ["func_evt", "func_act"]:
+                # Execute func code if provided
+                func_code = event_data[k]
+                if func_code:
+                    try:
+                        exec(func_code, event_namespace)
+                        if k not in event_namespace:
+                            raise ValueError(f"{k} function not found after execution")
+                    except Exception as e:
+                        raise ValueError(f"Error executing {k} code: {str(e)}")
+                else:
+                    raise ValueError(f"{k} code is required but not provided")
+                parameters[k] = event_namespace[k]
+            else:
+                parameters[k] = eval(user_input, event_namespace)
+    return parameters
+
+
 def get_parameters_for_block_class(block_class, node, eval_namespace):
     parameters_for_class = inspect.signature(block_class.__init__).parameters
     parameters = {}
@@ -352,6 +433,33 @@ def make_connections(nodes, edges, blocks) -> list[Connection]:
     return connections_pathsim
 
 
+def make_events(events_data: list[dict], eval_namespace: dict = None) -> list[Event]:
+    """
+    Create a list of Event objects from the provided event data.
+
+    Args:
+        events_data: A list of dictionaries containing event information.
+        eval_namespace: A namespace for evaluating expressions. Defaults to None.
+
+    Returns:
+        A list of Event objects.
+    """
+    if eval_namespace is None:
+        eval_namespace = globals()
+
+    events = []
+    for event_data in events_data:
+        event_type = event_data.get("type")
+        event_class = map_str_to_event.get(event_type)
+
+        if not event_class:
+            raise ValueError(f"Unknown event type: {event_type}")
+
+        event = auto_event_construction(event_data, eval_namespace)
+        events.append(event)
+    return events
+
+
 def make_default_scope(nodes, blocks) -> tuple[Scope, list[Connection]]:
     scope_default = Scope(
         labels=[node["data"]["label"] for node in nodes],
@@ -374,6 +482,35 @@ def make_default_scope(nodes, blocks) -> tuple[Scope, list[Connection]]:
     return scope_default, connections_pathsim
 
 
+def make_var_name(node: dict) -> str:
+    """
+    Create a variable name from the node label, ensuring it is a valid Python identifier.
+    If the label contains invalid characters, they are replaced with underscores.
+    If the variable name is not unique, a number is appended to make it unique.
+
+    This is supposed to match the logic in NodeSidebar.jsx makeVarName function.
+    """
+    # Make a variable name from the label
+    invalid_chars = set("!@#$%^&*()+=[]{}|;:'\",.-<>?/\\`~")
+    base_var_name = node["data"]["label"].lower().replace(" ", "_")
+    for char in invalid_chars:
+        base_var_name = base_var_name.replace(char, "")
+
+    # Make the variable name unique by appending a number if needed
+    var_name = base_var_name
+    var_name = f"{base_var_name}_{node['id']}"
+
+    # Ensure the base variable name is a valid identifier
+    if not var_name.isidentifier():
+        var_name = f"var_{var_name}"
+        if not var_name.isidentifier():
+            raise ValueError(
+                f"Variable name must be a valid identifier. {node['data']['label']} to {var_name}"
+            )
+
+    return var_name
+
+
 def make_pathsim_model(graph_data: dict) -> tuple[Simulation, float]:
     nodes = graph_data.get("nodes", [])
     edges = graph_data.get("edges", [])
@@ -402,6 +539,12 @@ def make_pathsim_model(graph_data: dict) -> tuple[Simulation, float]:
         blocks.append(scope_default)
         connections_pathsim.extend(connections_scope_def)
 
+    # Create additional events
+    for node in nodes:
+        var_name = make_var_name(node)
+        eval_namespace[var_name] = find_block_by_id(node["id"], blocks)
+    events += make_events(graph_data.get("events", []), eval_namespace)
+
     # Create the simulation
     simulation = Simulation(
         blocks,
diff --git a/src/templates/block_macros.py b/src/templates/block_macros.py
index ce20e8f5..559c3a15 100644
--- a/src/templates/block_macros.py
+++ b/src/templates/block_macros.py
@@ -39,3 +39,21 @@
     {% endfor -%}
 ]
 {%- endmacro -%}
+
+{% macro create_event(event) -%}
+{% if "func_evt" in event %}
+{{ event["func_evt_desc"] }}
+{% endif %}
+
+{% if "func_act" in event %}
+{{ event["func_act_desc"] }}
+{% endif %}
+
+{{ event["name"] }} = {{ event["module_name"] }}.{{ event["class_name"] }}(
+    {%- for arg in event["expected_arguments"] %}
+    {%- if event.get(arg) -%}
+    {{ arg }}={{ event.get(arg) }}{% if not loop.last %}, {% endif %}
+    {%- endif -%}
+    {%- endfor %}
+)
+{%- endmacro -%}
\ No newline at end of file
diff --git a/src/templates/template_with_macros.py b/src/templates/template_with_macros.py
index f30cc03f..160c07df 100644
--- a/src/templates/template_with_macros.py
+++ b/src/templates/template_with_macros.py
@@ -4,7 +4,7 @@
 import matplotlib.pyplot as plt
 import src
 {# Import macros #}
-{% from 'block_macros.py' import create_block, create_integrator_block, create_bubbler_block, create_connections -%}
+{% from 'block_macros.py' import create_block, create_integrator_block, create_bubbler_block, create_connections, create_event -%}
 
 # Create global variables
 {% for var in globalVariables -%}
@@ -25,6 +25,12 @@
 
 {% endfor %}
 
+# Create events
+{% for event in events -%}
+{{ create_event(event) }}
+events.append({{ event["name"] }})
+{% endfor %}
+
 # Create connections
 
 {{ create_connections(edges) }}
diff --git a/test/test_convert_python.py b/test/test_convert_python.py
index 1bd5fa28..a19e8adc 100644
--- a/test/test_convert_python.py
+++ b/test/test_convert_python.py
@@ -43,6 +43,7 @@
             },
         },
     ],
+    "events": [],
     "edges": [
         {
             "source": "1",
@@ -146,6 +147,7 @@ def test_bubbler_has_reset_times():
             },
         ],
         "edges": [],
+        "events": [],
         "solverParams": {
             "Solver": "SSPRK22",
             "dt": "0.01",
diff --git a/test/test_events.py b/test/test_events.py
new file mode 100644
index 00000000..9351cac5
--- /dev/null
+++ b/test/test_events.py
@@ -0,0 +1,23 @@
+import pytest
+from src.pathsim_utils import make_events
+
+
+events_data = [
+    {
+        "name": "my_event",
+        "type": "ZeroCrossingDown",
+        "func_evt": "def func_evt(t):\n    *_, x = integrator_1()\n    return 10 - x",
+        "func_act": "def func_act(t):\n    source_0.off()",
+        "tolerance": "1e-8",
+        "id": 1754342253698,
+    }
+]
+
+
+def test_make_events():
+    eval_namespace = {}
+    events = make_events(events_data, eval_namespace)
+    assert len(events) == 1
+    assert events[0].func_evt.__code__.co_argcount == 1
+    assert events[0].func_act.__code__.co_argcount == 1
+    assert events[0].tolerance == 1e-08
diff --git a/test/test_files/bubbler.json b/test/test_files/bubbler.json
index 8acba0c0..f336d89e 100644
--- a/test/test_files/bubbler.json
+++ b/test/test_files/bubbler.json
@@ -57,6 +57,7 @@
       "dragging": false
     }
   ],
+  "events": [],
   "edges": [
     {
       "id": "e2-1-to_sample_in_soluble",
diff --git a/test/test_files/constant_delay_scope.json b/test/test_files/constant_delay_scope.json
index 98623d3f..0485a98c 100644
--- a/test/test_files/constant_delay_scope.json
+++ b/test/test_files/constant_delay_scope.json
@@ -55,6 +55,7 @@
       "dragging": false
     }
   ],
+  "events": [],
   "edges": [
     {
       "id": "e0-1",
diff --git a/test/test_files/custom_nodes.json b/test/test_files/custom_nodes.json
index 48c80685..d9d301dd 100644
--- a/test/test_files/custom_nodes.json
+++ b/test/test_files/custom_nodes.json
@@ -60,6 +60,7 @@
       "dragging": false
     }
   ],
+  "events": [],
   "edges": [],
   "nodeCounter": 3,
   "solverParams": {
diff --git a/test/test_files/same_label.json b/test/test_files/same_label.json
index dc23833c..2ac45949 100644
--- a/test/test_files/same_label.json
+++ b/test/test_files/same_label.json
@@ -58,6 +58,7 @@
       "dragging": false
     }
   ],
+  "events": [],
   "edges": [
     {
       "id": "e1-2",
diff --git a/test/test_files/spectrum.json b/test/test_files/spectrum.json
index 904c8ed8..e7d9f683 100644
--- a/test/test_files/spectrum.json
+++ b/test/test_files/spectrum.json
@@ -94,6 +94,7 @@
       }
     }
   ],
+  "events": [],
   "edges": [
     {
       "id": "e3-4",