The netcode SDK is a Unity Package Manager (UPM) package, not a typed client library. You install it, drop one component in place of UnityTransport, and Unity Netcode drives it through the standard INetworkInterface surface. Configuration is done in the inspector (or in C#), and the public method surface is UTP’s own — the package forwards it to the QUIC + MoQT substrate.

​
Install (UPM git URL)

Add the package to your Unity project via Package Manager → Add package from git URL: 
https://github.com/clutchcall/core-sdk.git?path=unity/com.clutchcall.transport
The package depends on com.unity.transport (it implements UTP’s INetworkInterface) and works with both Netcode for GameObjects and Netcode for Entities. Pin Netcode to a version compatible with your Unity editor; the transport tracks UTP’s stable interface, not a specific Netcode release.

​
Swap the transport

In your network manager prefab, remove UnityTransport and add ClutchCallTransport as the transport component. Unity Netcode discovers it the same way it discovers UTP, so no other wiring changes.
1

Select the NetworkManager

Open the prefab (or scene object) that holds your NetworkManager.
2

Replace the transport component

Remove the existing UnityTransport component and add ClutchCallTransport. If NetworkManager.NetworkConfig.NetworkTransport referenced the old component, point it at the new one.
3

Configure relay host + token

Set the relay host and an auth token in the inspector — the same way you’d configure a relay endpoint for UTP.

​
Component: ClutchCallTransport

ClutchCallTransport is a NetworkTransport (Netcode) that implements UTP’s INetworkInterface. It is the only type you reference directly; everything else is standard Netcode.

​
Inspector fields

​
Relay Host
string
required
The ClutchCall relay endpoint, e.g. relay.clutchcall.dev. Players dial the nearest POP behind this host.
​
Token
string
required
The ClutchCall auth token authorizing the QUIC session. Mint a short-lived, room-scoped token from your control-plane API rather than shipping a static secret in the build.
​
Room Id
string
The room / match namespace this player joins. Host and clients of the same match share one Room Id.
​
Server Certificate Hash
string
Optional pinned certificate hash for the relay’s TLS 1.3 certificate, for environments that pin instead of using the public trust store.
​
Max Datagram Size
int
default:"path MTU"
Upper bound for the unreliable (QUIC datagram) channel. Reads back through MaxPayloadSize(); payloads larger than this are rejected, not fragmented.

​
Configure from C#

You can set the same fields in code before StartHost / StartClient: 
using Unity.Netcode;
using ClutchCall.Transport; // namespace shipped by com.clutchcall.transport

var nm = GetComponent<NetworkManager>();
var transport = nm.GetComponent<ClutchCallTransport>();

transport.RelayHost = "relay.clutchcall.dev";
transport.Token     = await FetchRoomTokenAsync("duel-42", "alice");
transport.RoomId    = "duel-42";

// Host (authority) vs client is chosen by Netcode, not the transport:
nm.StartHost();   // or nm.StartClient();

​
UTP method surface

Because the package implements INetworkInterface, the methods you call are Unity Netcode / UTP methods — the transport forwards each to the QUIC + MoQT substrate. The ones that matter for porting:
UTP / Netcode callWhat the transport does
StartHost() / StartServer()opens the authority namespace on the relay
StartClient()publishes a discovery namespace + per-peer channels, announces to the host
Send(..., NetworkDelivery)maps reliable delivery to a subgroup stream, unreliable to a QUIC datagram
GetCurrentRtt(clientId)returns the QUIC transport’s smoothed RTT in ms
MaxPayloadSize()returns the live max datagram size for the unreliable lane
DisconnectLocalClient() / DisconnectRemoteClient()drops the session; the peer leaves every roster via namespace teardown
Shutdown()closes the QUIC connection and all tracks

​
NetworkDelivery → lane mapping

Unity’s NetworkDelivery enum selects the lane:
NetworkDeliveryLane
Reliable, ReliableSequenced, ReliableFragmentedSequencedMoQT subgroup stream (ordered, guaranteed)
Unreliable, UnreliableSequencedQUIC datagram (lossy, latest-wins)
Send high-frequency, latest-wins traffic (transforms, tick snapshots, inputs) as Unreliable, and reserve Reliable* for spawns, despawns, and RPCs. This is the same discipline you’d apply with UTP — the transport just realizes each lane over QUIC instead of UDP.

​
Events

The transport surfaces connection lifecycle through Netcode’s standard callbacks — you do not subscribe to transport-specific events:
Netcode callbackFires when
NetworkManager.OnClientConnectedCallbacka peer’s discovery namespace is announced and accepted
NetworkManager.OnClientDisconnectCallbacka peer’s session drops / namespace tears down
NetworkManager.OnServerStartedthe authority namespace is open
NetworkManager.OnTransportFailurethe QUIC session fails unrecoverably
nm.OnClientConnectedCallback += id => Debug.Log($"peer joined: {id}");
nm.OnClientDisconnectCallback += id => Debug.Log($"peer left: {id}");

​
Non-Unity engines

The Unity component is a thin wrapper over a shared C++ star session (host + N peers with reliable + unreliable + discovery). To integrate a non-Unity engine you implement a handful of engine-side hooks — discovery, RTT, max-datagram, capture-time telemetry, and the datagram-lane mapping — and reuse the rest of the session machinery. For a fully typed, language-native surface (TypeScript / Python / Go / Rust / Java / C#) without Unity, use the Games SDK, which exposes the same state / input / event channels directly. 
import { Games } from "@clutchcall/sdk/games";

const me = new Games({
  relayHost: "relay.clutchcall.dev",
  token:     await fetchRoomToken("duel-42", "alice"),
  roomId:    "duel-42",
  playerId:  "alice",
});
me.subscribeState(bytes => render(deserialize(bytes)));
const input = await me.publishInput();

Cookbook

Copy-paste snippets for the common porting tasks.

Games SDK

The typed, non-Unity surface for the same wire model.