Welcome back to the first development update of 2026. We hope you had a good start into the new year and are exited to show you what we've been up to.

We would like to start this post with a little bit of an explanation why progress seems so slow.

A lot of people might not know this but the game was once intended to ship with some kind of multiplayer support. You can find traces of this in script and in the general system design.
A lot of core systems are designed with this in mind, but newer systems and especially stuff after the 2.0 update is written without any regards for MP.

This causes constant issues for us, to the point where we usually spend more time wrangling system behavior into place, rather than actually implementing networking.

Let us show you an example:

We spent a lot of time improving our appearance sync recently. The reason for the improvement wasn't a bad sync, but rather a complex "state corruption".

The game stores your character customization in a structure called CharacterCustomizationState. Only one of these exists, it is a member of the CharacterCustomizationSystem and only designated for your PlayerPuppet.
If you re-customize your character in your apartment mirror, the game will update this "finalized state" and invoke a function called gameuiICharacterCustomizationSystem::ReFinalizeState by the games scripts.

This structure will be read by more than 10 different gameuiICharacterCustomizationComponent's which are responsible for applying appearance onto puppets. These are more or less complex depending on their task. The most complex one is probably the TPPRepresentationComponent, which does a lot of the heavy lifting when it comes to selecting what kind of appearance to spawn, if it should be visible, render layers etc. These components also take care of applying changes to your inventory NPCPuppet

The issue however is, that they never intended to have more than one "unique" PlayerPuppet entity in the world, so when they added the re-customization of characters in 2.0, they added listeners that register to "finalized state" changes to re-apply the new appearance on your PlayerPuppet and NPCPuppet.
The result of that is, that if you customize your character, the changes you make will wildly spread across all other PlayerPuppet's in your scope.

It takes hours if not days of tracing with breakpoints, hooks and reverse engineering to locate all of the undesired "data flow" and build proper patches and filtering hooks with ownership and locality checks.

So whilst we might add new sync for some system in a day, we usually spend weeks tracing down unintended behavior we need to correct.

This is one of the many patches for appearance sync:

Changelog

Scripting

We have made major improvements to our scripting environment since the last development update.

We added:

• class/struct property access
• optional parameters
• scriptref and enum parameters in hooks
• enum types of different sizes in both msgpack (hooks) and WIT (regular function calls)
• EBR based scripting bundle load/unload system to support safe hot-reloading of bundles with callbacks, hooks and event listeners without costly locks
• ConVar sv_ugc_automatic_restarts to enable filesystem monitoring of changed bundles for developer QoL
• Many more small improvements too specific to list

We also vastly improved the codegen that translates RTTI properties (classes, functions, enums, etc.) into WIT and guest languages and prepared CI builds for the initial guest-csharp target.
These CI builds produce nuget packages to depend on, reducing the complexity of setting up development environments drastically.

We will publish all sources and example projects when the time is right, but the tl;dr is:
You will only need NET Framework 10 and pull 4 nuget packages from a nuget repo. This works on linux and windows without any need for IDEs.

Net

We've made loads of improvement to our networking logic. Some of it being rather low level, quantization and proper bit packing have been added recently to reduce network load, some of it being more "game focused".

A few examples:

• Improved appearance sync with garment application after substantial component changes
• Vehicle door and window state sync
• Various fixes for animation driven sounds playing "in ear" instead of spatial
• StatPools sync for health, armor, stamina etc
• IK injection for improved "camera direction" sync
• Ownership migration of static entities (Ownership migration of other entities is planned and already considered in netcode design)
• Initial combat sync for players, vehicles and static entities like turrets

Code and build system

We made numerous improvements and updates to our build system and codebase.

• We upgraded to llvm-21
• We now build for x86-64-v3 / avx2 on clang and msvc
• We expanded our test suite to cover a lot more of our core logic
• We added proper handling of rpath for linux builds to prevent issues with LD_LIBRARY_PATH
• A lot of code cleanup and improvements for clang-tidy linting
• We improved on CI builds and did a lot of preparation for upcoming OSS workflows

Media

Youtube Video

Welcome to another development update.
As we mentioned before, we only post updates if we have something to show and today we do.

Changelog:

Scripting:

Today we're showing off the first aspects of our unified (read: consistent environment between server and client code) scripting system.
It is powered by WebAssembly, providing a fast and very secure environment for executing untrusted code.

Our current "user side implementation", referenced as guest from here on, is written in C#, which was chosen due to its simplistic syntax and language features that map nicely upon the games existing scripting layer.

Other guest languages will be supported and will benefit from an already fleshed out ABI developed for this current C# guest.
Guest WASM modules are downloaded and executed upon connecting to a game server or hot (re)loaded whilst in a server session.
They are isolated from each other and can only interact outside of their context through strictly defined interfaces.
They can interface with existing game code and control flow through multiple means.

A few examples of what is possible (Watch the attached video for a visual demonstration):

Please be aware that hooking syntax is WIP

Hooking scripted or native game function, no matter if global, static or class members:

Calling arbitrary functions:

Implementing a fully networked chat, using a JS/HTML/CSS UI in CEF as frontend with client and server guest code for activation and transport:

PSM (PlayerStateMachine) Control:

With the addition of guest scripting and more specifically hooking, we paved the way for manipulating state machine control flow into whatever way you desire for your game modes.
A demonstration of this can be seen in the hooking screenshot or the attached video.
Instead of fading to black and transitioning into a "Death" state, the psm is kept in a "probing for transition" state until user input (Think a "Press E to get up" or a "Press E to revive your friend") is received.

DLC Management:

Whilst we would personally recommend everyone to purchase the Phantom Liberty DLC (its really good!), some people might not be able to afford the purchase and may desire to run their server without DLC content.
We managed to implement hot-loading of DLC replacement content into an already running engine state (This is where we display our PreGame menu) based on a specific server ConVar

