diff --git a/src/main/ipc.ts b/src/main/ipc.ts
index e69f6402..40c79706 100644
--- a/src/main/ipc.ts
+++ b/src/main/ipc.ts
@@ -35,6 +35,8 @@ import {
   startPhase,
   startPhaseGroup,
   getCurrentTournament,
+  getSelectedSet,
+  setSelectedSetId,
 } from './startgg';
 import { enforceReplays, getReplaysInDir, writeReplays } from './replay';
 import {
@@ -226,26 +228,66 @@ export default function setupIPCs(mainWindow: BrowserWindow): void {
   ipcMain.removeHandler('getCurrentTournament');
   ipcMain.handle('getCurrentTournament', getCurrentTournament);
 
+  ipcMain.removeHandler('getSelectedSet');
+  ipcMain.handle('getSelectedSet', getSelectedSet);
+
+  ipcMain.removeHandler('setSelectedSetId');
+  ipcMain.handle(
+    'setSelectedSetId',
+    async (event: IpcMainInvokeEvent, selectedSetId: number) => {
+      setSelectedSetId(selectedSetId);
+    },
+  );
+
   ipcMain.removeHandler('getTournament');
   ipcMain.handle(
     'getTournament',
-    async (event: IpcMainInvokeEvent, slug: string) => {
+    async (event: IpcMainInvokeEvent, slug: string, recursive: boolean) => {
       if (!sggApiKey) {
         throw new Error('Please set start.gg API key');
       }
 
-      return getTournament(sggApiKey, slug);
+      await getTournament(sggApiKey, slug, recursive);
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
     },
   );
 
   ipcMain.removeHandler('getEvent');
-  ipcMain.handle('getEvent', async (event: IpcMainInvokeEvent, id: number) =>
-    getEvent(id),
+  ipcMain.handle(
+    'getEvent',
+    async (e: IpcMainInvokeEvent, id: number, recursive: boolean) => {
+      if (!sggApiKey) {
+        throw new Error('Please set start.gg API key');
+      }
+
+      await getEvent(sggApiKey, id, recursive);
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
+    },
   );
 
   ipcMain.removeHandler('getPhase');
-  ipcMain.handle('getPhase', async (event: IpcMainInvokeEvent, id: number) =>
-    getPhase(id),
+  ipcMain.handle(
+    'getPhase',
+    async (event: IpcMainInvokeEvent, id: number, recursive: boolean) => {
+      if (!sggApiKey) {
+        throw new Error('Please set start.gg API key');
+      }
+
+      await getPhase(sggApiKey, id, recursive);
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
+    },
   );
 
   ipcMain.removeHandler('getPhaseGroup');
@@ -260,7 +302,12 @@ export default function setupIPCs(mainWindow: BrowserWindow): void {
         throw new Error('Please set start.gg API key');
       }
 
-      return getPhaseGroup(sggApiKey, id, updatedSets);
+      await getPhaseGroup(sggApiKey, id, updatedSets);
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
     },
   );
 
@@ -309,7 +356,11 @@ export default function setupIPCs(mainWindow: BrowserWindow): void {
       }
 
       await startEvent(sggApiKey, id);
-      mainWindow.webContents.send('startggTournament', getCurrentTournament());
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
     },
   );
 
@@ -322,7 +373,11 @@ export default function setupIPCs(mainWindow: BrowserWindow): void {
       }
 
       await startPhase(sggApiKey, id, eventId);
-      mainWindow.webContents.send('startggTournament', getCurrentTournament());
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
     },
   );
 
@@ -340,7 +395,11 @@ export default function setupIPCs(mainWindow: BrowserWindow): void {
       }
 
       await startPhaseGroup(sggApiKey, id, phaseId, eventId);
