diff --git a/retroachievements/retroachievements.c b/retroachievements/retroachievements.c
index 62f0dc2b..533fdc01 100644
--- a/retroachievements/retroachievements.c
+++ b/retroachievements/retroachievements.c
@@ -327,7 +327,8 @@ static void event_handler(const rc_client_event_t *event, rc_client_t *client) {
 void ra_init_client(bool hardcore, bool challenge, bool leaderboard) {
   // Create the client instance (using a global variable simplifies this
   // example)
-  g_client = rc_client_create(read_memory, server_call);
+  if (!g_client)
+    g_client = rc_client_create(read_memory, server_call);
   g_rdram = NULL;
   g_rdram_size = 0;
 
diff --git a/src/device.rs b/src/device.rs
index ae4d4d30..3727d224 100644
--- a/src/device.rs
+++ b/src/device.rs
@@ -51,7 +51,7 @@ pub async fn run_game(
     device: &mut Device,
     rom_contents: &[u8],
     game_settings: ui::GameSettings,
-    discord_rich_presence: bool,
+    ra_config: retroachievements::RAConfig,
 ) {
     device.cpu.overclock = game_settings.overclock;
     if game_settings.disable_expansion_pak {
@@ -74,8 +74,12 @@ pub async fn run_game(
     ui::input::init(&mut device.ui);
 
     // must be after video init
-    let (discord_watch_tx, discord_handle) =
-        retroachievements::load_game(rom_contents, rom_contents.len(), discord_rich_presence).await;
+    let (discord_watch_tx, discord_handle) = if ra_config.enabled && device.netplay.is_none() {
+        retroachievements::load_game(rom_contents, rom_contents.len(), ra_config.rich_presence)
+            .await
+    } else {
+        (None, None)
+    };
 
     mi::init(device);
     pif::init(device);
diff --git a/src/lib.rs b/src/lib.rs
index 73123907..39f1f1d1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -156,11 +156,10 @@ pub async fn run(args: Args, arg_count: usize) -> std::io::Result<()> {
         let mut shutdown_tx = None;
         let mut usb_handle = None;
 
-        let rich_presence = if let Some(peer_addr) = args.netplay_peer_addr
+        if let Some(peer_addr) = args.netplay_peer_addr
             && let Some(player_number) = args.netplay_player_number
         {
             device.netplay = Some(netplay::init(peer_addr.parse().unwrap(), player_number));
-            false
         } else {
             for i in 0..4 {
                 if device.ui.config.input.transfer_pak[i]
@@ -176,39 +175,39 @@ pub async fn run(args: Args, arg_count: usize) -> std::io::Result<()> {
             if device.ui.config.emulation.usb {
                 (shutdown_tx, usb_handle, device.ui.usb) = ui::usb::init();
             }
+        }
 
-            let file_path = dirs.config_dir.join("retroachievements.json");
-            if let ra_config = std::fs::read(&file_path).unwrap_or_default()
-                && let ra_config =
-                    serde_json::from_slice::<retroachievements::RAConfig>(ra_config.as_ref())
-                        .unwrap_or_default()
-                && (ra_config.enabled || args.ra_username.is_some())
-            {
-                let username = args.ra_username.unwrap_or(ra_config.username);
-                retroachievements::init_client(
-                    if cfg!(ra_hardcore_enabled) {
-                        ra_config.hardcore
-                    } else {
-                        false
-                    },
-                    ra_config.challenge,
-                    ra_config.leaderboard,
-                );
-
-                let (tx, rx) = tokio::sync::oneshot::channel::<bool>();
-                if let Some(password) = args.ra_password {
-                    retroachievements::login_user(username, password, tx);
-                } else if !ra_config.token.is_empty() {
-                    retroachievements::login_token_user(username, ra_config.token, tx);
+        let file_path = dirs.config_dir.join("retroachievements.json");
+        let ra_config = if let ra_config = std::fs::read(&file_path).unwrap_or_default()
+            && let ra_config =
+                serde_json::from_slice::<retroachievements::RAConfig>(ra_config.as_ref())
+                    .unwrap_or_default()
+            && (ra_config.enabled || args.ra_username.is_some())
+        {
+            let username = args.ra_username.unwrap_or(ra_config.username.clone());
+            retroachievements::init_client(
+                if cfg!(ra_hardcore_enabled) {
+                    ra_config.hardcore
                 } else {
-                    tx.send(false).unwrap();
-                }
+                    false
+                },
+                ra_config.challenge,
+                ra_config.leaderboard,
+            );
 
-                rx.await.unwrap();
-                ra_config.rich_presence
+            let (tx, rx) = tokio::sync::oneshot::channel::<bool>();
+            if let Some(password) = args.ra_password {
+                retroachievements::login_user(username, password, tx);
+            } else if !ra_config.token.is_empty() {
+                retroachievements::login_token_user(username, ra_config.token.clone(), tx);
             } else {
-                false
+                tx.send(false).unwrap();
             }
+
+            rx.await.unwrap();
+            ra_config
+        } else {
+            retroachievements::RAConfig::default()
         };
 
         device::run_game(
@@ -220,10 +219,12 @@ pub async fn run(args: Args, arg_count: usize) -> std::io::Result<()> {
                 cheats,
                 load_savestate_slot: args.load_state,
             },
-            rich_presence,
+            ra_config,
         )
         .await;
 
+        // on Android, the client is shut down in the app_window function
+        #[cfg(not(target_os = "android"))]
         retroachievements::shutdown_client();
 
         if device.netplay.is_some() {