This means no restarting of the client depending on server configuration when joining a specific type of server

Media:

Youtube Video

Welcome back to another development update. Its been quite some time since we published a proper post besides the occasional small update info in discord.

Lets get right into it.

Changelog:

• UGC: Introducing support for user generated content bundles (called UGC bundle from here on) that are streamed to connecting clients on session join
  -- Bundles will be able to contain server and client code.
  -- Client code may contain "Web content" that will be overlaid on top of the game viewport (For UIs, dialogs or any other kind of user interaction)
  (Note: Client/Server code system is still under development. We have committed and merged multiple upstream PRs in preparation. We will have an extensive update log talking about that upcoming system soon)
  (Note2: Streaming of game mods is a roadmap feature, but no showcase of this is yet available)

• CEF: A lot of work has gone into our CEF implementation. Making it fast, stable, secure and as optimized as you can get something involving chromium
  -- ClientUI frontend for PreGame(server list, LAN servers, joining) and PostGame(disconnect reason) phase.
  Still under development, but functional enough for the connection flow you can see in the video showcase
  -- UGC "UI" host that supports multiple UGC bundle provided "Web UIs" concurrently. Supports layering, hardware acceleration, etc.

• Backend: Another big task has been the development of the required backend infrastructure to provide a server list and to authenticate users when connecting to a server
  -- Proof of identity: Provide an easy way for servers to uniquely identify connecting users to prevent the requirement of self-rolling player authentication for allowlisted communities

Note: Due to the lack of DRM systems (Seriously, this is great. Never forget to thank CDPR for their stance regarding DRM and mods) there is no existing "identifier" for clients / users / players.
Usage of this authentication system is completely optional, servers may opt to not validate joining account tokens against our backend and employ their own proof of identity.
This is also means LAN servers (and clients) are fully supported, without requiring an internet connection.

Media:
Youtube Video

Its been two weeks since our last update. As we mentioned before, we will only post stuff if we have a reason to do so.
That is the case today.

For everyone not interested in technicalities, we once again have some footage linked below.

• We implemented proper handling for time dilation events on both world and individual entity level
  Dilation is not processed unless it is applied by low level engine systems as a fix for world streaming.

• We improved debug console UX and added support for optional parameters for natively registered commands
  Usually all parameters specified in the native callback are strictly checked for presence and type when a ConCmd invocation is executed from the command buffer.
  Commands can now wrap parameters in their callbacks in std::optional and check for their presence inside the callback at invocation time.
  Nested type compatiblity inside optionals is still enforced.

• We implemented proper mounting synchronization with server validation.
  A demonstration of that can be seen in the attached video.

• We did a lot of major and minor networking fixes
  -- Reducing network traffic
  -- Even more integrity checks
  -- Load testing
  -- Congestion testing
  -- Adjustments to "raw" networking layer settings like MTU size to reduce transmission errors in "weird" networks

• We improved our netgraph visualization with more detailed metrics and some UX improvements for easier interpretation
  We added an extended netgraph mode that acts similar to a "message heatmap", to visualize which areas of networking produce the most traffic and need further improvements.

• We added a "component filtering" stage to our entity creation logic to dynamically remove unecessary entity components from remotely simulated entities
  This is used both for bug fixes and a general performance increase due to the avoided unecessary computations.

• We improved our third person perspective representation logic to deal with more edge cases

Video:

Youtube Video

Screenshots:

Netgraph

ConCmd optional parameters (this is a screenshot of our test suite)

As promised, today's update is a more visual one.

• We implemented state synchronization for world entities.
  Currently only for entities inheriting from gameDeviceBase, which covers the majority of gameplay relevant entities.
  A demonstration of that sync can be seen in the attached video.

• We made quite a lot of progress in our animation sync re-write effort. Still too early to showcase fully, but all of the door / window opening animations seen in the video (yes, those are animation driven) are created client local from shared state.
  While that state is currently sent from a client, we designed the system to support server enforced state in the future (This will be relevant for all servers choosing to limit the amount of state changes clients can author)

• We made various improvements regarding data locality on server and client to support synchronization and processing of thousands of entities at any given time.

Youtube Video

That's it for today, we'll keep you updated.

This update is going to be rather technical, no good looking screenshots today.

• We upgraded our toolchain to llvm 20, which took some time as we compile with maximum strictness against clang and msvc. We also run an aggressive clang-tidy config which always takes a bit of work after major toolchain upgrades.

• We made some other miscellaneous upgrades to our build system. Some for speed, mostly to improve compatibility and stability for the future open source release.

• We fixed a bug causing delayed crashes related to improper refcounting when dealing with game objects which plagued us for quite some time.

• We successfully merged a PR upstream relating to our scripting system (more on that soon hopefully).

Currently we are re-working large parts of our animation sync, as the current way is unsustainable when it comes to bandwidth usage.
We are moving towards a more direct integration within the games AI and Workspot systems to synchronize more state and author animations locally from that shared state.

We will keep you updated, but for now that's it.

Today's update is a little bit less flashy than the previous one.
Its a short demonstration of some of the features in our console implementation.

Specifically demonstrating config file execution, ConVar replication, quake like vstr groups and probably the most useful feature for most people: UI integrated and re-bindable ConCommands

Youtube Video

Today's development preview showcases some more vehicle related sync.
Vehicle appearance sync is disabled, interpolation was set at fixed 100ms and post sample extrapolation was disabled.

Youtube Video

Today's first post is gonna be a screenshot and a small video clip of two players on the same server.
Please excuse the slight stutter in the video, both clients are running on the same machine.

Youtube Video