Steam News25 June 20269d ago

5.823 Multiplayer Lanes

Full release notes here. Okay, the multiplayer changes in this one were... intense to find. The good news is that I had some confirmation from at least one group that things were working great for them prior build.

In this update4

Full notes

Full AI War 2 update

Read the full published notes in a cleaner layout. The original post stays linked below.

What changed

4 fixes2 additions3 changes3 removals

Balance
Fixes
Server
Gameplay
Performance
Store

fixedThere was also a one-line serialization bug that would cause desyncs for anyone using a specific group of mods, or a specific custom feature in the base game. That is also fixed. I've done an exhaustive audit and categorization of every serialization/deserialization pair of sites in the game, and they're all clean now. There are almost 200 sites, most of them dozens of lines long, and only one rarely-used one had a problem, so that was a pretty clean bill of health already (which of course made the one rogue case harder to find).

fixedMultiplayerFixed a one-line serialization difference in part of the multiplayer code. This would cause exceptions on clients trying to join to hosts if they had extra multiplayer validation tools on, but otherwise would cause no issues for other multiplayer players.

changedMultiplayerThe host no longer mistakes ordinary network latency for a client falling behind. Previously a client more than 2 network frames behind the host had its state-correction payloads suppressed. But 2 frames is only ~200ms, which is just the normal round-trip time on any cross-region connection — so a perfectly healthy player on a 200-300ms ping was being suppressed continuously, for the entire game, and never got the corrections that keep their ships in sync. The host now measures each client against its own ping (which we already track from the heartbeat) plus a 250ms cushion, and only suppresses a client that is genuinely lagging beyond what its ping accounts for. A normal high-ping client is simply never suppressed anymore. This is very likely the big fix in the set — it's the thing that was making wrong-planet flagships, invisible/undying ships, and unresponsive units durable instead of self-correcting for ordinary players.

changedMultiplayerWhile a client genuinely is being suppressed, corrections are now preserved instead of dropped. The host keeps doing the cheap-but-essential existence reconciliation even under suppression — telling the client to clean up ships the host has already destroyed (this is the "ships that never die" cleanup) — and defers the heavier value/position updates for a later cycle rather than silently throwing them away. The old code cleared the whole batch up front, which could permanently lose a repair the client actually needed.

