Repo ↗ · Source README ↗ · Markdown & license bundle

Image reference (original game): Skate 3 · original-game artwork, provided by IGDB. Image rights remain with their respective owners. This illustrates the referenced original game, not the actual visuals of this rewrite or mod.

Source maintainer: SK8-ENGINE · Revision: 311cd40e8a8f · Catalogued: 2026-10-12

Source license: MIT · LICENSE-PROJECT.md · Article: Source README (format adapted)

The source README follows, with formatting adapted for this site and images replaced by source links. Feature, completion and testing claims belong to its authors and have not been independently playtested here. The Traditional Chinese translation was prepared with AI assistance.

Skate 3 Custom Engine Layer

New here? Download the
current Windows release (preview.18)
and follow the five-step setup guide.
Do not download GitHub’s automatic Source code zip.

Skate 3 Custom Engine Layer builds a project-owned world, rendering,
physics, and Blender map-authoring layer on top of
Skate3Recomp. It keeps Skate 3’s
skater, board, tricks, animation, and gameplay while allowing original SKATE
worlds to be authored as editable Blender projects and loaded from an in-game
map library.

Current additions include custom visual geometry, authoritative collision,
grind paths, PBR materials, baked and dynamic lighting, day/night settings,
weather, mirrors, water, and contact-driven hinged doors. The project is
unofficial and is not affiliated with Electronic Arts.

Download and first start

The current public preview is for Windows and D3D12. Other platforms and
render paths exist upstream, but the Custom Engine Layer has not been properly
validated on Vulkan, Linux, or macOS yet.

Download
Skate3CustomEngineLayer-0.1.0-preview.18-Windows.zip
from the preview.18 Releases page.
Do not download GitHub’s automatic Source code zip.
Extract the entire zip to a normal folder you control.
Run skate3.exe.
Select your own legally obtained Skate 3 Xbox 360 ISO when prompted.
Let the installer prepare the local game files, then start the game
normally.

The included Blender Feature Park should be selected automatically on a fresh
install. Press Escape on keyboard or RB + Start on controller to open
the settings menu.

No retail maps or game files are included in the download.

Installing custom maps

Open Settings → Maps → Open Maps Folder.
Place your .skate map files in the folder that opens.
Return to the game and press Refresh Map List.
Select a map and press Load Selected Map.

The game restarts when you change maps so it can reload the collision, grinds,
physics, lighting, and renderer cleanly. Your selected map is remembered for
the next launch.

Only install .skate packages from people you trust. A .blend file is
Blender source and cannot be loaded directly by the game. See
Custom Maps for package compatibility, folder locations,
troubleshooting, and map-authoring links.

What happens when the custom world starts

Run the normal executable with no special launch flags. Once Skate 3 reaches
gameplay, the Custom Engine Layer activates automatically, loads the selected
map from the Maps folder, installs its native collision and grind data, and
removes the retail world’s static collision.

Updating the Custom Engine Layer

Windows release builds can update themselves from Settings → System →
Update Custom Engine Layer. The verified release is installed after the
game closes, while retail game data, saves, settings, and user maps are left
in place. The downloaded release also refreshes the standalone Blender addon
zip; users remain in control of installing it into Blender.

Preview.15 and preview.16 require one manual update to preview.17 because
their updater crashes while verifying a downloaded archive. Extract
preview.17 over the existing installation with the game closed, preserving
the existing game, maps, saves, and settings files. In-game updates work
normally from preview.17 onward.

Features at a glance

Self-contained custom maps: .skate packages can include visual
geometry, textures, materials, collision, grind paths, lights, authored
world settings, sounds, physics, doors, water, mirrors, and editable object
data. The current exporter writes SKATE v15.
Blender map authoring: the Windows release includes the installable
Owned World Authoring addon, the full source-only map toolkit, the
sk8-auto-map agent workflow, and an editable Feature Park example.
Custom renderer and world controls: custom maps support PBR materials,
baked and dynamic lighting, local lights, shadows, day/night palettes, and
world settings for time, sun, sky, ambient light, and lighting balance.
Vanilla Mode: the Maps menu can restart into Alex’s native renderer with
the retail University world, collision, GrindData, splines, shadows, and
gameplay authority while preserving custom-map settings.
NVIDIA DLSS Super Resolution: the Windows D3D12 release supports Off,
Quality, Balanced, Performance, and DLAA with safe fallback on unsupported
GPUs, drivers, backends, or missing plugins.
Live map editor and custom objects: press G during gameplay to enter
the editor and E to browse placeable objects. Shareable .skateobj
packages can carry their own rendering, collision, materials, grind rails,
and physics. Editor changes currently last for the running session only.
Experimental multiplayer: Steam lobbies replicate remote players,
boards, outfits, animation, tricks, and bails directly between peers.
Multiplayer remains experimental and does not yet provide shared collision,
scoring, trick authority, or host migration.

