GD-Sync now includes an optional Area of Interest (AOI) system, allowing synchronized state to be sent only to players who are nearby instead of broadcasting every update to the entire lobby. This can dramatically reduce bandwidth usage in larger multiplayer games while remaining completely transparent to existing synchronization systems.

The system is built around two new nodes:
• InterestViewer identifies a player's position and is typically added to each player character.
‍
• InterestObject defines the visibility range of a Node and determines which players should receive its synchronized state.

The host automatically manages visibility and determines which clients are within range of each InterestObject. Built-in synchronization nodes such as PropertySynchronizer automatically make use of this system, requiring no code changes in existing projects. Developers using manual synchronization can also take advantage of AOI through the new *_relevant APIs, which automatically send updates only to nearby players while falling back to a global broadcast when no InterestObject is present.

When a player re-enters an object's visibility range, GD-Sync automatically performs a state catch-up to ensure the object immediately appears in its correct state.

Area of Interest is entirely optional. Projects that do not use InterestViewer and InterestObject continue to behave exactly as before, and NodeInstantiator always spawns objects for every player regardless of AOI.

Check out the documentation for detailed usage information.

GD-Sync now includes a built-in matchmaking system for automatically grouping players into lobbies, removing the need to build your own custom queueing logic. A single MatchmakingRequest describes what kind of match you're looking for, and GD-Sync takes care of finding or creating a lobby that fits.

Requests can search existing public lobbies, queue players into a new one, or both, controlled through the search mode. Required tags ensure players only match with lobbies that share the exact same settings (game mode, map, region, and so on), while min_players and player_limit control how many players are needed before a queued lobby starts and how many it can hold in total. Optional skill-based matching groups players by rating, starting with a tight range that gradually widens over time so players aren't stuck waiting forever for a perfectly balanced match, and a timeout can be set to fail the search after a given duration instead of waiting indefinitely.

Once a suitable lobby is found or created, GD-Sync automatically joins it for you. You simply build a request, start it, and respond to the matchmaking signals as the process unfolds.

func _ready() -> void:
	GDSync.matchmaking_match_found.connect(_on_match_found)
	GDSync.matchmaking_failed.connect(_on_failed)

	var request := MatchmakingRequest.new(8)
	request.set_min_players(2)
	request.set_required_tags({"Mode": "Co-op"})
	request.set_search_mode(MatchmakingRequest.SearchMode.PUBLIC_THEN_MATCHMAKE)
	request.set_timeout(60.0)

	GDSync.matchmaking_start(request)

func _on_match_found(lobby_name: String) -> void:
	print("Match found: ", lobby_name)

func _on_failed(error: int) -> void:
	print("Matchmaking failed: ", error)

The plugin automatically joins the found lobby for you, no manual lobby_join call needed, so you just connect the matchmaking signals to track progress and react once a match is found.

Check out the documentation for detailed usage information.

GD-Sync now includes an optional permission system for remotely exposed functions, signals, and variables, giving you fine-grained control over which peers are allowed to interact with them. This makes it much easier to secure gameplay logic by ensuring that only authorized clients can invoke remote functions, emit synchronized signals, or modify synchronized variables.

For example, a function that starts a match should typically only be callable by the host, while certain variables or signals may only be intended to be modified or emitted by clients. By specifying a permission when exposing them, GD-Sync will automatically reject unauthorized remote requests.

If no permission is specified, the default behavior remains unchanged, allowing any connected peer to interact with the exposed function, signal, or variable.

func _ready() -> void:
	GDSync.expose_func(test_function1)
	GDSync.expose_func(test_function2, ENUMS.EXPOSE_PERMISSION.CLIENT)
	GDSync.expose_func(test_function3, ENUMS.EXPOSE_PERMISSION.HOST)
	
	GDSync.call_func(test_function1)
	GDSync.call_func(test_function2)
	GDSync.call_func(test_function3)

func test_function1() -> void:
	# Can be called by anyone
	pass

func test_function2() -> void:
	# Can only be called by clients
	pass

func test_function3() -> void:
	# Can only be called by the host
	pass

GD-Sync now supports exporting multiplayer games to the web. Projects can connect to the server network, join lobbies, synchronize game state, and use the majority of GD-Sync's features directly from a web browser.

