All Projects → MidLevel → Ruffles

MidLevel / Ruffles

Licence: mit
Lightweight and fully managed reliable UDP library.

Projects that are alternatives of or similar to Ruffles

Enet Csharp
Reliable UDP networking library
Stars: ✭ 464 (+254.2%)
Mutual labels:  unity, networking, protocol, udp
Ceras
Universal binary serializer for a wide variety of scenarios https://discord.gg/FGaCX4c
Stars: ✭ 374 (+185.5%)
Mutual labels:  network, networking, protocol, net
Game Networking Resources
A Curated List of Game Network Programming Resources
Stars: ✭ 4,208 (+3112.21%)
Mutual labels:  unity, network, networking
Networker
A simple to use TCP and UDP networking library for .NET. Compatible with Unity.
Stars: ✭ 408 (+211.45%)
Mutual labels:  unity, networking, udp
Mud
Multipath UDP library
Stars: ✭ 100 (-23.66%)
Mutual labels:  network, protocol, udp
Hisocket
It is a lightweight client socket solution, you can used it in C# project or Unity3d
Stars: ✭ 275 (+109.92%)
Mutual labels:  unity, network, net
Exscript
A Python module making Telnet and SSH easy
Stars: ✭ 337 (+157.25%)
Mutual labels:  network, networking, protocol
Hp Socket
High Performance TCP/UDP/HTTP Communication Component
Stars: ✭ 4,420 (+3274.05%)
Mutual labels:  network, networking, udp
Ignorance
Ignorance utilizes the power of ENet to provide a reliable UDP networking transport for Mirror Networking.
Stars: ✭ 158 (+20.61%)
Mutual labels:  unity, networking, udp
Librg
🚀 Making multi-player gamedev simpler since 2017
Stars: ✭ 813 (+520.61%)
Mutual labels:  library, network, networking
Ngtcp2
ngtcp2 project is an effort to implement IETF QUIC protocol
Stars: ✭ 589 (+349.62%)
Mutual labels:  networking, protocol, udp
Awareness
The new architecture of co-computation for data processing and machine learning.
Stars: ✭ 11 (-91.6%)
Mutual labels:  library, networking, protocol
Valvesockets Csharp
Managed C# abstraction of GameNetworkingSockets library by Valve Software
Stars: ✭ 273 (+108.4%)
Mutual labels:  unity, networking, udp
Benchmarknet
Benchmark for testing the reliable UDP networking solutions
Stars: ✭ 206 (+57.25%)
Mutual labels:  unity, networking, udp
Mirror
#1 Open Source Unity Networking Library
Stars: ✭ 2,905 (+2117.56%)
Mutual labels:  unity, networking, udp
Pnet
High level Java network library
Stars: ✭ 49 (-62.6%)
Mutual labels:  library, network, networking
Txeh
Go library and CLI utilty for /etc/hosts management.
Stars: ✭ 181 (+38.17%)
Mutual labels:  library, network, networking
Ecs
ECS for Unity with full game state automatic rollbacks
Stars: ✭ 151 (+15.27%)
Mutual labels:  unity, network, networking
Laminar
A simple semi-reliable UDP protocol for multiplayer games
Stars: ✭ 530 (+304.58%)
Mutual labels:  networking, protocol, udp
Whatpulse
WhatPulse reverse engineered
Stars: ✭ 30 (-77.1%)
Mutual labels:  library, network, protocol

Ruffles

Build Status NuGet GitHub Release Discord Licence

Ruffles is a fully managed UDP library designed for high performance and low latency.

Why another reliable UDP library?

There are many RUDP libraries such as ENET, Lidgren, LiteNetLib. While many of them are great, Ruffles aims to fill in one niche that is largely not filled, that being lightweight fully managed libraries.

To compare to the examples above, ENET is amazing and is pretty much what Ruffles wants to be, but it's unmanaged. Lidgren, LiteNetLib and many other managed libraries can feel too bloated and contain many features that are unnecessary and they are often much slower.

Features

Ruffles has many features that other libs lack. See below for a summary and a detailed explanation of each.

  • Connection challenge
  • DOS amplification prevention
  • Slot filling prevention
  • Connection management
  • High performance and garbage free
  • Channeling
  • Threaded by default
  • Thread safe
  • Dependency free
  • IPv4 and IPv6 dual mode
  • Small packet merging
  • Fragmentation
  • Ack merging
  • Connection statistics
  • Path MTU discovery
  • Bandwidth tracking

Connection Challenge

The Ruffles protocol requires a challenge to be completed before a connection can be established. Currently, the challenge is a hashcash like challenge that is supplied by the server, brute force solved by the client and submitted. (Uses Fowler-Noll-Vo hash function instead of SHA1 currently).

DOS Amplification Prevention

