diff --git a/apps/client/src/common/api/sync.ts b/apps/client/src/common/api/sync.ts
new file mode 100644
index 0000000000..12690aed28
--- /dev/null
+++ b/apps/client/src/common/api/sync.ts
@@ -0,0 +1,18 @@
+import axios from 'axios';
+import { SyncClientList, SyncHostConnectionRequest } from 'ontime-types';
+
+import { apiEntryUrl } from './constants';
+
+const syncPath = `${apiEntryUrl}/sync`;
+
+/**
+ * HTTP request to retrieve application info
+ */
+export async function getSyncList(): Promise<SyncClientList> {
+  const res = await axios.get(`${syncPath}/list`);
+  return res.data;
+}
+
+export async function connectToHost(settings: SyncHostConnectionRequest) {
+  await axios.post(`${syncPath}/connect`, settings);
+}
diff --git a/apps/client/src/common/hooks-query/useAppVersion.ts b/apps/client/src/common/hooks-query/useAppVersion.ts
index 399380b8d8..c002944330 100644
--- a/apps/client/src/common/hooks-query/useAppVersion.ts
+++ b/apps/client/src/common/hooks-query/useAppVersion.ts
@@ -1,34 +1,34 @@
-import { useQuery } from '@tanstack/react-query';
-import { dayInMs } from 'ontime-utils';
-
-import { version } from '../../../../../package.json';
-import { isLocalhost } from '../../externals';
-import { APP_VERSION } from '../api/constants';
-import { getLatestVersion, HasUpdate } from '../api/external';
-
-const placeholder: HasUpdate & { hasUpdates: boolean } = { url: '', version: '', hasUpdates: false };
-
-export default function useAppVersion() {
-  const {
-    data: fetchData,
-    status,
-    isFetching,
-    isError,
-    refetch,
-  } = useQuery({
-    queryKey: APP_VERSION,
-    queryFn: getLatestVersion,
-    placeholderData: (previousData, _previousQuery) => previousData,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    retry: false,
-    staleTime: dayInMs,
-    enabled: isLocalhost,
-  });
-
-  const hasUpdates = fetchData?.version && !fetchData.version.includes(version);
-
-  const data = fetchData ? { ...fetchData, hasUpdates } : placeholder;
-
-  return { data, placeholder, status, isFetching, isError, refetch };
-}
+import { useQuery } from '@tanstack/react-query';
+import { dayInMs } from 'ontime-utils';
+
+import { version } from '../../../../../package.json';
+import { isLocalhost } from '../../externals';
+import { APP_VERSION } from '../api/constants';
+import { getLatestVersion, HasUpdate } from '../api/external';
+
+const placeholder: HasUpdate & { hasUpdates: boolean } = { url: '', version: '', hasUpdates: false };
+
+export default function useAppVersion() {
+  const {
+    data: fetchData,
+    status,
+    isFetching,
+    isError,
+    refetch,
+  } = useQuery({
+    queryKey: APP_VERSION,
+    queryFn: getLatestVersion,
+    placeholderData: (previousData, _previousQuery) => previousData,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    retry: false,
+    staleTime: dayInMs,
+    enabled: isLocalhost,
+  });
+
+  const hasUpdates = fetchData?.version && !fetchData.version.includes(version);
+
+  const data = fetchData ? { ...fetchData, hasUpdates } : placeholder;
+
+  return { data, placeholder, status, isFetching, isError, refetch };
+}
diff --git a/apps/client/src/common/hooks-query/useSync.ts b/apps/client/src/common/hooks-query/useSync.ts
new file mode 100644
index 0000000000..73393f16ce
--- /dev/null
+++ b/apps/client/src/common/hooks-query/useSync.ts
@@ -0,0 +1,13 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { getSyncList } from '../api/sync';
+
+export function useSync() {
+  const { data, status, isError, refetch, isLoading } = useQuery({
+    queryKey: ['sync-client-list'],
+    queryFn: getSyncList,
+    placeholderData: (previousData, _previousQuery) => previousData,
+  });
+
+  return { list: data ?? [], status, isError, refetch, isLoading };
+}
diff --git a/apps/client/src/common/utils/socket.ts b/apps/client/src/common/utils/socket.ts
index c655443ceb..ce070385c0 100644
--- a/apps/client/src/common/utils/socket.ts
+++ b/apps/client/src/common/utils/socket.ts
@@ -182,7 +182,7 @@ export const connectSocket = () => {
               ontimeQueryClient.invalidateQueries({ queryKey: APP_SETTINGS });
               break;
             default: {
-              target satisfies never;
+              target satisfies never | RefetchKey.RestorePoint;
               break;
             }
           }
diff --git a/apps/client/src/features/app-settings/AppSettings.tsx b/apps/client/src/features/app-settings/AppSettings.tsx
index 90e4931cd0..262db0d735 100644
--- a/apps/client/src/features/app-settings/AppSettings.tsx
+++ b/apps/client/src/features/app-settings/AppSettings.tsx
@@ -10,6 +10,7 @@ import NetworkLogPanel from './panel/network-panel/NetworkLogPanel';
 import ProjectPanel from './panel/project-panel/ProjectPanel';
 import SettingsPanel from './panel/settings-panel/SettingsPanel';
 import ShutdownPanel from './panel/shutdown-panel/ShutdownPanel';
+import Sync from './panel/sync-panel/SyncPanel';
 import PanelContent from './panel-content/PanelContent';
 import PanelList from './panel-list/PanelList';
 import useAppSettingsNavigation from './useAppSettingsNavigation';