This release includes the necessary platform-specific networking improvements to ensure a smooth experience across desktop, mobile, and web builds, making it easier than ever to deploy multiplayer games to multiple platforms from a single project.

PropertySynchronizer now supports synchronizing individual components of compound properties. Instead of synchronizing an entire property, you can now specify a single component using indexed property syntax.

For example, if only a character's Y rotation changes, you can now synchronize just that value by inputting rotation:y instead of rotation.

Indexed properties are supported for Vector2, Vector3, Vector4, and Color values. By synchronizing only the components that actually change, you can significantly reduce bandwidth usage and improve network efficiency.

New SynchronizedGPUParticles2D and SynchronizedGPUParticles3D nodes have been added, making it easy to synchronize GPU particle effects across all clients.

When particles are emitted, GD-Sync automatically synchronizes the particle seed, ensuring every client sees the exact same particle simulation. This keeps visual effects such as explosions, spell effects, and environmental particles perfectly consistent across the network.

The new nodes provide synchronized emit_synced(), restart_synced(), and stop_synced() methods for controlling particle emission from any peer.

Check out the documentation for detailed usage information.

The account system has been extended with support for friend lobby invitations. Using the new GDSync.account_invite_friend_to_lobby(friend: String) function, players who are logged into a GD-Sync account can send an invitation directly to one of their friends.

Friends can retrieve all active invitations using GDSync.account_get_lobby_invitations(), which returns every lobby invitation they have received from their friends. This makes it easy to build invite notifications or an invitations menu directly into your game.

This addition makes it significantly easier for friends to find each other and play together without having to manually exchange lobby information.

Check out the documentation for detailed usage information.

The account system has been extended with the new global GDSync.account_logged_in(username: String) and GDSync.account_logged_out() signals, making it easier to react to account login state changes from anywhere in your project.

Additionally, the new GDSync.account_is_logged_in() function has been added, providing a simple way to check whether the local player is currently logged into a GD-Sync account.

The GD-Sync Network Profiler now allows you to configure artificial latency on a per-client basis. This makes it easy to simulate poor network conditions or large geographical distances between players directly from the editor.

This addition provides a simple way to test latency-sensitive gameplay, validate prediction and interpolation systems, and identify networking issues without requiring external tools or real-world network conditions.

Improved Packet Encryption

Packet encryption has been significantly improved to provide stronger security and better protection against packet tampering and unauthorized data inspection. These improvements are applied transparently, requiring no changes to existing projects while ensuring all encrypted communication benefits from the enhanced implementation.

Stable SynchronizedRigidBody2D and SynchronizedRigidBody3D

SynchronizedRigidBody2D and SynchronizedRigidBody3D are no longer marked as experimental. Following extensive testing and stability improvements, both nodes are now considered production-ready for use in multiplayer projects.

SynchronizedAnimationTree Null Reference

Fixed an issue where SynchronizedAnimationTree could throw a null reference exception when it was present in the project's starting scene. This no longer causes errors during initialization.

play_synced Forwarding

Fixed an issue where play_synced on SynchronizedAnimationPlayer and SynchronizedAnimatedSprite2D would not correctly forward the play request under specific circumstances, preventing the animation from being synchronized as expected.

SynchronizedAnimatedSprite2D Flip Synchronization

Fixed an issue where SynchronizedAnimatedSprite2D would not consistently synchronize its flip properties, causing sprites to occasionally appear with incorrect horizontal or vertical orientation across clients.

PropertySynchronizer Rotation Interpolation

Fixed an issue where rotation interpolation in PropertySynchronizer did not correctly account for angle wrapping. Rotations now interpolate along the shortest path, preventing objects from unnecessarily rotating nearly 360° when crossing the 0°/360° boundary.

Duplicate owner_changed Signal

Fixed an issue where the owner_changed signal could be emitted twice on the client that initiated the ownership change. The signal is now emitted once.

Clean First-Time Plugin Import

Fixed an issue where importing GD-Sync into a project for the first time would produce a large number of errors in the Godot console. The plugin now imports cleanly without generating these errors during the initial setup.

Paused Game Connection

Fixed an issue where GD-Sync would drop the connection when the game was paused.

GD-Sync is now no longer paused when the game is paused, ensuring the connection remains active and network communication continues normally.