# SDKs Overview

> Pick a language and dive in. All six SDKs ship the same five-modality surface.

All six SDKs are thin wrappers over the same C++ core. The **five modalities**
— voice, streams, robotics, games, data — are exposed as sub-imports (or
sub-namespaces / sub-packages) in every language. Method names align across
languages in idiomatic case; once you know one SDK, the others should feel
familiar.

  - **[TypeScript](/sdks/typescript/quickstart)** — `npm i @clutchcall/sdk`
  - **[Python](/sdks/python/quickstart)** — `pip install clutchcall`
  - **[Go](/sdks/go/quickstart)** — `go get github.com/clutchcall/clutchcall-sdk/go`
  - **[Rust](/sdks/rust/quickstart)** — `clutchcall = "0.1"`
  - **[Java](/sdks/java/quickstart)** — `com.clutchcall:clutchcall-sdk`
  - **[.NET / C#](/sdks/dotnet/quickstart)** — `dotnet add package ClutchCall.SDK`

Plus the **Unity UPM** transport for Netcode for GameObjects / Entities —
see [Netcode (Unity)](/modalities/netcode/details).

## The five modalities

Each SDK exposes the same five modalities as separate sub-imports:

| Modality       | TypeScript                       | Python                       | Go                       | Rust                    | Java                                 | .NET                  |
| -------------- | -------------------------------- | ---------------------------- | ------------------------ | ----------------------- | ------------------------------------ | --------------------- |
| **Voice**      | `@clutchcall/sdk/voice`           | `clutchcall.voice`           | `github.com/clutchcall/clutchcall-sdk/go/pkg/voice`   | `clutchcall::voice`     | `com.clutchcall.sdk.voice`           | `ClutchCall.SDK.Voice` |
| **Streams**    | `@clutchcall/sdk/streams`         | `clutchcall.streams`         | `github.com/clutchcall/clutchcall-sdk/go/pkg/streams` | `clutchcall::streams`   | `com.clutchcall.sdk.streams`         | `ClutchCall.SDK.Streams` |
| **Robotics**   | `@clutchcall/sdk/robotics`        | `clutchcall.robotics`        | `github.com/clutchcall/clutchcall-sdk/go/pkg/robotics` | `clutchcall::robotics` | `com.clutchcall.sdk.robotics`        | `ClutchCall.SDK.Robotics` |
| **Games**      | `@clutchcall/sdk/games`           | `clutchcall.games`           | `github.com/clutchcall/clutchcall-sdk/go/pkg/games`   | `clutchcall::games`     | `com.clutchcall.sdk.games`           | `ClutchCall.SDK.Games` |
| **Data**      | `@clutchcall/sdk/data`            | `clutchcall.data`            | `github.com/clutchcall/clutchcall-sdk/go/pkg/data`    | `clutchcall::data`      | `com.clutchcall.sdk.data`            | `ClutchCall.SDK.Data` |
| **MoQT (raw)** | `@clutchcall/sdk/moqt`            | `clutchcall.moqt`            | `github.com/clutchcall/clutchcall-sdk/go/pkg/moqt`    | `clutchcall::moqt`      | `com.clutchcall.sdk.Moqt`            | `ClutchCall.SDK.Moqt` |

Mix them freely in one app — they share the same QUIC connection, auth, and
relay underneath. The substrate (raw MoQT) is always available too; see
[Realtime Tracks](/concepts/realtime-tracks).

## Common shape

Every modality client follows the same shape:

| Concept               | Pattern                                                |
| --------------------- | ------------------------------------------------------ |
| Construct             | `new <Modality>({ relayHost / baseUrl, token, ... })`  |
| Publish               | `.publish<Kind>({ topic / namespace, ... })` returns a publication handle |
| Subscribe             | `.subscribe<Kind>({ topicFilter / namespace }, callback)` |
| Control plane (HTTP)  | tRPC procedure calls (`.calls.originate`, `.liveInputs.create`, ...) |
| Close                 | `.close()` — terminates the underlying connection      |

The publication / subscription handles wrap the underlying MoQT track —
they auto-reconnect, replay subscribes on reconnect, and surface
backpressure if the relay falls behind.

## Realtime tracks (the substrate)

When the five modalities don't fit your shape — custom protocol, research
experiment, transport another codebase already uses — drop below them and
import the `MoqtClient` directly. See [Realtime Tracks](/concepts/realtime-tracks).
Same auto-reconnect, capability routing, and relay fan-out — without the
modality-specific conventions on top.

## Choosing a language

| If you're …                                                  | Pick this        |
| ------------------------------------------------------------ | ---------------- |
| Building a browser dashboard, broadcast viewer, game client  | **TypeScript**   |
| Writing an LLM voice agent, robot fleet publisher, IoT pub/sub | **Python**     |
| Running a high-throughput batch service alongside K8s infra  | **Go**           |
| Embedding into an edge service or hot path                   | **Rust**         |
| Plugging into a JVM monolith / Spring stack                  | **Java**         |
| Integrating with Windows tooling or Unity .NET runtime       | **.NET / C#**    |
| Shipping a Unity game (Netcode for GameObjects / Entities)   | **Unity UPM** (`com.clutchcall.transport`) |

You can mix and match across languages — a Python publisher and a browser
subscriber co-exist on the same MoQT track, by design.