Steam

User identity, friends, achievements, stats, lobbies, game-server hosting, the in-game overlay, Cloud saves, Workshop, Remote Play, and rich presence. All wrapped over the Steamworks SDK.

local Steam = import("Steam")

if Steam.SteamPresent then
    print("Hi, " .. Steam.User.Name)
    Steam.Achievements.Unlock("FIRST_KILL")
    Steam.Achievements.Store()
end

Steam.SteamPresent

Boolean. True if the Steam SDK redistributable (steam_api64.dll / libsteam_api.so / libsteam_api.dylib) is present alongside the executable. That's the only thing it checks. Obtain the redist from partner.steamgames.com, drop it next to ruzitrun.exe during development or next to your shipped launcher exe, and list it under include = [...] in build.toml so ruzit build copies it into Generated/.

To make built games work standalone (no Steam launch required), the runtime briefly writes steam_appid.txt next to the exe at SDK init, lets Steam read it, then immediately deletes it. The AppID is pulled from your build.toml [steam] table, falling back to 480 (Spacewar) if unset. The file appears for a few milliseconds during startup and never lingers afterward — the AppID is effectively baked into the runtime binary. The user's Steam client must still be running and logged in for actual Steam API calls to succeed; if init fails, individual Steam calls return / error accordingly.

If a steam_appid.txt is already present next to the exe when the runtime starts (e.g., one you placed manually for testing), the runtime leaves it alone — your file wins, and it won't be deleted on shutdown.

Importing Steam never touches the SDK. SteamPresent is a file-existence check only. To actually wire up the SDK you call Steam.Initialize() explicitly — this is what triggers SteamAPI_Init under the hood. Wrap it in pcall so a missing-export delayload failure (caused by shipping the wrong SDK version of steam_api64.dll) doesn't take your script down:

local Steam = import("Steam")

local SteamReady = false
if Steam.SteamPresent then
    local ok, err = pcall(Steam.Initialize)
    if ok then
        SteamReady = true
    else
        print("Steam init failed: " .. tostring(err))
    end
end

local function on_kill()
    if not SteamReady then return end
    Steam.Achievements.Unlock("FIRST_KILL")
    Steam.Achievements.Store()
end

Supported Steamworks SDK version

Ruzit's steam Cargo feature is built against the steamworks Rust crate version 0.11.x, which is generated from Steamworks SDK ~1.59 / 1.60 (interface set SteamClient020, SteamUser023, SteamFriends017). The steam_api64.dll you ship with your game has to match this exact interface set — Windows will refuse to bind missing exports at first call and raise STATUS_DELAYLOAD_PROC_NOT_FOUND (0xC06D007F), terminating the process before any Rust code can catch it. Symptoms: the game launches, prints SteamInternal_SetMinidumpSteamID: ... [API loaded no], then dies with exit code -1066598273.

Where to get the exact DLL

The steamworks-sys Rust crate bundles the redistributable binaries it was built against. Just copy them from your local cargo registry:

# Windows host
~/.cargo/registry/src/index.crates.io-*/steamworks-sys-0.11.0/lib/steam/redistributable_bin/win64/steam_api64.dll

# Linux host
~/.cargo/registry/src/index.crates.io-*/steamworks-sys-0.11.0/lib/steam/redistributable_bin/linux64/libsteam_api.so

# macOS host
~/.cargo/registry/src/index.crates.io-*/steamworks-sys-0.11.0/lib/steam/redistributable_bin/osx/libsteam_api.dylib

Drop the file next to ruzitrun.exe during development. For shipping, list it in build.toml's include = [...] so ruzit build copies it into Generated/ next to your launcher exe.

Verification hashes

SHA-256 of the redistributables that ship with steamworks-sys 0.11.0:

If your file size matches but the hash doesn't, your DLL is from a different Steamworks SDK release with the same payload size. The hash is the authoritative check.

What about newer Steamworks SDK releases?

