The OMC testnet exists to prove one thing at scale: that idle consumer GPUs can be matched to real jobs, execute them in isolation, and have their output checked well enough that a cheater loses money. If you have a GPU sitting in a desktop, joining is the cheapest way to see how that machinery behaves — because everything that would be expensive on mainnet costs nothing here.

What hardware actually matters

Any CUDA or ROCm GPU works on the testnet. That is the floor, not the optimization. The matching engine scores nodes on several axes (TFLOPS, VRAM, bandwidth, latency and reputation), so the practical guidance is:

  • RTX 3090 / 4090-class cards land in the top hardware tiers — enough VRAM for real inference and rendering jobs, not just toy workloads.
  • NVLink-connected rigs get priority for multi-GPU jobs, because some tasks are sharded across cards and the interconnect is the bottleneck.
  • Anything older or smaller still runs and still earns reputation — expect to be matched to lighter jobs.
  • Your network matters more than you'd think. Jobs move data in and out; a slow uplink shows up as latency in your score, especially for training-adjacent work.

Step 1 — Get test tokens

Two different faucets, two different jobs. tBNB pays gas on BNB Smart Chain Testnet; tOMC covers the staking deposit each node has to lock before it can receive work.

Step 2 — Install the client

The node client is open source and containerized. On any machine with a working CUDA or ROCm stack:

git clone <node-client-repo>
cd <node-client-repo>
docker compose up

Two notes from people who have done this before. First, GPU access inside containers is the usual failure point — if docker compose up starts but the node reports zero devices, it's the container runtime's GPU passthrough, not the client. Second, Docker/Kubernetes is the supported path; the protocol runs jobs in hardened sandboxes by design, so don't plan on bypassing the container layer. Exact commands and the current repo location are on omc.network/testnet — use that page as the source of truth rather than any snapshot of it, including this one.

Step 3 — Stake and register

Before the network will route work to you, two things have to happen: you stake tOMC proportional to your hardware tier (the published rule is Staking_Min = Deposit × Tier, so a 4090-class node locks more than an entry-level card), and you register a node heartbeat so the scheduling layer knows you're alive.

The heartbeat is not a formality. It's how the network distinguishes an idle node from an offline one, and missing heartbeats is one of the behaviours that triggers slashing. If you're going to run a node on a machine you also game on, decide now how you'll keep it up — sporadic uptime is the most common way people lose test deposits for reasons that had nothing to do with cheating.

Step 4 — Execute and earn

Once registered, the matching engine routes jobs to you by score. Jobs arrive, execute inside an isolated container, and their output goes through verification. Pass, and the job is paid in tOMC. The lifecycle has one more property worth internalizing: requesters lock the fee tokens in escrow before dispatch, so payment isn't a promise — it's collateral already sitting in a contract when your job arrives.

How your work is checked (and what gets slashed)

Verification is per-job, and it's not all-or-nothing across the network. The protocol picks a policy based on the job: spot-check re-execution for most work, optional full redundancy across 2–3 independent nodes with output hashes compared where the stakes justify the cost, and hardware TEE for confidential workloads — that last tier is described as being in progress rather than generally available.

Failing that check is expensive for a reason. Fraudulent outputs, timeouts and fake heartbeats are slashed, and the split is deliberately unattractive to a cheater: 50% to the requesters who were harmed, 30% to the DAO treasury, 20% permanently burned. Note that two of those three destinations are not you, and the third doesn't come back.

The practical implication for an honest operator is simple: don't overclock into instability, don't accept jobs your card can't finish inside the deadline, and don't run the node on a machine you're about to reboot mid-job. Almost all slashing on a testnet is self-inflicted.

Before you plug in — the honest expectations. tOMC has no monetary value; you cannot sell it, and nobody legitimate will offer to buy it. Electricity, however, is real money, and a 3090-class node pulls roughly 350 W under load. Run the testnet to learn the flow and to build reputation — not as an income plan. Also: there is no official "node setup service". Nobody from OMC will ask for remote access to your machine, your keys, or a payment to onboard you. If someone offers to run your node for a cut, they're offering to hold your deposit.

What the testnet is actually buying you

Two things, and neither is cash. First, a working mental model: how staking tiers, heartbeats and verification behave under real conditions, learned before any of it costs money. Second, a recorded history — OMC's FAQ states that testnet compute contributions and reputation scores are tracked for the Compute Mining & Node Rewards pool, which is 50% of total supply at mainnet launch. That pool exists; what share of it any individual node ends up with is unknowable today, and anyone quoting you a number is guessing.

If you want the realistic financial picture before committing hardware, read what idle home compute actually earns and the cloud-vs-home TCO breakdown. Both are written to talk you out of bad assumptions, which is the most useful thing a guide can do.

Set it up, watch a job run end to end, and see how the verification layer behaves. That experience is the point — the testnet is a rehearsal, and rehearsals aren't supposed to pay.