$OREOS · Robinhood Chain · pre-launch
Mine for an hour. The heaviest hash takes the block.
An OS in your browser that mines one block an hour, paid in ETH from the coin's own fees.
- @useOreOS· soon
- github.com/useoreos· soon
- Docs
OreOS 0.1 · one window per hour, on the hour (UTC)
window: opens at launch · the hour turns in --:--
- device
- this browser · 1 CPU thread
- hashrate
- 0 H/s
- hashes
- 0
- heaviest
- 0bits0x…
A real SHA-256 search on a demo seed, five seconds on one thread. Nothing is sent anywhere.
Contract address: not yet.
$OREOS has not launched. When it does, the address appears here, and only here and in the docs.
Check the address against this page before you sign anything. Any other address claiming to be $OREOS is not.
A hash on its own is slag.
Browser mining is easy to start and almost always pointless. Four reasons it goes nowhere:
- 01
Work that buys nothing
A hash proves a machine did work. On its own it buys nothing; somebody has to attach value to it.
- 02
Credits that never leave
Browser-mining apps pay credits that live in their own database. On one live Robinhood Chain app, 327,901 credits had been mined and 38 spent (October 2026).
- 03
Rewards printed fresh
Proof-of-work coins on other chains pay miners in new coins, so every block dilutes everyone who holds.
- 04
Fees with no plan
Every launchpad trade already pays a creator fee in ETH. On most coins it lands in one wallet with no public plan.
OreOSOne hour. One block. The heaviest hash takes it.
Every hour, on the hour, a new window opens. Miners hash, the record moves, and when the hour ends the heaviest hash of that hour takes the block.
- 1
A trade feeds the Strongbox
2.7% of every $OREOS trade arrives in ETH: 70% of the launchpad's 1% curve fee plus the 2% creator tax.
- 2
The Strongbox splits it
Every pull is cut 80 / 10 / 10: Block Pool, Burn Pool, Ops. On chain, in one transaction.
- 3
A window opens at hh:00 UTC
Its seed is the hash of the window's first chain block, so nobody could start early.
- 4
Miners hash
sha256(seed, window, address, nonce). Weight = leading zero bits + lock bonus bits.
- 5
A heavier hash is submitted
One transaction, a few cents of network fee. The contract recomputes it and keeps it only if it beats the record.
- 6
The hour closes
The record holder receives 5% of the Block Pool in ETH; whoever closes the window receives 1% of that block.
- 7
The block joins the log
Every block stays public. The Hall keeps the heaviest hash ever mined.
closes in
--:--
record
—bits
no record yet this hour
records this hour
- no record yet this hour
No coin yet, so no race yet: these records are generated to show how an hour moves. The live board opens in the OS at launch.
Why the heaviest hash, not the first
No difficulty to tune
More miners push the record deeper. The hour stays one hour.
Few transactions
Only a hash that beats the record is sent. Across N hashes, only about ln(N) were ever a record.
Something to watch
The record board moves all hour, and the last minutes matter.
Fair by arithmetic
Your expected share of blocks is your share of the hour's weighted hashes. Nothing else.
Weigh your machine before you mine.
The same rules the contract runs, worked out for your hardware. Change any number.
Your heaviest hash in an hour
~42.7
bits
Everyone else's
~48.4
bits
Your share of the hour's weighted work
2.0%
One block, on average, every
2.1 days
One block at this volume
≈ $54
steady state: 2.7% of volume, 80% to blocks, spread over 24 blocks
A model of the rules, not a forecast. Most hours, most miners take nothing.
How rare a heavy hash is
The exact rule
your expected share of blocks
your hashes × 2^(your bonus bits)
Σ every miner's hashes × 2^(their bonus bits)
Heavier weight holds the record. On equal weight, the smaller 256-bit value is heavier, so ties never stand.
Every trade drops ETH into the strongbox.
The Strongbox is the Vault contract, and the coin's creator-fee recipient. No person holds a key that moves its funds; code moves them.
A trade of $OREOS
on the launchpad curve or the pool
2.7% in ETH
70% of the 1% curve fee + the 2% creator tax
Strongbox
pulls, splits, pays; anyone can trigger a pull
80%Block Pool
5% of it pays every hourly block
10%Burn Pool
buys $OREOS on the market and calls burn()
10%Ops
indexer, miner builds, contract review, the site
Why 5% of the pool every hour
- Smooth: a busy hour does not make one huge block and twenty-three tiny ones.
- Never empty: a quiet hour still pays from what the pool holds.
- Steady state: with inflow F per hour, the pool settles near 20 × F and each block near F.
- A record below 24 bits does not count: that hour's block stays in the pool.
Burns call burn() on the token, so total supply falls on chain. Nothing is parked at a dead address.
Illustration, not a forecast
Volume is the only input. No volume, no new ETH: the pool then drains 5% an hour and blocks shrink with it.
Lock coins, weigh your hashes.
A lock adds bits to every hash the wallet submits. Coins weigh hashes; they never replace them. No hashes, no block.
- no lock
Visitor
0
bits · base weight
- Mine every hour
- Every board, every doc
- 1,000,000+
Prospector
+1
bit · 2× your hashrate
- +1 bit on every hash
- Two extra desktop themes
- 5,000,000+
Foreman
+2
bits · 4× your hashrate
- +2 bits on every hash
- Every theme, season polls
- 20,000,000+
Engineer
+3
bits · 8× your hashrate
- +3 bits on every hash
- Name colour in every log
Rules of the lock
- A lock counts from the next window after it lands, so nobody locks in the last minute of an hour.
- Minimum lock 7 days. An unlock request ends the bonus at once and frees the coins 7 days later.
- The bonus stops at +3 bits.
What the coin never does
- Pay anything for holding alone: blocks go to hashes, never to balances.
- Give a share of fees: a lock only weighs hashes the wallet mines itself.
- Mint more of itself: no block, reward or lock creates a new $OREOS.
Token facts
- Supply
- 1,000,000,000 $OREOS, fixed at launch
- Launch
- 100% through the launchpad's bonding curve
- Presale or team allocation
- none
- Graduation
- at 4.2 ETH of curve reserve, into a pool
- Creator tax
- 2%, paid to the Strongbox
- Burns
- burn(): total supply falls on chain
- Emissions
- none, ever
A tab, a rig or a phone. Same race, same rules.
One contract judges every hash. Where the hash came from does not matter.
Browser tab
~2 GH/s on a gaming GPU
- 1Open the OS, connect a wallet
- 2Top up a session key once (~0.001 ETH)
- 3Press Start: WebGPU, or CPU threads
- 4Records are sent for you
Native miner
~20 GH/s on a top GPU
- 1Open source, from the project's code page
- 2CUDA, Metal or OpenCL
- 3Reads each seed from the chain
- 4Sends its own records
Phone
~0.2 GH/s
- 1The same OS, smaller
- 2Battery-aware intensity
- 3Rare blocks, real ones
- 4A pool for steady drips comes next
How the pieces talk
- Browser OS→HourRace· submit()
- Native miner→HourRace· submit()
- HourRace→Indexer · API· events
- HourRace→Strongbox· settle → block
- HourRace→OreLock· bonus(addr)
- Strongbox→$OREOS· buy + burn()
- OreLock→$OREOS· lock / unlock
What no miner ever has to do
- Trust a server with balances: there are none.
- Claim or withdraw points: blocks pay ETH directly.
- Install anything to mine in a browser.
- Sign a wallet pop-up per record.
- Hold the coin to mine: locks only add weight.
The hash, laid out for speed
- seed · 32
- reward address · 20
- window · 8
- pad · 4
- nonce · 8
- The first 64 bytes never change in a window, so every try costs one SHA-256 compression.
- The reward address is inside the hash: a nonce found for one address is worthless to any other.
- On chain, the check is the SHA-256 precompile.
Every block leaves a record.
An address, a number of zero bits and an amount of ETH, kept for good.
Heaviest hash ever
— bits
Nothing mined yet. The first block lands one hour after launch.
Badges, from on-chain facts only
First Block
took a block for the first time
Overtime
a record set in the last 60 seconds that stood
Deep Vein
a record of 48+ zero bits
Night Shift
a block between 00:00 and 06:00 UTC
Clean Sweep
three blocks in a row
Comeback
took the record after another address held it for 45+ minutes
Boards
- Heaviest today and this week
- Most blocks this season
- Longest streak of consecutive windows
Seasons
- One season = one calendar month (UTC). Boards reset; the all-time Hall never does.
- Lock tiers vote on one season rule from a short list. Money rules are never on the ballot.
Ways to cheat, and why they fail
Copy someone's nonce
Worthless: the reward address is inside the hash
Mine a window early
Impossible: the seed is the window's first chain block
Lock at the last second
A lock only counts from the next window
Flood the contract
Below 24 bits or not heavier: reverted, sender pays the fee
Split into many wallets
No gain: weight comes from hashes
Outbid at hh:59
The sequencer orders by arrival, not by fee
Fake a device name
Device names are shown for fun and decide nothing
What gets dug next.
Four phases. The first is being built now; nothing is deployed yet.
Phase 1
nowweeks 0-3
- Race, Strongbox and Lock contracts tested on a mainnet fork
- Browser miner (WebGPU + CPU), native miner v0.1
- The OS: miner, race, strongbox, lock, hall, docs
- Launch with the Strongbox as the creator-fee recipient
Phase 2
months 1-2
- Tab Pool: browser miners pooled, paid per share
- Native miner on Metal and OpenCL
- Badges, seasons, block cards
Phase 3
months 2-4
- Daily Heavy: one 24-hour window with its own pool
- Stock blocks (option): a block paid in a tokenized stock, if the route holds up in testing
Phase 4
months 6-12
- Race Kit: any new coin can run its own hourly race
- Partner races inside the OreOS desktop
- A public race data API
Watched every day
- Blocks settled per day (target: 24 of 24)
- Unique block-takers per week
- Share of blocks taken from browser tabs
- ETH into the Strongbox per day
- $OREOS locked and burned
Deliberately not watched
- Self-reported device names
- Follower counts
- Hashrate claims nobody can check
Decisions, and why
Heaviest hash, not first
no difficulty to tune
One window per hour
a moment every hour
SHA-256 + precompile
cheap check, fast kernels
Reward address in the hash
copied nonces are useless
Seed = window's first block
no early mining
Strongbox = fee recipient
fees reach miners by code
80 / 10 / 10 split
blocks first, burn, ops
Block = 5% of the pool
smooth, never empty
24-bit floor
keeps junk off the chain
Bonus capped at +3 bits
coins weigh, never replace
burn(), not a dead address
supply falls on chain
No owner, no pause
nothing to seize or stop
Fault lines, said out loud.
What makes OreOS strong, and what could break it.
Holds up
- Blocks pay ETH from real trading fees, not points or new supply.
- The contract checks every hash; no server holds balances.
- The rules are arithmetic anyone can check.
- A small contract set: three contracts and a kernel.
Could crack
- Rented GPUs and big rigs will take most blocks. That is how proof of work behaves; the Tab Pool is the answer for laptops.
- Block size follows volume. A quiet coin makes small blocks.
- The launchpad's owner can change a coin's fee recipient after a timelock. The docs show the live recipient.
- A session key lives in your browser with a little ETH. Treat it like cash in a pocket.
- Nothing is deployed yet. Every figure on this page is a rule or a model until launch.