The original skating, board physics, tricks, and animation still come from
Skate 3. The Custom Engine Layer controls the world and systems around that
gameplay. See Known Issues for the current limitations and
Changelog for what each preview adds.

Press F6 during gameplay to open the experimental native menu prototype.
It reconstructs Skate 3’s Career crossbar presentation with project-owned
C++/ImGui rendering and exact UI assets extracted locally from the user’s own
game copy. The prototype supports category and row navigation and can display
the reconstructed Game Settings screen without replacing the existing
settings menu.

This is an opt-in development feature, not a complete frontend replacement.
Game Settings entries are currently display-only, most menu actions are not
connected to gameplay outcomes, and sound-event mappings remain experimental.
No extracted retail assets are included in the repository or distributed with
source releases.

Documentation

Topic	Documentation
Installing and switching custom maps	Custom Maps
Creating and exporting a map in Blender	Blender Map Authoring
Extracting legally owned vanilla maps for Blender	Vanilla Map Extraction
SKATE v15 binary specification	SKATE Format
Building and packaging a release	Release Guide
Optional NVIDIA DLSS Super Resolution	DLSS Super Resolution
Private NVIDIA DLSS Neural Rendering preview	DLSS Neural Rendering Preview
Multiplayer sessions and visual replication	Multiplayer
Preview limitations	Known Issues
Release history	Changelog

The Blender addon is designed to be used without Python or command-line
knowledge. After installing it, open 3D View → Sidebar → Skate 3 Map,
place the spawn, and export. Ordinary Blender meshes, Principled materials and
textures, real Blender lights, UV channels, and sensible static collision are
prepared automatically. Visual/collision overrides, grind splines, doors,
contact materials, and experimental NPC routes remain available for authors
who need explicit control.

The repository includes only our original Blender Feature Park demonstration
and its self-contained Blender source under maps. No Skate 3 retail
files, third-party maps, or extracted assets are distributed. You must provide
your own legally obtained game copy, and map authors must have permission to
distribute everything embedded in their SKATE packages.

Licensing and upstream permission

Original Custom Engine Layer code is available under
the MIT License. Upstream-derived and third-party files
retain their existing ownership and terms. This source fork is published with
the upstream maintainer’s permission as recorded in NOTICE.md.
No Electronic Arts game data or intellectual property is licensed or
distributed by this project.

Upstream Skate3Recomp README

The remainder of this README retains the upstream project information and
installation guidance. Release filenames have been adjusted for this fork.
Platform claims below describe upstream Skate3Recomp; this fork’s initial
Custom Engine Layer preview is validated only on Windows/D3D12.

README image：Skate 3 Native PC Recompilation

An unofficial native recompilation of the Xbox 360 version of Skate 3,
supporting Windows, Linux, and macOS.

As of v2.0.0, the game runs on a native renderer built directly on Direct3D 12 and Vulkan instead of emulating the Xbox 360 GPU. Compared to the emulated renderer it delivers more than twice the frame rate at roughly a quarter of the GPU power draw, and on Apple Silicon the frame rate uplift is closer to 10x.

The new native renderer is early and is likely to have issues, I haven’t tested the game all the way through.

The project does not include Skate 3 retail game files. To run or build the project, you must provide files from your own legally obtained Xbox 360 copy of Skate 3.

Native Rendering Showcase (click to go to YouTube):

README link

How Do I Play?

Notes:

The Windows version is the most tested, followed by Linux, and then macOS.
On some hardware configurations, you may have a better experience running the Windows version through a translation layer like Proton rather than the native Linux build itself.
The macOS ARM build is experimental and more prone to issues.

Windows

Download the latest Skate3CustomEngineLayer Windows release from the releases page.
Extract it anywhere you like, to a folder you control.
Run skate3.exe.
Click “Select ISO” to select your legally obtained copy of Skate 3.
Wait for the installer to extract the game files.
Click “Start Game”.

