diff --git a/packages/client-web/src/components/modals/config/server/saves-config.tsx b/packages/client-web/src/components/modals/config/server/saves-config.tsx
index 5ff43fe0..56c3b88a 100644
--- a/packages/client-web/src/components/modals/config/server/saves-config.tsx
+++ b/packages/client-web/src/components/modals/config/server/saves-config.tsx
@@ -13,6 +13,7 @@ import { TabsContent } from "@retrom/ui/components/tabs";
 import {
   SavesConfigSchema,
   ServerConfig,
+  SaveDirStructure,
 } from "@retrom/codegen/retrom/server/config_pb";
 import { useUpdateServerConfig } from "@/mutations/useUpdateServerConfig";
 import { zodResolver } from "@hookform/resolvers/zod";
@@ -31,6 +32,7 @@ type SavesConfigShape = Record<
 const savesSchema = z.object({
   maxSaveFilesBackups: z.coerce.number().default(5),
   maxSaveStatesBackups: z.coerce.number().default(5),
+  saveDirStructure: z.nativeEnum(SaveDirStructure).default(SaveDirStructure.EMULATOR_GAME),
 }) satisfies z.ZodObject<SavesConfigShape>;
 
 export function SavesConfig(props: {
@@ -41,9 +43,10 @@ export function SavesConfig(props: {
 
   const form = useForm<z.infer<typeof savesSchema>>({
     resolver: zodResolver(savesSchema),
-    defaultValues: props.currentConfig.saves ?? {
-      maxSaveFilesBackups: 5,
-      maxSaveStatesBackups: 5,
+    defaultValues: {
+      maxSaveFilesBackups: props.currentConfig.saves?.maxSaveFilesBackups ?? 5,
+      maxSaveStatesBackups: props.currentConfig.saves?.maxSaveStatesBackups ?? 5,
+      saveDirStructure: props.currentConfig.saves?.saveDirStructure ?? SaveDirStructure.EMULATOR_GAME,
     },
   });
 
@@ -110,6 +113,27 @@ export function SavesConfig(props: {
             )}
           />
 
+          <FormField
+            control={form.control}
+            name="saveDirStructure"
+            render={({ field }) => (
+              <FormItem>
+                <FormLabel>Save File Directory Structure</FormLabel>
+                <FormControl>
+                  <select 
+                    className="w-full px-3 py-2 bg-background border rounded-md"
+                    value={field.value}
+                    onChange={(e) => field.onChange(parseInt(e.target.value))}
+                  >
+                    <option value={SaveDirStructure.EMULATOR_GAME}>Emulator/Game ID Based</option>
+                    <option value={SaveDirStructure.MIRROR_LIBRARY}>Mirror Game Library Structure</option>
+                  </select>
+                </FormControl>
+                <FormMessage />
+              </FormItem>
+            )}
+          />
+
           <DialogFooter className="gap-2">
             <Button
               onClick={() =>
diff --git a/packages/client-web/src/providers/emulator-js/ejs-session.tsx b/packages/client-web/src/providers/emulator-js/ejs-session.tsx
index d490ffe6..c53e54d6 100644
--- a/packages/client-web/src/providers/emulator-js/ejs-session.tsx
+++ b/packages/client-web/src/providers/emulator-js/ejs-session.tsx
@@ -44,7 +44,12 @@ export function EJSSessionStateProvider(props: PropsWithChildren) {
   // const { uploadFiles, downloadFiles } = useRemoteFiles();
   const { mutateAsync: updateSave } = useUpdateSaveFiles();
   const saveFilesQuery = useGetSaveFiles({
-    saveFilesSelectors: [{ gameId: game.id, emulatorId: emulator?.id }],
+    saveFilesSelectors: [
+      {
+        gameId: game?.id ?? 0,
+        emulatorId: emulator?.id,
+      },
+    ],
   });
 
   const startTime = useMemo(() => Date.now(), []);
diff --git a/packages/client-web/src/queries/saveFiles.tsx b/packages/client-web/src/queries/saveFiles.tsx
index cd839cce..a382ddf7 100644
--- a/packages/client-web/src/queries/saveFiles.tsx
+++ b/packages/client-web/src/queries/saveFiles.tsx
@@ -22,10 +22,12 @@ export function useStatSaveFiles(
 
 export function useGetSaveFiles(
   request: MessageInitShape<typeof GetSaveFilesRequestSchema>,
+  options?: { enabled?: boolean },
 ) {
   const retromClient = useRetromClient();
 
   return useQuery({
+    enabled: options?.enabled !== false,
     queryFn: async () => {
       const { update } = toast({
         id: "download-remote-saves",
diff --git a/packages/client-web/vite.config.ts b/packages/client-web/vite.config.ts
index 8794de72..cd454b24 100644
--- a/packages/client-web/vite.config.ts
+++ b/packages/client-web/vite.config.ts
@@ -59,6 +59,15 @@ export default defineConfig(({ mode }) => {
         "/v1/traces": {
           target: localTracesEndpoint,
           changeOrigin: true,
+          configure: (proxy, _options) => {
+            proxy.on('error', (err, _req, _res) => {
+              if (err.code === 'ECONNREFUSED') {
+                // Silently ignore telemetry connection errors
+                return;
+              }
+              console.log('proxy error', err);
+            });
+          },
         },
       },
     },
diff --git a/packages/codegen/protos/retrom/server/config.proto b/packages/codegen/protos/retrom/server/config.proto
index 83db1640..0aca5294 100644
--- a/packages/codegen/protos/retrom/server/config.proto
+++ b/packages/codegen/protos/retrom/server/config.proto
@@ -49,9 +49,17 @@ message SteamConfig {
   string user_id = 2;
 }
 
+enum SaveDirStructure {
+  // Default save directory structure: <data_dir>/saves/<emulator_id>/<game_id>/
+  EMULATOR_GAME = 0;
+  // Mirror game library structure: <data_dir>/saves/<game_library_path>/
+  MIRROR_LIBRARY = 1;
+}
+
 message SavesConfig {
   int32 max_save_files_backups = 1;
   int32 max_save_states_backups = 2;
+  optional SaveDirStructure save_dir_structure = 3;
 }
 
 message MetadataConfig {
diff --git a/packages/codegen/protos/retrom/services/server-config.proto b/packages/codegen/protos/retrom/services/server-config.proto
new file mode 100644
index 00000000..da843f47
--- /dev/null
+++ b/packages/codegen/protos/retrom/services/server-config.proto
@@ -0,0 +1,4 @@
+syntax = "proto3";
+package retrom;
+
+// This file was moved to server/config.proto
\ No newline at end of file
diff --git a/packages/grpc-service/src/saves/mod.rs b/packages/grpc-service/src/saves/mod.rs
index aa9aabf0..6c8584ee 100644
--- a/packages/grpc-service/src/saves/mod.rs
+++ b/packages/grpc-service/src/saves/mod.rs
@@ -184,6 +184,7 @@ impl SavesService for SavesServiceHandlers {
 
                 let save_dir = save_file_manager
                     .get_saves_dir(emulator_id)
+                    .await
                     .map_err(|e| tonic::Status::internal(e.to_string()))?;
 
                 for file_stat in save_file_stat.file_stats.into_iter() {
@@ -256,6 +257,7 @@ impl SavesService for SavesServiceHandlers {
 
             let states_dir = save_state_manager
                 .get_states_dir(emulator_id)
+                .await
                 .map_err(|e| tonic::Status::internal(e.to_string()))?;
 
             for save_states_stat in save_states {
diff --git a/packages/grpc-service/src/saves/save_file_manager.rs b/packages/grpc-service/src/saves/save_file_manager.rs
index 604ddeda..b4de2f4c 100644
--- a/packages/grpc-service/src/saves/save_file_manager.rs
+++ b/packages/grpc-service/src/saves/save_file_manager.rs
@@ -46,8 +46,8 @@ impl GameSaveFileManager {
 pub trait SaveFileManager {
     async fn resolve_save_files(&self, include_backups: bool) -> Result<Vec<SaveFilesStat>>;
     async fn reindex_backups(&self, emulator_id: Option<i32>) -> Result<()>;
-    fn get_saves_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
-    fn get_saves_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
+    async fn get_saves_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
+    async fn get_saves_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
 
     async fn backup_save_files(
         &self,
@@ -96,8 +96,8 @@ impl SaveFileManager for GameSaveFileManager {
         let mut files = vec![];
 
         for emulator_id in emulators.iter().map(|e| e.id) {
-            let save_dir = self.get_saves_dir(Some(emulator_id))?;
-            let backup_dir = self.get_saves_backup_dir(Some(emulator_id))?;
+            let save_dir = self.get_saves_dir(Some(emulator_id)).await?;
+            let backup_dir = self.get_saves_backup_dir(Some(emulator_id)).await?;
 
             let file_stats: Vec<FileStat> = if save_dir.exists() {
                 WalkDir::new(&save_dir)
@@ -227,7 +227,8 @@ impl SaveFileManager for GameSaveFileManager {
     }
 
     #[instrument(skip(self), fields(game_id = self.game.id))]
-    fn get_saves_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
+    async fn get_saves_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
+        let config = self.config.get_config().await;
         let saves_dir = RetromDirs::new().data_dir().join("saves");
 
         let emulator_id = match emulator_id {
@@ -239,13 +240,79 @@ impl SaveFileManager for GameSaveFileManager {
             }
         };
 
-        Ok(saves_dir
-            .join(emulator_id.to_string())
-            .join(self.game.id.to_string()))
+        // Check if we should use the game library path structure
+        let save_dir_structure = config.saves.as_ref().and_then(|s| s.save_dir_structure);
+        let mirror_library_value = retrom_codegen::retrom::SaveDirStructure::MirrorLibrary as i32;
+        tracing::info!(
+            "get_saves_dir - Game ID: {}, Save dir structure config: {:?}, MirrorLibrary enum value: {}, comparison: {}",
+            self.game.id,
+            save_dir_structure,
+            mirror_library_value,
+            save_dir_structure.map(|s| s == mirror_library_value).unwrap_or(false)
+        );
+        
+        if save_dir_structure.map(|s| s == mirror_library_value).unwrap_or(false) {
+            let game_path = PathBuf::from(&self.game.path);
+            tracing::info!("Mirror library mode - Game path: {:?}", game_path);
+            
+            // Find the content directory that contains this game
+            let content_dirs = &config.content_directories;
+            tracing::info!("Content directories: {:?}", content_dirs);
+            for content_dir in content_dirs {
+                let content_path = PathBuf::from(&content_dir.path);
+                tracing::info!("Checking content path: {:?}", content_path);
+                
+                // Try to get the relative path from the content directory to the game
+                if let Ok(relative_game_path) = game_path.strip_prefix(&content_path) {
+                    tracing::info!("Found matching content dir! Relative game path: {:?}", relative_game_path);
+                    
+                    // Extract platform and game name from the relative path
+                    let path_components: Vec<&str> = relative_game_path.components()
+                        .filter_map(|comp| {
+                            if let std::path::Component::Normal(os_str) = comp {
+                                os_str.to_str()
+                            } else {
+                                None
+                            }
+                        })
+                        .collect();
+                    
+                    tracing::info!("Path components: {:?}", path_components);
+                    
+                    // For both single-file and multi-file games, we want platform/game_name structure
+                    if path_components.len() >= 2 {
+                        let platform = path_components[0];
+                        let game_name = path_components[1];
+                        
+                        tracing::info!("Using platform: {:?}, game_name: {:?}", platform, game_name);
+                        
+                        // Sanitize each component
+                        if !platform.contains("..") && !game_name.contains("..") 
+                            && !platform.is_empty() && !game_name.is_empty() {
+                            let save_path = format!("{}/{}", platform, game_name);
+                            tracing::info!("Final save path: {:?}", save_path);
+                            return Ok(saves_dir.join(save_path));
+                        }
+                    }
+                    break; // Found the matching content directory, no need to continue
+                }
+            }
+            
+            // Fallback to default structure if no content directory matched or path is invalid
+            Ok(saves_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        } else {
+            // Default directory structure
+            Ok(saves_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        }
     }
 
     #[instrument(skip(self), fields(game_id = self.game.id))]
-    fn get_saves_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
+    async fn get_saves_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
+        let config = self.config.get_config().await;
         let backup_dir = RetromDirs::new().data_dir().join("saves_backups");
 
         let emulator_id = match emulator_id {
@@ -257,9 +324,56 @@ impl SaveFileManager for GameSaveFileManager {
             }
         };
 
-        Ok(backup_dir
-            .join(emulator_id.to_string())
-            .join(self.game.id.to_string()))
+        // Check if we should use the game library path structure
+        if config.saves.as_ref().and_then(|s| s.save_dir_structure).map(|s| s == retrom_codegen::retrom::SaveDirStructure::MirrorLibrary as i32).unwrap_or(false) {
+            let game_path = PathBuf::from(&self.game.path);
+            
+            // Find the content directory that contains this game
+            let content_dirs = &config.content_directories;
+            for content_dir in content_dirs {
+                let content_path = PathBuf::from(&content_dir.path);
+                
+                // Try to get the relative path from the content directory to the game
+                if let Ok(relative_game_path) = game_path.strip_prefix(&content_path) {
+                    // Get the parent directory of the game file (game directory)
+                    if let Some(game_dir) = relative_game_path.parent() {
+                        let path_components: Vec<&str> = game_dir.components()
+                            .filter_map(|comp| {
+                                if let std::path::Component::Normal(os_str) = comp {
+                                    os_str.to_str()
+                                } else {
+                                    None
+                                }
+                            })
+                            .collect();
+                        
+                        // We want platform/game_name structure (first two components)
+                        if path_components.len() >= 2 {
+                            let platform = path_components[0];
+                            let game_name = path_components[1];
+                            
+                            // Sanitize each component
+                            if !platform.contains("..") && !game_name.contains("..") 
+                                && !platform.is_empty() && !game_name.is_empty() {
+                                let save_path = format!("{}/{}", platform, game_name);
+                                return Ok(backup_dir.join(save_path));
+                            }
+                        }
+                    }
+                    break; // Found the matching content directory, no need to continue
+                }
+            }
+            
+            // Fallback to default structure if no content directory matched or path is invalid
+            Ok(backup_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        } else {
+            // Default directory structure
+            Ok(backup_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        }
     }
 
     #[instrument(skip(self), fields(game_id = self.game.id))]
@@ -276,7 +390,7 @@ impl SaveFileManager for GameSaveFileManager {
 
         for save_files in all_save_files.iter_mut() {
             let save_path = PathBuf::from(&save_files.save_path);
-            let backups_dir = self.get_saves_backup_dir(save_files.emulator_id)?;
+            let backups_dir = self.get_saves_backup_dir(save_files.emulator_id).await?;
             let backup_dir =
                 backups_dir.join(chrono::Local::now().to_utc().format("%s.%f").to_string());
 
@@ -362,7 +476,7 @@ impl SaveFileManager for GameSaveFileManager {
 
     #[instrument(skip_all, fields(game_id = self.game.id))]
     async fn update_save_files(&self, save_files: SaveFiles, dry_run: bool) -> Result<()> {
-        let save_dir = self.get_saves_dir(save_files.emulator_id)?;
+        let save_dir = self.get_saves_dir(save_files.emulator_id).await?;
         self.backup_save_files(save_files.emulator_id, dry_run)
             .await?;
 
@@ -461,7 +575,7 @@ impl SaveFileManager for GameSaveFileManager {
         emulator_id: Option<i32>,
         dry_run: bool,
     ) -> Result<()> {
-        let saves_dir = self.get_saves_dir(emulator_id)?;
+        let saves_dir = self.get_saves_dir(emulator_id).await?;
         let backup_path = PathBuf::from(backup.backup_path);
 
         if !backup_path.exists() {
diff --git a/packages/grpc-service/src/saves/save_state_manager.rs b/packages/grpc-service/src/saves/save_state_manager.rs
index d338762f..5c3456e6 100644
--- a/packages/grpc-service/src/saves/save_state_manager.rs
+++ b/packages/grpc-service/src/saves/save_state_manager.rs
@@ -46,8 +46,8 @@ impl GameSaveStateManager {
 pub trait SaveStateManager {
     async fn resolve_save_states(&self, include_backups: bool) -> Result<Vec<SaveStatesStat>>;
     async fn reindex_backups(&self, emulator_id: Option<i32>) -> Result<()>;
-    fn get_states_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
-    fn get_states_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
+    async fn get_states_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
+    async fn get_states_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf>;
 
     async fn backup_save_states(
         &self,
@@ -101,8 +101,8 @@ impl SaveStateManager for GameSaveStateManager {
         let mut files = vec![];
 
         for emulator_id in emulators.iter().map(|e| e.id) {
-            let states_dir = self.get_states_dir(Some(emulator_id))?;
-            let backups_dir = self.get_states_backup_dir(Some(emulator_id))?;
+            let states_dir = self.get_states_dir(Some(emulator_id)).await?;
+            let backups_dir = self.get_states_backup_dir(Some(emulator_id)).await?;
 
             let file_stats: Vec<FileStat> = if states_dir.exists() {
                 states_dir
@@ -234,8 +234,9 @@ impl SaveStateManager for GameSaveStateManager {
     }
 
     #[instrument(skip(self), fields(game_id = self.game.id))]
-    fn get_states_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
-        let states_dir = RetromDirs::new().data_dir().join("states");
+    async fn get_states_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
+        let config = self.config.get_config().await;
+        let backup_dir = RetromDirs::new().data_dir().join("states_backups");
 
         let emulator_id = match emulator_id {
             Some(id) => id,
@@ -246,14 +247,62 @@ impl SaveStateManager for GameSaveStateManager {
             }
         };
 
-        Ok(states_dir
-            .join(emulator_id.to_string())
-            .join(self.game.id.to_string()))
+        // Check if we should use the game library path structure
+        if config.saves.as_ref().and_then(|s| s.save_dir_structure).map(|s| s == retrom_codegen::retrom::SaveDirStructure::MirrorLibrary as i32).unwrap_or(false) {
+            let game_path = PathBuf::from(&self.game.path);
+            
+            // Find the content directory that contains this game
+            let content_dirs = &config.content_directories;
+            for content_dir in content_dirs {
+                let content_path = PathBuf::from(&content_dir.path);
+                
+                // Try to get the relative path from the content directory to the game
+                if let Ok(relative_game_path) = game_path.strip_prefix(&content_path) {
+                    // Get the parent directory of the ROM file (game directory)
+                    if let Some(game_dir) = relative_game_path.parent() {
+                        let path_components: Vec<&str> = game_dir.components()
+                            .filter_map(|comp| {
+                                if let std::path::Component::Normal(os_str) = comp {
+                                    os_str.to_str()
+                                } else {
+                                    None
+                                }
+                            })
+                            .collect();
+                        
+                        // We want platform/game_name structure (first two components)
+                        if path_components.len() >= 2 {
+                            let platform = path_components[0];
+                            let game_name = path_components[1];
+                            
+                            // Sanitize each component
+                            if !platform.contains("..") && !game_name.contains("..") 
+                                && !platform.is_empty() && !game_name.is_empty() {
+                                let save_path = format!("{}/{}", platform, game_name);
+                                return Ok(backup_dir.join(save_path));
+                            }
+                        }
+                    }
+                    break; // Found the matching content directory, no need to continue
+                }
+            }
+            
+            // Fallback to default structure if no content directory matched or path is invalid
+            Ok(backup_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        } else {
+            // Default directory structure
+            Ok(backup_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        }
     }
 
     #[instrument(skip(self), fields(game_id = self.game.id))]
-    fn get_states_backup_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
-        let backup_dir = RetromDirs::new().data_dir().join("states_backups");
+    async fn get_states_dir(&self, emulator_id: Option<i32>) -> Result<PathBuf> {
+        let config = self.config.get_config().await;
+        let states_dir = RetromDirs::new().data_dir().join("states");
 
         let emulator_id = match emulator_id {
             Some(id) => id,
@@ -264,9 +313,56 @@ impl SaveStateManager for GameSaveStateManager {
             }
         };
 
-        Ok(backup_dir
-            .join(emulator_id.to_string())
-            .join(self.game.id.to_string()))
+        // Check if we should use the game library path structure
+        if config.saves.as_ref().and_then(|s| s.save_dir_structure).map(|s| s == retrom_codegen::retrom::SaveDirStructure::MirrorLibrary as i32).unwrap_or(false) {
+            let game_path = PathBuf::from(&self.game.path);
+            
+            // Find the content directory that contains this game
+            let content_dirs = &config.content_directories;
+            for content_dir in content_dirs {
+                let content_path = PathBuf::from(&content_dir.path);
+                
+                // Try to get the relative path from the content directory to the game
+                if let Ok(relative_game_path) = game_path.strip_prefix(&content_path) {
+                    // Get the parent directory of the ROM file (game directory)
+                    if let Some(game_dir) = relative_game_path.parent() {
+                        let path_components: Vec<&str> = game_dir.components()
+                            .filter_map(|comp| {
+                                if let std::path::Component::Normal(os_str) = comp {
+                                    os_str.to_str()
+                                } else {
+                                    None
+                                }
+                            })
+                            .collect();
+                        
+                        // We want platform/game_name structure (first two components)
+                        if path_components.len() >= 2 {
+                            let platform = path_components[0];
+                            let game_name = path_components[1];
+                            
+                            // Sanitize each component
+                            if !platform.contains("..") && !game_name.contains("..") 
+                                && !platform.is_empty() && !game_name.is_empty() {
+                                let save_path = format!("{}/{}", platform, game_name);
+                                return Ok(states_dir.join(save_path));
+                            }
+                        }
+                    }
+                    break; // Found the matching content directory, no need to continue
+                }
+            }
+            
+            // Fallback to default structure if no content directory matched or path is invalid
+            Ok(states_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        } else {
+            // Default directory structure
+            Ok(states_dir
+                .join(emulator_id.to_string())
+                .join(self.game.id.to_string()))
+        }
     }
 
     #[instrument(skip(self), fields(game_id = self.game.id))]
@@ -283,7 +379,7 @@ impl SaveStateManager for GameSaveStateManager {
 
         for save_states in all_save_states.iter_mut() {
             let states_path = PathBuf::from(&save_states.states_path);
-            let backups_dir = self.get_states_backup_dir(save_states.emulator_id)?;
+            let backups_dir = self.get_states_backup_dir(save_states.emulator_id).await?;
             let backup_dir =
                 backups_dir.join(chrono::Local::now().to_utc().format("%s.%f").to_string());
 
@@ -369,7 +465,7 @@ impl SaveStateManager for GameSaveStateManager {
 
     #[instrument(skip_all, fields(game_id = self.game.id))]
     async fn update_save_states(&self, save_states: SaveStates, dry_run: bool) -> Result<()> {
-        let states_dir = self.get_states_dir(save_states.emulator_id)?;
+        let states_dir = self.get_states_dir(save_states.emulator_id).await?;
         self.backup_save_states(save_states.emulator_id, dry_run)
             .await?;
 
@@ -509,7 +605,7 @@ impl SaveStateManager for GameSaveStateManager {
         emulator_id: Option<i32>,
         dry_run: bool,
     ) -> Result<()> {
-        let states_dir = self.get_states_dir(emulator_id)?;
+        let states_dir = self.get_states_dir(emulator_id).await?;
         let backup_path = PathBuf::from(backup.backup_path);
 
         if !backup_path.exists() {
diff --git a/packages/service-common/src/config/mod.rs b/packages/service-common/src/config/mod.rs
index 2623ea54..ae2f675c 100644
--- a/packages/service-common/src/config/mod.rs
+++ b/packages/service-common/src/config/mod.rs
@@ -1,7 +1,7 @@
 use crate::retrom_dirs::RetromDirs;
 use config::{Config, ConfigError, File};
 use retrom_codegen::retrom::{
-    metadata_config::OptimizationConfig, ContentDirectory, MetadataConfig, SavesConfig,
+    metadata_config::OptimizationConfig, ContentDirectory, MetadataConfig, SaveDirStructure, SavesConfig,
     ServerConfig, StorageType,
 };
 use std::path::PathBuf;
@@ -38,6 +38,7 @@ impl ServerConfigManager {
             saves: Some(SavesConfig {
                 max_save_files_backups: 5,
                 max_save_states_backups: 5,
+                save_dir_structure: Some(i32::from(SaveDirStructure::EmulatorGame))
             }),
             metadata: Some(MetadataConfig {
                 store_metadata_locally: false,