R-RISINGRUST GAME RUNTIME
Independent project · early development

V Rising.
Rebuilt in Rust.

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.

RUSTWGPUMETALWEBASSEMBLY
A silver gothic letter R in a crimson eclipse
FROM ORIGINAL CONTENTTO A NEW RUNTIME
CURRENT SNAPSHOT

Progress you
can verify.

Every number belongs to a specific check. Overall compatibility with the game has not been measured.

API name matches5,118 / 187,377

Heuristic coverage of managed member names.
Game parity is unmeasured.

How it is counted
4,409/ 4,409

archives read

1,183/ 1,183

scene containers decoded

9,474instances

of one original scene drawn natively and in WebGPU

01 / COMPATIBILITY

What is ported right now

Full report

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.

01 Math API names97.8%

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.

02 ECS runtime API names3.0%

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.

03 Content archives checked on files100%

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.

04 EntityScene containers checked on files100%

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.

05 Rendering and browser working sliceviewer

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.

06 Original saves working slice8 jobs read

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.

07 Gameplay and 1:1 behaviour aheadnot done

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.

02 / REAL CONTENT

One renderer. Two hosts.

REAL SCREENSHOTS

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.

1280 × 720 · 9,474 instances · original scene
A mountain scene from V Rising drawn by the native Rust renderer at the entities' original positions
Native Rust renderer on macOS / Metal.Open the image

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.

03 / HOW THE ENGINE IS BUILT

The original is the specification.

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 crates
01Your game filesUnityFS · EntityScenes · materials
02Rust corecontent → ECS → scene / simulation
03wgpuNative / Metal + WASM / WebGPU
01

Your own copy of the game

Archives, models and other game assets are not in the repository. Running it needs a local installation.

02

Verifiable steps

File checks, GPU regressions and original-code replays are counted separately, and limits are stated openly.

03

Shared Rust code

Native and browser rendering share one implementation; platform-specific code stays at the boundary.

04 / TRY IT

Build. Open. Check.

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.

NATIVE

From source

Point it at the VRising_Data folder of your installed game.

TERMINAL
git clone https://github.com/LakoMoor/R-Rising
cd R-Rising
cargo run --release --locked -p rrising-app -- \
  --data /path/to/VRising_Data
Run options
WEBASSEMBLY

In the browser

Export a scene locally first, then open the file in the viewer. The data stays on your device.

LOCAL EXPORT
cargo run --locked -p rrising-app -- \
  --data /path/to/VRising_Data \
  --export-web scene.rrscene.json \
  --archives 5000 --items 48 \
  --width 1600 --height 900
Open the WebGPU viewer

Needs WebGPU. BC texture support is optional through CPU decoding. Physical mobile devices remain untested; no WebGL fallback.

05 / NEXT

From a scene
to a living world.

Development history
  1. DONE

    Reading content and two renderer hosts

    Native output, the WebGPU viewer and local transfer of real content.

  2. IN PROGRESS

    Original scene → ECS world

    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.

  3. LATER

    A first gameplay scenario

    Tie input, simulation and display together, and compare the result with the running original.

  4. AFTER BEHAVIOUR IS VERIFIED

    Performance and devices

    Comparable release timings, memory budgets and checks on physical target devices. BC texture fallback is already tested on desktop WebGPU.

BUILDING A COMPATIBLE RUNTIME

Follow the port.

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

Open GitHub