@@ -33,6 +34,7 @@ export default function AppSettings() {
           {panel === 'network' && <NetworkLogPanel location={location} />}
           {panel === 'about' && <AboutPanel />}
           {panel === 'shutdown' && <ShutdownPanel />}
+          {panel === 'sync' && <Sync />}
         </PanelContent>
       </ErrorBoundary>
     </div>
diff --git a/apps/client/src/features/app-settings/panel/sync-panel/SyncPanel.tsx b/apps/client/src/features/app-settings/panel/sync-panel/SyncPanel.tsx
new file mode 100644
index 0000000000..e8c7206efe
--- /dev/null
+++ b/apps/client/src/features/app-settings/panel/sync-panel/SyncPanel.tsx
@@ -0,0 +1,180 @@
+import { useForm } from 'react-hook-form';
+import { SyncHostConnectionRequest, SyncRoll } from 'ontime-types';
+
+import { connectToHost } from '../../../../common/api/sync';
+import { maybeAxiosError } from '../../../../common/api/utils';
+import Button from '../../../../common/components/buttons/Button';
+import Input from '../../../../common/components/input/input/Input';
+import Select from '../../../../common/components/select/Select';
+import { useSync } from '../../../../common/hooks-query/useSync';
+import { preventEscape } from '../../../../common/utils/keyEvent';
+import * as Panel from '../../panel-utils/PanelUtils';
+
+export default function Sync() {
+  const { list, refetch, isLoading } = useSync();
+  const {
+    handleSubmit,
+    register,
+    reset,
+    setError,
+    watch,
+    setValue,
+    formState: { isSubmitting, isDirty, isValid, errors },
+  } = useForm<SyncHostConnectionRequest>({
+    mode: 'onChange',
+    defaultValues: { host: 'http://127.0.0.1:4003', roll: SyncRoll.Listener },
+    resetOptions: {
+      keepDirtyValues: true,
+    },
+  });
+
+  const onSubmit = async (formData: SyncHostConnectionRequest) => {
+    try {
+      await connectToHost(formData);
+    } catch (error) {
+      const message = maybeAxiosError(error);
+      setError('root', { message });
+    } finally {
+      await refetch();
+    }
+  };
+
+  const submitError = '';
+  const disableSubmit = isSubmitting || !isValid;
+
+  const onReset = () => {
+    reset();
+  };
+
+  return (
+    <>
+      <Panel.Header>Machine Synchronization</Panel.Header>
+
+      {list.length === 0 && (
+        <Panel.Section
+          as='form'
+          onSubmit={handleSubmit(onSubmit)}
+          onKeyDown={(event) => preventEscape(event, onReset)}
+          id='sync-settings'
+        >
+          <Panel.Card>
+            <Panel.SubHeader>
+              Connect to a host
+              <Panel.InlineElements>
+                <Button disabled={!isDirty || isSubmitting} variant='ghosted' onClick={onReset}>
+                  Reset
+                </Button>
+                <Button
+                  type='submit'
+                  form='sync-settings'
+                  name='sync-settings-submit'
+                  loading={isSubmitting}
+                  disabled={disableSubmit}
+                  variant='primary'
+                >
+                  Connect
+                </Button>
+              </Panel.InlineElements>
+            </Panel.SubHeader>
+            {submitError && <Panel.Error>{submitError}</Panel.Error>}
+            <Panel.Divider />
+            <Panel.Section>
+              <Panel.Loader isLoading={isLoading} />
+              <Panel.ListGroup>
+                <Panel.ListItem>
+                  <Panel.Field title='Host' description='URL of the host ' error={errors.host?.message} />
+                  <Input
+                    id='host'
+                    type='text'
+                    style={{ width: '275px' }}
+                    {...register('host', {
+                      required: { value: true, message: 'Required field' },
+                    })}
+                  />
+                </Panel.ListItem>
+                <Panel.ListItem>
+                  <Panel.Field
+                    title='Roll'
+                    description='Select whether to push or pull the project from the host'
+                    error={errors.roll?.message}
+                  />
+                  <Select
+                    value={watch('roll')}
+                    onValueChange={(value: SyncRoll | null) => {
+                      if (value === null) return;
+                      setValue('roll', value, { shouldDirty: true });
+                    }}
+                    options={[
+                      { value: SyncRoll.Controller, label: 'Controller' },
+                      { value: SyncRoll.Listener, label: 'Listener' },
+                    ]}
+                  />
+                </Panel.ListItem>
+              </Panel.ListGroup>
+            </Panel.Section>
+          </Panel.Card>
+        </Panel.Section>
+      )}
+      {list.length > 0 && (
+        <Panel.Section>
+          <Panel.Card>
+            <Panel.SubHeader>
+              Connect to a host
+              <Panel.InlineElements>
+                <Button disabled={!isDirty || isSubmitting} variant='ghosted' onClick={onReset}>
+                  Reset
+                </Button>
+                <Button
+                  type='submit'
+                  form='sync-settings'
+                  name='sync-settings-submit'
+                  loading={isSubmitting}
+                  disabled={disableSubmit}
+                  variant='primary'
+                >
+                  Connect
+                </Button>
+              </Panel.InlineElements>
+            </Panel.SubHeader>
+            <Panel.Description>Description</Panel.Description>
+            <Panel.Table>
+              <thead>
+                <tr>
+                  <td>Client Name</td>
+                  <td>Roll</td>
+                  <td>Action</td>
+                  <td>Host</td>
+                </tr>
+              </thead>
+              <tbody>
+                {list.map(({ id, name, roll, host }) => {
+                  const isController = roll === SyncRoll.Controller;
+                  const hostName = list.find(({ id }) => id === host)?.name;
+                  return (
+                    <tr key={id}>
+                      <td> {name}</td>
+                      <td> {roll}</td>
+                      <Panel.InlineElements relation='inner' as='td'>
+                        <Button
+                          size='small'
+                          disabled={isController}
+                          variant='primary'
+                          onClick={() => {
+                            console.log('click');
+                          }}
+                        >
+                          Promote To Controller
+                        </Button>
+                      </Panel.InlineElements>
+                      <td> {hostName}</td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </Panel.Table>
+          </Panel.Card>
+        </Panel.Section>
+      )}
+    </>
+  );
+}
diff --git a/apps/server/package.json b/apps/server/package.json
index 07297d66a6..67649ddaa4 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -52,6 +52,8 @@
     "dev": "cross-env NODE_ENV=development tsx watch ./src/index.ts",
     "dev:electron": "pnpm dev",
     "dev:inspect": "cross-env NODE_ENV=development tsx watch --inspect ./src/index.ts",
+    "dev:synchost": "cross-env NODE_ENV=development HOST_SYNC=true PORT=4003 ONTIME_DATA=../../ontime-db tsx watch ./src/index.ts",
+
 
     "lint": "eslint . --quiet",
     "typecheck": "tsc --noEmit",
diff --git a/apps/server/src/adapters/WebsocketAdapter.ts b/apps/server/src/adapters/WebsocketAdapter.ts
index 036e7cd441..6e45e97cbe 100644
--- a/apps/server/src/adapters/WebsocketAdapter.ts
+++ b/apps/server/src/adapters/WebsocketAdapter.ts
@@ -34,6 +34,7 @@ import { logger } from '../classes/Logger.js';
 import { dispatchFromAdapter } from '../api-integration/integration.controller.js';
 import { generateId } from 'ontime-utils';
 import { authenticateSocket } from '../middleware/authenticate.js';
+import { syncService } from '../api-data/sync/sync.service.js';
 
 type ClientId = string;
 let instance: SocketServer | null = null;
@@ -115,10 +116,17 @@ class SocketServer implements IAdapter {
             case MessageTag.ClientSet: {
               const previousData = this.getOrCreateClient(clientId);
               const updatedClient = { ...previousData, ...payload };
-              this.clients.set(clientId, updatedClient);
-              if (this.shouldShowWelcome && updatedClient.path?.toLowerCase().includes('editor')) {
-                this.shouldShowWelcome = false;
-                sendPacket(MessageTag.Dialog, { dialog: 'welcome' });
+              if (updatedClient.type === 'sync') {
+                ws.removeAllListeners('message');
+                ws.removeAllListeners('close');
+                syncService.handleIncomingWsConnection(ws, clientId, updatedClient);
+                this.clients.delete(clientId);
+              } else {
+                this.clients.set(clientId, updatedClient);
+                if (this.shouldShowWelcome && updatedClient.path?.toLowerCase().includes('editor')) {
+                  this.shouldShowWelcome = false;
+                  sendPacket(MessageTag.Dialog, { dialog: 'welcome' });
+                }
               }
               this.sendClientList();
               break;
@@ -246,5 +254,6 @@ export const socket = new SocketServer();
  * Utility function to notify clients that the REST data is stale
  */
 export function sendRefetch(target: RefetchKey, revision: MaybeNumber = null) {
+  syncService.handleRefetch(target);
   socket.sendAsJson(MessageTag.Refetch, { target, revision });
 }
diff --git a/apps/server/src/api-data/index.ts b/apps/server/src/api-data/index.ts
index 388bdf92fc..d2bbb152ab 100644
--- a/apps/server/src/api-data/index.ts
+++ b/apps/server/src/api-data/index.ts
@@ -13,6 +13,7 @@ import { router as sessionRouter } from './session/session.router.js';
 import { router as viewSettingsRouter } from './view-settings/viewSettings.router.js';
 import { router as reportRouter } from './report/report.router.js';
 import { router as assetsRouter } from './assets/assets.router.js';
+import { router as syncRouter } from './sync/sync.router.js';
 
 export const appRouter = express.Router();
 
@@ -29,6 +30,7 @@ appRouter.use('/session', sessionRouter);
 appRouter.use('/view-settings', viewSettingsRouter);
 appRouter.use('/report', reportRouter);
 appRouter.use('/assets', assetsRouter);
+appRouter.use('/sync', syncRouter);
 
 // we don't want to redirect to react index when using api routes
 appRouter.all('/*splat', (_req, res) => {
diff --git a/apps/server/src/api-data/rundown/rundown.router.ts b/apps/server/src/api-data/rundown/rundown.router.ts
index 1e711cf5ec..fbb8ebcc4e 100644
--- a/apps/server/src/api-data/rundown/rundown.router.ts
+++ b/apps/server/src/api-data/rundown/rundown.router.ts
@@ -22,6 +22,7 @@ import {
   initRundown,
   reorderEntry,
   swapEvents,
+  loadRundown,
   ungroupEntries,
 } from './rundown.service.js';
 import {
@@ -62,19 +63,7 @@ router.get('/current', async (_req: Request, res: Response<Rundown>) => {
  */
 router.post('/:id/load', paramsWithId, async (req: Request, res: Response<ProjectRundownsList | ErrorResponse>) => {
   try {
-    // maybe the rundown is already loaded
-    if (req.params.id === getCurrentRundown().id) {
-      const projectRundowns = getDataProvider().getProjectRundowns();
-      res.status(200).json({ loaded: getCurrentRundown().id, rundowns: normalisedToRundownArray(projectRundowns) });
-      return;
-    }
-
-    const dataProvider = getDataProvider();
-    const rundown = dataProvider.getRundown(req.params.id);
-    const customField = dataProvider.getCustomFields();
-    await initRundown(rundown, customField);
-
-    const projectRundowns = getDataProvider().getProjectRundowns();
+    const projectRundowns = await loadRundown(req.params.id);
     res.status(200).json({ loaded: getCurrentRundown().id, rundowns: normalisedToRundownArray(projectRundowns) });
   } catch (error) {
     const message = getErrorMessage(error);
diff --git a/apps/server/src/api-data/rundown/rundown.service.ts b/apps/server/src/api-data/rundown/rundown.service.ts
index fc84223897..3bbf78a427 100644
--- a/apps/server/src/api-data/rundown/rundown.service.ts
+++ b/apps/server/src/api-data/rundown/rundown.service.ts
@@ -27,12 +27,14 @@ import { logger } from '../../classes/Logger.js';
 import {
   createTransaction,
   customFieldMutation,
+  getCurrentRundown,
   rundownCache,
   rundownMutation,
   updateBackgroundRundown,
 } from './rundown.dao.js';
 import type { RundownMetadata } from './rundown.types.js';
 import { generateEvent, getInsertAfterId, hasChanges } from './rundown.utils.js';
+import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
 
 /**
  * creates a new entry with given data
@@ -596,6 +598,20 @@ function notifyChanges(rundownMetadata: RundownMetadata, revision: number, optio
   }
 }
 
+/**
+ * @throws if the provided id dose not exist
+ */
+export async function loadRundown(id: string) {
+  const dataProvider = getDataProvider();
+  if (id === getCurrentRundown().id) {
+    return dataProvider.getProjectRundowns();
+  }
+  const rundown = dataProvider.getRundown(id);
+  const customField = dataProvider.getCustomFields();
+  await initRundown(rundown, customField);
+  return dataProvider.getProjectRundowns();
+}
+
 /**
  * Sets a new rundown in the cache
  * and marks it as the currently loaded one
diff --git a/apps/server/src/api-data/sync/sync.router.ts b/apps/server/src/api-data/sync/sync.router.ts
new file mode 100644
index 0000000000..8d253753b3
--- /dev/null
+++ b/apps/server/src/api-data/sync/sync.router.ts
@@ -0,0 +1,46 @@
+import express from 'express';
+import type { Request, Response } from 'express';
+
+export const router = express.Router();
+
+import { body } from 'express-validator';
+
+import { requestValidationFunction } from '../validation-utils/validationFunction.js';
+import { syncService } from './sync.service.js';
+import { getErrorMessage } from 'ontime-utils';
+import { consoleError } from '../../utils/console.js';
+import { SyncClientList, SyncRoll } from 'ontime-types';
+
+/**
+ * validate array of URL preset objects
+ */
+export const validateDirector = [
+  body().isObject().withMessage('No data found in request'),
+  body('host').isString().trim().notEmpty().isURL(),
+  body('roll').isString().isIn(Object.values(SyncRoll)),
+  requestValidationFunction,
+];
+
+router.post('/connect', validateDirector, async (req: Request, res: Response) => {
+  const { host, roll } = req.body;
+  try {
+    if (await syncService.connect(host, roll)) {
+      res.sendStatus(200);
+    } else {
+      res.status(422).send('Failed health check');
+    }
+  } catch (error) {
+    const message = getErrorMessage(error);
+    consoleError(message);
+    res.status(500).send(message);
+  }
+});
+
+router.post('/disconnect', async (_req: Request, res: Response) => {
+  await syncService.disconnect();
+  res.sendStatus(204);
+});
+
+router.get('/list', async (_req: Request, res: Response<SyncClientList>) => {
+  res.status(200).send(syncService.getClientList());
+});
diff --git a/apps/server/src/api-data/sync/sync.service.ts b/apps/server/src/api-data/sync/sync.service.ts
new file mode 100644
index 0000000000..5937d64f3f
--- /dev/null
+++ b/apps/server/src/api-data/sync/sync.service.ts
@@ -0,0 +1,471 @@
+import { WebSocket } from 'ws';
+import { setSyncHost } from '../../services/app-state-service/AppStateService.js';
+import { generateId } from 'ontime-utils';
+import {
+  Client,
+  CustomFields,
+  DatabaseModel,
+  MessageTag,
+  RefetchKey,
+  Rundown,
+  RuntimeStore,
+  SyncClientList,
+  SyncRoll,
+  WsPacketToClient,
+  WsPacketToServer,
+} from 'ontime-types';
+import { logger } from '../../classes/Logger.js';
+import { shouldCrashDev } from '../../utils/development.js';
+import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
+import { createProjectWithPatch, getCurrentProject } from '../../services/project-service/ProjectService.js';
+import { getCurrentRundown, rundownCache, getProjectCustomFields } from '../rundown/rundown.dao.js';
+import { loadRundown } from '../rundown/rundown.service.js';
+import { sendRefetch } from '../../adapters/WebsocketAdapter.js';
+import { RestorePoint } from '../../services/restore-service/restore.type.js';
+import { restoreService } from '../../services/restore-service/restore.service.js';
+import { runtimeService } from '../../services/runtime-service/runtime.service.js';
+import getRandomName from '../../utils/getRandomName.js';
+import { isSyncHost } from '../../setup/environment.js';
+import { RuntimeState } from '../../stores/runtimeState.js';
+import * as runtimeState from '../../stores/runtimeState.js';
+import { eventStore } from '../../stores/EventStore.js';
+import { dispatchFromAdapter } from '../../api-integration/integration.controller.js';
+/**
+ * Host: a server that waits with an open websocket
+ * Client: a server that reaches out and connects to another servers websocket
+ * Controller: a server that is in charge of the session
+ * Listener: a server that listens to updates in the session
+ */
+
+const SYNC = 'SYNC';
+
+enum SyncTag {
+  List = 'sync-list',
+  Roll = 'sync-roll',
+  RefetchData = 'sync-refetch-data',
+  RuntimeData = 'sync-runtime-data',
+  Api = 'sync-api',
+}
+
+type ClientListPacket = { tag: SyncTag.List; payload: SyncClientList };
+type ClientRollPacket = { tag: SyncTag.Roll; payload: { id: string; roll: SyncRoll } };
+
+type RefetchDataPacket = {
+  tag: SyncTag.RefetchData;
+  payload:
+    | {
+        tag: RefetchKey.All;
+        data: DatabaseModel;
+        filename: string;
+        currentRundown: string;
+        restorePoint: RestorePoint | null;
+      }
+    | { tag: RefetchKey.Rundown; data: { rundown: Rundown; customFields: CustomFields } }
+    | { tag: RefetchKey.CustomFields; data: { rundown: Rundown; customFields: CustomFields } }
+    | { tag: RefetchKey.RestorePoint; data: RestorePoint | null };
+};
+
+type RuntimeDataPacket = { tag: SyncTag.RuntimeData; payload: Readonly<RuntimeState> };
+
+type ApiDataPacket = { tag: SyncTag.Api; payload: { tag: string; payload: unknown } };
+
+type SyncMessage =
+  | ApiDataPacket
+  | ClientListPacket
+  | ClientRollPacket
+  | RefetchDataPacket
+  | RuntimeDataPacket
+  | Extract<WsPacketToClient, { tag: MessageTag.RuntimeData }>
+  | Extract<WsPacketToClient, { tag: MessageTag.ClientInit }>
+  | Extract<WsPacketToServer, { tag: MessageTag.ClientSet }>;
+
+type InternalSyncClient = { name: string; roll: SyncRoll; ws: WebSocket };
+
+// TEST PACKAGES
+// {
+//     "tag": "client-set",
+//     "payload": {
+//         "name": "postman",
+//         "type": "sync"
+//     }
+// }
+// {
+//     "tag": "session-roll",
+//     "payload": "3a9884",
+//     "roll": "controller"
+// }
+
+abstract class SyncService {
+  protected roll = SyncRoll.Controller;
+
+  protected id = generateId();
+  protected name = getRandomName();
+  protected dataProvider = getDataProvider();
+  protected clientList: SyncClientList = [];
+  // protected clientList: SyncClientList = [{ name: this.name, id: this.id, roll: SyncRoll.Unknown, host: null }];
+  protected syncRuntimeStore = eventStore.poll();
+  protected switchRoll(newRoll: SyncRoll) {
+    logger.info(SYNC, `Switching roll to [${newRoll}]`);
+    this.roll = newRoll;
+    eventStore.set('sync', { roll: this.roll });
+  }
+
+  /**
+   * Get the list of all connected to this sync session, is generated by the hosting server
+   */
+  public getClientList() {
+    return this.clientList;
+  }
+
+  /**
+   * get the roll of this server
+   */
+  public isListening() {
+    return this.roll === SyncRoll.Listener;
+  }
+
+  /**
+   * get the runtime sore distributed by this sync session
+   */
+  public getRuntimeStore() {
+    return this.syncRuntimeStore;
+  }
+
+  public abstract forwardIntegrationRequests(tag: string, payload: unknown): void;
+
+  /**
+   * take over a ws connection
+   * only available in host mode
+   */
+  public handleIncomingWsConnection(ws: WebSocket, _id: string, _clientInfo: Client): boolean {
+    logger.warning(SYNC, 'received a connection request but this server dose not support that');
+    ws.close();
+    return false;
+  }
+
+  /**
+   * connect to a sync host
+   * not available in host mode
+   */
+  public async connect(_host: string, _roll: SyncRoll): Promise<boolean> {
+    throw new Error('Can not connect to another host if already designated as host');
+  }
+
+  /**
+   * connect to a sync host
+   * not available in host mode
+   */
+  public async disconnect(): Promise<void> {
+    throw new Error('Can not disconnect from a host if already designated as host');
+  }
+
+  /**
+   * propagate refetch messages
+   */
+  public handleRefetch(_target: RefetchKey) {
+    //TODO:
+  }
+
+  /**
+   * propagate runtime state updates
+   */
+  public handleRuntimeStateUpdate(_state: Readonly<RuntimeState>) {
+    //TODO:
+  }
+
+  public handleRuntimeStoreUpdate(_state: Readonly<RuntimeStore>) {
+    //TODO:
+  }
+
+  protected async generateRefetchData(tag: RefetchKey): Promise<RefetchDataPacket['payload'] | undefined> {
+    // if (this.roll !== SyncRoll.Controller) return;
+    console.log('sending refetch', tag);
+
+    switch (tag) {
+      case RefetchKey.All:
+        return {
+          tag,
+          data: this.dataProvider.getData(),
+          filename: (await getCurrentProject()).filename,
+          currentRundown: getCurrentRundown().id,
+          restorePoint: restoreService.get(),
+        };
+      case RefetchKey.CustomFields:
+      case RefetchKey.Rundown:
+        return { tag, data: { rundown: getCurrentRundown(), customFields: getProjectCustomFields() } };
+      case RefetchKey.RestorePoint:
+        return { tag, data: restoreService.get() };
+      default:
+        //@ts-expect-error - FIXME: should be remove before release
+        tag satisfies never;
+        break;
+    }
+  }
+
+  protected async receiveRefetchData(packet: RefetchDataPacket['payload']) {
+    if (this.roll !== SyncRoll.Listener) {
+      logger.warning(SYNC, 'received a data packet while not in Listener mode');
+      return;
+    }
+    console.log('receiving refetch', packet.tag);
+
+    switch (packet.tag) {
+      case RefetchKey.All: {
+        const { data, filename, currentRundown, restorePoint } = packet;
+        // ensure we don't change the server port
+        data.settings = { ...data.settings, serverPort: this.dataProvider.getSettings().serverPort };
+        await createProjectWithPatch(`[SYNC]${filename}`, data);
+        await loadRundown(currentRundown);
+        runtimeService.init(restorePoint);
+        break;
+      }
+      case RefetchKey.CustomFields:
+      case RefetchKey.Rundown: {
+        const { rundown, customFields } = packet.data;
+        rundownCache.init(rundown, customFields);
+        setImmediate(() => {
+          sendRefetch(RefetchKey.Rundown, rundown.revision);
+          sendRefetch(RefetchKey.CustomFields, rundown.revision);
+        });
+        break;
+      }
+      case RefetchKey.RestorePoint:
+        runtimeService.init(packet.data);
+        break;
+      default:
+        //@ts-expect-error - FIXME: should be remove before release
+        packet.tag satisfies never;
+        break;
+    }
+  }
+
+  protected receiveRuntimeStoreData(packet: Partial<RuntimeStore>) {
+    if (this.roll !== SyncRoll.Listener) {
+      logger.warning(SYNC, 'received a data packet while not in Listener mode');
+      return;
+    }
+    // drop the sync data as we want that to come from inside the server
+    const { sync: _sync, ...rest } = packet;
+    eventStore.createPatch(rest);
+  }
+
+  // protected receiveRuntimeStateData(packet: Partial<RuntimeState>) {
+  //   if (this.roll !== SyncRoll.Listener) {
+  //     logger.warning(SYNC, 'received a data packet while not in Listener mode');
+  //     return;
+  //   }
+  //   this.syncRuntimeStore = { ...this.syncRuntimeStore, ...packet };
+  // }
+
+  /**
+   * send a message to a specific ws socket
+   */
+  protected sendToSpecificSocket<T extends MessageTag | SyncTag>(
+    ws: WebSocket | null,
+    tag: T,
+    payload: Pick<SyncMessage & { tag: T }, 'payload'>['payload'],
+  ) {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    try {
+      const stringifiedMessage = JSON.stringify({ tag, payload });
+      ws.send(stringifiedMessage);
+    } catch (_) {
+      /** We do not handle this error */
+    }
+  }
+}
+
+class SyncServiceClient extends SyncService {
+  private host: URL | null = null;
+  private ws: null | WebSocket = null;
+
+  public forwardIntegrationRequests(tag: string, payload: unknown): void {
+    this.sendToSpecificSocket(this.ws, SyncTag.Api, { tag, payload });
+  }
+
+  async connect(host: string, roll: SyncRoll): Promise<boolean> {
+    const healthCheckUrl = new URL(host);
+    healthCheckUrl.pathname += 'health';
+    const responds = await fetch(healthCheckUrl, { method: 'GET', headers: { 'x-ontime-client': 'server' } });
+    if (!responds.ok) {
+      throw new Error('Failed to helthcheck host server');
+    }
+
+    await setSyncHost(host);
+    this.host = new URL(host);
+    const wsUrl = new URL('ws', this.host);
+    this.ws?.close();
+    this.ws = new WebSocket(wsUrl);
+
+    this.ws.once('open', async () => {
+      logger.info(SYNC, 'connected to host');
+      this.sendToSpecificSocket(this.ws, MessageTag.ClientSet, { name: this.name, type: 'sync' });
+      this.roll = roll;
+    });
+
+    this.ws.once('close', async () => {
+      logger.info(SYNC, 'host disconnected, switching to controller mode');
+      this.switchRoll(SyncRoll.Controller);
+    });
+
+    this.ws.on('message', async (data) => {
+      const msg = JSON.parse(data.toString()) as SyncMessage;
+      const { tag, payload } = msg;
+
+      switch (tag) {
+        case SyncTag.List: {
+          this.clientList = payload;
+          const me = payload.find(({ id }) => id === this.id);
+          if (!me) {
+            throw new Error('This is missing from client list');
+          }
+          this.switchRoll(me.roll);
+          break;
+        }
+        case MessageTag.ClientInit:
+          this.id = payload.clientId;
+          this.sendToSpecificSocket(this.ws, SyncTag.Roll, { id: this.id, roll });
+          break;
+        case MessageTag.RuntimeData:
+          this.receiveRuntimeStoreData(payload);
+          break;
+        case SyncTag.RefetchData:
+          await this.receiveRefetchData(payload);
+          break;
+        case SyncTag.RuntimeData:
+          // this.receiveRuntimeStateData(payload);
+          break;
+        default:
+          tag satisfies never | MessageTag.ClientSet | MessageTag.Refetch | SyncTag.Roll;
+          break;
+      }
+    });
+    return true;
+  }
+}
+
+class SyncServiceHost extends SyncService {
+  private clients = new Map<string, InternalSyncClient>();
+
+  public forwardIntegrationRequests(tag: string, payload: unknown): void {
+    this.propagateMessage(this.id, SyncTag.Api, { tag, payload });
+  }
+
+  public async handleRefetch(key: RefetchKey): Promise<void> {
+    if (this.isListening()) return;
+    const refetchMessage = await this.generateRefetchData(key);
+    if (!refetchMessage) return;
+    this.propagateMessage(this.id, SyncTag.RefetchData, refetchMessage);
+  }
+
+  /**
+   * propagate runtime state updates
+   */
+  public handleRuntimeStateUpdate(_state: Readonly<RuntimeState>) {
+    if (this.isListening()) return;
+    this.propagateMessage(this.id, SyncTag.RuntimeData, runtimeState.getState());
+  }
+
+  /**
+   * Host specific function, takes over the ws connections form the adaptor
+   */
+  handleIncomingWsConnection(ws: WebSocket, id: string, clientInfo: Client) {
+    this.clients.set(id, { name: clientInfo.name, roll: SyncRoll.Unknown, ws });
+    logger.info(SYNC, `client [${id}]${clientInfo.name} joined`);
+    // this.sendToSpecificSocket(ws, SyncTag.Connected, { id });
+    this.propagateMessage(this.id, SyncTag.List, this.generateClientList());
+
+    ws.on('message', async (data) => {
+      const msg = JSON.parse(data.toString()) as SyncMessage;
+      const { tag, payload } = msg;
+      switch (tag) {
+        case SyncTag.Roll: {
+          const { id: selectedId, roll } = payload;
+          const selectedClient = this.clients.get(selectedId);
+          if (roll === SyncRoll.Controller) {
+            throw new Error('TODO: handle SyncRoll.Controller');
+            // for (const [id, client] of clients) {
+            //   if (id === newControllerId) {
+            //     clients.set(id, { ...client, roll: SyncRoll.Controller });
+            //   } else {
+            //     clients.set(id, { ...client, roll: SyncRoll.Listener });
+            //   }
+            // }
+          } else if (roll === SyncRoll.Listener && selectedClient?.roll === SyncRoll.Unknown) {
+            logger.info(
+              SYNC,
+              `client [${id}]${clientInfo.name} switched from [${selectedClient.roll}] to [${SyncRoll.Listener}]`,
+            );
+
+            this.clients.set(selectedId, { ...selectedClient, roll: SyncRoll.Listener });
+            this.propagateMessage(this.id, SyncTag.List, this.generateClientList());
+
+            this.propagateMessage(this.id, SyncTag.RuntimeData, runtimeState.getState());
+            const refetchMessage = await this.generateRefetchData(RefetchKey.All);
+            if (!refetchMessage) throw new Error('Failed to generate refetch message');
+            this.sendToSpecificSocket(selectedClient.ws, SyncTag.RefetchData, refetchMessage);
+          }
+          break;
+        }
+        case SyncTag.Api:
+          dispatchFromAdapter(payload.tag, payload.payload);
+          break;
+        default: {
+          //@ts-expect-error - FIXME: should be remove before release
+          tag satisfies never;
+        }
+      }
+    });
+
+    ws.on('close', () => {
+      const client = this.clients.get(id);
+      if (!client) {
+        logger.error(SYNC, `client [${id}]should exist`);
+        this.clients.delete(id);
+        return;
+      }
+      if (client.roll === SyncRoll.Controller) {
+        logger.warning(SYNC, `controlling client [${id}]${client.name} disconnected, NOW WHAT?`);
+      } else {
+        logger.info(SYNC, `client [${id}]${client.name} disconnected`);
+      }
+      this.clients.delete(id);
+    });
+
+    return true;
+  }
+
+  /**
+   * generate a list of all connected clients
+   */
+  private generateClientList = (): SyncClientList => {
+    const c = Array.from(
+      this.clients.entries().map(([id, { roll, name }]) => {
+        return { id, roll, name, host: this.id };
+      }),
+    );
+    c.push({ id: this.id, roll: this.roll, name: this.name, host: this.id });
+    return c;
+  };
+
+  /**
+   * Propagate messages to all connected clients
+   */
+  private propagateMessage<T extends MessageTag | SyncTag>(
+    srcId: string,
+    tag: T,
+    payload: Pick<SyncMessage & { tag: T }, 'payload'>['payload'],
+  ) {
+    shouldCrashDev(!isSyncHost, 'is not session host');
+    const senderRoll = srcId === this.id ? this.roll : this.clients.get(srcId)?.roll;
+    if (senderRoll === SyncRoll.Controller) {
+      const stringifiedMessage = JSON.stringify({ tag, payload });
+      for (const [id, client] of this.clients) {
+        if (id === srcId) continue;
+        client.ws.send(stringifiedMessage);
+      }
+    }
+  }
+}
+
+export const syncService: SyncService = isSyncHost ? new SyncServiceHost() : new SyncServiceClient();
diff --git a/apps/server/src/api-data/sync/understudy.middleware.ts b/apps/server/src/api-data/sync/understudy.middleware.ts
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/apps/server/src/api-integration/integration.controller.ts b/apps/server/src/api-integration/integration.controller.ts
index 9d9f473933..4da59990a0 100644
--- a/apps/server/src/api-integration/integration.controller.ts
+++ b/apps/server/src/api-integration/integration.controller.ts
@@ -24,10 +24,12 @@ import { coerceEnum } from '../utils/coerceType.js';
 import { editEntry } from '../api-data/rundown/rundown.service.js';
 import { willCauseRegeneration } from '../api-data/rundown/rundown.utils.js';
 import { getCurrentRundown, getProjectCustomFields } from '../api-data/rundown/rundown.dao.js';
+import { syncService } from '../api-data/sync/sync.service.js';
 
 let lastRequest: Date | null = null;
 
 export function dispatchFromAdapter(tag: string, payload: unknown, _source?: 'osc' | 'ws' | 'http') {
+  if (syncService.isListening()) return syncService.forwardIntegrationRequests(tag, payload);
   const action = tag.toLowerCase();
   const handler = actionHandlers[action as ApiActionTag];
   lastRequest = new Date();
diff --git a/apps/server/src/app.ts b/apps/server/src/app.ts
index 9f27afc3a2..e9a4760fd2 100644
--- a/apps/server/src/app.ts
+++ b/apps/server/src/app.ts
@@ -9,7 +9,7 @@ import cookieParser from 'cookie-parser';
 
 // import utils
 import { publicDir, srcDir } from './setup/index.js';
-import { environment, isProduction } from './setup/environment.js';
+import { environment, isProduction, override_port } from './setup/environment.js';
 import { updateRouterPrefix } from './externals.js';
 import { ONTIME_VERSION } from './ONTIME_VERSION.js';
 import { consoleSuccess, consoleHighlight, consoleError } from './utils/console.js';
@@ -182,7 +182,7 @@ export const startServer = async (): Promise<{ message: string; serverPort: numb
   expressServer = http.createServer(app);
 
   // the express server must be started before the socket otherwise the on error event listener will not attach properly
-  const resultPort = await serverTryDesiredPort(expressServer, desiredPort);
+  const resultPort = await serverTryDesiredPort(expressServer, override_port || desiredPort);
   await getDataProvider().setSettings({ ...settings, serverPort: resultPort });
   const showWelcome = await getShowWelcomeDialog();
 
diff --git a/apps/server/src/services/app-state-service/AppStateService.ts b/apps/server/src/services/app-state-service/AppStateService.ts
index 45bfe05d3f..63c8ca83c7 100644
--- a/apps/server/src/services/app-state-service/AppStateService.ts
+++ b/apps/server/src/services/app-state-service/AppStateService.ts
@@ -5,11 +5,13 @@ import { publicFiles } from '../../setup/index.js';
 import { isTest } from '../../setup/environment.js';
 import { isPath } from '../../utils/fileManagement.js';
 import { shouldCrashDev } from '../../utils/development.js';
+import { MaybeString } from 'ontime-types';
 
 interface AppState {
   projectName?: string;
   rundownId?: string;
   showWelcomeDialog?: boolean;
+  syncHost?: MaybeString;
 }
 
 const adapter = new JSONFile<AppState>(publicFiles.appState);
@@ -59,3 +61,16 @@ export async function setShowWelcomeDialog(show: boolean): Promise<boolean> {
   await config.write();
   return show;
 }
+
+export async function getUnderstudy(): Promise<MaybeString> {
+  if (isTest) return null;
+
+  await config.read();
+  return config.data.syncHost ?? null; // default to null
+}
+
+export async function setSyncHost(host: MaybeString): Promise<MaybeString> {
+  config.data.syncHost = host;
+  await config.write();
+  return host;
+}
diff --git a/apps/server/src/services/restore-service/restore.service.ts b/apps/server/src/services/restore-service/restore.service.ts
index 15d647fdfa..5871166cb5 100644
--- a/apps/server/src/services/restore-service/restore.service.ts
+++ b/apps/server/src/services/restore-service/restore.service.ts
@@ -5,6 +5,8 @@ import { publicFiles } from '../../setup/index.js';
 
 import { isRestorePoint } from './restore.parser.js';
 import type { RestorePoint } from './restore.type.js';
+import { sendRefetch } from '../../adapters/WebsocketAdapter.js';
+import { RefetchKey } from 'ontime-types';
 
 let failedCreateAttempts = 0;
 let savedState: RestorePoint | null = null;
@@ -18,8 +20,13 @@ export const restoreService = {
   save,
   load,
   clear,
+  get,
 };
 
+function get() {
+  return savedState;
+}
+
 /**
  * Saves a restore point
  * @param [writeFn=write] - allows overriding the write function for testing
@@ -36,8 +43,9 @@ async function save(data: RestorePoint, writeFn = write) {
   }
 
   try {
-    await writeFn(data);
     savedState = { ...data };
+    await writeFn(data);
+    sendRefetch(RefetchKey.RestorePoint);
     failedCreateAttempts = 0;
   } catch (_error) {
     failedCreateAttempts += 1;
diff --git a/apps/server/src/services/runtime-service/runtime.service.ts b/apps/server/src/services/runtime-service/runtime.service.ts
index 4d10e67cb9..ad91004cb5 100644
--- a/apps/server/src/services/runtime-service/runtime.service.ts
+++ b/apps/server/src/services/runtime-service/runtime.service.ts
@@ -42,6 +42,7 @@ import {
   isNewSecond,
 } from './runtime.utils.js';
 import { RundownMetadata } from '../../api-data/rundown/rundown.types.js';
+import { syncService } from '../../api-data/sync/sync.service.js';
 
 /**
  * Service manages runtime status of app
@@ -661,6 +662,10 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
   descriptor.value = function (...args: any[]) {
     // call the original method and get the state
     const result = originalMethod.apply(this, args);
+
+    // if the sync service is slaved to another server
+    if (syncService.isListening()) return result;
+
     const state = runtimeState.getState();
     const batch = eventStore.createBatch();
 
@@ -765,6 +770,10 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
         });
     }
 
+    // if (batch.hasPendingUpdates()) {
+    //   syncService.handleRuntimeUpdate(state);
+    // }
+
     batch.send();
     return result;
   };
diff --git a/apps/server/src/setup/environment.ts b/apps/server/src/setup/environment.ts
index 7e0c62e801..db4b1b9bcc 100644
--- a/apps/server/src/setup/environment.ts
+++ b/apps/server/src/setup/environment.ts
@@ -5,4 +5,7 @@ export const isTest = Boolean(process.env.IS_TEST);
 export const environment = isTest ? 'test' : env;
 export const isDocker = env === 'docker';
 export const isProduction = isDocker || (env === 'production' && !isTest);
-export const isOntimeCloud = Boolean(process.env.IS_CLOUD);
\ No newline at end of file
+export const isOntimeCloud = Boolean(process.env.IS_CLOUD);
+export const isSyncHost = Boolean(process.env.HOST_SYNC);
+
+export const override_port = process.env.PORT ? Number(process.env.PORT) : undefined;
diff --git a/apps/server/src/stores/EventStore.ts b/apps/server/src/stores/EventStore.ts
index 18134664b8..1d26ced4a8 100644
--- a/apps/server/src/stores/EventStore.ts
+++ b/apps/server/src/stores/EventStore.ts
@@ -36,8 +36,16 @@ export const eventStore = {
         store = { ...store, ...patch };
         socket.sendAsJson(MessageTag.RuntimeData, patch);
       },
+      hasPendingUpdates() {
+        return !isEmptyObject(patch);
+      },
     };
   },
+  createPatch(patch: Partial<RuntimeStore>) {
+    if (isEmptyObject(patch)) return;
+    store = { ...store, ...patch };
+    socket.sendAsJson(MessageTag.RuntimeData, patch);
+  },
   poll() {
     return store as RuntimeStore;
   },
diff --git a/packages/types/src/api/sync/BackendResponse.type.ts b/packages/types/src/api/sync/BackendResponse.type.ts
new file mode 100644
index 0000000000..d2a66b3ee8
--- /dev/null
+++ b/packages/types/src/api/sync/BackendResponse.type.ts
@@ -0,0 +1,5 @@
+import { MaybeString } from '../../utils/utils.type';
+import { SyncRoll } from './wsApi.type';
+
+export type SyncClientList = { id: string; roll: SyncRoll; name: string; host: MaybeString }[];
+export type SyncHostConnectionRequest = {host: string, roll: SyncRoll}
\ No newline at end of file
diff --git a/packages/types/src/api/sync/wsApi.type.ts b/packages/types/src/api/sync/wsApi.type.ts
new file mode 100644
index 0000000000..8a03c03ada
--- /dev/null
+++ b/packages/types/src/api/sync/wsApi.type.ts
@@ -0,0 +1,5 @@
+export enum SyncRoll {
+  Controller = 'controller',
+  Listener = 'listener',
+  Unknown = 'unknown',
+}
diff --git a/packages/types/src/api/websocket/refetch.type.ts b/packages/types/src/api/websocket/refetch.type.ts
index fdaac6b751..5601104bf6 100644
--- a/packages/types/src/api/websocket/refetch.type.ts
+++ b/packages/types/src/api/websocket/refetch.type.ts
@@ -8,4 +8,5 @@ export enum RefetchKey {
   ViewSettings = 'view-settings',
   Translation = 'translation',
   Settings = 'settings',
+  RestorePoint = 'restore-point'
 }
diff --git a/packages/types/src/definitions/Clients.type.ts b/packages/types/src/definitions/Clients.type.ts
index 7d7d80f863..7db6607b6e 100644
--- a/packages/types/src/definitions/Clients.type.ts
+++ b/packages/types/src/definitions/Clients.type.ts
@@ -1,4 +1,4 @@
-export type ClientType = 'unknown' | 'ontime' | string;
+export type ClientType = 'unknown' | 'ontime' | 'sync' | string;
 
 export type Client = {
   name: string;
diff --git a/packages/types/src/definitions/runtime/RuntimeStore.ts b/packages/types/src/definitions/runtime/RuntimeStore.ts
index 00ebaaec8a..d2feb12d34 100644
--- a/packages/types/src/definitions/runtime/RuntimeStore.ts
+++ b/packages/types/src/definitions/runtime/RuntimeStore.ts
@@ -1,3 +1,4 @@
+import { SyncRoll } from '../../api/sync/wsApi.type.js';
 import { SimpleDirection, SimplePlayback } from './AuxTimer.type.js';
 import { OffsetMode } from './Offset.type.js';
 import { Playback } from './Playback.type.js';
@@ -67,4 +68,7 @@ export const runtimeStorePlaceholder: Readonly<RuntimeStore> = {
     playback: SimplePlayback.Stop,
   },
   ping: 1,
+  sync: {
+    roll: SyncRoll.Unknown,
+  },
 };
diff --git a/packages/types/src/definitions/runtime/RuntimeStore.type.ts b/packages/types/src/definitions/runtime/RuntimeStore.type.ts
index d2517c3f64..76f2a5eedc 100644
--- a/packages/types/src/definitions/runtime/RuntimeStore.type.ts
+++ b/packages/types/src/definitions/runtime/RuntimeStore.type.ts
@@ -1,3 +1,4 @@
+import { SyncRoll } from '../../api/sync/wsApi.type.js';
 import type { OntimeEvent, OntimeGroup } from '../core/OntimeEntry.js';
 import type { SimpleTimerState } from './AuxTimer.type.js';
 import type { MessageState } from './MessageControl.type.js';
@@ -32,4 +33,7 @@ export type RuntimeStore = {
 
   // utils
   ping: number;
+  sync: {
+    roll: SyncRoll
+  }
 };
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 4d0bfc7edb..110ca6df6e 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -132,3 +132,7 @@ export type { RGBColour } from './definitions/Colour.type.js';
 
 // Translations
 export { langEn, type TranslationObject } from './translations/index.js';
+
+//Sync
+export { SyncRoll } from './api/sync/wsApi.type.js';
+export type { SyncClientList , SyncHostConnectionRequest} from './api/sync/BackendResponse.type.js';