Linux

Download the latest Skate3CustomEngineLayer Linux release from the releases page.
Extract it anywhere you like, to a folder you control.
Run skate3.
Click “Select ISO” to select your legally obtained copy of Skate 3.
Wait for the installer to extract the game files.
Click “Start Game”.

macOS (ARM / Experimental)

Download the latest Skate3CustomEngineLayer macOS release from the releases page.
Extract it anywhere you like, to a folder you control.
Run the game by opening the skate3recomp app. Game files, saves and settings are kept in the folder containing the app, so keep it in a folder you control rather than in Downloads or Applications.
The first time, right-click the app and choose Open, or approve it under System Settings > Privacy & Security, before macOS will allow it to run.
Click “Select ISO” to select your legally obtained copy of Skate 3.
Wait for the installer to extract the game files.
Click “Start Game”.

Native Renderer

Since v2.0.0 the game no longer relies on emulating the Xbox 360 GPU. A native renderer draws the game directly through Direct3D 12 or Vulkan, covering the entire game: gameplay, menus, HUD, loading screens, videos, and the photo, replay, skater, and park editors. It runs exact ports of the game’s own material shading for the world, characters, vehicles, and water, so the image stays at close visual parity with the original console output while running far faster and more efficiently.

The native renderer is on by default. Settings > Video > Renderer switches between Native and Emulated live, and F5 hot-toggles between them at any time. If the native renderer ever hits an unrecoverable error, the game falls back to the emulated renderer and shows a corner indicator; F5 retries the native path.
On Windows, a single build ships both graphics API backends: Settings > Video > Graphics API selects DirectX 12 or Vulkan (applied with Apply & Restart; DirectX 12 is preferred by default). Linux uses Vulkan, and macOS uses Vulkan through MoltenVK.
Optional enhancements beyond the original game live under Settings > Video: MSAA up to 8x, enhanced real-time sun shadows with contact-hardening soft shadows, ambient occlusion, bloom, volumetric lighting, extended draw distance and world streaming, render scale up to 3x, and true ultrawide.

Known issues:

Occasional texture and asset pop-in or brief flicker while streaming quickly around the map (also present in the emulated renderer)
Issues with rendering skater customization options in the edit skater mode (skin, hair, clothing etc.)
Hall of Meat currently not rendered properly (missing bone highlights etc.)
Skate parks and park editing currently have some general visual parity / rendering issues

Installing DLC

To use DLC, you must provide package files from your own legally obtained Xbox 360 DLC.

Create a dlc folder either beside the executable, inside the installed game folder,
or in the user data folder. Place the DLC package files in that
folder and start the game.

Saves and Portable Mode

Saved games live in the user data folder by default (%APPDATA%\skate3, i.e.
AppData\Roaming\skate3, on Windows). Two portable options are available:

Create a saves folder next to the executable and the game keeps saved games
there instead. The folder must exist before launch, and existing saves are not
migrated automatically - copy them over from the user data folder.
Create an empty portable.txt file next to the executable to keep all user
data in the executable’s folder.

True Ultrawide

The builds include an experimental true ultrawide mode: the native renderer draws the world at your display’s full aspect ratio (21:9 and wider) with a matching wider field of view, while the HUD and menus stay centered and undistorted. Enable it via the Aspect Ratio setting or skate3_ultrawide = true. It requires the native renderer; with the emulated renderer the game presents in standard 16:9. Rendering more of the scene costs proportionally more GPU time.

Controls

Standard Xbox controls using an Xbox controller are the preferred and main input method.
PlayStation (DualShock/DualSense), Switch and most generic controllers are supported through the SDL controller backend: set Settings > Controls > Controller Backend to SDL and restart the game. Steam Input through XInput also works. On Linux and macOS the SDL backend is always used, so these controllers work out of the box.
Keyboard controls can be enabled in the game settings menu.
Press Escape on keyboard or (RB + Start) on the controller to open the game settings menu. The chord can be changed in Settings > Controls.

Keyboard Keybinds

Left stick: W/A/S/D
Right stick: mouse movement
A/B/X/Y: Space/C/E/F
LT/RT: RMB/LMB
LB/RB: Q/R
Left stick press: Shift
Right stick press: MMB
Back/Start: Tab/Return

In-game map editor (MVP)

