Skate 3 Rust Engine: a Bevy reimplementation of Skate 3

What the project is and where the knowledge came from

The Skate 3 Rust Engine is a Rust and Bevy skating project built from Skate 3 reverse engineering research. It includes skating, tricks, grinds, offboard movement, difficulty settings and .skate map support, and the README says gameplay parity is still a work in progress.

The history section is the most interesting part of the documentation, because it explains where the difficult part of the work actually was. Before this rewrite existed, dumbad spent more than two years reverse engineering Skate 3 and building the tools needed to understand and work with it, digging through undocumented file formats, animation data and game interaction systems, then testing those discoveries in the original game. Much of that work is collected in a separate repository, DumbadsSkate3ModdingTools, including tools for custom maps, meshes, collision, challenges and DLC.

That research laid the groundwork for this project. Chasm later worked on a recompilation and a custom renderer based on dumbad's earlier renderer work, before moving into the Rust and Bevy rewrite. And the README draws the lesson explicitly: the rewrite's development time tells only part of the story, because the knowledge and tools it relies on took years of work to establish.

The AI usage section makes the same point from a different angle. AI coding tools were used to develop the rewrite, but the README is careful to say that none of it would have been possible without the reverse engineering effort, and that describing the project as AI rewriting Skate 3 leaves out the work that made it possible. The stated position is that AI helped turn that knowledge into a new implementation and does not replace credit for discovering how the game works, and that using original assets or showing working tricks does not mean every system behaves exactly like the original.

The licence field on the repository records GPL-3.0, and the primary language is Rust.

Playing it: the setup flow and the asset boundary

The play instructions are unusually explicit about the asset boundary, and that is the part a reader needs before anything else.

You download the Experimental release, extract the Windows ZIP and run skate3rust.exe. Then you select your Skate 3 Xbox 360 ISO, or select default.xex in an extracted game folder, and keep its data folder alongside it. The setup prepares the skater, the animations and all the disc maps, then starts University. The original scoring and session-marker HUD assets are also exported automatically during setup. No Blender, Python or Rust installation is needed to play, and the ISO extraction needs internet access, with the first conversion taking a while.

The bold line is that Skate 3 assets are not included. Your converted files stay in the data folder beside your executable. Each freshly unpacked copy runs its own setup and does not adopt another installation, and in-place updates refresh only changed asset groups.

That last arrangement is worth noting. It means the game is fully offline after the first conversion, and it means an update does not re-convert everything, which matters when the conversion is the slow part.

The controls are a compatible gamepad, since SDL3 supports Xbox and XInput, PlayStation, Switch and generic HID controllers, with XInput remaining available as a Windows fallback. Escape opens the graphics, difficulty and map settings, and maps can be switched without restarting the game.

The releases are labelled experimental, and successful main builds replace the prerelease. Choose Latest in Updates for experimental updates, with Stable as the default. The recent tags are experimental from 2026-09-09 and a skyline-driving-update from 2026-09-12, and the last push was on 2026-10-09.

The crate layout and the vendored Bevy patches

The Cargo workspace shows how the engine is decomposed, and the crate names describe the systems.

members = ["crates/skate-core", "crates/skate-audio", "crates/skate-audio-fma", "crates/skate-data", "crates/skate-game", "crates/skate-dynamics", "crates/skate-mods", "crates/skate-net", "crates/skate-steam-relay"]

The split separates the concerns that a game engine of this kind has to keep apart. skate-core is the shared foundation, skate-data handles the game's data formats, skate-game is the gameplay layer, skate-dynamics is the physics, skate-mods is the mod system, skate-net and skate-steam-relay are the online pieces, and the audio is split into a base crate and an FMA variant, which is the usual way to offer an optimised path alongside a portable one.

The workspace uses edition 2024 with resolver version 3, and it is marked as not publishable, which is correct for an application rather than a library. The Bevy dependency is pinned exactly, to 0.18.1, which is what a project with vendored patches needs.

The patch section is the important part.

[patch.crates-io]
bevy_pbr = { path = "vendor/bevy_pbr" }
bevy_core_pipeline = { path = "vendor/bevy_core_pipeline" }
sdl3-sys = { path = "vendor/sdl3-sys" }

Three crates are patched locally, two of them core Bevy rendering crates and one the SDL3 system binding, and the patched sources and their licences live in the vendor/ directory with the tooling under tools/vendor/. The SDL3 patch is the one that matters for the gamepad support the README describes, since sdl3-sys is the native layer underneath it.

The profile settings are tuned for a game rather than a library. The dev profile uses opt-level 3, and every package in dev inherits it, with debug information kept in release and stripping disabled, which is a choice aimed at producing useful crash reports and traces rather than small binaries.

Building from source and the diagnostics tooling

Building requires Windows, Rust with the MSVC toolchain, and LLVM installed in its default location. There are two batch files, BUILD.bat to build and PLAY.bat to launch the test world, and PLAY.bat opens the saved map, University by default, so you can switch maps from the in-game menu or by dragging a .skate file onto it. An SDL3-compatible gamepad is required for gameplay, and Escape opens the difficulty and graphics settings.

