RustClash publishes its own fairness page
RustClash keeps its fairness material at rustclash.com/fairness. That is a document, not a forwarding address, and this page said otherwise until 20 September 2026.
The document is Clash.gg's, near enough. Same tabbed layout, same introductory text, same per-mode descriptions word for word, and the same two CodePen embeds carrying the same code. The tab list is shorter. RustClash covers Case Opening, Battles, Double, Upgrader, Mines, Plinko, Roll, Crash and Tiles, without the Champion and Bomb Rush modes that appear on Clash.gg.
Two identical documents are not one shared document. Either copy can be edited without the other, and nothing on either page records which was touched last. As of 20 September 2026 they match.
What the generator does with your seeds
RustClash inherits an algorithm that hashes nothing to produce your result. Most platforms covered here take a digest, slice a few hex characters out of it and convert those to a number. The Clash engine uses your seeds to seed a JavaScript pseudo-random number generator, then reads the first number it produces.
seedrandom( "serverSeed:clientSeed:round" ) seedrandom 3.0.5, colon separated
|
v
first output, a float from 0 up to but never reaching 1
|
v
( float x 100,000 ) truncated = your ticket, 0 to 99,999
That makes the library part of the specification rather than an implementation detail. A hash is the same function in every language, so a written formula is enough for anyone to rebuild it. A seeded generator is defined by its own source code, and substituting a different generator, or a different version of the same one, returns a number that is no less random and simply wrong. RustClash's published code pins version 3.0.5, and pinning it is what makes the method reproducible at all.
The commitment is a plain SHA-256 of the server seed, which behaves the way you would expect.
The round is an index inside your bet
The third value is not a running count of everything you have opened. It is the position of one roll inside a single action. Open three cases at once and you get rounds 1, 2 and 3 against the same pair of seeds.
Running RustClash's own published code on the seeds rustclash-server-seed and rustclash-client-seed returns 41,752, 69,793 and 17,987 for those three rounds. Nothing about those seeds is special. They are here so you can paste them into the verifier above and watch the tool agree before you trust it with values of your own.
A check that refuses to reproduce is usually a round number, so re-read that before anything else.
Two superseded validators, still public, still undated
Knowing the algorithm is not the hard part of a RustClash check. Knowing which algorithm applied is.
The case code on the fairness page today is version 2. An earlier validator, built for RustClash, is still hosted publicly on the same account. It is unlinked from the fairness page but reachable, and it is a different calculation rather than a variant of the same one:
| Current | The earlier validator | |
|---|---|---|
| Fed to the generator | The server seed and client seed | The hashes of those seeds |
| Extra step | None | A further SHA-256 over the combined string |
| Multiplier | 100,000 | 1,000 |
| Ticket range | 0 to 99,999 | 0 to 999 |
A second orphan sits beside it, a validator titled for the RustClash Upgrader, also public and also unlinked.
Nothing on RustClash states a date, a round ID or a nonce marking where the old code stopped applying. The battle validator carries its own New and Old switch with no boundary attached either, and the verifier above exposes that switch for exactly that reason: we cannot tell you which side of it your round sits on.
A recent round therefore checks cleanly. An older one yields two answers on two different scales, with no published fact to choose between them, which is not a verification.
What "verified" means on this page
Two different strengths of evidence sit behind that status, and stating them as one would flatter the weaker half.
Battles were cross-checked against the operator's own hosted verifier on 14 July 2026. Thirteen of thirteen sampled outputs reproduced, including the tie-break value. That tool is titled for Clash.gg, RustClash and DotaClash together, so what it returns is the operator's answer rather than only the operator's source code.
Case opening rests on less. Both published pens ship with empty input fields and no worked example, so RustClash states no input-and-output pair anywhere in its fairness material. The 41,752 above is computed by running its code, not a figure RustClash publishes. Running an operator's code correctly proves our implementation matches theirs. It does not prove the code on the fairness page is the code the site runs, which is what a published pair would do. CSGORoll publishes one. JemLit publishes one. RustClash does not.
The three values, and the one that arrives late
A case check needs the hashed server seed, your client seed and the round. The first two live in the fairness area of your account, where the client seed is editable and can be set to rotate automatically after each bet. Save the hash before you play. It is the commitment, and it is what the revealed seed has to match.
The unhashed server seed appears only once you rotate. That is the design rather than an oversight: a server seed still in use cannot be published, because anyone holding it could compute every remaining outcome in advance.
Battles need a different set. The shared input is drawn from Random.org after the last player joins, so it belongs to neither you nor RustClash. Take that seed from the battle's details, then pair it with the round and your slot, both counting from 1. Slots follow the format: two for a 1v1, four for a 2v2, six for a 3v3.
Tickets follow a published rule and an unpublished table
A ticket is a whole number from 0 to 99,999, and RustClash publishes the rule that maps tickets to items: an item listed at 1% holds exactly 1,000 of them, one at 0.1% holds 100. A ticket space of a round 100,000 rather than a power of two makes that arithmetic easy to follow.
What the fairness page does not carry is the per-item tables. The rule tells you how many tickets an item should hold. It does not tell you which numbers belong to which Rust skin in a given case, and without that the ticket is where the check stops. Whether those tables appear inside a logged-in account is outside what this page tested.
One company, two records
Clash.gg and RustClash sharing an operator is not an inference from pages that look alike. Both state it in their own terms. RustClash.com is owned and operated by Rust Clash Entertainment Ltd, at an address in Nicosia that Clash.gg's terms give as well, in text last updated on the same day, 26 January 2026. DotaClash is named beside both in the validator titles. The full engine walkthrough sits on the Clash.gg layer, and a method that works on one site works unchanged on the others.
The engine is settled, then. The operating record is a separate question and it does not transfer.
239 reviews, spread across a much longer window
On Trustpilot, RustClash holds 3.6 out of 5 across 239 reviews, on a profile claimed in June 2022, with 67% five-star and 29% one-star. Clash.gg holds 3.0 across 851.
One caution before comparing those two piles, because the numbers invite the mistake. The twenty visible one-star reviews on RustClash span January 2025 to September 2026, roughly twenty months. CSGORoll's twenty span about two. A smaller pile collected over a longer period is not a smaller rate, and a sentence here reading "fewer complaints" without that context would be false.
Sorted by subject, those twenty split as eight about account restrictions, six of which mention identity verification, four about how support replied, three about odds or a belief that results are steered, two about withdrawals, and the remainder about deposits and a related company.
The support cluster is the distinctive one. Three reviewers, in October and November 2025, separately describe replies that repeated the same text back at them. Nothing at that weight appeared on the other platforms checked for this site.
The reply figures run opposite to the impression they give. RustClash reports the lowest stated reply rate on negative reviews of any platform here, 18%, with a typical reply time given as over a month, and had still answered eight of the twenty visible one-star reviews. Clash.gg reports 44% and had answered none of its twenty. A March 2026 reviewer describes winning 2,800 gems, being asked for identity verification and then being permanently banned; RustClash replied roughly two months later, stating that accounts are not banned for winning and that verification follows its compliance procedures.
Those are individual accounts rather than findings. They sit here because account access is the one thing a fairness check cannot speak to.
A mechanic the operator described itself
Replying to a January 2025 reviewer, RustClash stated that deposits under $3.01 are credited as Coins, and that Coins cannot be withdrawn. That is the operator describing its own site, which is a better class of evidence than any review. It is also easier to read before a small first deposit than after one.
What a passing check settles
A match proves the round came from values committed before you played, and that nobody altered it afterwards, provided the round is recent enough for the current code to be the right one.
It settles nothing beyond that. Not whether a withdrawal arrives, not how support answers, and on a Rust skin not what the item is worth, since condition and float do the pricing rather than the name. Those are separate questions carrying separate evidence, and what verification cannot prove stays a standing page here because the distinction gets blurred so often.