From source
Point it at the VRising_Data folder of your installed game.
git clone https://github.com/LakoMoor/R-Rising
cd R-Rising
cargo run --release --locked -p rrising-app -- \
--data /path/to/VRising_DataRun options A compatible engine that reads the content of your own copy of the game. The goal is 1:1 behaviour, better performance, and running from desktop to browser.
Original scenes can already be viewed. The game is not playable yet.
Every number belongs to a specific check. Overall compatibility with the game has not been measured.
Heuristic coverage of managed member names.
Game parity is unmeasured.
archives read
scene containers decoded
of one original scene drawn natively and in WebGPU
Open a subsystem to see what is implemented, how it was checked and what is missing. Parsing content and reproducing game behaviour have different standards of done.
Vectors, matrices, quaternions, RigidTransform and half. 4,850 of 4,961 metadata member names are matched to Rust code. 31 original math function bodies are replayed on thousands of inputs; quaternion normalization uses a sqrt helper stub.
Remaining: most of the library is not checked against the original runtime, plus exact operation order, SIMD approximations and the remaining overloads. A name match does not prove the same result.
Entity table with versions, archetype layout, chunk versions and enable masks, create/destroy and simple queries, and a World built from all 1,183 scenes. The metric is refreshed from the repository report: 259 of 8,486.
A deterministic schedule runs the transform system on all 372 scenes that carry transforms. Its World output can feed the viewer and browser export. Change-version filtering now matches original instructions across counter wrap-around and first updates.
Remaining: more systems, shared, managed and chunk components as real values (kept opaque), and a running game loop. Read the native replay evidence.
All 4,409 UnityFS archives of this installation are read. 188,063 objects are indexed: models, textures, materials and other assets.
Limit: reading files does not mean every dependency loads correctly or that any game logic runs. No game files are distributed.
All 1,183 scene containers are decoded: node trees, archetypes, chunks, enable masks, dynamic buffers, shared and managed components, and blob assets. All 1,772 component type hashes are resolved and all 17,579 archetypes (1,385,671 entities) pass layout checks.
Remaining: a live ECS world used in a normal game launch. The percentage refers to parsing. Stored transforms: 99.3% of 112,177 recomputed matrices are within 1e-5 of the originals; static entities are not covered.
One wgpu renderer and WGSL shader serve the native app and WebAssembly. An original scene is drawn at its stored entity positions, natively and in Chrome / WebGPU from a local export.
Remaining: lighting parity, HDRP, animation, direct archive import in the browser and physical mobile-device testing. WebGPU is required; BC textures now have a CPU fallback, tested in Chrome with BC disabled.
The original dedicated server produced six autosaves through CrossOver. Rust reads both retained save containers, their complete headers and all eight serialization jobs. The saves contain 274,238 and 274,236 entity rows. Entity versions match the saved world table, and Rust reads the saved simulation frame. The binding test covers all job entities and 41,205 prefab handles per capture with synthetic live handles. All 23,583 saved prefab GUIDs and linked group sizes also match registrations read from nine original server scenes. A live Rust ECS projection allocates all saved job and prefab handles and projects 263 observed saved component types when using the extended server layout report. The terrain stage places 235,589 MegaStatic instances per autosave and rebinds 471,178 references. It also copies 4.75 million supported root component values from original prefab scenes; a separate clone test covers all 23,583 original prefabs and checks 50,296 in-group reference patches. Scene enable masks survive import and prefab cloning. The Rust save loader verifies query counts for 49 restored tag types. The default Simulate query now omits the 262,167 entities marked Disabled in each original save. Full gameplay remains unverified.
Remaining: restore the remaining components and system state, then verify a gameplay replay. Read the measured save boundary.
Shared steering and waypoint selection each match 4,096 controlled original cases. Steering also runs through the Rust World; five ECS accessors are isolated in its native replay. Combat, building, HUD, physics, audio and networking remain unimplemented. There are no deterministic gameplay scenarios compared against the running original yet.
Performance: speed against the original is not measured. Rust-only timings (one Apple M4 run): all scenes into a World 3.4 s, offscreen frame 1.42 ms median. Being faster is a goal, not a result.
1:1 compatibility is still unknown. API percentages can overstate coverage because names are shared. They do not show how much of the game could be played. Open the raw metrics JSON.
Original models and textures from a local installation. The scene views place entities at their stored positions; there is no lighting parity, animation or gameplay.
Comparison with frames of the original game will come after reproducible scenarios are recorded. These images show that the renderer works, not visual 1:1 compatibility. View the Chrome capture with BC disabled.
R-Rising aims to run real content and reproduce the behaviour of one specific build of the game. Work goes from file formats and a deterministic core towards a connected game world.
Reading Unity content is kept separate from the GPU. The browser host uses the same renderer through a local scene transfer, without the native library loader.
Browse the cratesArchives, models and other game assets are not in the repository. Running it needs a local installation.
File checks, GPU regressions and original-code replays are counted separately, and limits are stated openly.
Native and browser rendering share one implementation; platform-specific code stays at the boundary.
Reference build: V Rising v1.1.13.0-r99712-b17, Unity 2022.3.58f1. Rust 1.99.0 is pinned by the repository. There is no packaged release yet.
Point it at the VRising_Data folder of your installed game.
git clone https://github.com/LakoMoor/R-Rising
cd R-Rising
cargo run --release --locked -p rrising-app -- \
--data /path/to/VRising_DataRun options Export a scene locally first, then open the file in the viewer. The data stays on your device.
cargo run --locked -p rrising-app -- \
--data /path/to/VRising_Data \
--export-web scene.rrscene.json \
--archives 5000 --items 48 \
--width 1600 --height 900Open the WebGPU viewer Needs WebGPU. BC texture support is optional through CPU decoding. Physical mobile devices remain untested; no WebGL fallback.
Native output, the WebGPU viewer and local transfer of real content.
Scene Worlds, transforms and controlled shared steering are connected. Rust can read saved entity handles and component bytes from the original server. Next: restore worlds from those saves and compare live input.
Tie input, simulation and display together, and compare the result with the running original.
Comparable release timings, memory budgets and checks on physical target devices. BC texture fallback is already tested on desktop WebGPU.

Source code, evidence and the remaining gaps are all in the open repository.