6 files changed, 635 insertions, 0 deletions
diff --git a/src/main/java/examples/CreateAndVerifyRaftSimulation.java b/src/main/java/examples/CreateAndVerifyRaftSimulation.java
new file mode 100644
index 0000000..126c37c
--- /dev/null
+++ b/src/main/java/examples/CreateAndVerifyRaftSimulation.java
@@ -0,0 +1,142 @@
+package examples;
+
+import simulator.*;
+import core.*;
+import prefs.*;
+import events.*;
+import events.internal.*;
+import events.implementations.*;
+import serialize.VSSerialize;
+import java.io.*;
+
+/**
+ * Creates a Raft simulation and verifies it can be loaded properly.
+ */
+public class CreateAndVerifyRaftSimulation {
+    
+    private static final String RAFT_PROTOCOL = "protocols.implementations.VSRaftProtocol";
+    
+    public static void main(String[] args) throws Exception {
+        System.out.println("=== Creating and Verifying Raft Simulation ===\n");
+        
+        // Initialize
+        VSDefaultPrefs prefs = new VSDefaultPrefs();
+        prefs.fillWithDefaults();
+        VSRegisteredEvents.init(prefs);
+        
+        // Step 1: Create the simulation
+        System.out.println("Step 1: Creating Raft simulation...");
+        
+        VSSimulatorFrame frame = new VSSimulatorFrame(prefs, null);
+        VSSimulator simulator = new VSSimulator(prefs, frame);
+        frame.addSimulator(simulator);
+        
+        // Access visualization
+        java.lang.reflect.Field vizField = VSSimulator.class.getDeclaredField("simulatorVisualization");
+        vizField.setAccessible(true);
+        VSSimulatorVisualization viz = (VSSimulatorVisualization) vizField.get(simulator);
+        
+        // Add processes (5 total: 3 servers + 2 clients)
+        while (viz.getNumProcesses() < 5) {
+            java.lang.reflect.Method addProcessMethod = VSSimulatorVisualization.class.getDeclaredMethod("addProcess");
+            addProcessMethod.setAccessible(true);
+            addProcessMethod.invoke(viz);
+        }
+        
+        VSTaskManager taskManager = viz.getTaskManager();
+        
+        // Add Raft server activations
+        System.out.println("  - Adding 3 Raft servers");
+        for (int i = 0; i < 3; i++) {
+            VSProtocolEvent serverEvent = new VSProtocolEvent();
+            serverEvent.setProtocolClassname(RAFT_PROTOCOL);
+            serverEvent.isClientProtocol(false);
+            serverEvent.isProtocolActivation(true);
+            
+            VSTask task = new VSTask(0, viz.getProcess(i), serverEvent, false);
+            taskManager.addTask(task);
+        }
+        
+        // Add Raft client activations
+        System.out.println("  - Adding 2 Raft clients");
+        for (int i = 3; i < 5; i++) {
+            VSProtocolEvent clientEvent = new VSProtocolEvent();
+            clientEvent.setProtocolClassname(RAFT_PROTOCOL);
+            clientEvent.isClientProtocol(true);
+            clientEvent.isProtocolActivation(true);
+            
+            // Stagger client starts
+            VSTask task = new VSTask(200 + (i-3)*100, viz.getProcess(i), clientEvent, false);
+            taskManager.addTask(task);
+        }
+        
+        // Add some events
+        System.out.println("  - Adding crash/recovery events");
+        
+        // Server 0 crashes at 1000, recovers at 1500
+        VSProcessCrashEvent crash = new VSProcessCrashEvent();
+        taskManager.addTask(new VSTask(1000, viz.getProcess(0), crash, false));
+        
+        VSProcessRecoverEvent recover = new VSProcessRecoverEvent();
+        taskManager.addTask(new VSTask(1500, viz.getProcess(0), recover, false));
+        
+        // Save simulation
+        File outputFile = new File("saved-simulations/raft-verified.dat");
+        outputFile.getParentFile().mkdirs();
+        
+        VSSerialize serialize = new VSSerialize();
+        serialize.saveSimulator(outputFile.getAbsolutePath(), simulator);
+        
+        frame.dispose();
+        
+        System.out.println("  ✓ Simulation saved to: " + outputFile.getName());
+        
+        // Step 2: Verify the simulation can be loaded
+        System.out.println("\nStep 2: Loading and verifying simulation...");
+        
+        VSSimulatorFrame frame2 = new VSSimulatorFrame(prefs, null);
+        VSSimulator loadedSim = serialize.openSimulator(outputFile.getAbsolutePath(), frame2);
+        
+        if (loadedSim == null) {
+            System.err.println("  ✗ Failed to load simulation!");
+            System.exit(1);
+        }
+        
+        // Verify contents
+        vizField = VSSimulator.class.getDeclaredField("simulatorVisualization");
+        vizField.setAccessible(true);
+        VSSimulatorVisualization loadedViz = (VSSimulatorVisualization) vizField.get(loadedSim);
+        
+        System.out.println("  ✓ Simulation loaded successfully");
+        System.out.println("  - Processes: " + loadedViz.getNumProcesses());
+        
+        // Check tasks
+        VSTaskManager loadedTaskManager = loadedViz.getTaskManager();
+        java.lang.reflect.Field tasksField = VSTaskManager.class.getDeclaredField("tasks");
+        tasksField.setAccessible(true);
+        Object taskQueue = tasksField.get(loadedTaskManager);
+        java.lang.reflect.Method sizeMethod = taskQueue.getClass().getMethod("size");
+        int taskCount = (Integer) sizeMethod.invoke(taskQueue);
+        
+        System.out.println("  - Scheduled tasks: " + taskCount);
+        
+        frame2.dispose();
+        
+        // Step 3: Provide instructions
+        System.out.println("\n=== Success! ===");
+        System.out.println("\nTo run the Raft simulation:");
+        System.out.println("1. Start the simulator:");
+        System.out.println("   java -jar target/ds-sim-1.0.1-SNAPSHOT.jar");
+        System.out.println("\n2. Load the simulation:");
+        System.out.println("   File → Open → saved-simulations/raft-verified.dat");
+        System.out.println("\n3. Run the simulation:");
+        System.out.println("   Click the 'Run' button (▶)");
+        System.out.println("\n4. What to look for:");
+        System.out.println("   - Leader election messages (REQUEST_VOTE, VOTE_RESPONSE)");
+        System.out.println("   - Heartbeats from leader (APPEND_ENTRIES)");
+        System.out.println("   - Client requests and responses");
+        System.out.println("   - Re-election when server 0 crashes at time 1000");
+        
+        System.exit(0);
+    }
+}
+\ No newline at end of file
diff --git a/src/main/java/examples/CreateMinimalRaftSimulation.java b/src/main/java/examples/CreateMinimalRaftSimulation.java
new file mode 100644
index 0000000..62db468
--- /dev/null
+++ b/src/main/java/examples/CreateMinimalRaftSimulation.java
@@ -0,0 +1,86 @@
+package examples;
+
+import simulator.*;
+import core.*;
+import prefs.*;
+import events.*;
+import events.internal.*;
+import serialize.VSSerialize;
+import java.io.*;
+import java.lang.reflect.*;
+
+/**
+ * Creates a minimal Raft simulation with just protocol activations.
+ * This tests if the basic simulation saving/loading works.
+ */
+public class CreateMinimalRaftSimulation {
+    
+    public static void main(String[] args) throws Exception {
+        System.out.println("=== Creating Minimal Raft Simulation ===\n");
+        
+        // Initialize
+        VSDefaultPrefs prefs = new VSDefaultPrefs();
+        prefs.fillWithDefaults();
+        VSRegisteredEvents.init(prefs);
+        
+        // Create simulator without GUI
+        VSSimulatorFrame frame = new VSSimulatorFrame(prefs, null);
+        VSSimulator simulator = new VSSimulator(prefs, frame);
+        frame.addSimulator(simulator);
+        
+        // Access visualization via reflection
+        Field vizField = VSSimulator.class.getDeclaredField("simulatorVisualization");
+        vizField.setAccessible(true);
+        VSSimulatorVisualization viz = (VSSimulatorVisualization) vizField.get(simulator);
+        
+        // Add 3 processes
+        Method addProcessMethod = VSSimulatorVisualization.class.getDeclaredMethod("addProcess");
+        addProcessMethod.setAccessible(true);
+        for (int i = 0; i < 3; i++) {
+            addProcessMethod.invoke(viz);
+        }
+        
+        VSTaskManager taskManager = viz.getTaskManager();
+        
+        // Create only one Raft server activation at time 0
+        System.out.println("Adding single Raft server activation on process 0...");
+        VSProtocolEvent serverEvent = new VSProtocolEvent();
+        serverEvent.setProtocolClassname("protocols.implementations.VSRaftProtocol");
+        serverEvent.isClientProtocol(false);
+        serverEvent.isProtocolActivation(true);
+        
+        VSTask task = new VSTask(0, viz.getProcess(0), serverEvent, false);
+        taskManager.addTask(task);
+        
+        // Save simulation
+        File outputFile = new File("saved-simulations/raft-minimal.dat");
+        outputFile.getParentFile().mkdirs();
+        
+        VSSerialize serialize = new VSSerialize();
+        serialize.saveSimulator(outputFile.getAbsolutePath(), simulator);
+        
+        frame.dispose();
+        
+        System.out.println("\nSimulation saved to: " + outputFile.getAbsolutePath());
+        System.out.println("\nTo test:");
+        System.out.println("1. Run: java -jar target/ds-sim-1.0.1-SNAPSHOT.jar");
+        System.out.println("2. File → Open → saved-simulations/raft-minimal.dat");
+        System.out.println("3. Click Run button and check the logs");
+        
+        // Try to immediately load it back to verify
+        System.out.println("\nVerifying saved file can be loaded...");
+        try {
+            VSSimulatorFrame frame2 = new VSSimulatorFrame(prefs, null);
+            VSSimulator loaded = serialize.openSimulator(outputFile.getAbsolutePath(), frame2);
+            if (loaded != null) {
+                System.out.println("✓ File loaded successfully!");
+                frame2.dispose();
+            } else {
+                System.out.println("✗ Failed to load file!");
+            }
+        } catch (Exception e) {
+            System.out.println("✗ Error loading file: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}
+\ No newline at end of file
diff --git a/src/main/java/examples/CreateSimpleRaftSimulation.java b/src/main/java/examples/CreateSimpleRaftSimulation.java
new file mode 100644
index 0000000..278824d
--- /dev/null
+++ b/src/main/java/examples/CreateSimpleRaftSimulation.java
@@ -0,0 +1,122 @@
+package examples;
+
+import simulator.*;
+import core.*;
+import prefs.*;
+import events.*;
+import events.internal.*;
+import events.implementations.*;
+import serialize.VSSerialize;
+import java.io.*;
+
+/**
+ * Creates a simple working Raft simulation.
+ * The key insight: Raft protocol uses HAS_ON_SERVER_START, so servers
+ * automatically start when activated. We just need to activate them!
+ */
+public class CreateSimpleRaftSimulation {
+    
+    private static final String RAFT_PROTOCOL = "protocols.implementations.VSRaftProtocol";
+    
+    public static void main(String[] args) throws Exception {
+        // Initialize
+        VSDefaultPrefs prefs = new VSDefaultPrefs();
+        prefs.fillWithDefaults();
+        VSRegisteredEvents.init(prefs);
+        
+        // Create frame and simulator
+        VSSimulatorFrame frame = new VSSimulatorFrame(prefs, null);
+        VSSimulator simulator = new VSSimulator(prefs, frame);
+        frame.addSimulator(simulator);
+        
+        // Access visualization via reflection
+        java.lang.reflect.Field vizField = VSSimulator.class.getDeclaredField("simulatorVisualization");
+        vizField.setAccessible(true);
+        VSSimulatorVisualization viz = (VSSimulatorVisualization) vizField.get(simulator);
+        
+        // Add more processes - we want 5 total (3 servers, 2 clients)
+        while (viz.getNumProcesses() < 5) {
+            java.lang.reflect.Method addProcessMethod = VSSimulatorVisualization.class.getDeclaredMethod("addProcess");
+            addProcessMethod.setAccessible(true);
+            addProcessMethod.invoke(viz);
+        }
+        
+        VSTaskManager taskManager = viz.getTaskManager();
+        
+        // Activate Raft SERVERS on processes 0, 1, 2
+        // Since Raft uses HAS_ON_SERVER_START, onServerStart() will be called automatically!
+        System.out.println("Creating Raft server activations...");
+        for (int i = 0; i < 3; i++) {
+            VSProtocolEvent serverEvent = new VSProtocolEvent();
+            serverEvent.setProtocolClassname(RAFT_PROTOCOL);
+            serverEvent.isClientProtocol(false); // Server mode
+            serverEvent.isProtocolActivation(true); // Activation
+            
+            // Activate at time 0
+            VSTask task = new VSTask(0, viz.getProcess(i), serverEvent, false);
+            taskManager.addTask(task);
+            System.out.println("  - Server " + i + " will activate at time 0");
+        }
+        
+        // Activate Raft CLIENTS on processes 3, 4
+        // Clients will react to server heartbeats and start sending requests
+        System.out.println("\nCreating Raft client activations...");
+        for (int i = 3; i < 5; i++) {
+            VSProtocolEvent clientEvent = new VSProtocolEvent();
+            clientEvent.setProtocolClassname(RAFT_PROTOCOL);
+            clientEvent.isClientProtocol(true); // Client mode
+            clientEvent.isProtocolActivation(true); // Activation
+            
+            // Activate clients a bit later so servers have time to elect leader
+            VSTask task = new VSTask(300 + (i-3)*100, viz.getProcess(i), clientEvent, false);
+            taskManager.addTask(task);
+            System.out.println("  - Client " + (i-3) + " will activate at time " + (300 + (i-3)*100));
+        }
+        
+        // Add crash/recovery to demonstrate leader re-election
+        System.out.println("\nAdding failure scenarios...");
+        
+        // Crash server 0 at time 1000
+        VSProcessCrashEvent crash = new VSProcessCrashEvent();
+        VSTask crashTask = new VSTask(1000, viz.getProcess(0), crash, false);
+        taskManager.addTask(crashTask);
+        System.out.println("  - Server 0 will crash at time 1000");
+        
+        // Recover server 0 at time 1500
+        VSProcessRecoverEvent recover = new VSProcessRecoverEvent();
+        VSTask recoverTask = new VSTask(1500, viz.getProcess(0), recover, false);
+        taskManager.addTask(recoverTask);
+        System.out.println("  - Server 0 will recover at time 1500");
+        
+        // Save simulation
+        File outputFile = new File("saved-simulations/raft-simple.dat");
+        outputFile.getParentFile().mkdirs();
+        
+        VSSerialize serialize = new VSSerialize();
+        serialize.saveSimulator(outputFile.getAbsolutePath(), simulator);
+        
+        frame.dispose();
+        
+        System.out.println("\n===========================================");
+        System.out.println("Simple Raft simulation saved successfully!");
+        System.out.println("===========================================");
+        System.out.println("\nFile: " + outputFile.getAbsolutePath());
+        System.out.println("\nWhat happens in this simulation:");
+        System.out.println("1. Time 0: Three Raft servers start and begin leader election");
+        System.out.println("2. Time ~150-300: One server becomes leader (watch for election messages)");
+        System.out.println("3. Time 300: First client activates and starts sending requests");
+        System.out.println("4. Time 400: Second client activates and starts sending requests");
+        System.out.println("5. Time 1000: Server 0 crashes, triggering new leader election");
+        System.out.println("6. Time 1500: Server 0 recovers and rejoins as follower");
+        System.out.println("\nTo run the simulation:");
+        System.out.println("1. java -jar target/ds-sim-1.0.1-SNAPSHOT.jar");
+        System.out.println("2. File -> Open -> saved-simulations/raft-simple.dat");
+        System.out.println("3. Click 'Run' and watch the Raft consensus in action!");
+        System.out.println("\nLook for:");
+        System.out.println("- REQUEST_VOTE and VOTE_RESPONSE messages during elections");
+        System.out.println("- APPEND_ENTRIES messages (heartbeats) from leader");
+        System.out.println("- CLIENT_REQUEST messages and their processing");
+        
+        System.exit(0);
+    }
+}
+\ No newline at end of file
diff --git a/src/main/java/examples/CreateWorkingRaftSimulation.java b/src/main/java/examples/CreateWorkingRaftSimulation.java
new file mode 100644
index 0000000..0bc5df4
--- /dev/null
+++ b/src/main/java/examples/CreateWorkingRaftSimulation.java
@@ -0,0 +1,152 @@
+package examples;
+
+import simulator.*;
+import core.*;
+import prefs.*;
+import events.*;
+import events.internal.*;
+import events.implementations.*;
+import serialize.VSSerialize;
+import java.io.*;
+import java.lang.reflect.*;
+
+/**
+ * Creates a working Raft simulation by properly setting up the event queue
+ * and ensuring protocols are activated through the normal event system.
+ */
+public class CreateWorkingRaftSimulation {
+    
+    private static final String RAFT_PROTOCOL = "protocols.implementations.VSRaftProtocol";
+    
+    public static void main(String[] args) throws Exception {
+        System.out.println("=== Creating Working Raft Simulation ===\n");
+        
+        // Initialize
+        VSDefaultPrefs prefs = new VSDefaultPrefs();
+        prefs.fillWithDefaults();
+        VSRegisteredEvents.init(prefs);
+        
+        // Create simulator with frame
+        VSSimulatorFrame frame = new VSSimulatorFrame(prefs, null);
+        VSSimulator simulator = new VSSimulator(prefs, frame);
+        frame.addSimulator(simulator);
+        
+        // Access visualization
+        Field vizField = VSSimulator.class.getDeclaredField("simulatorVisualization");
+        vizField.setAccessible(true);
+        VSSimulatorVisualization viz = (VSSimulatorVisualization) vizField.get(simulator);
+        
+        // Add 5 processes (3 servers + 2 clients)
+        Method addProcessMethod = VSSimulatorVisualization.class.getDeclaredMethod("addProcess");
+        addProcessMethod.setAccessible(true);
+        System.out.println("Adding 5 processes...");
+        for (int i = 0; i < 5; i++) {
+            addProcessMethod.invoke(viz);
+        }
+        
+        VSTaskManager taskManager = viz.getTaskManager();
+        
+        // Schedule Raft server activations at time 0
+        System.out.println("\nScheduling Raft server activations:");
+        for (int i = 0; i < 3; i++) {
+            VSProtocolEvent serverEvent = new VSProtocolEvent();
+            serverEvent.setProtocolClassname(RAFT_PROTOCOL);
+            serverEvent.isClientProtocol(false); // Server mode
+            serverEvent.isProtocolActivation(true); // This is an activation
+            
+            VSTask task = new VSTask(0, viz.getProcess(i), serverEvent, false);
+            taskManager.addTask(task);
+            System.out.println("  - Server " + i + " activation scheduled at time 0");
+        }
+        
+        // Schedule Raft client activations with slight delay
+        System.out.println("\nScheduling Raft client activations:");
+        for (int i = 3; i < 5; i++) {
+            VSProtocolEvent clientEvent = new VSProtocolEvent();
+            clientEvent.setProtocolClassname(RAFT_PROTOCOL);
+            clientEvent.isClientProtocol(true); // Client mode
+            clientEvent.isProtocolActivation(true); // This is an activation
+            
+            // Start clients after servers have initialized
+            long startTime = 500 + (i - 3) * 200;
+            VSTask task = new VSTask(startTime, viz.getProcess(i), clientEvent, false);
+            taskManager.addTask(task);
+            System.out.println("  - Client " + (i-3) + " activation scheduled at time " + startTime);
+        }
+        
+        // Add some interesting events
+        System.out.println("\nAdding crash/recovery events:");
+        
+        // Process 0 crashes at time 2000 and recovers at 3000
+        VSProcessCrashEvent crash1 = new VSProcessCrashEvent();
+        taskManager.addTask(new VSTask(2000, viz.getProcess(0), crash1, false));
+        System.out.println("  - Server 0 crash scheduled at time 2000");
+        
+        VSProcessRecoverEvent recover1 = new VSProcessRecoverEvent();
+        taskManager.addTask(new VSTask(3000, viz.getProcess(0), recover1, false));
+        System.out.println("  - Server 0 recovery scheduled at time 3000");
+        
+        // Process 1 crashes at time 4000 and recovers at 5000
+        VSProcessCrashEvent crash2 = new VSProcessCrashEvent();
+        taskManager.addTask(new VSTask(4000, viz.getProcess(1), crash2, false));
+        System.out.println("  - Server 1 crash scheduled at time 4000");
+        
+        VSProcessRecoverEvent recover2 = new VSProcessRecoverEvent();
+        taskManager.addTask(new VSTask(5000, viz.getProcess(1), recover2, false));
+        System.out.println("  - Server 1 recovery scheduled at time 5000");
+        
+        // Save simulation
+        File outputFile = new File("saved-simulations/raft-working.dat");
+        outputFile.getParentFile().mkdirs();
+        
+        System.out.println("\nSaving simulation...");
+        VSSerialize serialize = new VSSerialize();
+        serialize.saveSimulator(outputFile.getAbsolutePath(), simulator);
+        
+        frame.dispose();
+        
+        System.out.println("\n✓ Simulation saved to: " + outputFile.getAbsolutePath());
+        
+        // Create instruction file
+        File instructionFile = new File("saved-simulations/README-raft.txt");
+        try (PrintWriter writer = new PrintWriter(instructionFile)) {
+            writer.println("RAFT CONSENSUS SIMULATION");
+            writer.println("========================");
+            writer.println();
+            writer.println("This directory contains Raft consensus protocol simulations:");
+            writer.println();
+            writer.println("1. raft-working.dat - Full working simulation with:");
+            writer.println("   - 3 Raft servers (processes 0-2)");
+            writer.println("   - 2 Raft clients (processes 3-4)");
+            writer.println("   - Server crash/recovery events");
+            writer.println();
+            writer.println("To run the simulation:");
+            writer.println("1. java -jar target/ds-sim-1.0.1-SNAPSHOT.jar");
+            writer.println("2. File → Open → saved-simulations/raft-working.dat");
+            writer.println("3. Click Run (▶) button");
+            writer.println();
+            writer.println("What to look for:");
+            writer.println("- Leader election (REQUEST_VOTE messages)");
+            writer.println("- Heartbeats from leader (APPEND_ENTRIES)");
+            writer.println("- Client requests and responses");
+            writer.println("- Re-election when servers crash");
+            writer.println();
+            writer.println("Timeline:");
+            writer.println("- Time 0: Servers start, begin leader election");
+            writer.println("- Time 500-700: Clients start");
+            writer.println("- Time 2000: Server 0 crashes");
+            writer.println("- Time 3000: Server 0 recovers");
+            writer.println("- Time 4000: Server 1 crashes");
+            writer.println("- Time 5000: Server 1 recovers");
+        }
+        
+        System.out.println("✓ Instructions saved to: " + instructionFile.getAbsolutePath());
+        
+        System.out.println("\n=== Success! ===");
+        System.out.println("\nThe Raft simulation has been created with the following setup:");
+        System.out.println("- 3 servers implementing Raft consensus");
+        System.out.println("- 2 clients that will send requests");
+        System.out.println("- Crash/recovery events to test fault tolerance");
+        System.out.println("\nRun the simulator and load the file to see it in action!");
+    }
+}
+\ No newline at end of file
diff --git a/src/main/java/examples/RaftSimulationBuilder.java b/src/main/java/examples/RaftSimulationBuilder.java
new file mode 100644
index 0000000..c802448
--- /dev/null
+++ b/src/main/java/examples/RaftSimulationBuilder.java
@@ -0,0 +1,76 @@
+package examples;
+
+import simulator.*;
+import core.*;
+import prefs.*;
+import events.*;
+import events.internal.*;
+import serialize.VSSerialize;
+import java.io.*;
+
+/**
+ * Builder for creating Raft simulations programmatically.
+ * Uses reflection to access private simulator fields when necessary.
+ */
+public class RaftSimulationBuilder {
+    
+    private static final String RAFT_PROTOCOL = "protocols.implementations.VSRaftProtocol";
+    
+    public static void main(String[] args) throws Exception {
+        // Initialize
+        VSDefaultPrefs prefs = new VSDefaultPrefs();
+        prefs.fillWithDefaults();
+        VSRegisteredEvents.init(prefs);
+        
+        // Create frame and simulator
+        VSSimulatorFrame frame = new VSSimulatorFrame(prefs, null);
+        VSSimulator simulator = new VSSimulator(prefs, frame);
+        frame.addSimulator(simulator);
+        
+        // Access private field via reflection
+        java.lang.reflect.Field vizField = VSSimulator.class.getDeclaredField("simulatorVisualization");
+        vizField.setAccessible(true);
+        VSSimulatorVisualization viz = (VSSimulatorVisualization) vizField.get(simulator);
+        
+        // Build Raft simulation
+        VSTaskManager taskManager = viz.getTaskManager();
+        
+        // Add server activations (processes 0,1)
+        for (int i = 0; i < 2; i++) {
+            VSProtocolEvent serverEvent = new VSProtocolEvent();
+            serverEvent.setProtocolClassname(RAFT_PROTOCOL);
+            serverEvent.isClientProtocol(false);
+            serverEvent.isProtocolActivation(true);
+            
+            VSTask task = new VSTask(0, viz.getProcess(i), serverEvent, false);
+            taskManager.addTask(task);
+        }
+        
+        // Add client activation (process 2)
+        VSProtocolEvent clientEvent = new VSProtocolEvent();
+        clientEvent.setProtocolClassname(RAFT_PROTOCOL);
+        clientEvent.isClientProtocol(true);
+        clientEvent.isProtocolActivation(true);
+        
+        VSTask clientTask = new VSTask(100, viz.getProcess(2), clientEvent, false);
+        taskManager.addTask(clientTask);
+        
+        // Save
+        File outputFile = new File("saved-simulations/raft-consensus.dat");
+        outputFile.getParentFile().mkdirs();
+        
+        VSSerialize serialize = new VSSerialize();
+        serialize.saveSimulator(outputFile.getAbsolutePath(), simulator);
+        
+        frame.dispose();
+        
+        System.out.println("Raft simulation created: " + outputFile.getAbsolutePath());
+        System.out.println("\nContains:");
+        System.out.println("- 2 Raft servers (processes 0-1)");
+        System.out.println("- 1 Raft client (process 2)");
+        System.out.println("\nRun with: java -jar target/ds-sim-1.0.1-SNAPSHOT.jar");
+        System.out.println("Then open: " + outputFile.getName());
+        
+        System.exit(0);
+    }
+}
+\ No newline at end of file
diff --git a/src/main/java/examples/TestRaftLoading.java b/src/main/java/examples/TestRaftLoading.java
new file mode 100644
index 0000000..ebad379
--- /dev/null
+++ b/src/main/java/examples/TestRaftLoading.java
@@ -0,0 +1,57 @@
+package examples;
+
+import events.VSRegisteredEvents;
+import prefs.VSDefaultPrefs;
+import java.util.Vector;
+
+/**
+ * Test if Raft protocol is properly registered and loadable
+ */
+public class TestRaftLoading {
+    public static void main(String[] args) {
+        // Initialize
+        VSDefaultPrefs prefs = new VSDefaultPrefs();
+        prefs.fillWithDefaults();
+        VSRegisteredEvents.init(prefs);
+        
+        // List all registered protocols
+        System.out.println("=== Registered Protocols ===");
+        Vector<String> protocolNames = VSRegisteredEvents.getProtocolNames();
+        for (String name : protocolNames) {
+            String className = VSRegisteredEvents.getClassnameByEventname(name);
+            System.out.println(name + " -> " + className);
+        }
+        
+        System.out.println("\n=== Protocol Classnames ===");
+        Vector<String> protocolClassnames = VSRegisteredEvents.getProtocolClassnames();
+        for (String className : protocolClassnames) {
+            String shortName = VSRegisteredEvents.getShortnameByClassname(className);
+            System.out.println(className + " (short: " + shortName + ")");
+        }
+        
+        // Check Raft specifically
+        System.out.println("\n=== Raft Protocol Check ===");
+        String raftClass = "protocols.implementations.VSRaftProtocol";
+        String raftShortName = VSRegisteredEvents.getShortnameByClassname(raftClass);
+        String raftEventName = VSRegisteredEvents.getNameByClassname(raftClass);
+        
+        System.out.println("Class: " + raftClass);
+        System.out.println("Short name: " + raftShortName);
+        System.out.println("Event name: " + raftEventName);
+        
+        // Try to load the class
+        try {
+            Class<?> clazz = Class.forName(raftClass);
+            System.out.println("Class loaded successfully: " + clazz.getName());
+            
+            // Check if it's a protocol
+            if (protocols.VSAbstractProtocol.class.isAssignableFrom(clazz)) {
+                System.out.println("✓ Is a valid protocol class");
+            } else {
+                System.out.println("✗ NOT a protocol class!");
+            }
+        } catch (ClassNotFoundException e) {
+            System.out.println("✗ Class not found: " + e.getMessage());
+        }
+    }
+}
+\ No newline at end of file