-      mainWindow.webContents.send('startggTournament', getCurrentTournament());
+      mainWindow.webContents.send(
+        'startggTournament',
+        getSelectedSet(),
+        getCurrentTournament(),
+      );
     },
   );
 
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 8ed23fc5..7bc54d95 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -6,12 +6,9 @@ import {
   Context,
   CopySettings,
   EnforceResult,
-  Event,
   InvalidReplay,
   Mode,
   Output,
-  Phase,
-  PhaseGroup,
   Replay,
   ReportSettings,
   Set,
@@ -55,14 +52,15 @@ const electronHandler = {
   chooseCopyDir: (): Promise<string> => ipcRenderer.invoke('chooseCopyDir'),
   getCurrentTournament: (): Promise<Tournament | undefined> =>
     ipcRenderer.invoke('getCurrentTournament'),
-  getTournament: (slug: string): Promise<Tournament> =>
-    ipcRenderer.invoke('getTournament', slug),
-  getEvent: (id: number): Promise<Event> => ipcRenderer.invoke('getEvent', id),
-  getPhase: (id: number): Promise<Phase> => ipcRenderer.invoke('getPhase', id),
-  getPhaseGroup: (
-    id: number,
-    updatedSets?: Map<number, Set>,
-  ): Promise<PhaseGroup> =>
+  getSelectedSet: (): Promise<Set | undefined> =>
+    ipcRenderer.invoke('getSelectedSet'),
+  getTournament: (slug: string, recursive: boolean): Promise<void> =>
+    ipcRenderer.invoke('getTournament', slug, recursive),
+  getEvent: (id: number, recursive: boolean): Promise<void> =>
+    ipcRenderer.invoke('getEvent', id, recursive),
+  getPhase: (id: number, recursive: boolean): Promise<void> =>
+    ipcRenderer.invoke('getPhase', id, recursive),
+  getPhaseGroup: (id: number, updatedSets?: Map<number, Set>): Promise<void> =>
     ipcRenderer.invoke('getPhaseGroup', id, updatedSets),
   startSet: (id: number): Promise<Set> => ipcRenderer.invoke('startSet', id),
   reportSet: (set: StartggSet): Promise<Set[]> =>
@@ -146,11 +144,14 @@ const electronHandler = {
   onTournament: (
     callback: (
       event: IpcRendererEvent,
+      selectedSet: Set | undefined,
       tournament: Tournament | undefined,
     ) => void,
+    selectedSetId: number,
   ) => {
     ipcRenderer.removeAllListeners('startggTournament');
     ipcRenderer.on('startggTournament', callback);
+    ipcRenderer.invoke('setSelectedSetId', selectedSetId);
   },
   onUsb: (callback: (event: IpcRendererEvent, newDir: string) => void) => {
     ipcRenderer.removeAllListeners('usbstorage');
diff --git a/src/main/startgg.ts b/src/main/startgg.ts
index 7c531382..d32dd36b 100644
--- a/src/main/startgg.ts
+++ b/src/main/startgg.ts
@@ -22,6 +22,8 @@ const phaseIdToPhaseGroupIds = new Map<number, number[]>();
 const idToPhaseGroup = new Map<number, PhaseGroup>();
 const phaseGroupIdToEntrants = new Map<number, Entrant[]>();
 const phaseGroupIdToSets = new Map<number, Sets>();
+const idToSet = new Map<number, Set>();
+let selectedSetId = 0;
 export function getCurrentTournament() {
   if (!currentTournament) {
     return undefined;
@@ -53,6 +55,18 @@ export function getCurrentTournament() {
   return tournament;
 }
 
+export function getSelectedSet() {
+  if (!selectedSetId) {
+    return undefined;
+  }
+
+  return idToSet.get(selectedSetId);
+}
+
+export function setSelectedSetId(id: number) {
+  selectedSetId = id;
+}
+
 async function wrappedFetch(
   input: URL | RequestInfo,
   init?: RequestInit | undefined,
@@ -148,181 +162,6 @@ function getDomain(streamSource: number) {
 
 const playerIdToPronouns = new Map<number, string>();
 const idToStream = new Map<number, Stream>();
-const TOURNAMENT_PARTICIPANTS_QUERY = `
-  query TournamentParticipantsQuery($slug: String, $eventIds: [ID], $page: Int) {
-    tournament(slug: $slug) {
-      participants(query: {page: $page, perPage: 499, filter: {eventIds: $eventIds}}) {
-        pageInfo {
-          totalPages
-        }
-        nodes {
-          player {
-            id
-            user {
-              genderPronoun
-            }
-          }
-        }
-      }
-    }
-  }
-`;
-export async function getTournament(
-  key: string,
-  slug: string,
-): Promise<Tournament> {
-  const response = await wrappedFetch(
-    `https://api.smash.gg/tournament/${slug}?expand[]=event`,
-  );
-  const json = await response.json();
-  const { id, name } = json.entities.tournament;
-  const streamsPromise = wrappedFetch(
-    `https://api.smash.gg/station_queue/${id}`,
-  );
-  const events: Event[] = [];
-  const eventIds: number[] = [];
-  (json.entities.event as Array<any>)
-    .filter((event: any) => {
-      const isMelee = event.videogameId === 1;
-      const isSinglesOrDoubles =
-        event.teamRosterSize === null ||
-        (event.teamRosterSize.minPlayers === 2 &&
-          event.teamRosterSize.maxPlayers === 2);
-      return isMelee && isSinglesOrDoubles;
-    })
-    .forEach((event: any) => {
-      const newEvent: Event = {
-        id: event.id,
-        name: event.name,
-        slug: event.slug,
-        isOnline: event.isOnline,
-        state: event.state,
-        phases: [],
-      };
-      events.push(newEvent);
-      eventIds.push(event.id);
-      idToEvent.set(event.id, newEvent);
-    });
-
-  let nextData;
-  let page = 1;
-  do {
-    // eslint-disable-next-line no-await-in-loop
-    nextData = await fetchGql(key, TOURNAMENT_PARTICIPANTS_QUERY, {
-      page,
-      slug,
-      eventIds: events.map((event) => event.id),
-    });
-    const { nodes } = nextData.tournament.participants;
-    if (Array.isArray(nodes)) {
-      nodes.forEach((participant) => {
-        playerIdToPronouns.set(
-          participant.player.id,
-          participant.player.user?.genderPronoun || '',
-        );
-      });
-    }
-    page += 1;
-  } while (page <= nextData.tournament.participants.pageInfo.totalPages);
-
-  const streamsResponse = await streamsPromise;
-  const streamsJson = await streamsResponse.json();
-  const streams = streamsJson.data?.entities?.stream;
-  if (Array.isArray(streams)) {
-    streams.forEach((stream) => {
-      idToStream.set(stream.id, {
-        domain: getDomain(stream.streamSource),
-        path: stream.streamName,
-      });
-    });
-  }
-
-  currentTournament = { name, slug, events: [] };
-  tournamentSlugToEventIds.set(slug, eventIds);
-  return { name, slug, events };
-}
-
-export async function getEvent(id: number): Promise<Event> {
-  const response = await wrappedFetch(
-    `https://api.smash.gg/event/${id}?expand[]=phase`,
-  );
-  const json = await response.json();
-  const phases: Phase[] = [];
-  const phaseIds: number[] = [];
-  (json.entities.phase as Array<any>).forEach((phase) => {
-    const newPhase: Phase = {
-      id: phase.id,
-      name: phase.name,
-      phaseGroups: [],
-      state: phase.state,
-    };
-    phases.push(newPhase);
-    phaseIds.push(phase.id);
-    idToPhase.set(phase.id, newPhase);
-  });
-  const { event } = json.entities;
-  idToEvent.set(id, {
-    id: event.id,
-    name: event.name,
-    slug: event.slug,
-    isOnline: event.isOnline,
-    state: event.state,
-    phases: [],
-  });
-  eventIdToPhaseIds.set(id, phaseIds);
-  return {
-    id: event.id,
-    name: event.name,
-    slug: event.slug,
-    isOnline: event.isOnline,
-    state: event.state,
-    phases,
-  };
-}
-
-export async function getPhase(id: number): Promise<Phase> {
-  const response = await wrappedFetch(
-    `https://api.smash.gg/phase/${id}?expand[]=groups`,
-  );
-  const json = await response.json();
-  const phaseGroups: PhaseGroup[] = [];
-  const phaseGroupIds: number[] = [];
-  (json.entities.groups as Array<any>)
-    .sort((groupA, groupB) =>
-      groupA.displayIdentifier.localeCompare(groupB.displayIdentifier),
-    )
-    .forEach((group) => {
-      const newPhaseGroup: PhaseGroup = {
-        id: group.id,
-        bracketType: group.groupTypeId,
-        entrants: [],
-        name: group.displayIdentifier,
-        sets: {
-          pendingSets: [],
-          completedSets: [],
-        },
-        state: group.state,
-      };
-      phaseGroups.push(newPhaseGroup);
-      phaseGroupIds.push(group.id);
-      idToPhaseGroup.set(group.id, newPhaseGroup);
-    });
-  const { phase } = json.entities;
-  idToPhase.set(id, {
-    id: phase.id,
-    name: phase.name,
-    state: phase.state,
-    phaseGroups: [],
-  });
-  phaseIdToPhaseGroupIds.set(id, phaseGroupIds);
-  return {
-    id: phase.id,
-    name: phase.name,
-    state: phase.state,
-    phaseGroups,
-  };
-}
-
 const reportedSetIds = new Map<number, boolean>();
 const setIdToOrdinal = new Map<number, number | null>();
 
@@ -483,6 +322,7 @@ export async function getPhaseGroup(
       } else {
         pendingSets.push(newSet);
       }
+      idToSet.set(newSet.id, newSet);
     });
 
     if (missingStreamSets.length > 0) {
@@ -534,6 +374,227 @@ export async function getPhaseGroup(
   };
 }
 
+export async function getPhase(key: string, id: number, recursive: boolean) {
+  const response = await wrappedFetch(
+    `https://api.smash.gg/phase/${id}?expand[]=groups`,
+  );
+  const json = await response.json();
+  const phaseGroups: PhaseGroup[] = [];
+  const phaseGroupIds: number[] = [];
+  (json.entities.groups as Array<any>)
+    .sort((groupA, groupB) =>
+      groupA.displayIdentifier.localeCompare(groupB.displayIdentifier),
+    )
+    .forEach((group) => {
+      const newPhaseGroup: PhaseGroup = {
+        id: group.id,
+        bracketType: group.groupTypeId,
+        entrants: [],
+        name: group.displayIdentifier,
+        sets: {
+          pendingSets: [],
+          completedSets: [],
+        },
+        state: group.state,
+      };
+      phaseGroups.push(newPhaseGroup);
+      phaseGroupIds.push(group.id);
+      idToPhaseGroup.set(group.id, newPhaseGroup);
+    });
+  const { phase } = json.entities;
+  idToPhase.set(id, {
+    id: phase.id,
+    name: phase.name,
+    state: phase.state,
+    phaseGroups: [],
+  });
+  phaseIdToPhaseGroupIds.set(id, phaseGroupIds);
+
+  const phaseGroupIdsWithChildren = phaseGroupIds.filter((phaseGroupId) => {
+    const maybeSets = phaseGroupIdToSets.get(phaseGroupId);
+    return (
+      maybeSets &&
+      (maybeSets.completedSets.length > 0 || maybeSets.pendingSets.length > 0)
+    );
+  });
+  if (recursive) {
+    await Promise.all(
+      phaseGroupIds.map(async (phaseGroupId) =>
+        getPhaseGroup(key, phaseGroupId),
+      ),
+    );
+  } else if (phaseGroupIdsWithChildren.length > 0) {
+    await Promise.all(
+      phaseGroupIdsWithChildren.map(async (phaseGroupId) =>
+        getPhaseGroup(key, phaseGroupId),
+      ),
+    );
+  } else if (phaseGroupIds.length === 1) {
+    await getPhaseGroup(key, phaseGroupIds[0]);
+  }
+}
+
+export async function getEvent(key: string, id: number, recursive: boolean) {
+  const response = await wrappedFetch(
+    `https://api.smash.gg/event/${id}?expand[]=phase`,
+  );
+  const json = await response.json();
+  const phases: Phase[] = [];
+  const phaseIds: number[] = [];
+  (json.entities.phase as Array<any>).forEach((phase) => {
+    const newPhase: Phase = {
+      id: phase.id,
+      name: phase.name,
+      phaseGroups: [],
+      state: phase.state,
+    };
+    phases.push(newPhase);
+    phaseIds.push(phase.id);
+    idToPhase.set(phase.id, newPhase);
+  });
+  const { event } = json.entities;
+  idToEvent.set(id, {
+    id: event.id,
+    name: event.name,
+    slug: event.slug,
+    isOnline: event.isOnline,
+    state: event.state,
+    phases: [],
+  });
+  eventIdToPhaseIds.set(id, phaseIds);
+
+  const phaseIdsWithChildren = phaseIds.filter((phaseId) => {
+    const maybePhaseGroupIds = phaseIdToPhaseGroupIds.get(phaseId);
+    return maybePhaseGroupIds && maybePhaseGroupIds.length > 0;
+  });
+  if (recursive) {
+    await Promise.all(
+      phaseIds.map(async (phaseId) => getPhase(key, phaseId, recursive)),
+    );
+  } else if (phaseIdsWithChildren.length > 0) {
+    await Promise.all(
+      phaseIdsWithChildren.map(async (phaseId) =>
+        getPhase(key, phaseId, recursive),
+      ),
+    );
+  } else if (phaseIds.length === 1) {
+    await getPhase(key, phaseIds[0], recursive);
+  }
+}
+const TOURNAMENT_PARTICIPANTS_QUERY = `
+  query TournamentParticipantsQuery($slug: String, $eventIds: [ID], $page: Int) {
+    tournament(slug: $slug) {
+      participants(query: {page: $page, perPage: 499, filter: {eventIds: $eventIds}}) {
+        pageInfo {
+          totalPages
+        }
+        nodes {
+          player {
+            id
+            user {
+              genderPronoun
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+export async function getTournament(
+  key: string,
+  slug: string,
+  recursive: boolean,
+) {
+  const response = await wrappedFetch(
+    `https://api.smash.gg/tournament/${slug}?expand[]=event`,
+  );
+  const json = await response.json();
+  const { id, name } = json.entities.tournament;
+  const events: Event[] = [];
+  const eventIds: number[] = [];
+  (json.entities.event as Array<any>)
+    .filter((event: any) => {
+      const isMelee = event.videogameId === 1;
+      const isSinglesOrDoubles =
+        event.teamRosterSize === null ||
+        (event.teamRosterSize.minPlayers === 2 &&
+          event.teamRosterSize.maxPlayers === 2);
+      return isMelee && isSinglesOrDoubles;
+    })
+    .forEach((event: any) => {
+      const newEvent: Event = {
+        id: event.id,
+        name: event.name,
+        slug: event.slug,
+        isOnline: event.isOnline,
+        state: event.state,
+        phases: [],
+      };
+      events.push(newEvent);
+      eventIds.push(event.id);
+      idToEvent.set(event.id, newEvent);
+    });
+
+  const eventIdsWithChildren = eventIds.filter((eventId) => {
+    const maybePhaseIds = eventIdToPhaseIds.get(eventId);
+    return maybePhaseIds && maybePhaseIds.length > 0;
+  });
+
+  if (eventIdsWithChildren.length === 0) {
+    const streamsPromise = wrappedFetch(
+      `https://api.smash.gg/station_queue/${id}`,
+    );
+    let nextData;
+    let page = 1;
+    do {
+      // eslint-disable-next-line no-await-in-loop
+      nextData = await fetchGql(key, TOURNAMENT_PARTICIPANTS_QUERY, {
+        page,
+        slug,
+        eventIds: events.map((event) => event.id),
+      });
+      const { nodes } = nextData.tournament.participants;
+      if (Array.isArray(nodes)) {
+        nodes.forEach((participant) => {
+          playerIdToPronouns.set(
+            participant.player.id,
+            participant.player.user?.genderPronoun || '',
+          );
+        });
+      }
+      page += 1;
+    } while (page <= nextData.tournament.participants.pageInfo.totalPages);
+
+    const streamsResponse = await streamsPromise;
+    const streamsJson = await streamsResponse.json();
+    const streams = streamsJson.data?.entities?.stream;
+    if (Array.isArray(streams)) {
+      streams.forEach((stream) => {
+        idToStream.set(stream.id, {
+          domain: getDomain(stream.streamSource),
+          path: stream.streamName,
+        });
+      });
+    }
+  }
+
+  currentTournament = { name, slug, events: [] };
+  tournamentSlugToEventIds.set(slug, eventIds);
+  if (recursive) {
+    await Promise.all(
+      eventIds.map(async (eventId) => getEvent(key, eventId, recursive)),
+    );
+  } else if (eventIdsWithChildren.length > 0) {
+    await Promise.all(
+      eventIdsWithChildren.map(async (eventId) =>
+        getEvent(key, eventId, recursive),
+      ),
+    );
+  } else if (eventIds.length === 1) {
+    await getEvent(key, eventIds[0], recursive);
+  }
+}
+
 const GQL_SET_INNER = `
   id
   fullRoundText
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index ddb36dde..f3e704a7 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -39,13 +39,10 @@ import {
   ContextScore,
   ContextSlot,
   CopySettings,
-  Event,
   GuideState,
   InvalidReplay,
   Mode,
   Output,
-  Phase,
-  PhaseGroup,
   PlayerOverrides,
   Replay,
   ReportSettings,
@@ -185,6 +182,7 @@ function Hello() {
   const [dir, setDir] = useState('');
   const [dirInit, setDirInit] = useState(false);
   const [copyDir, setCopyDir] = useState('');
+  const [selectedSet, setSelectedSet] = useState<Set>(EMPTY_SET);
   const [slug, setSlug] = useState('');
   const [tournament, setTournament] = useState<Tournament>({
     slug: '',
@@ -211,6 +209,7 @@ function Hello() {
       const replaysDirPromise = window.electron.getReplaysDir();
       const copyDirPromise = window.electron.getCopyDir();
       const tournamentPromise = window.electron.getCurrentTournament();
+      const selectedSetPromise = window.electron.getSelectedSet();
 
       // req network
       const latestAppVersionPromise = window.electron.getLatestVersion();
@@ -240,6 +239,10 @@ function Hello() {
         setSlug(currentTournament.slug);
         setTournament(currentTournament);
       }
+      const initSelectedSet = await selectedSetPromise;
+      if (initSelectedSet) {
+        setSelectedSet(initSelectedSet);
+      }
 
       // req network
       const errorMessages: string[] = [];
@@ -528,7 +531,10 @@ function Hello() {
     resetDq();
   };
   useEffect(() => {
-    window.electron.onTournament((e, newTournament) => {
+    window.electron.onTournament((e, newSelectedSet, newTournament) => {
+      if (newSelectedSet) {
+        setSelectedSet(newSelectedSet);
+      }
       if (newTournament) {
         if (
           tournamentSet &&
@@ -541,8 +547,14 @@ function Hello() {
         }
         setTournament(newTournament);
       }
-    });
-  }, [confirmedCopySettings, copyDirSet, tournamentSet, tournamentStarted]);
+    }, selectedSet.id);
+  }, [
+    confirmedCopySettings,
+    copyDirSet,
+    selectedSet,
+    tournamentSet,
+    tournamentStarted,
+  ]);
   useEffect(() => {
     window.electron.onUsb((e, newDir) => {
       setDir(newDir);
@@ -551,7 +563,6 @@ function Hello() {
     });
   }, [refreshReplays]);
 
-  const [selectedSet, setSelectedSet] = useState<Set>(EMPTY_SET);
   const availablePlayers: PlayerOverrides[] = [];
   selectedSet.entrant1Participants.forEach((participant) => {
     availablePlayers.push({
@@ -618,51 +629,11 @@ function Hello() {
   };
 
   // start.gg tournament view
-  const getPhaseGroup = async (
-    id: number,
-    phaseId: number,
-    eventId: number,
-    isRoot: boolean,
-    updatedSets?: Map<number, Set>,
-  ) => {
-    const editEvent = tournament.events.find((event) => event.id === eventId);
-    if (!editEvent) {
-      return;
-    }
-
-    let newPhaseGroup;
+  const getPhaseGroup = async (id: number, updatedSets?: Map<number, Set>) => {
     try {
-      newPhaseGroup = await window.electron.getPhaseGroup(id, updatedSets);
+      await window.electron.getPhaseGroup(id, updatedSets);
     } catch (e: any) {
       showErrorDialog([e.toString()]);
-      return;
-    }
-
-    const editPhase = editEvent.phases.find((phase) => phase.id === phaseId);
-    if (!editPhase) {
-      return;
-    }
-
-    const editPhaseGroup = editPhase.phaseGroups.find(
-      (phaseGroup) => phaseGroup.id === id,
-    );
-    if (editPhaseGroup) {
-      Object.assign(editPhaseGroup, newPhaseGroup);
-      if (selectedSet.id > 0) {
-        const updatedSelectedSet =
-          newPhaseGroup.sets.completedSets.find(
-            (set) => set.id === selectedSet.id,
-          ) ||
-          newPhaseGroup.sets.pendingSets.find(
-            (set) => set.id === selectedSet.id,
-          );
-        if (updatedSelectedSet) {
-          setSelectedSet(updatedSelectedSet);
-        }
-      }
-      if (isRoot) {
-        setTournament({ ...tournament });
-      }
     }
   };
 
@@ -861,125 +832,19 @@ function Hello() {
     );
   };
 
-  const getPhase = async (
-    id: number,
-    eventId: number,
-    isRoot: boolean,
-    fullyRecursive: boolean = false,
-  ) => {
-    let newPhase;
+  const getPhase = async (id: number, recursive: boolean = false) => {
     try {
-      newPhase = await window.electron.getPhase(id);
+      await window.electron.getPhase(id, recursive);
     } catch (e: any) {
       showErrorDialog([e.toString()]);
-      return;
-    }
-
-    const editEvent = tournament.events.find((event) => event.id === eventId);
-    if (!editEvent) {
-      return;
-    }
-
-    const editPhase = editEvent.phases.find((phase) => phase.id === id);
-    if (editPhase) {
-      if (editPhase.phaseGroups.length > 0) {
-        const phaseGroupsMap = new Map<number, PhaseGroup>();
-        editPhase.phaseGroups.forEach((phaseGroup) => {
-          phaseGroupsMap.set(phaseGroup.id, phaseGroup);
-        });
-        newPhase.phaseGroups.forEach((phaseGroup) => {
-          const existingPhaseGroup = phaseGroupsMap.get(phaseGroup.id);
-          if (existingPhaseGroup) {
-            phaseGroup.entrants = existingPhaseGroup.entrants;
-            phaseGroup.sets = existingPhaseGroup.sets;
-          }
-        });
-      }
-      Object.assign(editPhase, newPhase);
-      const phaseGroupsWithChildren = newPhase.phaseGroups.filter(
-        (phaseGroup) =>
-          phaseGroup.sets.completedSets.length > 0 ||
-          phaseGroup.sets.pendingSets.length > 0,
-      );
-      if (fullyRecursive) {
-        await Promise.all(
-          newPhase.phaseGroups.map(async (phaseGroup) =>
-            getPhaseGroup(phaseGroup.id, id, eventId, false),
-          ),
-        );
-      } else if (phaseGroupsWithChildren.length > 0) {
-        await Promise.all(
-          phaseGroupsWithChildren.map(async (phaseGroup) =>
-            getPhaseGroup(phaseGroup.id, id, eventId, false),
-          ),
-        );
-      } else if (newPhase.phaseGroups.length === 1) {
-        await getPhaseGroup(newPhase.phaseGroups[0].id, id, eventId, false);
-      }
-      if (isRoot) {
-        setTournament({ ...tournament });
-      }
     }
   };
 
-  const getEvent = async (
-    id: number,
-    isRoot: boolean,
-    fullyRecursive: boolean = false,
-  ) => {
-    let newEvent;
+  const getEvent = async (id: number, recursive: boolean = false) => {
     try {
-      newEvent = await window.electron.getEvent(id);
+      await window.electron.getEvent(id, recursive);
     } catch (e: any) {
       showErrorDialog([e.toString()]);
-      return;
-    }
-
-    const editEvent = tournament.events.find((event) => event.id === id);
-    if (editEvent) {
-      if (editEvent.phases.length > 0) {
-        const phasesMap = new Map<number, Phase>();
-        editEvent.phases.forEach((phase) => {
-          phasesMap.set(phase.id, phase);
-        });
-        newEvent.phases.forEach((phase) => {
-          const existingPhase = phasesMap.get(phase.id);
-          if (existingPhase) {
-            phase.phaseGroups = existingPhase.phaseGroups;
-          }
-        });
-      }
-      Object.assign(editEvent, newEvent);
-      const phasesWithChildren = newEvent.phases.filter(
-        (phase) => phase.phaseGroups.length > 0,
-      );
-      if (fullyRecursive) {
-        await Promise.all(
-          newEvent.phases.map(async (phase) =>
-            getPhase(phase.id, id, false, true),
-          ),
-        );
-      } else if (phasesWithChildren.length > 0) {
-        await Promise.all(
-          phasesWithChildren.map(async (phase) =>
-            getPhase(phase.id, id, false),
-          ),
-        );
-      } else if (newEvent.phases.length === 1) {
-        await getPhase(newEvent.phases[0].id, id, false);
-      }
-      if (
-        newEvent.state !== State.PENDING &&
-        tournamentSet &&
-        copyDirSet &&
-        confirmedCopySettings &&
-        !tournamentStarted
-      ) {
-        setGuideBackdropOpen(false);
-      }
-      if (isRoot) {
-        setTournament({ ...tournament });
-      }
     }
   };
 
@@ -988,50 +853,16 @@ function Hello() {
       return false;
     }
 
-    let newTournament;
     setGettingTournament(true);
     try {
-      newTournament = await window.electron.getTournament(maybeSlug);
+      await window.electron.getTournament(maybeSlug, initial && vlerkMode);
+      return true;
     } catch (e: any) {
       showErrorDialog([e.toString()]);
-      setGettingTournament(false);
       return false;
+    } finally {
+      setGettingTournament(false);
     }
-
-    if (tournament.slug === maybeSlug && tournament.events.length > 0) {
-      const eventsMap = new Map<number, Event>();
-      tournament.events.forEach((event) => {
-        eventsMap.set(event.id, event);
-      });
-      newTournament.events.forEach((event) => {
-        const existingEvent = eventsMap.get(event.id);
-        if (existingEvent) {
-          event.phases = existingEvent.phases;
-        }
-      });
-    }
-    tournament.events = newTournament.events;
-    tournament.name = newTournament.name;
-    tournament.slug = maybeSlug;
-    const eventsWithChildren = newTournament.events.filter(
-      (event) => event.phases.length > 0,
-    );
-    if (initial && vlerkMode) {
-      await Promise.all(
-        newTournament.events.map(async (event) =>
-          getEvent(event.id, false, true),
-        ),
-      );
-    } else if (eventsWithChildren.length > 0) {
-      await Promise.all(
-        eventsWithChildren.map(async (event) => getEvent(event.id, false)),
-      );
-    } else if (newTournament.events.length === 1) {
-      await getEvent(newTournament.events[0].id, false);
-    }
-    setTournament(tournament);
-    setGettingTournament(false);
-    return true;
   };
 
   // set controls
@@ -1097,9 +928,6 @@ function Hello() {
         const updatedSet = await window.electron.startSet(setId);
         await getPhaseGroup(
           selectedSetChain.phaseGroupId,
-          selectedSetChain.phaseId,
-          selectedSetChain.eventId,
-          true,
           new Map([[updatedSet.id, updatedSet]]),
         );
       } else if (mode === Mode.CHALLONGE) {
@@ -1129,13 +957,7 @@ function Hello() {
         updatedSets.set(updatedSet.id, updatedSet);
       });
     }
-    await getPhaseGroup(
-      selectedSetChain.phaseGroupId,
-      selectedSetChain.phaseId,
-      selectedSetChain.eventId,
-      true,
-      updatedSets,
-    );
+    await getPhaseGroup(selectedSetChain.phaseGroupId, updatedSets);
     resetDq();
     return updatedSets.get(set.setId);
   };
@@ -1811,13 +1633,9 @@ function Hello() {
               searchSubstr={searchSubstr}
               tournament={tournament}
               vlerkMode={vlerkMode}
-              getEvent={(id: number) => getEvent(id, true)}
-              getPhase={(id: number, eventId: number) =>
-                getPhase(id, eventId, true)
-              }
-              getPhaseGroup={(id: number, phaseId: number, eventId: number) =>
-                getPhaseGroup(id, phaseId, eventId, true)
-              }
+              getEvent={(id: number) => getEvent(id)}
+              getPhase={(id: number) => getPhase(id)}
+              getPhaseGroup={(id: number) => getPhaseGroup(id)}
               selectSet={(
                 set: Set,
                 phaseGroupId: number,
diff --git a/src/renderer/StartggView.tsx b/src/renderer/StartggView.tsx
index fdda061b..2a25221a 100644
--- a/src/renderer/StartggView.tsx
+++ b/src/renderer/StartggView.tsx
@@ -102,11 +102,7 @@ function PhaseGroupView({
   tournamentSlug: string;
   searchSubstr: string;
   vlerkMode: boolean;
-  getPhaseGroup: (
-    id: number,
-    phaseId: number,
-    eventId: number,
-  ) => Promise<void>;
+  getPhaseGroup: (id: number) => Promise<void>;
   selectSet: (set: Set) => void;
   showError: (error: string) => void;
 }) {
@@ -117,7 +113,7 @@ function PhaseGroupView({
 
   const get = async () => {
     setGetting(true);
-    await getPhaseGroup(phaseGroup.id, phaseId, eventId);
+    await getPhaseGroup(phaseGroup.id);
     setGetting(false);
   };
   const start = async () => {
@@ -305,12 +301,8 @@ function PhaseView({
   tournamentSlug: string;
   searchSubstr: string;
   vlerkMode: boolean;
-  getPhase: (id: number, eventId: number) => Promise<void>;
-  getPhaseGroup: (
-    id: number,
-    phaseId: number,
-    eventId: number,
-  ) => Promise<void>;
+  getPhase: (id: number) => Promise<void>;
+  getPhaseGroup: (id: number) => Promise<void>;
   selectSet: (set: Set, phaseGroupId: number, phaseGroupName: string) => void;
   showError: (error: string) => void;
 }) {
@@ -320,7 +312,7 @@ function PhaseView({
 
   const get = async () => {
     setGetting(true);
-    await getPhase(phase.id, eventId);
+    await getPhase(phase.id);
     setGetting(false);
   };
   const start = async () => {
@@ -445,12 +437,8 @@ function EventView({
   searchSubstr: string;
   vlerkMode: boolean;
   getEvent: (id: number) => Promise<void>;
-  getPhase: (id: number, eventId: number) => Promise<void>;
-  getPhaseGroup: (
-    id: number,
-    phaseId: number,
-    eventId: number,
-  ) => Promise<void>;
+  getPhase: (id: number) => Promise<void>;
+  getPhaseGroup: (id: number) => Promise<void>;
   selectSet: (
     set: Set,
     phaseGroupId: number,
@@ -606,12 +594,8 @@ export default function StartggView({
   tournament: Tournament;
   vlerkMode: boolean;
   getEvent: (id: number) => Promise<void>;
-  getPhase: (id: number, eventId: number) => Promise<void>;
-  getPhaseGroup: (
-    id: number,
-    phaseId: number,
-    eventId: number,
-  ) => Promise<void>;
+  getPhase: (id: number) => Promise<void>;
+  getPhaseGroup: (id: number) => Promise<void>;
   selectSet: (
     set: Set,
     phaseGroupId: number,