Valve adds new interfaces (SteamFriends018, SteamUser024, etc.) every couple of SDK releases. A newer DLL removes the old interface exports the steamworks crate is hard-wired to import — that's why a 317 KB DLL from a 2025 release crashes against the bindings expecting the 301 KB DLL. To use a newer SDK you'd have to bump the steamworks Cargo dep to a matching version (the crate is maintained out-of-tree from Valve's release cadence). Stick with the bundled binary unless you have a specific reason to chase the latest SDK.

Steam.OnDisconnected / OnConnected / OnConnectFailure

Top-level signals reporting the local Steam client's connection to the Steam backend. Affects every Steam-backed feature — lobbies, matchmaking, friends, achievements/stat sync, cloud, etc. — so this is the right place to globally pause networking when Steam goes offline.

If you only care about lobby disconnects, hook SteamLobby.OnDisconnected on the specific lobby — it distinguishes "Disconnected" from "Kicked" / "Banned", and only fires for that lobby.

local Steam = import("Steam")

Steam.OnLobbyJoinRequested:Connect(function(lobbyId, friendId)
    Steam.Lobby.Join(lobbyId):Connect(function(lobby, err)
        if lobby then enter_match_with(lobby) end
    end)
end)

-- Cold launch: game was offline when the invite was clicked.
local pending = Steam.Launch.GetQueryParam("connect_lobby")
if pending then Steam.Lobby.Join(pending):Connect(...) end

local Steam = import("Steam")

Steam.OnDisconnected:Connect(function(reason)
    -- Pause matchmaking UI, show "reconnecting…" toast, etc.
    print("Steam offline:", reason)
end)

Steam.OnConnected:Connect(function()
    print("Steam back online")
end)

Steam.User

Steam.Achievements

name is the API id from the partner site, not the display name. Always call Store() after a batch of unlocks.

Steam.Stats

Steam.Lobby

Each entry returns a Signal that fires once with the result. Connect once to handle the response.

Steam.Lobby.Create(8, "FriendsOnly"):Connect(function(lobby, err)
    if err then print("create failed: " .. err) return end
    print("lobby " .. lobby.ID .. " up")
end)

Steam.Overlay

Steam.App

Steam.Cloud

Per-user file storage that auto-syncs across devices. Files are scoped to the calling user; quota is set in the partner site.

Steam.Workshop

Steam.Server

Steam.RichPresence

Steam.Launch

Metadata about how the current process started. Useful for handling "Join Game" deep links and for branching dev vs. shipped runs.

RunType payload

Steam.Utils

Steam.RemotePlay

Object reference

Every type returned by Steam methods, in one place. The string-literal types up top are pure aliases, "Public", "Online", etc.

SteamLobby

Returned by Steam.Lobby.Create and Steam.Lobby.Join. Holds member state, lobby-wide and per-member key/value data, and a chat channel.

P2P networking via the lobby

:Send / :Broadcast / OnMessage are backed by Steam Networking Sockets — Valve's modern P2P transport with NAT punch-through, free relay fallback, end-to-end encryption, and addressing by SteamID (peers never see each other's IPs). Use this for actual gameplay packets; :SendChat is rate- limited and only fits lobby-room chat.

local Steam = import("Steam")

Steam.Lobby.Create(8, "Public"):Connect(function(lobby)
    -- Receive packets from any other member.
    lobby.OnMessage:Connect(function(senderId, bytes)
        print(senderId, "sent", #bytes, "bytes")
    end)

    -- Reliable (default) — ordered, no-loss. For chat, RPCs, state syncs.
    lobby:Broadcast("hello everyone")

    -- Unreliable — fast, may drop. For positions/inputs.
    Heart:Connect(function()
        lobby:Broadcast(serialize_player_state(), "Unreliable")
    end)
end)

SteamServer

Returned by Steam.Server.Start. The game-server side of the Steamworks SDK.

SteamServerOptions

Plain table passed to Steam.Server.Start.

SteamFriend

Returned in lists by Steam.User:GetFriends().

SteamFriendInfo

Returned by Steam.User:GetFriendInfo(id). Adds nickname + game.

SteamLobbyInfo

Returned by Steam.Lobby.List, lighter-weight than a live SteamLobby.

SteamCloudFile

One entry from Steam.Cloud.ListFiles().

WorkshopItemState

Returned by Steam.Workshop.ItemState(id).

WorkshopInstallInfo

Returned by Steam.Workshop.InstallInfo(id) when the item is on disk.

WorkshopItem

Combined snapshot from Steam.Workshop.GetItem(id), union of WorkshopItemState + WorkshopInstallInfo + a file lister.

RemotePlaySession

One entry from Steam.RemotePlay.Sessions().

RunType

Returned by Steam.Launch.GetRunType().

String enums