## 1. What this pause does

This procedure stops the Remote Switch software that is running now and prevents it from starting after future Windows reboots. It **does not uninstall or delete** OBS, Parsec, VB-CABLE, Python, the bridge repository, its patched controller mapping, the Pico firmware, drivers, logs, scheduled tasks, or any Switch data.

When you finish, the expected state is:

- `Remote Switch - Controller Bridge` is stopped and disabled.
- `Remote Switch - OBS` is stopped and disabled.
- OBS is closed, and its automatic projector script is unloaded but still saved at `C:\RemoteSwitch\obs-auto-projector.lua`.
- Parsec hosting, startup, app, and background service are off.
- Windows automatic sign-in is off.
- The PC can sleep normally again if you choose the optional power step.

> **Do this while physically at the Windows PC.** Quitting Parsec and stopping its service immediately ends any Parsec session. Do not rely on Parsec as your only way back into the PC while following this page.

## 2. Turn off Parsec cleanly

Do this before stopping the Windows service so Parsec can save its settings:

1. Disconnect every remote guest.
2. On the Windows host, open **Parsec > Settings > Host**.
3. Set **Hosting Enabled** to **Off**.
4. Right-click the Parsec icon in the Windows notification area by the clock.
5. Clear **Run when computer starts**.
6. Right-click the tray icon again and choose **Quit**.

Parsec's current Windows documentation confirms that **Hosting Enabled** controls whether the PC accepts connections and that **Run when computer starts** controls system startup. A per-computer installation also has an always-running Windows service, so the PowerShell step below disables that service too. See [Parsec App for Windows](https://support.parsec.app/hc/en-us/articles/32381199341716-Parsec-App-for-Windows), [Install Parsec App on Windows](https://support.parsec.app/hc/en-us/articles/32381368159124-Install-Parsec-App-on-Windows), and [Why Is Parsec Running in the Background on Startup?](https://support.parsec.app/hc/en-us/articles/32381334155412-Why-Is-Parsec-Running-in-the-Background-on-Startup).

## 3. Close OBS and unload the automatic projector

1. If the Switch projector is full-screen, press **Esc**.
2. In OBS, open **Tools > Scripts**.
3. Select `obs-auto-projector.lua`.
4. Click the **minus (−)** button to unload it.
5. Close the Scripts window.
6. Use **File > Exit** to close OBS cleanly.

Unloading the script changes only OBS's active script list. The script file remains at `C:\RemoteSwitch\obs-auto-projector.lua` for a future restart of the project.

## 4. Disable Windows automatic sign-in

The original setup used Microsoft Sysinternals Autologon. Find the `Autologon64.exe` you used during setup, then:

1. Right-click `Autologon64.exe` and choose **Run as administrator**.
2. Select **Disable**.
3. Close Autologon.