Press G to enter or leave the runtime editor. The local skater remains
visible, while normal gameplay input and the gameplay camera are suspended.
Hold RMB to hide/capture mouse-look and release RMB to restore the cursor; use W/A/S/D
to fly, Space to rise, Q or C to descend, Shift for fast movement, and
Ctrl for slow movement. LMB selects an authored map object; drag a coloured
world-space axis arrow to move it, or drag one of the three rings to rotate it. Releasing LMB
commits the pose. The selected object has a subtle cyan outer contour. The
E key opens the spawn-object list, which groups .skateobj files in the
objects folder beside skate3.exe and maps by their immediate parent
folder. Use
Build defaults from installed Skate 3 on first setup to convert the
supported built-in drop items from your own local game/data/content/parkassets.big.
The converter takes the category names and item membership from Skate 3’s
retail park-asset recipes, writes the resulting files only to the current
installation’s objects folder, and can safely be rerun to reuse valid packages or
repair incomplete ones. No extracted game asset is bundled with the editor.
Non-model recipe helpers such as teleport and spawner markers are reported
as unsupported rather than emitted as unusable objects. Every immediate
subfolder of objects is a category, so users can add any category simply by
creating and naming a folder. The .skateobj format is unchanged. The
list’s Refresh objects button rescans
all category folders without restarting;
select an entry and click Spawn selected or press Enter to place it on the
surface under the camera aim. Spawned render geometry, collision, and attached
grind splines use the same runtime transform as authored objects. The
editor releases cursor capture and ignores all keyboard/mouse state whenever
the game is not the foreground window. Changes affect rendering, native
collision, and associated grind rails for the current run only and are not
saved.

The native vanilla-style menu remains on F6. Screenshots use Shift+F6, the
draw-distance debug marker is Alt+F6 (or LB+B), and the standalone drone
camera remains on End outside editor mode.

Use scripts/Run-MapEditorVisualCheck.ps1 -UseGeneratedEditorMap for the
dedicated three-object validation map. The script performs incremental
Release/test builds, generates the validation asset locally, stages an
isolated portable run, launches the game only when invoked by the user, and
writes timestamped event and STATUS telemetry logs under
out/map-editor-runs. Add -FullRebuild only for troubleshooting; ordinary
checks should remain incremental.

The visual-check build verifies the expanded retail codegen image separately
from the packaged runtime game directory, and restores the reviewed
preview.14 generated-source cache before compiling. Override their locations
with SKATE3_CODEGEN_GAME_DATA_ROOT and SKATE3_TRUSTED_GENERATED_ROOT only
when intentionally reproducing that exact release boundary.

Building from Source

All platforms build with CMake 3.25+, Ninja, and Clang 18 or newer - ReXGlue
requires Clang, so MSVC and Apple Clang are not supported. On Windows, install
LLVM for Windows and Ninja.

Clone with submodules:

git clone --recursive <repo-url> skate3recomp
cd skate3recomp

If you already cloned without submodules:

git submodule sync --recursive
git submodule update --init --recursive --jobs "$(nproc 2>/dev/null || echo 4)"

The build-time codegen needs an extracted game dump containing default.xex and
data/webkit/EAWebkit.xex. Put that dump in game/, or pass a path with
SKATE3_GAME_DATA_ROOT.

The runtime also needs the Skate 3 Title Update 3 package - the same
TU_12K2276_000000C000000.00000000000O3 file the in-game title update
installer downloads. Place it in the repository root under its original name,
or pass a path with -DSKATE3_TITLE_UPDATE_PACKAGE=. The build extracts and
stages its .xexp patches next to the application.

Custom Engine Layer release codegen deliberately keeps the base executable’s
stable addresses because the owned collision, grind, trick, and lifecycle
observers are reviewed against that address space. The TU3 function-boundary
configuration is still required so TU-only alternate entry points are present
in the generated function table, and TU3 is then applied by the runtime. If an
extracted dump already contains both .xexp files, the build detects and
stages them without needing the original package. Generating host code directly
from the patched executable is an experimental upstream path available with
-DSKATE3_CODEGEN_PATCHED_TITLE_UPDATE=ON; it is not compatible with the
current owned observer patch set.

Generate the recompiled source first:

cmake --preset relwithdebinfo -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset relwithdebinfo --target generate-all --parallel

Then reconfigure so CMake sees the generated source lists and build:

cmake --preset relwithdebinfo -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset relwithdebinfo --parallel

For release packaging, use the release preset on Windows, the
linux-release preset on Linux, or the macos-release preset on macOS.