DOS amplification is prevented by requiring unproportional connection message sizes. In addition, because of the connection challenge it's not computationally feasible to attack on Layer 4.

Slot Filling Prevention

Ruffles has a fixed amount of connection slots that can be used for pending connections, this limits the usability of slot filling attacks on Layer 4. Pending connections have a fixed timeout to solve the computationally expensive HashCash challenge before being knocked out, the slot will be available once again after that. As this only limits slot filling attacks, Ruffles also has a security mechanism where a HashCash has to be solved in the first message. This challenge is generated by the client and the server will verify that the date used is recent and that the IV has not already been used, forcing clients to recompute the HashCash challenge every time they want to initialize a handshake.

With these security mitigations, the only way to bring the server down is to exhaust all CPU resources.

Connection Management

Ruffles handles all connection management for you. It's a fully connection oriented protocol with heartbeat keepalive packets sent to ensure the connection is alive.

High Performance

Ruffles is fully garbage free, this is accomplished with a custom memory allocator in GC space. This ensures no memory is leaked to the garbage collector unless for resizing purposes. This makes Ruffles blazing fast. It also avoids memory copies as much as possible. Because Ruffles still runs in GC space, any memory leaks in Ruffles will be handled by the garbage collector and the user will be notified as the memory's destructor is called along with a stacktrace of where the leaked memory was originally allocated. See Implementation.

Reliability and Sequencing

There are currently a few ways of sending messages in Ruffles. The types are:

Reliable

All messages are guaranteed to be delivered, the order is not guaranteed, duplicates are dropped. Uses a fixed sliding window.

ReliableSequenced

All messages are guaranteed to be delivered with the order also being guaranteed, duplicates are dropped. Uses a fixed sliding window.

ReliableSequencedFragmented

All messages are guaranteed to be delivered with the order also being guaranteed, duplicates are dropped. Uses a fixed sliding window. Allows large messages to be fragmented.

Unreliable

Delivery is not guaranteed nor is the order. Duplicates are dropped.

UnreliableOrdered

Delivery is not guaranteed but the order is. Older packets and duplicates are dropped.

UnreliableRaw

Delivery is not guaranteed nor is the order. Duplicates are not dropped.

UnconnectedMessages

Raw UDP packets that does not require a connection.

ReliableOrdered

All messages are not guaranteed to be delivered. If you send multiple messages, at least one is guranteed to arrive. If you send a single message, it is guaranteed to arrive. Messages will always be in order. Duplicates are dropped.

ReliableFragmented

All messages are guaranteed to be delivered, the order is not guaranteed, duplicates are dropped. Uses a fixed sliding window. Allows large messages to be fragmented.

Threading

Ruffles is natively multi threaded and uses a background worker thread by default to handle network I/O.

Thread Safe

All public APIs in Ruffles are designed to be thread safe and can be accessed from any thread.

Dependency Free

Ruffles is 100% dependency free, it's thus very portable and should run on most platforms.

IPv6 Dual Mode

Ruffles supports IPv6 dual socket mode. It does this by using two sockets bound to the same port, thus accomplishing full dual stack functionality that is invisible to the user.

Small Packet Merging

Small packets will be delayed for sending, this allows them to be merged into one larger packet. This can be disabled and enabled on a per packet basis. The delay and max merge size can also be configured.

Fragmentation

Packets can be sent as ReliableSequencedFragmented or ReliableFragmented which allows for a single packet to be of a size of up to 2^15*1450 bytes = 47513600 bytes = 47.5 megabyte.

Ack Merging

Ack packets are merged into bitfields to make them much more compact.

Connection Statistics

Detailed statistics can be retrieved from connections, including the bytes sent, packets sent, round trip times and more.

Path MTU

Automatically discovers the largest MTU possible for each connection.

Bandwidth Tracking

Limit the amount of traffic allowed to be sent to a connection. Custom algorithms can be adapted with the IBandwidthTracker interface.

Roadmap

This is stuff I want to and plan to add

  • Adaptable window sizes
  • Basic bandwidth control, limit the amount of acks that are sent etc
  • More Fragmentation Types
  • Explicit Nack
  • MLAPI.Relay Support
  • MLAPI.NAT (Holepuncher) support
  • Bloatless Moduled Library (Make all the garbage features like relay support separate modules to keep the core library bloat free and small)

Maybe Roadmap

Here are the features that are considered but not decided. This is to prevent bloat.

  • Multicasting
  • Meshing / Peer relaying

Fragmented

The fragmented channel currently does not have any flow rate for ack resends.

Unity Support

Due to a Unity bug, Ruffles does not work properly in IL2CPP by default. The bug has been reported to Unity. If you need to run Ruffles with IL2CPP, compile it with the MILLISECONDS_SELECT define. This will make the Socket.Select method use a millisecond based timeout instead of microseconds. This has been patched. Feel free to use IL2CPP in your project.

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].