If you no longer have the utility, download it again from [Microsoft Sysinternals Autologon](https://learn.microsoft.com/en-us/sysinternals/downloads/autologon). Microsoft specifically documents **Disable** as the way to turn automatic logon off. Holding Shift during startup bypasses autologon only once; it is not a permanent pause.

## 5. Stop and disable the Remote Switch tasks and Parsec service

Open **PowerShell as Administrator** on the Windows host. Copy and run this entire block once:

```powershell
# Preserve the Parsec service's current state so it can be restored later.
$pauseStateDir = "C:\RemoteSwitch\pause-state"
New-Item -ItemType Directory -Path $pauseStateDir -Force | Out-Null

$parsecServices = @(Get-CimInstance Win32_Service | Where-Object {
    $_.Name -match "parsec" -or $_.DisplayName -match "parsec"
})

$statePath = Join-Path $pauseStateDir (
    "parsec-services-before-pause-{0}.json" -f (Get-Date -Format "yyyyMMdd-HHmmss")
)
@($parsecServices | Select-Object Name, DisplayName, State, StartMode) |
    ConvertTo-Json -Depth 3 |
    Set-Content -Path $statePath -Encoding utf8

# Stop and disable both Remote Switch scheduled tasks without deleting them.
$taskNames = @(
    "Remote Switch - Controller Bridge",
    "Remote Switch - OBS"
)

foreach ($taskName in $taskNames) {
    $task = Get-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue
    if ($null -ne $task) {
        Stop-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue
        Disable-ScheduledTask -TaskName $taskName | Out-Null
    } else {
        Write-Warning "Scheduled task not found: $taskName"
    }
}

# Stop only Python processes running this controller bridge.
$bridgeProcesses = @(Get-CimInstance Win32_Process | Where-Object {
    $_.Name -in @("python.exe", "pythonw.exe") -and
    $_.CommandLine -match "switch_pico_bridge\.controller_uart_bridge"
})

foreach ($process in $bridgeProcesses) {
    Stop-Process -Id $process.ProcessId -Force -ErrorAction SilentlyContinue
}

# Stop and disable the installed Parsec service or services.
foreach ($service in $parsecServices) {
    Stop-Service -Name $service.Name -Force -ErrorAction SilentlyContinue
    Set-Service -Name $service.Name -StartupType Disabled
}

Write-Host "Pause state saved to: $statePath"
Write-Host "Remote Switch scheduled tasks and Parsec services are now paused."
```

This creates only a small service-state record under `C:\RemoteSwitch\pause-state`. It does not remove anything. The state record lets the resume procedure restore the Parsec service's previous startup mode instead of guessing.

### Check the immediate result

Run this in the same Administrator PowerShell window:

```powershell
$taskNames = @(
    "Remote Switch - Controller Bridge",
    "Remote Switch - OBS"
)

Get-ScheduledTask -TaskName $taskNames -ErrorAction SilentlyContinue |
    Select-Object TaskName, State

Get-CimInstance Win32_Service |
    Where-Object { $_.Name -match "parsec" -or $_.DisplayName -match "parsec" } |
    Select-Object Name, DisplayName, State, StartMode

Get-CimInstance Win32_Process |
    Where-Object {
        $_.Name -eq "obs64.exe" -or
        $_.Name -eq "parsecd.exe" -or
        $_.Name -eq "pservice.exe" -or
        $_.CommandLine -match "switch_pico_bridge\.controller_uart_bridge"
    } |
    Select-Object ProcessId, Name, CommandLine
```

Expected results:

- Both scheduled tasks show `Disabled`.
- Every Parsec service shows `Stopped` and `Disabled`.
- The final process query prints nothing.

If `obs64.exe` appears, close OBS with **File > Exit**. If a Parsec process appears, confirm you chose **Quit** from its tray icon, then rerun the service portion of the pause block.

## 6. Check for duplicate startup entries

The tested build uses the two scheduled tasks above, but it is worth checking that an older troubleshooting attempt did not also add a Startup-folder copy.

1. Open **Settings > Apps > Startup**.
2. Turn off any entries named Parsec, OBS Studio, Remote Switch, controller bridge, Python, or `start-switch-bridge.cmd` that exist specifically for this setup.
3. Open **Task Manager > Startup apps** and confirm the same entries are disabled.
4. Do **not** disable unrelated Python tools merely because Python is installed.

Use this read-only inventory if an entry is unclear:

```powershell
Get-CimInstance Win32_StartupCommand |
    Where-Object {
        $_.Name -match "Parsec|OBS|Remote Switch|bridge" -or
        $_.Command -match "Parsec|obs64|RemoteSwitch|start-switch-bridge"
    } |
    Select-Object Name, Command, Location, User |
    Format-List
```

Leave VB-CABLE, the Elgato driver, the Parsec Virtual USB driver, the Debug Probe driver, Python, and the Pico firmware installed. Drivers and virtual audio devices do not launch the Remote Switch workflow by themselves.

## 7. Optional: restore ordinary PC power behavior

These are not background programs, but the original unattended-host setup intentionally kept the PC awake. If you want normal desktop behavior again, run this in Administrator PowerShell to turn off the display after 15 minutes and sleep after 30 minutes while plugged in:

```powershell
powercfg /change monitor-timeout-ac 15
powercfg /change standby-timeout-ac 30
```

Change the minute values to your preference. A value of `0` means **Never**.

Also consider reversing these optional unattended-host choices if you enabled them:

- **Control Panel > Power Options > Change plan settings > Change advanced power settings > USB settings > USB selective suspend setting:** set to **Enabled**.
- In BIOS/UEFI, change **Restore on AC Power Loss** from **Power On** to **Power Off** or **Last State**, whichever you prefer for a normal PC.
- On the Switch, restore **Auto-Sleep (Connected to TV)** to your preferred value.

## 8. Optional: disconnect the dedicated hardware

After OBS, the bridge, and Parsec are stopped, you may unplug the Elgato's USB cable and the USB-to-UART Debug Probe from the PC to free the ports. You may also disconnect the Pico from the Switch dock. Leave the three UART jumper wires assembled if you want the easiest future restart.

Label the cables before moving anything. None of this is required; leaving unpowered or idle hardware connected will not start the software.

## 9. Reboot and verify the project stays paused

Restart Windows once. The successful result is:

- Windows stops at the sign-in screen instead of automatically signing in.
- No Remote Switch command window appears.
- OBS does not open.
- Parsec does not open and the PC is not available as a Parsec host.

After signing in manually, open Administrator PowerShell and run:

```powershell
$taskNames = @(
    "Remote Switch - Controller Bridge",
    "Remote Switch - OBS"
)

Get-ScheduledTask -TaskName $taskNames -ErrorAction SilentlyContinue |
    Select-Object TaskName, State

Get-CimInstance Win32_Service |
    Where-Object { $_.Name -match "parsec" -or $_.DisplayName -match "parsec" } |
    Select-Object Name, DisplayName, State, StartMode

$winlogonPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon"
$autoLogon = (Get-ItemProperty $winlogonPath -Name AutoAdminLogon -ErrorAction SilentlyContinue).AutoAdminLogon
Write-Host "AutoAdminLogon = $autoLogon"

$unexpected = @(Get-CimInstance Win32_Process | Where-Object {
    $_.Name -eq "obs64.exe" -or
    $_.Name -eq "parsecd.exe" -or
    $_.Name -eq "pservice.exe" -or
    $_.CommandLine -match "switch_pico_bridge\.controller_uart_bridge"
})

if ($unexpected.Count -eq 0) {
    Write-Host "PASS: no Remote Switch background processes are running."
} else {
    $unexpected | Select-Object ProcessId, Name, CommandLine
}
```

Pass conditions:

- Both tasks are `Disabled`.
- Parsec services are `Stopped` with `StartMode` equal to `Disabled`.
- `AutoAdminLogon` is `0` or blank.
- The script prints `PASS: no Remote Switch background processes are running.`

## 10. Resume the project later

Keep this section for the future. First restore the Parsec service from the newest saved state. Run this block in **Administrator PowerShell**:

```powershell
$stateFile = Get-ChildItem -Path "C:\RemoteSwitch\pause-state\parsec-services-before-pause-*.json" |
    Sort-Object LastWriteTime -Descending |
    Select-Object -First 1

if ($null -eq $stateFile) {
    throw "No saved Parsec service state was found."
}

$savedServices = @(
    Get-Content $stateFile.FullName -Raw | ConvertFrom-Json
)

foreach ($service in $savedServices) {
    $startupType = switch ($service.StartMode) {
        "Auto"     { "Automatic" }
        "Manual"   { "Manual" }
        "Disabled" { "Disabled" }
        default    { "Automatic" }
    }

    Set-Service -Name $service.Name -StartupType $startupType
    if ($service.State -eq "Running" -and $startupType -ne "Disabled") {
        Start-Service -Name $service.Name
    }
}

Get-CimInstance Win32_Service |
    Where-Object { $_.Name -match "parsec" -or $_.DisplayName -match "parsec" } |
    Select-Object Name, DisplayName, State, StartMode
```

Then restore the app settings:

1. Launch Parsec, set **Settings > Host > Hosting Enabled** to **On**, and enable **Run when computer starts** from its tray menu.
2. Launch OBS, open **Tools > Scripts**, click **+**, and reload `C:\RemoteSwitch\obs-auto-projector.lua`.
3. Reconnect any hardware you unplugged.
4. Re-enable—but do not immediately duplicate—the two existing scheduled tasks:

```powershell
Enable-ScheduledTask -TaskName "Remote Switch - Controller Bridge"
Enable-ScheduledTask -TaskName "Remote Switch - OBS"
```

5. If you again want unattended recovery, run `Autologon64.exe` as administrator and choose **Enable**. This is optional.
6. Restart Windows and repeat the staged acceptance test in the [main Remote Switch guide](/#17-staged-acceptance-test-after-the-reboot).

Do not recreate the scheduled tasks: the originals were disabled, not deleted.