The native renderer’s HLSL sources live in src/native/shaders and are
embedded into the build automatically. The matching Vulkan SPIR-V binaries are
pre-compiled offline with DXC and committed under src/native/shaders/spirv,
so building needs no shader tooling; the SPIR-V header only needs regenerating
after editing the HLSL.

Ubuntu/Linux Build

These instructions target Ubuntu 24.04 LTS on x86_64. Other distributions need
the same toolchain shape: CMake, Ninja, Clang 20 or newer, Vulkan development
headers, GTK 3 development headers, and SDL-compatible audio/input development
packages.

ReXGlue requires Clang. Clang 20 is recommended on Ubuntu because it matches the
Linux toolchain used by the rexglue SDK CI and avoids Ubuntu 24.04’s
Clang 18/libstdc++ std::expected feature-test mismatch.

Install LLVM’s apt repository and dependencies:

sudo apt update
sudo apt install -y wget gnupg lsb-release software-properties-common
wget https://apt.llvm.org/llvm.sh
chmod +x llvm.sh
sudo ./llvm.sh 20
sudo apt install -y \
  git cmake ninja-build build-essential pkg-config p7zip-full \
  clang-20 lld-20 \
  libgtk-3-dev libx11-xcb-dev \
  libvulkan-dev vulkan-tools mesa-vulkan-drivers \
  libasound2-dev libpulse-dev libpipewire-0.3-dev libudev-dev

Optional packages improve controller/input and diagnostics coverage in SDL:

sudo apt install -y libusb-1.0-0-dev libunwind-dev libibus-1.0-dev liburing-dev

Initialize submodules as described above, then configure, generate,
reconfigure, and build a development build:

cmake --preset linux-relwithdebinfo -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset linux-relwithdebinfo --target generate-all --parallel
cmake --preset linux-relwithdebinfo -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset linux-relwithdebinfo --parallel

Build a Linux release:

cmake --preset linux-release -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset linux-release --target generate-all --parallel
cmake --preset linux-release -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset linux-release --parallel

The release artifacts are:

out/build/linux-release/skate3
out/build/linux-release/librexruntime.so

macOS Build (Apple Silicon)

macOS builds use Homebrew LLVM - the macos-* presets expect the toolchain at
/opt/homebrew/opt/llvm. Vulkan is provided by MoltenVK; the build copies the
library next to the executable and writes a MoltenVK_icd.json, looking in
$VULKAN_SDK/lib, /opt/homebrew/lib, and /usr/local/lib.

brew install llvm cmake ninja molten-vk

Configure, generate, reconfigure, and build a release:

cmake --preset macos-release -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset macos-release --target generate-all --parallel
cmake --preset macos-release -DSKATE3_GAME_DATA_ROOT="$PWD/game"
cmake --build --preset macos-release --parallel

The release artifacts are out/build/macos-release/skate3 and
librexruntime.dylib, plus the MoltenVK library and ICD manifest beside them.

Running a Development Build

Run the built executable directly with a game dump. On Linux:

LD_LIBRARY_PATH="$PWD/third_party/rexglue-sdk/out/linux-amd64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" \
  ./out/build/linux-relwithdebinfo/skate3 --game_data_root="$PWD/game"

On Windows:

.\out\build\relwithdebinfo\skate3.exe --game_data_root="$PWD\game"

Keyboard-to-controller emulation is off by default; enable it in
Settings > Controls > Mouse & Keyboard Mode.

Fullscreen is on by default. Pass --fullscreen=false to start windowed.
On Windows, ultrawide displays are detected automatically in fullscreen. For an
ultrawide window, pass matching --window_width and --window_height values;
the native renderer then draws true widescreen frames at that aspect.

rexglue Fork

third_party/rexglue-sdk is pinned as a Git submodule to the
skate3-sdk-clean branch of the Skate-specific rexglue fork. Clone
recursively or run:

git submodule sync --recursive
git submodule update --init --recursive --jobs "$(nproc 2>/dev/null || echo 4)"

The fork is based on rexglue’s 0.8.0 release line and contains the Skate 3
runtime, codegen, input, timing, the Direct3D 12 and Vulkan backends used by
the native renderer, the settings overlay, and the Linux and macOS fixes
needed by this project.

Credits

rexglue SDK, the recompilation SDK
used by this project.
Xenia, whose Xbox 360 research and
tooling have helped the broader recompilation ecosystem.

