Skip to content
A pure managed C# socket-agnostic reliability layer inspired by and yojimbo
Branch: master
Clone or download
KillaMaaki Merge pull request #7 from gresolio/master
Index to distinguish EndPoints like in yojimbo
Latest commit c5a7339 Nov 25, 2017
Type Name Latest commit message Commit time
Failed to load latest commit information.
UnitTestProject1 Removed files from the Git index that are now in .gitignore Sep 21, 2017
.gitignore Added .gitignore Sep 21, 2017
LICENSE Initial commit Aug 11, 2017


A pure managed C# socket agnostic reliability layer inspired by and yojimbo.

ReliableNetcode.NET provides a simple and easy-to-use reliability layer designed for use in games built on unreliable UDP connections. It is a great fit for use with Netcode.IO.NET, my C# port of Glenn Fiedler's secure UDP communication protocol, but it can also be used with any other system you want.


  • Multiple quality-of-service options (reliable, unreliable, and unreliable-ordered) for different use cases in a single API
  • Lightweight packet acking and packet resending
  • Supports messages up to about 16kB large using automatic message fragmentation and reassembly.
  • Simple congestion control changes the packet send rate according to round-trip-time.
  • GC-friendly for maximum performance.


All of the API is provided under the ReliableNetcode namespace.

Usage is really simple. First, to create a new instance of ReliableEndpoint:

var reliableEndpoint = new ReliableEndpoint();
reliableEndpoint.ReceiveCallback = ( buffer, size ) =>
	// this will be called when the endpoint extracts messages from received packets
	// buffer is byte[] and size is number of bytes in the buffer.
	// do not keep a reference to buffer as it will be pooled after this function returns
reliableEndpoint.TransmitCallback = ( buffer, size ) =>
	// this will be called when a datagram is ready to be sent across the network.
	// buffer is byte[] and size is number of bytes in the buffer
	// do not keep a reference to the buffer as it will be pooled after this function returns

To send a message, call ReliableEndpoint.SendMessage:

// Send a message through the qos channel
// messageBytes is a byte array, messageSize is number of bytes in the array, and qos type is either:
// QoSType.Reliable - message is guaranteed to arrive and in order.
// QoSType.Unreliable - message is not guaranteed delivery.
// QoSType.UnreliableOrdered - message is not guaranteed delivery, but received messages will be in order.
reliableEndpoint.SendMessage( messageBytes, messageSize, qosType );

When you receive a datagram from your socket implementation, use ReliableEndpoint.ReceivePacket:

// when you receive a datagram, pass the byte array and the number of bytes to ReceivePacket
// this will extract messages from the datagram and call your custom ReceiveCallback with any received messages.
reliableEndpoint.ReceivePacket( packetBytes, packetSize );

And, finally, make sure you call ReliableEndpoint.Update at regular and frequent intervals to update the internal buffers (you could run it on a separate network thread, from your game loop, or whatever you choose):

// update internal buffers
You can’t perform that action at this time.