We’ve made a bunch of changes to how networking performs, mostly aimed at cutting down frame time and making things scale better as more players are connected.

The biggest improvement comes from how Sync Vars and networked Transforms are handled. We now track which players already have the latest version of a networked value, so we don’t waste time checking their state vs the current state each tick. This is really good when you have a lot of networked objects which aren't changing.

We’ve also completely reworked how delta snapshots are stored and built. Each networked object now keeps its own local snapshot state and caches data between updates. When we need to send new data to a player, we can quickly compare it to their last acknowledged snapshot using xxHash3, and only send what’s actually changed.

Here is an example frame time differences when you have 200 mostly static networked objects, with 64 connections, where each networked object also has 3 Sync Vars.

We’ve added LZ4 compression for larger packets. It kicks in automatically when the payload is larger than 128 bytes, cutting bandwidth use without adding much CPU overhead. Really small packets stay uncompressed.

And finally - this one’s a big deal for dedicated servers - we’ve raised the Steam Networking send rate limit from 1 Mbps to 1 Gbps. The old cap could choke servers that were trying to handle a lot of traffic.

There's now a proper resource editor for Sprites, which makes it a lot easier to create larger Sprites with multiple animations (and gives us tons of room to expand upon instead of stuffing everything into the Inspector...)

So now, viewing a Sprite in the Inspector will show a list of animations that you can preview (kinda like models) and if you want to make any changes you will have to open the Editor.

And for Sprites with only a single frame (typically Embedded Sprites), the Inspector will only show you the properties for its Texture and Origin so you can still quickly embed Textures as Sprites without having to open the Editor.

We finally managed to move the Rope Component from the sandbox game mode to engine.
The ropes use verlet integration and collide with the world.
Paired with the LineRenderer component you can set up ropes and cables in no time.

You could always make a render target and use it programatically. Now you can do it entirely through the editor by creating a RenderTexture asset, drag it onto a camera to render to it and use the texture anywhere, like in UI or a light cookie.

The input settings menu was broken for a while, that's fixed so you can rebind again.

We've exposed a second slot for binds so you can have two binds for a single action.

We've also improved the look of the menu. This isn't the final design, we'll end up changing it up more in the future.

We’ve rewritten our navmesh generation in C#. There’s no immediate visual change, but it fixes crashes, plugs a major memory leak, and sets the stage for future navigation features.

Until now we used the Recast library and in our rewrite we still follow the same underlying algorithmic approach. However, almost all of the original Recast code was stripped, and retailored to our needs.
Recast served us well, but it’s effectively a dead library, and the old half‑native / half‑managed setup had become fragile: messy ownership, large unmanaged buffers crossing boundaries, awkward threading, and painful maintenance.

This also fits our broader push to reduce legacy dependencies, we don’t want core systems hinging on unmaintained decade‑old C++ code. Now it’s cleaner, safer, and fully ours to evolve.