int to Compuon<int>
That's it.
A self-hosted integrity server compares exact arithmetic for each value the client registers, raising the cost of runtime data tampering. User-space only. No kernel driver.
int Health = 100; int Gold = 500; int Armor = 25; int Damage = 12; int Reward = 50; Health -= Damage; Gold += Reward; bool Alive = Health > 0;
#include <compuon/compuon.h> using namespace compuon; Compuon<int> Health(100); Compuon<int> Gold(500); Compuon<int> Armor(25); Compuon<int> Damage(12); Compuon<int> Reward(50); Health -= Damage; Gold += Reward; bool Alive = Health > 0;
Measured 2026-09-28 on one AMD Ryzen 7 5825U (MSVC 19.51 x64 Release, LTCG link) with Compuon's internal operator benchmark (not yet in a released core), linked against the core 0752031 library: median of three invocations of 9 runs. That is one build, from one seed; every SDK build comes from its own seed and times differently (builds from two other seeds took 113 ns and 366 ns for x += y on the same machine). Frame impact is the per-call median times 100, not a timed loop. Other CPUs and compilers give other figures.
Protected values in the client. Integrity server on your infra.
Compuon is not a kernel agent and not a full anti-cheat replacement. It is an auditable runtime integrity layer that raises the cost of client-side value tampering in multiplayer — and, in single-player, an unauthenticated copy keeps running but computes wrong values for the variables you protect. It raises the cost of a crack; it does not claim to prevent one.
Auditable in your own binary
Compuon compiles into the game itself, so your engineers can inspect what ships, reason about the runtime data path, and avoid a black-box client agent.
Self-hosted integrity server
Live deployments always use the integrity server. We ship the Docker image; your team runs the service on infrastructure you control.
Designed to layer cleanly
Use Compuon alongside EAC, anti-tamper, DRM, or existing server-authoritative checks when the problem is runtime value manipulation inside the client.
Wrap the values you care about
Replace vulnerable engine values with `Compuon<T>` or the Unreal wrappers and keep writing gameplay code the same way.
Run the integrity server yourself
Production use includes the integrity server by design. You run it privately, keep the traffic path under your control, and avoid a vendor-hosted gameplay dependency.
Raise the cost of tampering
Cheaters can still edit plaintext values in memory, but the integrity proxy kept alongside each value does not follow the edit. For each value the client registers, the server compares exact arithmetic; a mismatch is a value mismatch, not a behavioural guess.
Built for the failures that actually cost live games: ammo that never drains, durability that never drops, currency that forks away from the rules.
Those are the runtime-data incidents that force emergency patches, rollbacks, and live-ops apologies. If your game already uses EAC, anti-tamper, or DRM, Compuon is the layer that checks the values those systems do not: exact arithmetic on each registered value, compared server-side.
Exact comparison, not heuristics
Memory editors can modify plaintext values freely. The integrity proxy diverges, and for each value the client registers, the server compares exact arithmetic. No kernel driver. The comparison is exact arithmetic rather than a behavioural heuristic, so what the server sees is a value mismatch, not a probabilistic guess about the player. This raises the cost of tampering; it does not make it impossible.
A complementary protection layer for offline games
Compuon<T, true> (alias CompuonDeferred<T>, C++ SDK only — the Unreal wrappers use the default mode) keeps no plaintext in the object: the variable stores a protected value under a session-bound encoding, and the plaintext is derived at read time, existing in the clear only for the instant an operation consumes it. Without a valid session, the game runs — but inventory, currency, and progression computed through these values come out wrong. No crash, no DRM launcher. The encoding differs per build, so a patch has to be re-located for each one (re-location cost unmeasured).
Protect the values that matter first.
Start with health, ammo, durability, score, currency, or ranked progression. Layer it into the rest of your protection stack without pretending every problem needs the same tool.