Quick Start

// YourGame.Build.cs
string CompuonPath = Path.Combine(ModuleDirectory, "ThirdParty", "compuon-core");
PublicIncludePaths.Add(Path.Combine(CompuonPath, "include"));
// compuon.lib sits at the zip root, not under lib/
PublicAdditionalLibraries.Add(Path.Combine(CompuonPath, "compuon.lib"));

# COMPUON_SDK = the unzipped package; the library is at its root
set(COMPUON_SDK ${CMAKE_SOURCE_DIR}/third_party/compuon)
add_library(compuon STATIC IMPORTED)
set_target_properties(compuon PROPERTIES
  IMPORTED_LOCATION ${COMPUON_SDK}/compuon.lib   # libcompuon.a on Linux
  INTERFACE_INCLUDE_DIRECTORIES ${COMPUON_SDK}/include
)
target_link_libraries(YourGame PRIVATE compuon)
# Windows: match the package's /MD runtime (see TOOLCHAIN.txt for the toolset)
set_property(TARGET YourGame PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")

#include "CompuonTypes.h"   // Unreal module, delivered separately (not in the zip)

// Before:  float Health = 100.f;
// After:
FCompuonFloat Health = FCompuonFloat::Make(100.f);
FCompuonInt Ammo = FCompuonInt::Make(30);

// All operators work the same:
Health -= FCompuonFloat::Make(Damage);   // Make() builds two values per call (see below)
Ammo.Set(30);                            // Tier 1: re-encodes (x = v: 5.9 µs)
bool bDead = Health.Val() <= 0.f;

CompuonTypes.h(FCompuonInt, FCompuonFloat, UCompuonSubsystem) and its Build.cs are not in the SDK zip. The Unreal module is delivered separately during the pilot — email hello@compuon.dev.

#include <compuon/compuon.h>
using namespace compuon;

// Anti-cheat mode (default) — plaintext cached, tamper detected:
Compuon<int> hp(100);
Compuon<float> speed(5.5f);

hp -= 25;                   // plain number: builds a temporary value (x += 25: 6.2 µs)
speed = 7.5f;               // Tier 1: re-encodes (x = v on Compuon<int>: 5.9 µs)
bool dead = (hp <= 0);      // reads cached value

// Deferred mode — no plaintext in the object. Every read and every op folds
// against the server's operand bundle, and a read then decodes: a read took
// 37 µs, about 17 times verify(), on the machine below.
// Needs the server-issued seeds (AUTH_OK -> api::rekey_session) and the
// server's operand bundle: create these only after AUTH_OK. Not
// spot-checkable in this release — do not register their ids with the server.
Compuon<int, true> gold(500);
gold += reward;

Timings: one AMD Ryzen 7 5825U, MSVC 19.51 x64 Release (LTCG), 2026-09-28, Compuon's internal operator benchmark (not yet in a released core) on Compuon<int> and Compuon<int, true>, core 0752031 library (median of three invocations of 9 runs). That is one build, from one seed; your SDK build comes from its own seed and will time differently. A plain-number operand to += or -= builds and destroys a temporary value, and FCompuonFloat::Make builds two values on every call: in a copy of the Unreal wrapper built outside UE, H -= FCompuonFloat::Make(d)took 1.9–2.0 times x -= Compuon<int>(25). Compuon<float> was not in the benchmark, and the server-verified profile has not been measured inside a game loop. See Operation Tiers.

// UCompuonSubsystem comes up automatically with the game module.
// It does no per-frame SDK work. Rotation arrives on your
// integrity-server connection -- see the Key Rotation guide.

#include <compuon/compuon.h>
#include <protocol/sync_handler.h>

// The two seeds you pass to init() are placeholders. The real seeds are
// issued by the integrity server on AUTH_OK and applied with
// compuon::api::rekey_session(session_seed, rotation_seed) -- SyncHandler
// does that for you once you opt in below. Create protected values only
// after AUTH_OK (handler.is_authenticated()), and never call init() twice:
// a second init() re-arms locally minted operands.
compuon::api::init(placeholder_session_seed, placeholder_rotation_seed,
                   /*bootstrap_operands=*/false);   // server-verified profile

compuon::SyncHandler handler;
handler.set_request_session_seed(true);   // ask the server for per-session seeds
handler.send_auth(player_id, project_id, api_key);
// Your WebSocket code feeds received messages to handler.on_message() and
// drains handler.pop_outgoing() to the socket. KEY_ROTATE is applied by the
// handler (api::rotate) -- you do not call rotate() yourself.

// No per-frame SDK call is required.

// At teardown. Terminal: every handle dangles afterwards.
compuon::api::shutdown();