Complete transparency into the Schizo Racing algorithm
| Attribute | Weight |
|---|---|
| Speed Raw top speed — the most impactful attribute for overall race performance | 20% |
| Acceleration How quickly the racer reaches top speed from standstill or after slowdown | 12% |
| Endurance Resistance to fatigue — maintains performance in later race segments | 10% |
| Grip Traction and cornering ability — reduces speed loss on turns | 10% |
| Luck Influences RNG favorability and chance of receiving positive chaos events | 8% |
| Aerodynamics Wind resistance efficiency — maintains speed at higher velocities | 8% |
| WeightInverse Body mass — heavier racers are slower (inverse: lower is better) | 8% |
| Reflexes Reaction time to track conditions and obstacles | 7% |
| Stamina Energy reserves — works with Endurance to resist late-race fatigue | 7% |
| Recovery How quickly the racer bounces back after a chaos event penalty | 5% |
| Chaos Resistance Reduces the impact of negative chaos events (Banana Slip, Oil Slick) | 5% |
Inverse — heavier racers are slower. The Weight attribute value is inverted before calculation: (100 - weight)
performance = (stats_score × 0.75) + (rng_factor × 0.25) stats_score = Σ(attribute_value × attribute_weight) for all 11 attributes rng_factor = deterministic_random(vrf_seed, racer_index, segment)
This 75/25 split ensures that stronger racers have a consistent advantage, but underdogs can still win on any given day. High-stat racers win more often over time, but the RNG component — derived from the VRF seed — means no race is ever a foregone conclusion.
See real diversity metrics proving this works →Before the race begins, the system requests randomness from the Switchboard oracle on Solana.
The Switchboard oracle generates a cryptographic proof and a random seed using its secure enclave (commit-reveal pattern).
The 32-byte seed and its cryptographic proof are stored on-chain in the VRF state account — visible and verifiable by anyone.
The seed deterministically generates ALL race randomness — every RNG call, chaos event selection, and affected racer choice derives from this single seed.
Affected: 1-3 racers
Effect: lose 1-3 positions
Selection: Lower Chaos Resistance = more likely
Affected: 2-5 racers
Effect: lose 1-2 positions
Selection: Lower Chaos Resistance = more likely
Affected: 1-2 racers
Effect: gain 2-4 positions
Selection: Higher Luck = more likely
Affected: 1 racer
Effect: gain 3-5 positions
Selection: Higher Luck = more likely
Total: 30% + 30% + 25% + 15% = 100%
The race is split into 20 segments over 180 seconds (~9s each).
Each segment calculates every racer's distance traveled using their weighted attribute score (75%) plus a seeded RNG factor (25%). Fatigue reduces performance in later segments based on Endurance and Stamina.
At designated segments, chaos events modify racer positions. Negative events (Banana Slip, Oil Slick) reduce distance for vulnerable racers. Positive events (Turbo Boost, Lucky Star) increase distance for lucky racers.
Each racer's total distance is accumulated across all segments. The running total determines positions at every point in the race.
After all segments complete, racers are sorted by total accumulated distance. Most distance = 1st place. Ties are broken by the Speed attribute.
After the simulation completes, a SHA256 hash is computed from the canonical JSON representation of: the VRF seed, all participant attributes (sorted), and the final positions. This hash is stored on-chain and can be independently verified.
The simulation is 100% deterministic: given the same participants and the same VRF seed, it will always produce identical results. Every random number, every chaos event, and every position change is derived from the single VRF seed through a seeded pseudo-random number generator.
Find the race's VRF seed from the on-chain race record. Each race stores its 32-byte seed in the VRF state account.
Retrieve the full participant list (mints + attributes) from the on-chain race state account.
Use the open-source simulation engine with the same VRF seed and participant list. The engine is fully deterministic.
The simulation produces a SHA256 hash of the full result. Compare your locally computed hash with the on-chain result hash — if they match, the race was fair.
3 participants with known attributes, VRF seed: 0xabc123... (full seed available on-chain)
Run the simulation engine with the same seed and participants. The engine will produce segment-by-segment results, chaos events, and final positions.
Compute the SHA256 hash of the canonical result JSON. If your hash matches the on-chain result hash, the algorithm is verified — the race was fair.