u/Former-University905

Solo-dev project for FO4 1.11.191 next-gen. The clip below shows two

clients side-by-side: peer A equips clothes / armor / a modded weapon,

peer B sees the exact same on A's ghost in real time, animated with

A's pose.

---

**What's in the clip**

- **Clothes sync** — peer A equips a Vault Suit / Raider outfit,

peer B sees it on A's ghost.

- **Armor sync** — combat / synth / power armor resolves through the

engine's `TESObjectARMO -> TESObjectARMA` chain. The right tier

(Lite / Mid / Heavy) is picked from the OMOD effective priority

pulled out of the equipped item's `BGSObjectInstance`, and the

body under the armor gets culled where covered (no z-fight).

- **Modded weapon sync** — peer A equips a 10mm with reflex sight,

suppressor, heavy receiver, extended mag → peer B sees the exact

same configuration in A's ghost hand. Receivers, mags, scopes,

suppressors, grips. Assault rifle and hunting rifle with their

attachments also show up correctly. As far as I can tell this

hasn't been shipped before in the FO4 multiplayer modding scene —

Fallout Together / F4MP never reached this point. Happy to be

corrected if I missed a project.

---

**The bit modders may care about**

The engine has no user-callable "apply this OMOD list to this NiNode"

function. After roughly ten failed approaches I landed on per-OMOD

attach via `sub_140434DA0(omod_form, base_BSFadeNode, NULL, 0)` at

RVA `+0x00434DA0`. It reads the OMOD's `TESModel.modelPath` at

`OMOD+0x50`, loads the sub-NIF, deep-clones, registers materials,

then parents via `sub_14186E960` — which is **BSConnectPoint pairing**,

not `NiNode::AttachChild`.

The base weapon NIF carries a `BSConnectPoint::Children` extra-data

array on its root (entries like `Pistol10mmReceiver`, `WeaponMagazine`,

`WeaponOptics1`); the mod sub-NIFs carry a matching

`BSConnectPoint::Parents`; the engine matches the two by string. All

driven by data baked into the NIF files, not by anything on the form.

Refuted along the way: synthetic `TESObjectREFR` via `vt[170]`,

direct `sub_1404580C0` sync load, BSModelProcessor post-hook reading

the OIE, `find_node_by_name` + `AttachChild` driven by INNT,

receiver-side primer + 50/100/500 ms refresh schedules. Full trace

in the changelog (linked below) if anyone wants the gory details.

---

**What this is NOT**

- Not playable multiplayer. No combat sync, no damage, no shared NPC

AI, no shared loot drops. Visual / world-state sync only — what

each client sees of the other's avatar and a small set of world

objects (so far: doors).

- Not a finished project. Solo dev, evening pace. Tested with 2

peers; 10-peer scaling is still theoretical.

- Not a fork of any existing FO4 multiplayer project. Custom

framework (FoM-lite), native scene-graph injection (`BSFadeNode ->

ShadowSceneNode`), no D3D11 render hijack, no actor hijack — the

local engine animates each remote peer's ghost using the same anim

graph it uses for the local player.

---

**Architecture in one paragraph**

C++ MinHook proxy DLL (`dxgi.dll`) on each client → Python asyncio

UDP server in the middle. Binary protocol, ~44 B per pose frame at

20 Hz, 31 joints replicated full-body. Rust rewrite planned for later

milestone. Open source (personal mod, no Bethesda IP committed,

requires owned copy of FO4).

---

**Status**

v0.5.0 (2026-05-07). Shipped so far: full-body animation sync,

container/inventory sync, door open/close sync, clothes + armor +

modded firearms sync. M9 milestone is 5/5 wedges done for pistols.

The changelog calls out rifles as a pending issue, but during

recording I noticed assault rifle and hunting rifle also render

correctly with mods — deeper testing pending; the changelog will

be updated after a full pass.

---

**Links**

- New video: https://youtu.be/r34D4IL7wAk

- Repo (open source): https://github.com/ThePie88/FO4_Wrld

- Changelog with full RE writeup: https://github.com/ThePie88/FO4_Wrld/blob/master/CHANGELOG.md

- Previous demo (movement + container sync): https://youtu.be/Qs3dNzXnnko

- Door sync demo: https://youtu.be/T8wLZmCqjxw

Happy to answer technical questions in the thread.

## What is this

A multiplayer mod for Fallout 4 1.11.191 next-gen built solo over the last 5 evenings. Goal: small persistent-world coop (target 10 peers) with full body animation sync, server-authoritative state, and proper anti-dupe on container operations.

This isn't another "two players see each other's position" demo. The ghost player body for each remote peer is a real native scene-graph node injected into Fallout 4's renderer — same lighting, depth occlusion, shadows as any vanilla actor. ~31 skeleton joints replicated over UDP at 20Hz, driving the engine's own UpdateDownwardPass for animation. Walking, running, idle, sneak, turn, jump all visible peer to peer.

## What works right now

- **Full-body animation sync** — body + head + hands joints replicated end-to-end over network. Local peer moves, remote peer's ghost mirrors in real time.
- **Container operations with anti-dupe** — TAKE/PUT intercepted before engine mutation, validated server-side, then committed. Two peers can't simultaneously grab the same item.
- **Ground pickup replication** — peer A picks up an item, peer B sees it disappear from the world.
- **Kill events** — synced and persistent across server restarts.
- **Worldstate** — global vars sync live, quest stages reverse-engineered (apply layer pending wire-up).
- **2 instances on same machine** for local testing — single-byte binary patch, no Goldberg/wine workarounds needed.

## Architecture

- **Server**: Python asyncio UDP, authoritative, identity-keyed state (base, cell), reliable channel with SACK + retransmit, JSON snapshot persistence with rolling backups.

- **Client**: native C++ DLL injected via DXGI proxy + MinHook detours. No F4SE dependency at runtime. Scene-graph injection (BSFadeNode → ShadowSceneNode) for ghost rendering, NIF native loader, apply-materials walker for proper textures.
- **Protocol**: binary, byte-identical between Python (SSOT) and C++ client via static_assert.

## What doesn't work yet (known limitations)

- Fingers don't articulate — exist only in havok skel, not in render scene-graph tree.
- 1st-person sender → ghost adopts T-pose stub (camera detection RE pending).
- Ghost has no shadow yet (separate render flag, deferred).
- Tested with 2 peers; multi-peer ghost cache not yet implemented; 10-peer scaling theoretical at this stage.
- 20Hz sync rate, no receiver-side interpolation yet.

## Why this and not Fallout Together / F4MP

Both stalled before reaching stable bone-level animation replication. This project takes a different architectural bet: native scene-graph injection + per-bone joint replication via the engine's own anim propagation, instead of reimplementing skinning from scratch. The 1.11.191 next-gen RE work (skin pipeline, bones_pri pointer cache layout, NIF loader public API) is documented in `re/` for anyone attempting similar.

## Links

- 90s video demo: https://www.youtube.com/watch?v=Qs3dNzXnnko
- Source: https://github.com/ThePie88/FO4_Wrld

## Notes

PolyForm Noncommercial license. Source published for transparency, not accepting external PRs at this stage — the codebase uses unconventional approaches in critical areas and contributions could break invariants that aren't documented at the line level. May reconsider after the architecture stabilizes.

Treating this as documentation of progress, not a release. Happy to answer technical questions but no ETA on a playable build.