FastSave C++ - Fast Binary Saving for Godot 4 (v2.1 - Data Oriented)

Hi! I created this GDExtension because I was working with big data structures in Godot 4 (thousands of items, procedural worlds, enemy states) and the native JSON saving was absolutely destroying my performance.

Godot's native JSON stringify is slow and freezes the screen because it converts everything to text. FastSave C++ v2.1 fixes this. It bypasses the text parsing completely and writes raw binary chunks directly to the disk using optimized C++.

By utilizing a Data-Oriented approach (Structure of Arrays), version 2.0 passes flat, contiguous memory blocks (Packed Arrays) through the GDExtension boundary, eliminating overhead entirely.

The Benchmark (1,000,000 Entities Test)

I made a stress test in Godot 4 (Release build) generating 1,000,000 entities in RAM (containing vectors, strings, and integers) to compare the native system against this tool.

Here are the real results from my console:

Operation (1M Entities)	Native Godot JSON	FastSave (C++ GDExtension)	How much faster?
Save to Disk	5720 ms (Huge freeze)	41 ms	140x Faster
Load to RAM	3488 ms	30 ms	116x Faster

With JSON, your game freezes for almost 6 seconds. With FastSave v2.1, it handles that massive block of data in just 41 milliseconds (under 1 frame at 60fps), making it completely safe for mid-game autosaves or massive save files without dropping frames.

Why is it faster? 

Data-Oriented Memory Layout: Traditional saving iterates through millions of separate dictionary keys, causing heavy GDExtension boundary overhead. FastSave v2.1 avoids this by letting you group data into Packed Arrays. The C++ backend loops only a few times, handling memory blocks instantly.

No Text Overhead: It doesn't convert your floats or vectors into strings. It takes the raw bytes from memory using Godot's internal binary hooks (var_to_bytes) and dumps them into the file.

Memory Control & Lightweight: Written in pure C++, it avoids garbage collection spikes in GDScript. You call the function, it writes the bytes, and it closes the file. Zero background bloat.

How to use it (Code Example)

The C++ backend is 100% generic. You can use any custom key names and as many arrays as your game requires. To get maximum performance, simply group your massive entities attributes into Packed Arrays:

extends Node
func save_my_game():
    var saver = FastSave.new()
    
    # 1. Group your massive data into parallel Packed Arrays
    var positions = PackedVector3Array()
    var healths = PackedInt32Array()
    
    positions.resize(1000000)
    healths.resize(1000000)
    
    # Populate them normally during your game loop...
    positions[0] = Vector3(1, 2, 3)
    healths[0] = 100
    
    # 2. Wrap them into a single Dictionary. You can still mix single variables!
    var game_data = {
        "player_name": "Gordo_Pro",
        "high_score": 99999,
        "positions": positions,
        "health_values": healths
    }
    
    # Save everything instantly (The C++ loop only runs 4 times!)
    var success = saver.save_binary("user://savegame.fast", game_data)
    if success:
        print("Game saved!")
func load_my_game():
    var saver = FastSave.new()
    var loaded_data = saver.load_binary("user://savegame.fast")
    
    print(loaded_data["player_name"]) # Output: Gordo_Pro
    
    # Access your arrays instantly
    var pos_array = loaded_data["positions"]
    print("First entity position: ", pos_array[0]) # Output: (1, 2, 3)