Development builds use a prepared asset set in assets/private/ or the installed asset directory, and scripts/Build-Release.ps1 builds the portable Windows package and requires Python 3.13. GitHub Actions builds main automatically, while numbered releases are published separately, so the continuous integration output and the release artefacts are two different pipelines.

The repository also has TRACE_PLAY.bat and an opt-in performance timeline capture through the --trace command line option, including optional GPU pass diagnostics, with the documentation for it in docs/. Implementation notes are in the same docs/ directory.

Two things about scope are stated. Custom animations and climbing support remain available, but no custom clips are shipped. And the included format-demo map is original procedural content, which is worth noticing because it means the repository is not distributing third party map content, in line with the licence section.

The project is explicitly unofficial and not affiliated with EA, and that statement is in the implementation notes section rather than hidden.

The licence, and the boundary it draws around the assets

The licence section is the most careful piece of writing in the README and it is worth reading closely, because the project is dealing with a commercial game.

The copyright is held by dumbad and the Skate 3 Rust Engine contributors for 2026. Unless otherwise noted, the project's original code is licensed under the GNU General Public License version 3 only, GPL-3.0-only. You may use, modify and distribute it, including commercially. If you distribute a modified version or a binary of the covered software, you must also make its corresponding source available under GPLv3 and preserve the required notices.

Third-party code retains its existing licences and copyright notices, including the vendored Bevy crates and the tooling under tools/vendor/.

Then the sentence that makes the whole arrangement coherent. This licence does not grant rights to Electronic Arts' game code, data, assets or trademarks, or to content supplied by other map and mod authors.

So the structure is clean in a way that many reverse engineering projects are not. The engine is GPLv3 and freely redistributable, the game assets are not included and are not licensed, and the user supplies their own copy of the game. That is the same arrangement the open source reimplementations of older games tend to arrive at, and the explicit disclaimer in the licence text rather than only in the prose is a better way of handling it than leaving it implied.

The `skate-core` crate names in the workspace and the mods/ and maps/ directories at the root are consistent with that boundary. A mod or map supplied by another author is not covered by the engine's licence, which is stated plainly.

Where the Skate 3 Rust Engine is the wrong choice

The first limitation is the platform. The build requires Windows, the release is a Windows ZIP, and the batch file workflow assumes it. There is no Linux or macOS path described, which is a notable constraint for a project written in Rust, because Rust is exactly the language where cross-platform development is usually cheap. The Windows requirement appears to come from the asset conversion pipeline rather than from the engine itself.

The second is that the assets are not there, and the setup depends on extracting an Xbox 360 ISO. That is a requirement with a legal dimension as well as a practical one, and the project is careful about the second while the first is simply a fact about how the game was distributed.

The third is that gameplay parity is explicitly not there. The README says the project is still a work in progress and that using original assets or showing working tricks does not mean every system behaves exactly like the original. So a player looking for a Skate 3 replacement will find a project with skating, tricks, grinds, offboard movement and map support, and not a complete game.

The fourth is that the interesting part is not in this repository. The file format knowledge, the tools for custom maps, meshes, collision, challenges and DLC, and the earlier renderer work all live in other projects, so evaluating this repository alone understates the work behind it and also means that using the engine well requires understanding formats documented elsewhere.

The fifth is the AI-assisted development. The project is upfront about it and makes a point of crediting the underlying research, but a reader assessing the engineering should know that the code was written with coding assistants on top of a large body of hard-won knowledge, and that the knowledge was not produced by the same process.

How it compares with a native reimplementation and with a mod

The comparison with a native reimplementation, the kind of project that reimplements a console game's engine in C or C++ from the original binaries, is the first one. The difference in approach is that this project starts from the documentation of the behaviour rather than from the original code, and it targets a modern engine and a modern toolchain. That gives you a codebase in Rust that a Bevy developer can read, and it means the rendering and the physics come from an engine that is maintained, at the cost of parity being approximate, which the README says outright.

The second comparison is with a mod. A mod runs inside the original game, so it inherits the original's fidelity exactly, and it is limited to what the original exposes. This project replaces the original entirely, which means it can add systems the original did not have and can be developed with modern tooling, and it means the behaviour is reconstructed rather than original.

The third comparison is with a from-scratch skating game in an engine, using one of the existing physics and animation frameworks. The difference is the asset pipeline and the data model. This project already has the Skate 3 data formats, the animation data and the map format worked out, so the work of building the game is the part that is already behind it.

The fourth is the interesting case of what the modding tools enable. The repository referenced for those tools covers custom maps, meshes, collision, challenges and DLC, so the natural workflow is to build with the engine and to use the older tools to author content for it, which is a two-project dependency rather than one.

Editorial conclusion

The Skate 3 Rust Engine suits a player or a modder who wants to work on the game's systems in a modern engine, with a codebase that is readable and licensed under GPLv3, and who is prepared to run the Windows-only setup. It is the wrong tool for someone who wants a finished game, since the project says gameplay parity is a work in progress, and the wrong choice if you need the original assets, because they are not included and cannot be redistributed. Before you run the setup, read the licence section carefully, since the engine code and the game data are under different terms and the project explicitly grants no rights to Electronic Arts' assets.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. README
4. Releases
5. SK8-ENGINE/skate-3-rust-engine on GitHub