About Us

A Verifiably Fair, Latency-Equalized Engine for Okrummy, Rummy, and Aviator

Today’s real cash rummy apps-money and competitive card and crash games face three persistent gaps: opaque randomness, latency-driven advantages, and weak, post-hoc anti-collusion. We present a demonstrable advance for Okrummy, classic Rummy, and Aviator that closes these gaps with a single, verifiably fair engine. It combines public verifiability of randomness, latency equalization at the input layer, privacy-preserving integrity analytics, and built-in player protection. Crucially, every claim can be independently tested by players, auditors, and regulators without trusting the operator.

At the core is a provably fair randomness pipeline. Before each hand or round, the server publishes a hash commitment of a secret server seed and a per-round nonce. Each player optionally supplies a client seed. After the hand or flight, the server reveals its seed; the final randomness is derived by hashing server seed, client seed(s), and nonce, then feeding that digest into a standard, open Fisher–Yates shuffle for rummy decks or into the Aviator curve function. Anyone can reproduce the deck order or the crash multiplier offline and confirm exact alignment with the recorded outcome.

We extend reproducibility with a Verifiable Random Function (VRF) option for jurisdictions that prefer public randomness. When enabled, the system uses a VRF proof attached to each round, making the source of randomness auditable without leaking the server’s long-term secret. The entire seed chain is time-stamped and linked so tampering with one round breaks verifiability of all subsequent rounds; this creates a tamper-evident audit trail players can inspect on demand.

To neutralize network advantages, we introduce input-phase latency equalization. Player actions are collected in short, synchronized ticks (e.g., 100–250 ms) with cryptographic time-locked commitments: a client first submits a hash of the intended action, then reveals the action within the tick. The engine orders all revealed actions by commitment time within that window, eliminating “last-millisecond sniping” in Aviator and unfair reaction races in rummy discards. The demonstrable test: connect one device over fiber and another over congested mobile data; simultaneous actions land in the same tick and are resolved by predeclared, auditable rules.

Anti-collusion moves from ad hoc heuristics to a measurable, privacy-preserving pipeline. We model discard echoes, meld timing correlations, improbable draw symmetries, and inter-table transfer patterns with a graph-based detector. Sensitive features are computed on-device and shared as anonymized sketches; flagged clusters are reviewed by an explainable layer that highlights which signals triggered suspicion. To demonstrate, we ship a red-team simulator that generates controlled collusion scenarios and shows the detector’s precision/recall under varied parameters, so auditors can reproduce detection performance without accessing player identities or raw hands.

Okrummy adds a learning mode that is both useful and fair. In ranked play, assistance is disabled. In Learn mode, after each action is irrevocably committed, an “Explain” button reveals counterfactuals—what alternative discard would have improved meld probability over N future draws—powered by a regret-minimization model trained on synthetic play. Because explanations are delayed until after commitment and logged with the same seed chain, players can verify that coaching never influenced the randomness or their opponents’ information.

For Aviator, we address two frequent pain points: last-frame exits and perceived curve manipulation. First, a snapshot-lock ensures that cash-out requests received within a tick are evaluated against the curve at the start of that tick, removing the outcome from the mercy of UI or network jitter. Second, because the crash multiplier is derived from the same revealed seeds used for rummy shuffles, players can regenerate the curve offline. An open-source verifier replays the multiplier curve from seeds and confirms each cash-out’s eligibility at the locked snapshot time.

Tournament integrity receives the same treatment. Swiss pairings, seating orders, and tie-breakers are generated from publicly committed seeds; pause/resume state is hashed and signed, so disputes can be resolved by re-simulating from the last confirmed state. If a client disconnects, a secure enclave preserves its commitment state and rejoins with proofs that prevent rollback or ghost inputs.

Responsible play is integrated, not bolted on. We include a loss-velocity governor that slows session tempo after predefined thresholds, friction-increasing breaks with transparent timers, and voluntary limits enforceable across devices. Every limit change and enforcement event is signed and exportable, so regulators and players can confirm that controls were applied exactly as configured.

Perhaps the most important property is demonstrability. A “Verify” button on every completed hand or flight reveals seeds, hashes, and a one-click link to an independent verifier. Players can copy the seed bundle, reproduce the exact deck order or crash curve, and confirm that the engine, not the operator, determined outcomes. Latency fairness can be observed with two phones, different networks, and synchronized taps; action ordering follows the same, documented tick rules every time.

Bringing these elements together—verifiable randomness, latency equalization, explainable anti-collusion, fair coaching for Okrummy, transparent Aviator cash-outs, and auditable tournaments—represents a practical, testable leap beyond the status quo. It replaces “trust us” with “verify it,” gives honest players an even field, and equips operators and regulators with shared, objective truth about every outcome.