WebRTC

    This is a great opportunity for both demos and full games, but used to come with some limitations. In the area of networking, browsers used to support only HTTPRequests until recently, when first WebSocket and then WebRTC were proposed as standards.

    When the WebSocket protocol was standardized in December 2011, it allowed browsers to create stable and bidirectional connections to a WebSocket server. The protocol is quite simple, but a very powerful tool to send push notifications to browsers, and has been used to implement chats, turn-based games, etc.

    WebSockets, though, still use a TCP connection, which is good for reliability but not for latency, so not good for real-time applications like VoIP and fast-paced games.

    For this reason, since 2010, Google started working on a new technology called WebRTC, which later on, in 2017, became a W3C candidate recommendation. WebRTC is a much more complex set of specifications, and relies on many other technologies behind the scenes (ICE, DTLS, SDP) to provide fast, real-time, and secure communication between two peers.

    The idea is to find the fastest route between the two peers and establish whenever possible a direct communication (i.e. try to avoid a relaying server).

    However, this comes at a price, which is that some media information must be exchanged between the two peers before the communication can start (in the form of Session Description Protocol - SDP strings). This usually takes the form of a so-called WebRTC Signaling Server.

    Peers connect to a signaling server (for example a WebSocket server) and send their media information. The server then relays this information to other peers, allowing them to establish the desired direct communication. Once this step is done, peers can disconnect from the signaling server and keep the direct Peer-to-Peer (P2P) connection open.

    Using WebRTC in Godot

    WebRTC is implemented in Godot via two main classes WebRTCPeerConnection and , plus the multiplayer API implementation WebRTCMultiplayer. See section on for more details.

    Note

    These classes are available automatically in HTML5, but require an external GDNative plugin on native (non-HTML5) platforms. Check out the webrtc-native plugin repository for instructions and to get the latest .

    Warning

    When exporting to Android, make sure to enable the permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

    This will print:

    1. P1 received: Hi from P1
    2. P2 received: Hi from P2

    This example expands on the previous one, separating the peers in two different scenes, and using a singleton as a signaling server.

    And now for the local signaling server:

    Note

    This local signaling server is supposed to be used as a to connect two peers in the same scene.

    1. # A local signaling server. Add this to autoloads with name "Signaling" (/root/Signaling)
    2. extends Node
    4. var peers = []
    6. func register(path):
    7.     assert(peers.size() < 2)
    9.     # If it's the second one, create an offer
    10.     if peers.size() == 2:
    11.         get_node(peers[0]).peer.create_offer()
    13. func _find_other(path):
    14.     # Find the other registered peer.
    15.     for p in peers:
    16.             return p
    17.     return ""
    19. func send_session(path, type, sdp):
    20.     var other = _find_other(path)
    21.     assert(other != "")
    22.     get_node(other).peer.set_remote_description(type, sdp)
    24. func send_candidate(path, mid, index, sdp):
    25.     var other = _find_other(path)
    26.     assert(other != "")
    27.     get_node(other).peer.add_ice_candidate(mid, index, sdp)

    Then you can use it like this:

    A more advanced demo using WebSocket for signaling peers and is available in the godot demo projects under networking/webrtc_signaling.