Quickstart

Link the SDK, build one client at launch, keep it for the session. That is the full default integration — you pass nothing to init, because Arcane Powered gives your process the ids it needs.

Prerequisites

Rust (edition 2021), or a native engine that can load the C ABI
The Arcane desktop app is installed (init opens it when a ticket must be refreshed online)

Arcane Powered sets ARCANE_GAME_ID and ARCANE_USER_ID on your game process when it launches it, so a shipped game needs nothing else. To run your build outside the launcher, you set those variables yourself — see Local development.

Get started

Link the SDK

Rust:

Cargo.toml

[dependencies]
arcane-sdk = "0.10"

Engines (Unity / Unreal / C++): build the shared library, include include/arcane_sdk.h, and load the C ABI.

cargo build --release

Build the client at launch

Call init with no arguments. It reads the game id from ARCANE_GAME_ID and checks ownership as part of building the client — there is no separate ownership call.

use arcane_sdk::{ArcaneClient, SdkError};

fn boot() -> Result<ArcaneClient, SdkError> {
    let client = ArcaneClient::init()?;
    // Owned, or DRM is disabled for this title — either way, launch.
    Ok(client)
}

char err[512];
if (arcane_sdk_init(err, sizeof(err)) != 0) {
  /* err is "code: message — hint (context…)" — see Errors */
}

Read state from the client, not from new calls

The client holds the result in memory. Nothing downstream needs the game id again.

client.user_id();          // Option<&str> — the signed-in Arcane account
client.game_id();          // &str — what Arcane Powered launched you with
client.is_owned();         // bool
client.ownership();        // Owned | DrmDisabled
client.device_hash();      // this machine, for this account
client.ticket_expires_at() // Option<i64>

char user_id[64];
int written = arcane_sdk_user_id(user_id, sizeof(user_id));
/* written >= 0 on success; negative values are errors — see C ABI */

Call frame() in your render loop

Optional, one line. init already tracks playtime; frame() is what lets Arcane sample the frame rate.

loop {
    render();
    client.frame();   // an atomic load, ~30 s per 5 min an increment too
}

arcane_sdk_frame();

Nothing else is needed. Sampling happens in 30-second windows, only while the player allows it in the Arcane desktop app, and a game that never calls frame() simply reports no FPS. See Session.

You are done for the default launch path. Store the client (or rely on the C ABI singleton) and read from it.

Ownership is never revalidated on its own: a session that runs for hours and wants to re-confirm it calls refresh() explicitly. The client does run one lightweight thread for the play session — asleep about 59 seconds out of 60 — which reports playtime and FPS samples and never blocks your game. See Client and Session.

Changed in 0.10. init takes no argument. Arcane Powered passes the game id in ARCANE_GAME_ID and the signed-in account in ARCANE_USER_ID when it launches your game, and the SDK reads both. A game started without ARCANE_GAME_ID fails with the new missing_game_id code. game_id() still answers with that id. To run your build by hand, set the variables yourself — see Local development.

Handle failures

Every failure is an SdkError with a stable code, a player-facing message, a developer-facing hint, and a context naming the values involved.

match ArcaneClient::init() {
    Ok(client) => start_game(client),
    Err(err) => {
        // One log line is enough to debug:
        // not_owned: You do not own this game. — Buy it on the Arcane Store
        //   or marketplace, then retry. (detail=…)
        eprintln!("{err}");

        match err.code() {
            "missing_game_id" => show_launch_from_arcane(err.message()),
            "not_owned" => show_store_prompt(err.message()),
            "network_required" | "not_authenticated" => show_retry(err.message()),
            _ => show_generic_error(err.message()),
        }
    }
}

missing_game_id means the player started the executable directly rather than through Arcane Powered — tell them to launch the game from the desktop app. Use err.is_retryable() to decide whether a retry button makes sense. The full table is in Errors.

Next steps

Client — lifecycle, what is cached, when to refresh
Local development — run your build outside the launcher
Session — playtime, FPS sampling, shutdown
Achievements — client.achievements().unlock("first_blood")?, one line, idempotent
Friends — client.friends().list()?, with online and in_game
Lobbies — client.p2p().create_lobby(...)?, a join code, invites, and your own netcode
Ownership model — what init does under the hood
Errors — this code → this problem → this fix
Rust API · C ABI

Getting started

Concepts

Engines

Reference

Prerequisites

Get started

Handle failures

Next steps

​Prerequisites

​Get started

​Handle failures

​Next steps

Prerequisites

Get started

Handle failures

Next steps