diff --git a/gcs/data/default_settings.json b/gcs/data/default_settings.json
index db0c6ce60..fbc68b971 100644
--- a/gcs/data/default_settings.json
+++ b/gcs/data/default_settings.json
@@ -31,6 +31,12 @@
       "default": false,
       "type": "boolean",
       "display": "Speech Announcements"
+    },
+    "experimentalDeveloperFeatures": {
+      "default": false,
+      "type": "boolean",
+      "display": "Experimental Developer Features",
+      "description": "These may be unstable and can cause unexpected bugs or crashes."
     }
   },
   "Dashboard": {
diff --git a/gcs/src/components/connectionProgress.jsx b/gcs/src/components/connectionProgress.jsx
new file mode 100644
index 000000000..9c902d0ea
--- /dev/null
+++ b/gcs/src/components/connectionProgress.jsx
@@ -0,0 +1,22 @@
+import { Progress } from "@mantine/core"
+
+export default function ConnectionProgress({ connecting, status }) {
+  return (
+    <>
+      {connecting &&
+        status.message !== null &&
+        typeof status.progress === "number" && (
+          <>
+            <p className="text-center my-4">{status.message}</p>
+            <Progress
+              animated
+              size="lg"
+              transitionDuration={300}
+              value={status.progress}
+              className="w-full mx-auto my-auto"
+            />
+          </>
+        )}
+    </>
+  )
+}
diff --git a/gcs/src/components/navbar.jsx b/gcs/src/components/navbar.jsx
index 88b234b6a..2b5fe7090 100644
--- a/gcs/src/components/navbar.jsx
+++ b/gcs/src/components/navbar.jsx
@@ -16,7 +16,6 @@ import {
   Group,
   LoadingOverlay,
   Modal,
-  Progress,
   SegmentedControl,
   Select,
   Tabs,
@@ -78,6 +77,10 @@ import { useEffect } from "react"
 import { twMerge } from "tailwind-merge"
 import { showErrorNotification } from "../helpers/notification.js"
 
+// Modals
+import SimulationModal from "./toolbar/simulationModal.jsx"
+import ConnectionProgress from "./connectionProgress.jsx"
+
 export default function Navbar() {
   // Redux
   const dispatch = useDispatch()
@@ -320,22 +323,10 @@ export default function Navbar() {
           </Group>
         </form>
 
-        {connecting &&
-          droneConnectionStatus.message !== null &&
-          typeof droneConnectionStatus.progress === "number" && (
-            <>
-              <p className="text-center my-4">
-                {droneConnectionStatus.message}
-              </p>
-              <Progress
-                animated
-                size="lg"
-                transitionDuration={300}
-                value={droneConnectionStatus.progress}
-                className="w-full mx-auto my-auto"
-              />
-            </>
-          )}
+        <ConnectionProgress
+          connecting={connecting}
+          status={droneConnectionStatus}
+        />
       </Modal>
 
       <Modal
@@ -402,6 +393,8 @@ export default function Navbar() {
         )}
       </Modal>
 
+      <SimulationModal />
+
       <div className="w-full flex justify-between gap-x-4 xl:grid xl:grid-cols-2 xl:gap-0">
         <div className="flex items-center wrap">
           {/* Navigation */}
diff --git a/gcs/src/components/toolbar/menus/advanced.jsx b/gcs/src/components/toolbar/menus/advanced.jsx
index 7606ddccc..3e491307a 100644
--- a/gcs/src/components/toolbar/menus/advanced.jsx
+++ b/gcs/src/components/toolbar/menus/advanced.jsx
@@ -5,11 +5,14 @@
 // Local Imports
 import { useDispatch } from "react-redux"
 import { setForwardingAddressModalOpened } from "../../../redux/slices/droneConnectionSlice"
+import { setSimulationModalOpened } from "../../../redux/slices/simulationParamsSlice"
 import MenuItem from "./menuItem"
 import MenuTemplate from "./menuTemplate"
+import { useSettings } from "../../../helpers/settings"
 
 export default function AdvancedMenu(props) {
   const dispatch = useDispatch()
+  const { getSetting } = useSettings()
   return (
     <MenuTemplate
       title="Advanced"
@@ -28,6 +31,14 @@ export default function AdvancedMenu(props) {
           dispatch(setForwardingAddressModalOpened(true))
         }}
       />
+      {getSetting("General.experimentalDeveloperFeatures") && (
+        <MenuItem
+          name="SITL Simulator"
+          onClick={() => {
+            dispatch(setSimulationModalOpened(true))
+          }}
+        />
+      )}
     </MenuTemplate>
   )
 }
diff --git a/gcs/src/components/toolbar/simulationModal.jsx b/gcs/src/components/toolbar/simulationModal.jsx
new file mode 100644
index 000000000..faee795e2
--- /dev/null
+++ b/gcs/src/components/toolbar/simulationModal.jsx
@@ -0,0 +1,305 @@
+import { useEffect, useState } from "react"
+import { useDispatch, useSelector } from "react-redux"
+import {
+  Modal,
+  Text,
+  Button,
+  Select,
+  NumberInput,
+  Checkbox,
+  Tooltip,
+  Group,
+  ActionIcon,
+} from "@mantine/core"
+import { IconAlertCircle, IconInfoCircle, IconTrash } from "@tabler/icons-react"
+import {
+  SimulationStatus,
+  addSimulationPort,
+  emitStartSimulation,
+  emitStopSimulation,
+  removeSimulationPortById,
+  selectIsSimulationRunning,
+  selectSimulationConnectAfterStart,
+  selectSimulationModalOpened,
+  selectSimulationPorts,
+  selectSimulationStatus,
+  selectSimulationVehicleType,
+  setSimulationConnectAfterStart,
+  setSimulationModalOpened,
+  setSimulationVehicleType,
+  updateSimulationPortById,
+} from "../../redux/slices/simulationParamsSlice"
+import { selectIsConnectedToSocket } from "../../redux/slices/socketSlice"
+import { showNotification } from "../../helpers/notification"
+import {
+  emitDisconnectFromDrone,
+  selectConnectedToDrone,
+  selectConnectedToSimulator,
+  selectConnecting,
+  selectConnectionStatus,
+} from "../../redux/slices/droneConnectionSlice"
+import ConnectionProgress from "../connectionProgress"
+
+const normalizePort = (val) => {
+  if (val === null || val === "" || val === undefined || isNaN(val)) {
+    return undefined
+  }
+  return Number(val)
+}
+
+const getDuplicates = (values) => {
+  const counts = new Map()
+  values.forEach((v) => {
+    if (v === null || v === undefined) return
+    const current = counts.get(v) || 0
+    counts.set(v, current + 1)
+  })
+  return new Set(
+    Array.from(counts.entries())
+      .filter(([, count]) => count > 1)
+      .map(([value]) => value),
+  )
+}
+
+export default function SimulationModal() {
+  const dispatch = useDispatch()
+  const modalOpen = useSelector(selectSimulationModalOpened)
+  const isSimulationRunning = useSelector(selectIsSimulationRunning)
+  const simulationStatus = useSelector(selectSimulationStatus)
+  const ports = useSelector(selectSimulationPorts)
+  const vehicleType = useSelector(selectSimulationVehicleType)
+  const connectAfterStart = useSelector(selectSimulationConnectAfterStart)
+  const connectedToSocket = useSelector(selectIsConnectedToSocket)
+  const droneConnectionStatus = useSelector(selectConnectionStatus)
+  const connecting = useSelector(selectConnecting)
+  const connectedToDrone = useSelector(selectConnectedToDrone)
+  const connectedToSimulator = useSelector(selectConnectedToSimulator)
+
+  const [pendingStopAfterDisconnect, setPendingStopAfterDisconnect] =
+    useState(false)
+
+  // Wait for disconnect before stopping simulation
+  useEffect(() => {
+    if (!pendingStopAfterDisconnect) return
+    if (connectedToDrone) return
+    if (!isSimulationRunning) {
+      setPendingStopAfterDisconnect(false)
+      return
+    }
+
+    dispatch(emitStopSimulation())
+    setPendingStopAfterDisconnect(false)
+  }, [
+    pendingStopAfterDisconnect,
+    connectedToDrone,
+    isSimulationRunning,
+    dispatch,
+  ])
+
+  // Make connect after start false if already connected to a drone
+  useEffect(() => {
+    if (connectedToDrone && !connectedToSimulator && connectAfterStart) {
+      dispatch(setSimulationConnectAfterStart(false))
+    }
+  }, [connectedToDrone, connectedToSimulator, connectAfterStart, dispatch])
+
+  const duplicateHostPorts = getDuplicates(ports.map((p) => p.hostPort))
+  const duplicateContainerPorts = getDuplicates(
+    ports.map((p) => p.containerPort),
+  )
+  const hasEmptyPort = ports.some(
+    (p) =>
+      normalizePort(p.hostPort) === undefined ||
+      normalizePort(p.containerPort) === undefined,
+  )
+
+  return (
+    <Modal
+      opened={modalOpen}
+      onClose={() => {
+        dispatch(setSimulationModalOpened(false))
+        if (simulationStatus === SimulationStatus.Starting) {
+          showNotification(
+            "Simulation still starting",
+            "The simulator is still starting and will continue in the background",
+          )
+        } else if (simulationStatus === SimulationStatus.Stopping) {
+          showNotification(
+            "Simulation still stopping",
+            "The simulator is still stopping and will continue in the background",
+          )
+        }
+      }}
+      title="SITL Simulator"
+      centered
+      overlayProps={{
+        backgroundOpacity: 0.55,
+        blur: 3,
+      }}
+      styles={{
+        content: {
+          borderRadius: "0.5rem",
+        },
+      }}
+    >
+      {ports.map((port) => (
+        <Group spacing="md" mb="md" key={port.id} wrap="nowrap" align="end">
+          <NumberInput
+            label="Host Port"
+            min={1025}
+            max={65535}
+            hideControls
+            allowDecimal={false}
+            value={port.hostPort}
+            style={{ flex: 1 }}
+            error={
+              duplicateHostPorts.has(port.hostPort) ||
+              normalizePort(port.hostPort) === undefined
+            }
+            onChange={(val) =>
+              dispatch(
+                updateSimulationPortById({
+                  id: port.id,
+                  key: "hostPort",
+                  value: normalizePort(val),
+                }),
+              )
+            }
+          />
+
+          <NumberInput
+            label="Container Port"
+            min={1}
+            max={65535}
+            hideControls
+            allowDecimal={false}
+            value={port.containerPort}
+            style={{ flex: 1 }}
+            error={
+              duplicateContainerPorts.has(port.containerPort) ||
+              normalizePort(port.containerPort) === undefined
+            }
+            onChange={(val) =>
+              dispatch(
+                updateSimulationPortById({
+                  id: port.id,
+                  key: "containerPort",
+                  value: normalizePort(val),
+                }),
+              )
+            }
+          />
+
+          {ports.length > 1 && (
+            <Tooltip label="Remove port" withArrow>
+              <ActionIcon
+                color="red"
+                aria-label="Remove port"
+                size={36}
+                onClick={() => dispatch(removeSimulationPortById(port.id))}
+              >
+                <IconTrash size={20} />
+              </ActionIcon>
+            </Tooltip>
+          )}
+        </Group>
+      ))}
+
+      {(duplicateHostPorts.size > 0 || duplicateContainerPorts.size > 0) && (
+        <Group mb="md" gap={6} align="center">
+          <IconAlertCircle size={18} color="red" />
+          <Text size="sm" c="red.7">
+            Duplicated ports
+          </Text>
+        </Group>
+      )}
+
+      <Button
+        fullWidth
+        variant="default"
+        mb="md"
+        onClick={() => dispatch(addSimulationPort())}
+      >
+        Add Port
+      </Button>
+
+      <Select
+        mb="md"
+        label="Vehicle type"
+        placeholder="Pick value"
+        data={["ArduCopter", "ArduPlane"]}
+        value={vehicleType}
+        allowDeselect={false}
+        onChange={(value) => {
+          if (value) dispatch(setSimulationVehicleType(value))
+        }}
+      />
+
+      <Text mt="md" c="dimmed" size="sm">
+        Note: Docker must be running to start the simulator.
+      </Text>
+
+      <Group justify="space-between" className="pt-4">
+        <div className="flex flex-row gap-2">
+          <Checkbox
+            label="Connect after starting"
+            checked={connectAfterStart}
+            onChange={(event) =>
+              dispatch(
+                setSimulationConnectAfterStart(event.currentTarget.checked),
+              )
+            }
+            disabled={
+              !connectedToSocket || (connectedToDrone && !connectedToSimulator)
+            }
+          />
+          <Tooltip
+            label={
+              connectedToSocket
+                ? "Connect to the first listed port if the simulator starts correctly"
+                : "Not connected to socket"
+            }
+          >
+            <IconInfoCircle size={20} />
+          </Tooltip>
+        </div>
+
+        <Button
+          variant="filled"
+          color={isSimulationRunning ? "red" : "green"}
+          onClick={() => {
+            if (isSimulationRunning) {
+              if (connectedToDrone && connectedToSimulator) {
+                setPendingStopAfterDisconnect(true)
+                dispatch(emitDisconnectFromDrone())
+                return
+              }
+
+              dispatch(emitStopSimulation())
+              return
+            }
+
+            dispatch(emitStartSimulation())
+          }}
+          loading={
+            simulationStatus === SimulationStatus.Starting ||
+            simulationStatus === SimulationStatus.Stopping
+          }
+          disabled={
+            !connectedToSocket ||
+            duplicateHostPorts.size > 0 ||
+            duplicateContainerPorts.size > 0 ||
+            hasEmptyPort
+          }
+        >
+          {isSimulationRunning ? "Stop Simulator" : "Start Simulator"}
+        </Button>
+      </Group>
+
+      <ConnectionProgress
+        connecting={connecting}
+        status={droneConnectionStatus}
+      />
+    </Modal>
+  )
+}
diff --git a/gcs/src/redux/middleware/emitters.js b/gcs/src/redux/middleware/emitters.js
index 295224961..b523f520e 100644
--- a/gcs/src/redux/middleware/emitters.js
+++ b/gcs/src/redux/middleware/emitters.js
@@ -37,6 +37,12 @@ import {
   setCurrentPage,
   setIsForwarding,
 } from "../slices/droneConnectionSlice"
+import {
+  setSimulationStatus,
+  SimulationStatus,
+  emitStartSimulation,
+  emitStopSimulation,
+} from "../slices/simulationParamsSlice"
 import {
   emitListFiles,
   emitListLogFiles,
@@ -203,6 +209,30 @@ export function handleEmitters(socket, store, action) {
         }),
     },
 
+    {
+      emitter: emitStartSimulation,
+      callback: () => {
+        store.dispatch(setSimulationStatus(SimulationStatus.Starting))
+
+        const storeState = store.getState()
+        const simulationParams = storeState.simulationParams
+        socket.socket.emit("start_docker_simulation", {
+          ports: simulationParams.ports,
+          vehicleType: simulationParams.vehicleType,
+          connect: simulationParams.connectAfterStart,
+        })
+      },
+    },
+
+    {
+      emitter: emitStopSimulation,
+      callback: () => {
+        store.dispatch(setSimulationStatus(SimulationStatus.Stopping))
+
+        socket.socket.emit("stop_docker_simulation")
+      },
+    },
+
     /*
       ============
       = MISSIONS =
diff --git a/gcs/src/redux/middleware/socketMiddleware.js b/gcs/src/redux/middleware/socketMiddleware.js
index ea8534b4d..0635e4250 100644
--- a/gcs/src/redux/middleware/socketMiddleware.js
+++ b/gcs/src/redux/middleware/socketMiddleware.js
@@ -9,10 +9,13 @@ import {
 
 // drone actions
 import {
+  ConnectionType,
+  emitConnectToDrone,
   emitGetComPorts,
   emitIsConnectedToDrone,
   setComPorts,
   setConnected,
+  setConnectedToSimulator,
   setConnecting,
   setConnectionModal,
   setConnectionStatus,
@@ -21,14 +24,24 @@ import {
   setSelectedComPorts,
 } from "../slices/droneConnectionSlice"
 
+import {
+  setSimulationStatus,
+  SimulationStatus,
+  setSimulationLoadingNotificationId,
+  clearSimulationLoadingNotificationId,
+} from "../slices/simulationParamsSlice"
+
 // socket factory
 import { dataFormatters } from "../../helpers/dataFormatters.js"
 import { isGlobalFrameHomeCommand } from "../../helpers/filterMissions.js"
 import { FRAME_CLASS_MAP } from "../../helpers/mavlinkConstants.js"
 import {
+  closeLoadingNotification,
   showErrorNotification,
+  showLoadingNotification,
   showSuccessNotification,
   showWarningNotification,
+  redColor,
 } from "../../helpers/notification.js"
 import SocketFactory from "../../helpers/socket"
 import {
@@ -133,6 +146,8 @@ const SocketEvents = Object.freeze({
   isConnectedToDrone: "is_connected_to_drone",
   listComPorts: "list_com_ports",
   linkDebugStats: "link_debug_stats",
+  onSimulationResult: "simulation_result",
+  onSimulationLoading: "simulation_loading",
 })
 
 const DroneSpecificSocketEvents = Object.freeze({
@@ -378,6 +393,7 @@ const socketMiddleware = (store) => {
         // Flags that the drone is disconnected
         socket.socket.on("disconnected_from_drone", () => {
           store.dispatch(setConnected(false))
+          store.dispatch(setConnectedToSimulator(false))
           window.ipcRenderer.send("window:update-title", "FGCS")
         })
 
@@ -425,6 +441,74 @@ const socketMiddleware = (store) => {
           store.dispatch(setTotalTimeFlying(0))
         })
 
+        // Simulation status messages
+        socket.socket.on(SocketEvents.onSimulationLoading, (msg) => {
+          const operationId = msg.operationId || "simulation-loading"
+          const state = store.getState()
+          const idsByOp =
+            state.simulationParams.loadingNotificationIdsByOperation
+          const existingId = idsByOp?.[operationId]
+
+          if (msg.loading) {
+            if (existingId != null) {
+              closeLoadingNotification(
+                existingId,
+                "Cancelled",
+                "Overwritten by new loading notification",
+              )
+            }
+
+            const id = showLoadingNotification(msg.title, msg.message)
+            store.dispatch(
+              setSimulationLoadingNotificationId({
+                operationId,
+                notificationId: id,
+              }),
+            )
+          } else {
+            if (existingId != null) {
+              closeLoadingNotification(
+                existingId,
+                msg.title,
+                msg.message,
+                msg.success === false ? { color: redColor } : {},
+              )
+              store.dispatch(
+                clearSimulationLoadingNotificationId({ operationId }),
+              )
+            }
+          }
+        })
+
+        // Simulation final messages
+        socket.socket.on(SocketEvents.onSimulationResult, (msg) => {
+          if (msg.running === true) {
+            store.dispatch(setSimulationStatus(SimulationStatus.Running))
+          } else if (msg.running === false) {
+            store.dispatch(setSimulationStatus(SimulationStatus.Idle))
+          }
+          // Else result does not change the status
+
+          msg.success
+            ? showSuccessNotification(msg.message)
+            : showErrorNotification(msg.message)
+
+          if (msg.connect) {
+            const storeState = store.getState()
+            store.dispatch(setConnecting(true))
+            store.dispatch(
+              emitConnectToDrone({
+                port: `tcp:127.0.0.1:${msg.port}`,
+                baud: 115200,
+                wireless: true,
+                connectionType: ConnectionType.Network,
+                forwardingAddress: storeState.droneConnection.forwardingAddress,
+              }),
+            )
+            store.dispatch(setConnectedToSimulator(true))
+          }
+        })
+
         // Link stats
         socket.socket.on(SocketEvents.linkDebugStats, (msg) => {
           window.ipcRenderer.invoke("app:update-link-stats", msg)
diff --git a/gcs/src/redux/slices/droneConnectionSlice.js b/gcs/src/redux/slices/droneConnectionSlice.js
index ff184e6e3..99efde26f 100644
--- a/gcs/src/redux/slices/droneConnectionSlice.js
+++ b/gcs/src/redux/slices/droneConnectionSlice.js
@@ -14,6 +14,7 @@ const initialState = {
     message: "",
     progress: 0,
   },
+  connected_to_simulator: false,
 
   // aircraft type
   aircraft_type: 0,
@@ -62,6 +63,11 @@ const droneConnectionSlice = createSlice({
         state.connected = action.payload
       }
     },
+    setConnectedToSimulator: (state, action) => {
+      if (action.payload !== state.connected_to_simulator) {
+        state.connected_to_simulator = action.payload
+      }
+    },
     setBaudrate: (state, action) => {
       if (action.payload !== state.baudrate) {
         state.baudrate = action.payload
@@ -172,6 +178,7 @@ const droneConnectionSlice = createSlice({
   selectors: {
     selectConnecting: (state) => state.connecting,
     selectConnectedToDrone: (state) => state.connected,
+    selectConnectedToSimulator: (state) => state.connected_to_simulator,
     selectBaudrate: (state) => state.baudrate,
     selectConnectionType: (state) => state.connection_type,
     selectFetchingComPorts: (state) => state.fetching_com_ports,
@@ -200,6 +207,7 @@ export const {
   // Setters
   setConnecting,
   setConnected,
+  setConnectedToSimulator,
   setBaudrate,
   setConnectionType,
   setFetchingComPorts,
@@ -242,6 +250,7 @@ export const {
 export const {
   selectConnecting,
   selectConnectedToDrone,
+  selectConnectedToSimulator,
   selectBaudrate,
   selectConnectionType,
   selectFetchingComPorts,
diff --git a/gcs/src/redux/slices/simulationParamsSlice.js b/gcs/src/redux/slices/simulationParamsSlice.js
new file mode 100644
index 000000000..d23ec3ed5
--- /dev/null
+++ b/gcs/src/redux/slices/simulationParamsSlice.js
@@ -0,0 +1,107 @@
+import { createSlice } from "@reduxjs/toolkit"
+import { v4 as uuidv4 } from "uuid"
+
+export const SimulationStatus = {
+  Idle: "idle",
+  Starting: "starting",
+  Running: "running",
+  Stopping: "stopping",
+}
+
+const initialState = {
+  simulationModalOpened: false,
+  simulationStatus: SimulationStatus.Idle,
+  ports: [{ id: uuidv4(), hostPort: 5760, containerPort: 5760 }],
+  vehicleType: "ArduCopter",
+  connectAfterStart: true,
+  loadingNotificationIdsByOperation: {},
+}
+
+const simulationParamsSlice = createSlice({
+  name: "simulationParams",
+  initialState,
+  reducers: {
+    setSimulationModalOpened: (state, action) => {
+      state.simulationModalOpened = action.payload
+    },
+    setSimulationStatus: (state, action) => {
+      state.simulationStatus = action.payload
+    },
+    addSimulationPort: (state) => {
+      const startPort = 5762
+      let hostPort = startPort
+      while (state.ports.some((port) => port.hostPort === hostPort)) {
+        hostPort += 1
+      }
+      let containerPort = startPort
+      while (state.ports.some((port) => port.containerPort === containerPort)) {
+        containerPort += 1
+      }
+      state.ports.push({ id: uuidv4(), hostPort, containerPort })
+    },
+    removeSimulationPortById: (state, action) => {
+      state.ports = state.ports.filter((p) => p.id !== action.payload)
+    },
+    updateSimulationPortById: (state, action) => {
+      const { id, key, value } = action.payload
+      const port = state.ports.find((p) => p.id === id)
+      if (port) port[key] = value
+    },
+    setSimulationVehicleType: (state, action) => {
+      state.vehicleType = action.payload
+    },
+    setSimulationConnectAfterStart: (state, action) => {
+      state.connectAfterStart = action.payload
+    },
+    setSimulationLoadingNotificationId: (state, action) => {
+      const { operationId, notificationId } = action.payload
+      state.loadingNotificationIdsByOperation[operationId] = notificationId
+    },
+    clearSimulationLoadingNotificationId: (state, action) => {
+      const { operationId } = action.payload
+      delete state.loadingNotificationIdsByOperation[operationId]
+    },
+
+    // Emits
+    emitStartSimulation: () => {},
+    emitStopSimulation: () => {},
+  },
+  selectors: {
+    selectSimulationStatus: (state) => state.simulationStatus,
+    selectIsSimulationRunning: (state) =>
+      state.simulationStatus === SimulationStatus.Running ||
+      state.simulationStatus === SimulationStatus.Stopping,
+    selectSimulationModalOpened: (state) => state.simulationModalOpened,
+    selectSimulationPorts: (state) => state.ports,
+    selectSimulationVehicleType: (state) => state.vehicleType,
+    selectSimulationConnectAfterStart: (state) => state.connectAfterStart,
+    selectSimulationLoadingNotificationIdsByOperation: (state) =>
+      state.loadingNotificationIdsByOperation,
+  },
+})
+
+export const {
+  setSimulationStatus,
+  setSimulationModalOpened,
+  addSimulationPort,
+  removeSimulationPortById,
+  updateSimulationPortById,
+  setSimulationVehicleType,
+  setSimulationConnectAfterStart,
+  setSimulationLoadingNotificationId,
+  clearSimulationLoadingNotificationId,
+
+  emitStartSimulation,
+  emitStopSimulation,
+} = simulationParamsSlice.actions
+export const {
+  selectSimulationStatus,
+  selectIsSimulationRunning,
+  selectSimulationModalOpened,
+  selectSimulationPorts,
+  selectSimulationVehicleType,
+  selectSimulationConnectAfterStart,
+  selectSimulationLoadingNotificationIdsByOperation,
+} = simulationParamsSlice.selectors
+
+export default simulationParamsSlice
diff --git a/gcs/src/redux/store.js b/gcs/src/redux/store.js
index 001997fc5..8d5141974 100644
--- a/gcs/src/redux/store.js
+++ b/gcs/src/redux/store.js
@@ -23,6 +23,7 @@ import missionInfoSlice, { setPlannedHomePosition } from "./slices/missionSlice"
 import paramsSlice from "./slices/paramsSlice"
 import socketSlice from "./slices/socketSlice"
 import statusTextSlice from "./slices/statusTextSlice"
+import simulationParamsSlice from "./slices/simulationParamsSlice"
 
 const rootReducer = combineSlices(
   logAnalyserSlice,
@@ -36,6 +37,7 @@ const rootReducer = combineSlices(
   checklistSlice,
   applicationSlice,
   ftpSlice,
+  simulationParamsSlice,
 )
 
 export const store = configureStore({
diff --git a/radio/app/endpoints/__init__.py b/radio/app/endpoints/__init__.py
index 76ed1417b..a8c7bd48a 100644
--- a/radio/app/endpoints/__init__.py
+++ b/radio/app/endpoints/__init__.py
@@ -13,6 +13,7 @@
 from . import nav as nav
 from . import params as params
 from . import rc as rc
+from . import simulation as simulation
 from . import states as states
 
 endpoints = Blueprint("endpoints", __name__)
diff --git a/radio/app/endpoints/simulation.py b/radio/app/endpoints/simulation.py
new file mode 100644
index 000000000..56cea1b5d
--- /dev/null
+++ b/radio/app/endpoints/simulation.py
@@ -0,0 +1,434 @@
+import os
+import threading
+from typing import Any, Tuple, Optional
+from typing_extensions import TypedDict
+
+from app import logger, socketio
+import docker
+from docker.errors import DockerException, NotFound, ImageNotFound, APIError
+
+from docker import DockerClient
+from docker.models.containers import Container
+
+
+def get_int_env(name: str, default: int) -> int:
+    """
+    Safely convert an environment variable to an int and if this fails log the error.
+    """
+    try:
+        return int(os.getenv(name, default))
+    except (TypeError, ValueError):
+        logger.exception(f"Invalid environment variable: {name} should be an int")
+        return default
+
+
+CONTAINER_NAME = "fgcs_ardupilot_sitl"
+IMAGE_NAME = os.getenv("ARDUPILOT_SITL_IMAGE", "kushmakkapati/ardupilot_sitl:latest")
+CONTAINER_START_TIMEOUT = get_int_env("CONTAINER_START_TIMEOUT", 60)
+CONTAINER_STOP_TIMEOUT = get_int_env("CONTAINER_STOP_TIMEOUT", 10)
+CONTAINER_READY_MESSAGE = "YOU CAN NOW CONNECT"
+ALLOWED_VEHICLE_TYPES = {"ArduCopter", "ArduPlane"}
+
+
+class SimulationError(Exception):
+    """Custom exception for simulation-related failures."""
+
+    def __init__(self, message: str, original_exception: Optional[Exception] = None):
+        super().__init__(message)
+        self.user_message = message
+        self.original_exception = original_exception
+
+
+class SimulationStartType(TypedDict, total=False):
+    ports: list[dict[str, Any]]
+    connect: bool
+    vehicleType: str
+
+
+class CommandParametersType(TypedDict, total=False):
+    vehicleType: str | None
+
+
+def get_docker_client() -> DockerClient:
+    """
+    Returns a Docker client if available.
+    """
+    try:
+        client = docker.from_env()
+        client.ping()  # verify reachable
+        return client
+    except DockerException as e:
+        raise SimulationError("Unable to connect to Docker", e) from e
+    except Exception as e:
+        raise SimulationError(
+            "Unexpected error when creating and pinging Docker client", e
+        ) from e
+
+
+def ensure_image_exists(client: DockerClient, image_name: str) -> bool:
+    """
+    Checks if the client contains the given image.
+    If not it attempts to download it.
+
+    Args:
+        client: The docker client.
+        image_name: String for the name of the docker image.
+
+    Returns:
+        True if the image exists or is successfully downloaded.
+    """
+    # Operation id to correlate loading start/finish in the UI
+    operation_id = f"docker-image:{image_name}"
+
+    try:
+        client.images.get(image_name)
+        return True
+    except ImageNotFound:
+        socketio.emit(
+            "simulation_loading",
+            {
+                "operationId": operation_id,
+                "loading": True,
+                "title": "Downloading Docker Image",
+                "message": "Image not found. Attempting to download. This may take a while.",
+            },
+        )
+
+        try:
+            client.images.pull(image_name)
+
+            socketio.emit(
+                "simulation_loading",
+                {
+                    "operationId": operation_id,
+                    "loading": False,
+                    "success": True,
+                    "title": "Downloaded Docker Image",
+                    "message": "Simulation image successfully downloaded",
+                },
+            )
+            return True
+        except DockerException as e:
+            socketio.emit(
+                "simulation_loading",
+                {
+                    "operationId": operation_id,
+                    "loading": False,
+                    "success": False,
+                    "title": "Docker Exception",
+                    "message": "Error downloading simulation image",
+                },
+            )
+            raise SimulationError("Error downloading simulation image", e) from e
+    except DockerException as e:
+        raise SimulationError("Unknown error getting simulation image", e) from e
+
+
+def build_command(data: CommandParametersType) -> Optional[list[str]]:
+    """
+    Parses the socketio data into the form required for the docker command.
+    Because they are not treated as environment variables by the container.
+
+    Args:
+        data: The parameters that the simulator should start with.
+
+    Returns:
+        The command containing the parameters in the correct format.
+    """
+    cmd = []
+
+    vehicle = data.get("vehicleType")
+    if vehicle:
+        if vehicle in ALLOWED_VEHICLE_TYPES:
+            cmd.append(f"VEHICLE={vehicle}")
+        else:
+            logger.debug("Ignoring unsupported vehicleType: %s", vehicle)
+
+    return cmd if cmd else None  # Docker start handles None better than empty lists
+
+
+def container_already_running(client: DockerClient, container_name: str) -> bool:
+    """
+    Checks if the client already has the given container running.
+    If it exists but is not running it will be forcibly removed.
+    """
+    try:
+        existing = client.containers.get(container_name)
+        existing.reload()
+        if existing.status == "running":
+            socketio.emit(
+                "simulation_result",
+                {
+                    "success": False,
+                    "running": True,
+                    "message": "Simulation already running",
+                },
+            )
+            return True
+        else:
+            try:
+                existing.remove(force=True)
+            except NotFound:
+                # container already removed
+                # (race condition with remove=True on container run)
+                pass
+            return False
+
+    except NotFound:
+        return False
+    except DockerException as e:
+        raise SimulationError(
+            "Unexpected Docker exception while checking if container is running", e
+        ) from e
+
+
+def stop_container(container: Container) -> None:
+    """
+    Stop the container if it exists and is created, running, or restarting
+    """
+    try:
+        container.reload()
+        if container.status in ("running", "created", "restarting"):
+            container.stop(timeout=CONTAINER_STOP_TIMEOUT)
+    except NotFound:
+        pass  # already gone (remove=True or race)
+    except DockerException:
+        logger.exception("Failed to cleanup container")
+
+
+def wait_for_container_connection_msg(
+    client: DockerClient,
+    container: Container,
+    connect: bool,
+    port: int,
+    timeout: int = CONTAINER_START_TIMEOUT,
+) -> None:
+    """
+    Waits for the container to emit CONTAINER_READY_MESSAGE in its logs.
+    Emits a simulation_result event on success or failure.
+
+    Uses a background thread to stream logs, enforcing a strict timeout.
+
+    Args:
+        client: Docker client to close after done.
+        container: The container to wait for.
+        connect: If FGCS should attempt connection after ready.
+        port: The host port to connect to.
+        timeout: Maximum time to wait for readiness.
+    """
+    line_found = False
+    failure_reason = f"Container did not become ready within {timeout}s"
+
+    def log_worker(result: dict):
+        try:
+            for line in container.logs(stream=True, follow=True):
+                log_line = line.decode("utf-8").strip()
+                if CONTAINER_READY_MESSAGE in log_line:
+                    result["found"] = True
+                    break
+        except DockerException:
+            result["error"] = "Docker error while streaming logs"
+        except Exception as e:
+            result["error"] = "Unexpected error while streaming logs"
+            logger.exception(e)
+
+    result: dict[str, bool | str] = {"found": False}
+    thread = threading.Thread(target=log_worker, args=(result,), daemon=True)
+    thread.start()
+    thread.join(timeout)  # Wait up to timeout seconds
+
+    if result.get("error"):
+        failure_reason = result["error"]  # type: ignore
+        stop_container(container)
+    elif result.get("found"):
+        line_found = True
+    else:
+        # Thread timed out without finding the message
+        stop_container(container)
+
+    try:
+        if hasattr(client, "close"):
+            client.close()
+    except Exception:
+        logger.exception("Error closing Docker client after waiting for container")
+
+    socketio.emit(
+        "simulation_result",
+        {
+            "success": line_found,
+            "running": line_found,
+            "connect": bool(connect) and line_found,
+            "port": port,
+            "message": "Simulation started" if line_found else failure_reason,
+        },
+    )
+
+
+def validate_ports(
+    ports: Optional[list[dict[str, Any]]]
+) -> Tuple[dict[str, str], Optional[int]]:
+    """
+    Construct the validated port mappings and primary host port
+    """
+    if not ports or not isinstance(ports, list):
+        raise ValueError("At least one port mapping is required")
+
+    validated_ports = {}
+    seen_host_ports = set()
+    seen_container_ports = set()
+    primary_host_port = None
+
+    for i, port in enumerate(ports):
+        if not isinstance(port, dict):
+            raise ValueError(f"Port entry {i + 1} is invalid")
+
+        host_port = validate_port(i, port.get("hostPort"), 1025, 65535)
+
+        if host_port in seen_host_ports:
+            raise ValueError(f"Duplicate host port detected: {host_port}")
+        seen_host_ports.add(host_port)
+
+        container_port = validate_port(i, port.get("containerPort"), 1, 65535)
+
+        if container_port in seen_container_ports:
+            raise ValueError(f"Duplicate container port detected: {container_port}")
+        seen_container_ports.add(container_port)
+
+        if primary_host_port is None:
+            primary_host_port = host_port
+
+        # Convert back to string because that's what Docker expects
+        validated_ports[str(container_port)] = str(host_port)
+
+    return validated_ports, primary_host_port
+
+
+def validate_port(i: int, port: Any, lower: int, upper: int) -> int:
+    """
+    Ensure that the given port is not none, an int and in the correct range.
+    NOTE: does not check that the port is actually available.
+    """
+    if port is None:
+        raise ValueError(f"Port entry {i + 1} is missing")
+
+    try:
+        port = int(port)
+    except (TypeError, ValueError) as e:
+        raise ValueError(f"Port entry {i + 1} must be an integer") from e
+
+    if not (lower <= port <= upper):
+        raise ValueError(f"Port entry {i + 1} must be between {lower} and {upper}")
+
+    return port
+
+
+@socketio.on("start_docker_simulation")
+def start_docker_simulation(data: SimulationStartType) -> None:
+    """
+    Starts the container identified by CONTAINER_NAME.
+
+    Args:
+        data: The parameters that the simulator should start with.
+    """
+    client = None
+
+    try:
+        validated_ports, primary_host_port = validate_ports(data.get("ports"))
+
+        connect = data.get("connect", False)
+        params: CommandParametersType = {"vehicleType": data.get("vehicleType")}
+        cmd = build_command(params)
+
+        client = get_docker_client()
+        ensure_image_exists(client, IMAGE_NAME)
+
+        if container_already_running(client, CONTAINER_NAME):
+            return
+
+        container = client.containers.run(
+            IMAGE_NAME,
+            name=CONTAINER_NAME,
+            ports=validated_ports,
+            detach=True,
+            remove=True,
+            command=cmd,
+        )
+
+        socketio.start_background_task(
+            wait_for_container_connection_msg,
+            client,
+            container,
+            connect,
+            primary_host_port,
+            CONTAINER_START_TIMEOUT,
+        )
+
+        client = None  # ownership transferred
+
+    except ValueError as e:
+        emit_error_message(str(e))
+    except SimulationError as e:
+        emit_error_message(e.user_message)
+        if e.original_exception:
+            logger.exception(e)
+    except APIError as e:
+        emit_error_message("Simulation failed to start: Docker API error")
+        logger.exception(e)
+    except DockerException as e:
+        emit_error_message("Simulation failed to start: Docker exception")
+        logger.exception(e)
+
+    finally:
+        if client is not None:
+            client.close()
+
+
+@socketio.on("stop_docker_simulation")
+def stop_docker_simulation() -> None:
+    """
+    Stops the running Docker container identified by CONTAINER_NAME.
+    """
+    try:
+        client = get_docker_client()
+    except SimulationError as e:
+        emit_error_message(e.user_message)
+        if e.original_exception:
+            logger.exception(e)
+        return
+
+    try:
+        container = client.containers.get(CONTAINER_NAME)
+        container.stop(timeout=CONTAINER_STOP_TIMEOUT)
+
+        socketio.emit(
+            "simulation_result",
+            {"success": True, "running": False, "message": "Simulation stopped"},
+        )
+
+    except NotFound as e:
+        emit_error_message("Simulation container could not be found")
+        logger.exception(e)
+    except DockerException as e:
+        emit_error_message("Docker error while stopping simulation")
+        logger.exception(e)
+
+    finally:
+        if client is not None:
+            client.close()
+
+
+def emit_error_message(message: str) -> None:
+    """
+    Emits the given message on "simulation_result" alongside false for success and running.
+
+    Args:
+        message: The message to be included in the emit.
+    """
+    socketio.emit(
+        "simulation_result",
+        {
+            "success": False,
+            "running": False,
+            "message": message,
+        },
+    )
diff --git a/radio/mypy.ini b/radio/mypy.ini
index 976a1bdc4..b99ebf7e3 100644
--- a/radio/mypy.ini
+++ b/radio/mypy.ini
@@ -11,3 +11,5 @@ ignore_missing_imports = True
 ignore_missing_imports = True
 [mypy-pytest.*]
 ignore_missing_imports = True
+[mypy-docker.*]
+ignore_missing_imports = True
diff --git a/radio/requirements.txt b/radio/requirements.txt
index d297acc10..9f628a0de 100644
--- a/radio/requirements.txt
+++ b/radio/requirements.txt
@@ -12,6 +12,7 @@ click==8.1.7
 colorama==0.4.6
 coverage==7.12.0
 distlib==0.3.7
+docker==7.1.0
 fastjsonschema==2.19.1
 filelock==3.13.1
 Flask==3.0.0