removedMultiplayerThe host's divergence-repair queue is now retry-safe. Repairs that can't be completed on a given cycle (a ship mid-jump, a fleet that's transiently missing, etc.) are now retained and retried instead of dropped, and a repair that's in flight is no longer lost if something errors out mid-send.

removedMultiplayerClients no longer flood the host with stale repair requests while they're materially behind. A behind client is comparing its own old-frame state against the host's current frame, which generates a storm of "fix this!" requests that mostly aren't real divergences — and all that upstream traffic competes with the acks and commands the client needs to catch up in the first place. Clients now hold those value/position requests while behind (re-checking and re-requesting the moment they catch up), while still always asking for any ship they're missing entirely.

AI War 2 changes

fixedFixed a one-line serialization difference in part of the multiplayer code. This would cause exceptions on clients trying to join to hosts if they had extra multiplayer validation tools on, but otherwise would cause no issues for other multiplayer players.

changedThe host no longer mistakes ordinary network latency for a client falling behind. Previously a client more than 2 network frames behind the host had its state-correction payloads suppressed. But 2 frames is only ~200ms, which is just the normal round-trip time on any cross-region connection — so a perfectly healthy player on a 200-300ms ping was being suppressed continuously, for the entire game, and never got the corrections that keep their ships in sync. The host now measures each client against its own ping (which we already track from the heartbeat) plus a 250ms cushion, and only suppresses a client that is genuinely lagging beyond what its ping accounts for. A normal high-ping client is simply never suppressed anymore. This is very likely the big fix in the set — it's the thing that was making wrong-planet flagships, invisible/undying ships, and unresponsive units durable instead of self-correcting for ordinary players.

changedWhile a client genuinely is being suppressed, corrections are now preserved instead of dropped. The host keeps doing the cheap-but-essential existence reconciliation even under suppression — telling the client to clean up ships the host has already destroyed (this is the "ships that never die" cleanup) — and defers the heavier value/position updates for a later cycle rather than silently throwing them away. The old code cleared the whole batch up front, which could permanently lose a repair the client actually needed.

removedThe host's divergence-repair queue is now retry-safe. Repairs that can't be completed on a given cycle (a ship mid-jump, a fleet that's transiently missing, etc.) are now retained and retried instead of dropped, and a repair that's in flight is no longer lost if something errors out mid-send.

Full release notes here.

Okay, the multiplayer changes in this one were... intense to find. The good news is that I had some confirmation from at least one group that things were working great for them prior build. But there were still some systemic problems for other folks. The difference turned out to be mostly related to the ping between clients and hosts, and how exactly the multiplayer model handles high-load situations and clients-falling-behind spots. It took a lot of analysis, but these changes should hopefully solve the existing problem cases, as well as leaving more breadcrumbs in your local logs (which you can share with me if you still experience any problems).

There was also a one-line serialization bug that would cause desyncs for anyone using a specific group of mods, or a specific custom feature in the base game. That is also fixed. I've done an exhaustive audit and categorization of every serialization/deserialization pair of sites in the game, and they're all clean now. There are almost 200 sites, most of them dozens of lines long, and only one rarely-used one had a problem, so that was a pretty clean bill of health already (which of course made the one rogue case harder to find).

Enjoy!

5.823 Changelog

Multiplayer

Fixed a one-line serialization difference in part of the multiplayer code. This would cause exceptions on clients trying to join to hosts if they had extra multiplayer validation tools on, but otherwise would cause no issues for other multiplayer players.
The host no longer mistakes ordinary network latency for a client falling behind. Previously a client more than 2 network frames behind the host had its state-correction payloads suppressed. But 2 frames is only ~200ms, which is just the normal round-trip time on any cross-region connection — so a perfectly healthy player on a 200-300ms ping was being suppressed continuously, for the entire game, and never got the corrections that keep their ships in sync. The host now measures each client against its own ping (which we already track from the heartbeat) plus a 250ms cushion, and only suppresses a client that is genuinely lagging beyond what its ping accounts for. A normal high-ping client is simply never suppressed anymore. This is very likely the big fix in the set — it's the thing that was making wrong-planet flagships, invisible/undying ships, and unresponsive units durable instead of self-correcting for ordinary players.
While a client genuinely is being suppressed, corrections are now preserved instead of dropped. The host keeps doing the cheap-but-essential existence reconciliation even under suppression — telling the client to clean up ships the host has already destroyed (this is the "ships that never die" cleanup) — and defers the heavier value/position updates for a later cycle rather than silently throwing them away. The old code cleared the whole batch up front, which could permanently lose a repair the client actually needed.
The host's divergence-repair queue is now retry-safe. Repairs that can't be completed on a given cycle (a ship mid-jump, a fleet that's transiently missing, etc.) are now retained and retried instead of dropped, and a repair that's in flight is no longer lost if something errors out mid-send.
Clients no longer flood the host with stale repair requests while they're materially behind. A behind client is comparing its own old-frame state against the host's current frame, which generates a storm of "fix this!" requests that mostly aren't real divergences — and all that upstream traffic competes with the acks and commands the client needs to catch up in the first place. Clients now hold those value/position requests while behind (re-checking and re-requesting the moment they catch up), while still always asking for any ship they're missing entirely.
Fixed a host-side send flood that occurred while "holding" for a catching-up client. When the host pauses to let a far-behind client catch up, that pause makes it eligible to send on every render frame. A rate limiter was supposed to keep the expensive sync payload down to roughly the simulation rate during these holds, but it was being bypassed whenever suppression was also active — which, during a hold, it essentially always is. The host was re-serializing and blasting the full sync payload many times per second at a client that couldn't even process it that fast. The limiter now applies during any hold regardless of suppression, while the cheap "you're authorized up to here" packet still goes out every frame so the client can actually catch up.
Added a lockstep safety guard so a very-far-behind client won't act on host-confirmed ship deletions out of order.
A reconnecting player's lingering old connection can no longer cause the host to wrongly suppress everyone.
Added a batch of new networking counters to the in-game network debug overlay so these behaviors (suppression state, per-client lag-vs-ping, deferred/retained repairs, gated requests) can be watched live during a session.

Forge of Empires

Fix a bug where the DZ Empire sometimes wouldn't have to pay the AIP cost when it captured a planet

Heart of the Machine 1.0 Is Out Now!

https://steamcommunity.com/games/2001070/announcements/detail/538879349212841215 https://steamcommunity.com/ogg/2001070/announcements/detail/710026912607507308

https://store.steampowered.com/app/2001070/Heart_of_the_Machine/

Source

Steam News / 25 June 2026

Open original post

Changelog.gg summarizes and formats this update. How we read updates.