License and provenance

The README and its translation retain MIT terms. Changes comprise translation, links and formatting. Editable Markdown, the original README, LICENSE and NOTICE files are included in the linked bundle. This grants no rights to the original games, their assets or trademarks.

LICENSE-PROJECT.md

MIT License

Copyright (c) 2026 Skate 3 Custom Engine Layer contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of the original Custom Engine Layer software and associated documentation
files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the following
conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

This license applies only to original project-owned additions. It does not
relicense Skate3Recomp, rexglue, third-party dependencies, Electronic Arts
game data, or assets embedded by map authors.

NOTICE.md

# Notices and upstream permission

Skate 3 Custom Engine Layer is an unofficial fan project. It is not affiliated
with, authorized by, or endorsed by Electronic Arts.

This repository is a fork of
[Skate3Recomp](https://github.com/mchughalex/skate3recomp) and uses a companion
fork of
[rexglue-skate3](https://github.com/mchughalex/rexglue-skate3). The project
maintainer has confirmed that the upstream maintainer gave permission to
publish this source fork. That permission is recorded here so the fork's
provenance is explicit; it does not replace or broaden the ownership and
licensing terms attached to upstream or third-party files.

Original Custom Engine Layer additions are covered by
[LICENSE-PROJECT.md](LICENSE-PROJECT.md). Third-party components retain their
own notices and licenses.

Owned-world rigid-body simulation uses Erin Catto's
[Box3D](https://github.com/erincatto/box3d), pinned at release `v0.1.0`
(`8441b4a06d6d09dcfb0b0f704df4d847d1437b92`). Box3D is distributed under
the MIT License; its complete license is retained at
`third_party/box3d/LICENSE` and copied into Windows release packages as
`LICENSE-Box3D.txt`.

SKATE package compression uses
[zlib](https://github.com/madler/zlib), pinned at release `v1.3.2`
(`da607da739fa6047df13e66a2af6b8bec7c2a498`), and
[Zstandard](https://github.com/facebook/zstd), pinned at release `v1.5.7`
(`f8745da6ff1ad1e7bab384bd1f9d742439278e99`). Their complete licenses are
retained at `third_party/zlib/LICENSE` and `third_party/zstd/LICENSE` and
copied into Windows release packages as `LICENSE-zlib.txt` and
`LICENSE-zstd.txt`.

Optional Windows DirectX 12 builds use
[NVIDIA RTX Streamline](https://github.com/NVIDIA-RTX/Streamline), pinned to
SDK release `v2.12.0`. The official SDK archive SHA-256 is
`f5c0a3d870707dddc3570fb4bcd3655cf48a8a68c3a9d342910cfa21b77dcf48`.
Streamline source and interface code are provided under the MIT License.
DLSS is NVIDIA proprietary technology; `nvngx_dlss.dll` is redistributed only
in object-code form under NVIDIA's DLSS license. A DLSS-enabled package keeps
the SDK's `license.txt`, `3rd-party-licenses.md`, and
`nvngx_dlss.license.txt` with the runtime. Development plugins, SDK samples,
tools, symbols, and headers are not distributed. Before a public or
commercial DLSS-enabled release, the distributor must comply with NVIDIA's
notification, attribution, protective-terms, and trademark requirements.
Exact runtime versions, checksums, official source links, and development
identity requirements are documented in
[DLSS_SUPER_RESOLUTION.md](DLSS_SUPER_RESOLUTION.md).

An optional local-only DLSS Neural Rendering integration can consume
NVIDIA-signed private Streamline 2.13 / NGX 310.8 artifacts supplied directly
to an authorized NVIDIA developer. Those preview bundles are not committed or
included in public packages. Because the supplied bundles do not contain the
complete 2.13 SDK license and redistribution notices, this repository makes no
redistribution claim for them and the release packager rejects preview-enabled
builds. Exact private artifact hashes and the capability limitation are
recorded in
[DLSS_NEURAL_RENDERING_PREVIEW.md](DLSS_NEURAL_RENDERING_PREVIEW.md).

No Skate 3 ISO, extracted retail files, title updates, DLC, saves, proprietary
maps, or Electronic Arts assets are included. Users must provide their own
legally obtained game copy. Map authors are responsible for the rights to
everything embedded in a `.skate` package.

SK8-Engine: Skate 3 Custom Engine Layer