# How to Run The Last of Us Remastered Natively on Windows: PC Port Setup Guide

> AI Release · @ai_release1 · https://ai-release.org/guides/kak-zapustit-the-last-of-us-remastered-nativno-na-windo_en.html

## TL;DR

- **Time to complete:** 30–45 minutes, plus download time
- **Difficulty:** Intermediate
- **You will need:** Windows 10/11 64-bit with admin rights, 7-Zip, Microsoft Visual C++ Redistributable 2015–2022 (x64), the current GPU driver from NVIDIA/AMD/Intel, and the community port's release archive together with its published SHA-256 checksum

Anything written in angle brackets — `<port-executable>`, `<port-release-archive>` — is a placeholder. Replace it with the exact file name from the release notes you downloaded. This guide deliberately does not invent versions, file names or minimum specs: community native ports are unofficial builds, each release ships its own requirements, and those notes are the only authority.

## Requirements and setup
![Illustration: Requirements and setup](https://ai-release.org/guides/img/kak-zapustit-the-last-of-us-remastered-nativno-na-windo-en-1.jpg?v=1794041891)


- **OS:** Windows 10 (64-bit) or Windows 11. Confirm with `winver`.
- **Rights:** a local administrator account — installing runtimes and adding Defender exclusions both require elevation.
- **Packer:** 7-Zip, because release archives are usually `.7z` and Windows Explorer cannot open them.
- **Runtime:** Microsoft Visual C++ Redistributable 2015–2022 **x64**. This is the shared library package most compiled Windows games link against; without it the executable refuses to start.
- **Driver:** the latest Game Ready / Adrenalin / Arc driver for your GPU.
- **Disk:** the free-space figure stated in the release notes, plus about 2 GB for extraction overhead.
- **Files:** the release archive and the checksum value published next to it.

Native ports are built by hobbyist teams and distributed from their own release pages, so there is no download URL in this article. Treat "no checksum published" as a red flag.

**Example:** run `winver` and you should see a dialog such as *Windows 11, Version 23H2 (OS Build 22631.xxxx)*. Anything below Windows 10 64-bit is a hard stop.

Setup checklist before you start:

- [ ] 64-bit Windows 10/11 confirmed
- [ ] Administrator session available
- [ ] 7-Zip installed
- [ ] VC++ 2015–2022 x64 installed
- [ ] GPU driver updated
- [ ] Archive + checksum downloaded
- [ ] Free space ≥ the value in the release notes

If you have already set up a different community native port, the flow is nearly identical to the [BotW-Native Windows guide](https://ai-release.org/guides/kak-zapustit-the-legend-of-zelda-breath-of-the-wild-nat.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide) — same archive, runtime and GPU-preference steps.

## Step 1. Verify the hardware and the archive before extracting
![Illustration: Step 1. Verify the hardware and the archive before extracting](https://ai-release.org/guides/img/kak-zapustit-the-last-of-us-remastered-nativno-na-windo-en-2.jpg?v=1794041902)


**What to do:** record your GPU model, driver version and free disk space, then compute the SHA-256 hash of the downloaded archive.

**Why:** A SHA-256 hash is a fingerprint of a file: if one byte changed during download, the fingerprint changes. Truncated downloads and outdated drivers cause most "it opens a black window and closes" reports, and hashing takes seconds while re-downloading takes an hour.

**How to check:** the printed hash must match the published value character for character, and free space must exceed the release-notes requirement.

```powershell
Get-FileHash -Algorithm SHA256 "$env:USERPROFILE\Downloads\<port-release-archive>.7z"
```

Expected output — an `Algorithm` column reading `SHA256`, a 64-character `Hash`, and the `Path`:

```
Algorithm       Hash                                                             Path
---------       ----                                                             ----
SHA256          9F2C...<64 hex characters total>...4A1B                            C:\Users\me\Downloads\<port-release-archive>.7z
```

Now capture the machine profile:

```powershell
Get-CimInstance Win32_VideoController | Select-Object Name, DriverVersion, DriverDate
Get-PSDrive C | Select-Object @{n='FreeGB';e={[math]::Round($_.Free/1GB,1)}}
```

**Example output:** `NVIDIA GeForce RTX 3060`, `DriverVersion 5xx.xx`, `DriverDate 2024-xx-xx`, and `FreeGB 84.3`. If `FreeGB` is below the release-notes figure, move the archive to another drive before continuing.

## Step 2. Extract to a short path, install the runtime, and launch
![Illustration: Step 2. Extract to a short path, install the runtime, and launch](https://ai-release.org/guides/img/kak-zapustit-the-last-of-us-remastered-nativno-na-windo-en-3.jpg?v=1794041913)


**What to do:** extract the archive with 7-Zip into a short ASCII path such as `C:\Games\TLoUR`, install the VC++ runtime if Step 1 did not confirm it, add a Defender exclusion for that folder, then start the executable from a small batch launcher that writes a log.

**Why:** Long paths containing spaces or non-Latin characters break some builds, because internal asset loaders concatenate paths without quoting. The executable is unsigned, so Windows Defender may quarantine it mid-extraction. The batch launcher matters because a native port that crashes on startup usually prints the reason to stdout, and double-clicking the `.exe` discards it.

**How to check:** the extraction log ends without errors, the folder contains the executable plus the data directory, and `launch.log` is created on the first run.

```powershell
& "C:\Program Files\7-Zip\7z.exe" x "$env:USERPROFILE\Downloads\<port-release-archive>.7z" -o"C:\Games\TLoUR" -y
Get-ChildItem "C:\Games\TLoUR" | Select-Object Mode, Length, Name
```

Expected listing — the executable and at least one data folder:

```
Mode   Length        Name
----   ------        ----
d-----               data
-a---- 73400320      <port-executable>.exe
-a---- 1024          README.txt
```

Create `C:\Games\TLoUR\launch.cmd` in Notepad (choose *All Files* as the type) with these three lines:

```bat
@echo off
cd /d C:\Games\TLoUR
"<port-executable>.exe" > launch.log 2>&1
```

Then run it and read the log:

```powershell
& "C:\Games\TLoUR\launch.cmd"
Get-Content "C:\Games\TLoUR\launch.log" -Tail 20
```

**Example:** a healthy first start prints lines about initialising the renderer and creating a window, and the game window appears within a few seconds. If Defender removed the executable, add the exclusion first, then re-extract:

```powershell
Add-MpPreference -ExclusionPath "C:\Games\TLoUR"
```

Only exclude a folder whose hash you verified in Step 1.

## Step 3. Confirm the port runs natively, then tune graphics

**What to do:** prove that nothing is emulating console hardware, confirm the port is using the discrete GPU, and only then adjust resolution and frame settings in the game's own options menu.

**Why:** "native" means the executable was compiled for x86-64 Windows and talks straight to DirectX/Vulkan, with no emulator translating console instructions. An emulator is a program that imitates console hardware in software — it costs performance and is exactly what this setup avoids. Sorting out GPU selection first prevents you from tuning settings against the wrong adapter.

**How to check:** no emulator processes exist, the port's process appears in Task Manager, and the GPU engine graph moves off idle.

```powershell
Get-Process | Where-Object { $_.Name -match 'rpcs3|yuzu|ryujinx|cemu|shadps4' } | Select-Object Name, Id
Get-Process -Name "<port-executable>" | Select-Object Name, Id, Path
```

**Example:** the first command returns nothing at all — that is the proof that no emulator is loaded. The second returns one row, e.g. `Name <port-executable>`, a `Path` of `C:\Games\TLoUR\<port-executable>.exe`. Then open Task Manager → *Performance* → *GPU*: the *3D* engine graph follows the in-game load instead of sitting at 0%.

Finally, open the port's in-game graphics menu and set the resolution to your monitor's native value. If the build ships an `.ini` or `.cfg` file, edit it with `notepad C:\Games\TLoUR\<config-file>` and change only keys that already exist in that file — never add new ones, since unknown keys are ignored or crash the parser depending on the build.

## Troubleshooting

**Problem. The game does not start and Windows reports a missing DLL**

- Error: `The code execution cannot proceed because VCRUNTIME140_1.dll was not found. Reinstalling the program may fix this problem.`
- Cause: the Visual C++ 2015–2022 x64 runtime is absent, so the executable cannot resolve its C++ standard-library dependency.
- Solution: install `vc_redist.x64.exe` from Microsoft, reboot, and rerun `C:\Games\TLoUR\launch.cmd`. Verify with `Get-ChildItem C:\Windows\System32\vcruntime140_1.dll` — the file must exist.

**Problem. The executable exits instantly with a hexadecimal status code**

- Error: `The application was unable to start correctly (0xc000007b). Click OK to close the application.`
- Cause: a 32-bit/64-bit mismatch — typically a 32-bit runtime installed next to a 64-bit executable, or a stray DLL copied into the game folder by a third-party "fix".
- Solution: install **both** the x86 and x64 redistributables, delete any DLLs you added manually from `C:\Games\TLoUR`, and confirm the executable's bitness via right-click → *Properties* → *Details*. Compare against the bitness stated in the release notes.

**Problem. The archive extracts incompletely or the executable disappears**

- Error: `Operation did not complete successfully because the file contains a virus or potentially unwanted software.`
- Cause: Defender heuristics flag unsigned community builds; the file is quarantined during extraction.
- Solution: add the exclusion (`Add-MpPreference -ExclusionPath "C:\Games\TLoUR"`), re-extract with 7-Zip using `-y`, and check *Windows Security → Protection history* to confirm nothing else was removed. Re-verify the SHA-256 afterwards.

If you also run ports on Android, the process of picking the right build and dropping the emulator layer is described in the [NVIDIA SHIELD ports guide](https://ai-release.org/guides/kak-zapustit-metal-gear-solid-2-hd-i-drugie-porty-nvidi.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

## Summary and next steps

You now have a verified archive, a clean extraction path, and a launcher that produces a readable log every time the game starts. Next, tune resolution and frame settings one variable at a time, then compare the result against the emulator-based route to see the performance difference for yourself.

## FAQ

**Do I need an emulator to play The Last of Us Remastered on Windows?**
No. A native port is compiled for Windows and talks directly to DirectX or Vulkan, so no console emulator is involved; Step 3 shows how to confirm that with a process check.

**Is this an official PC release from the game's publisher?**
No. The builds described here are unofficial community ports distributed by their authors, which is why this guide points you to release notes instead of a download link.

**How do I know the download is safe?**
Compare the SHA-256 hash from `Get-FileHash` with the value published alongside the release. If no checksum is published or the values differ, do not run the executable.

**The game launches but the window is black — what do I check first?**
Read `launch.log` in the install folder: it names the failing subsystem. Then confirm the GPU driver version from Step 1 matches the current release from your GPU vendor, and check that the resolution in the game's config does not exceed your monitor's native value.
