P
BrowserCoin Pool
browser-based mining
disconnected height —
Pool Hashrate
0.0 H/s
0 miners connected
Network Share
— %
of total network hashrate
Blocks Found
0
by this pool
Last Block
—
found by the pool
Current Block #—
—
since last block

Mine

Set your payout address to start mining.
⚡ 1 threads 🧠 ~32 MB RAM 📊 ~—% CPU

Connected Miners refreshes every 10 s — may lag your live stats above

Address Connections Hashrate Share % Est. Reward Connected
No miners connected yet.
ramping up just started — shares still filling the payout window, earnings climbing to full ramping down stopped hashing — still earning while old shares age out of the window idle connected but not hashing, no shares left in the window

Blocks Found

Height Hash Found By Reward Effort Time
No blocks found yet.

How It Works

BrowserCoin uses Argon2id proof-of-work — a memory-hard algorithm designed to be ASIC-resistant and fair for general-purpose hardware. Mining happens entirely inside your browser using Web Workers, so there is nothing to install. Each worker allocates ~32 MB of RAM and runs the hash function in a loop, searching for valid proofs.

Shares
The pool gives every miner a personal share target that is far easier than the real network difficulty, auto-tuned (vardiff) so you find a share roughly every 20 seconds — whether you mine on a phone or a 32-core rig. Each share is credited by its difficulty, so your round score stays exactly proportional to your real work.
Rounds & Blocks
A round is the work on one block height. Your shares aren't discarded when a round ends — they stay in a rolling PPLNS window that spans rounds, so every block the pool finds pays out the most recent shares regardless of which round they landed in.
Reward Distribution & Fee
Rewards use PPLNS (pay-per-last-N-shares): each block is split by your weight in a rolling window of the most recent shares, so your earnings track your real work instead of swinging with single-round luck — and work done during rounds the pool loses to other miners still gets paid. The pool keeps a fee of 2% of each block reward to cover server and operating costs — the rest goes entirely to the miners.
Payouts
Your earned BRC accumulates as a pending balance. Once it reaches the minimum threshold (1 BRC), the pool automatically sends a transaction to your payout address. You can track your pending and paid balances in the stats section above.

Tip: Use the power slider to balance mining speed against system load. Each thread uses one CPU core and ~32 MB of RAM for the Argon2id memory buffer. Leave at least one core free so your browser stays responsive. Want the full technical details? Read the deep-dive — switching pages won't interrupt your mining.

Pool Address loading…

How This Pool Works

A technical walkthrough of everything that happens between the moment you press Start Mining and the moment BRC lands in your wallet — with the actual code that runs on both sides.

1 · Architecture

Three components talk to each other. Your browser does the hashing, the pool server coordinates the work and holds a full copy of the blockchain, and the BrowserCoin network helpers connect the pool to the rest of the network.

Your Browser
Web Workers hash Argon2id
submits shares via WebSocket
⇄
Pool Server
full chain node · builds templates
validates shares · pays out
⇄
BRC Network
API helpers + P2P miners
accept blocks & transactions

The pool keeps its own validated copy of the chain. It checks the network tip every ~3 seconds (with a full re-sync every 30) so stale work is kept to a minimum. When it finds a block, it pushes it to the helpers; when other miners find one first, the pool picks it up within seconds and starts a fresh round.

2 · The Proof-of-Work: Argon2id

BrowserCoin uses Argon2id — a memory-hard hash function originally designed for password hashing. Every single hash requires filling and reading a 32 MB memory buffer, which is why one hash takes ~40–125 ms instead of nanoseconds. This makes GPUs and ASICs far less dominant: the bottleneck is memory bandwidth, not raw compute, so ordinary laptops stay competitive.

What gets hashed is the 116-byte block header. The miner's job is to find a nonce (bytes 112–115) that makes the hash smaller than the target: 

// The mining loop — what each Web Worker runs.
// The nonce is a 32-bit big-endian integer at byte offset 112 of the header.
header[112] = (nonce >>> 24) & 0xff;
header[113] = (nonce >>> 16) & 0xff;
header[114] = (nonce >>>  8) & 0xff;
header[115] =  nonce         & 0xff;

const hash = await powHash(header);   // Argon2id, ~32 MB, 40–125 ms

// Interpret the 32-byte hash as a 256-bit number…
let hashNum = 0n;
for (let i = 0; i < hash.length; i++) hashNum = (hashNum << 8n) | BigInt(hash[i]);

// …a hash "wins" when it is below the target.
if (hashNum < poolTarget) submitShare(nonce, hash);

Lower target = harder puzzle. The network adjusts the target after every block (ASERT difficulty adjustment) so that one block is found every 150 seconds on average, no matter how much hashrate joins or leaves.

3 · Work Distribution

When you start mining, your browser opens a WebSocket to the pool and authenticates with your payout address. The pool answers with a job — a ready-to-mine block header it assembled from the current chain tip and pending transactions: 

// → browser sends
{ "type": "auth", "address": "04df6bb9…" }

// ← pool responds with work
{
  "type": "work",
  "jobId": "57-mq9o3ygr",          // height + unique id, rotates every block
  "headerHex": "0000003a…",        // 116-byte header, nonce zeroed
  "poolTargetHex":    "0000ff…",   // your personal share target (vardiff)
  "networkTargetHex": "000000ff…", // real target — solves the block
  "height": 57
}

The header already contains the pool's address as the block miner, the transaction root, and the resulting state root — your browser only has to grind nonces. Each worker thread starts from a different random nonce so they never duplicate work: 

// The 2^32 nonce space is sliced between workers.
const slice = Math.floor(0x1_0000_0000 / workers.length);
const base  = Math.floor(Math.random() * 0xffff_ffff);

workers[i].postMessage({
  type: 'start',
  headerBytes,
  targetHex: poolTargetHex,
  startNonce: (base + i * slice) >>> 0,
});

4 · Shares — Proving Your Work

A solo miner only gets rewarded when they solve an entire block, which can take a very long time on a single machine. A pool fixes that with shares: it hands each miner a personal target that is much easier than the real network target. The difficulty is tuned automatically per connection — classic vardiff, the same mechanism stratum pools use — aiming for roughly one share every 20 seconds no matter how fast your hardware is. 

// Per-miner pool target (vardiff, server side). More bits = easier.
// Every 60s the pool compares your share rate to the ideal (~1 per 20s)
// and steps your difficulty up or down — like classic stratum vardiff.
const networkTarget = compactToTarget(difficulty);
let poolTarget = networkTarget << BigInt(conn.shareBits); // 4–24 bits per miner
if (poolTarget > FLOOR_TARGET) poolTarget = FLOOR_TARGET;

Every hash that beats your target is a share. Since targets differ between miners, each share is credited with a weight proportional to its difficulty: a share from a 2× harder target counts exactly 2× more score. Fast rigs submit rare, heavy shares; slow laptops submit frequent, light ones — everyone sees steady progress, and payouts stay precisely hashrate-proportional. And because any share can also beat the network target, shares and block solutions come from the same stream of work — nothing is wasted.

The pool re-verifies every share server-side. Trust, but verify:

// Server-side share validation (abridged from the real code).
async function validateShare(job, nonce, claimedHashHex) {
  const headerBytes = new Uint8Array(job.headerBytes);
  writeNonce(headerBytes, nonce);

  const hash = await powHash(headerBytes);        // recompute Argon2id ourselves
  if (bytesToHex(hash) !== claimedHashHex)
    return { valid: false, reason: 'hash mismatch' };

  // compared against YOUR personal vardiff target:
  if (toBigInt(hash) >= targetForBits(networkTarget, conn.shareBits))
    return { valid: false, reason: 'does not meet your share target' };

  return { valid: true, meetsNetwork: toBigInt(hash) < networkTarget };
}

Cheating is also blocked at the protocol level: duplicate nonces are rejected (submittedNonces set per job), submissions are rate-limited per connection, and a share for an outdated job ("stale job") counts for nothing.

5 · Reward Distribution (PPLNS)

Every accepted share adds its difficulty weight to a rolling window of the most recent N weight of shares — the last 2× a block's worth of work. When the pool seals a block, the reward is split proportionally to each miner's weight in that window, not to a single round: 

// PPLNS payout — straight from the pool server.
const reward      = blockReward(height);                // e.g. 50 BRC
const poolCut     = BigInt(Math.floor(Number(reward) * POOL_FEE));  // 2%
const minerReward = reward - poolCut;

// pplns = rolling window of the last N share-weight (spans rounds)
for (const [addr, weight] of pplns.byAddr) {
  const payout = (minerReward * BigInt(weight)) / BigInt(pplns.totalWeight);
  pendingBalances.set(addr, (pendingBalances.get(addr) ?? 0n) + payout);
}
your payout = (block reward − 2% fee) ×  your weight in the windowtotal window weight

Because the window spans block boundaries, single-round luck stops mattering and work you did during rounds the pool loses to another miner is still paid on the pool's next block — PROP throws that work away. It also removes any pool-hopping advantage. The window is sized so it only holds a couple of blocks' worth of work, so a new miner reaches their steady share within a few minutes of joining, and keeps earning briefly after they stop as their shares age out.

6 · Payouts

Earnings accumulate as a pending balance on the pool. Once a balance reaches 1 BRC, the next payout cycle (every 60 seconds) signs a regular on-chain transaction from the pool's wallet to your address: 

// Automatic payout loop (every 60 s).
for (const [addr, amount] of pendingBalances) {
  if (amount < MIN_PAYOUT) continue;          // 1 BRC threshold

  const tx = signTx(
    { from: poolKey.publicKey, to: hexToBytes(addr), amount, fee: 200n, nonce },
    poolKey.privateKey,
  );
  await broadcastToHelpers(tx);               // enters the mempool…
}                                             // …and confirms in the next block

The payout is a normal BrowserCoin transaction — you can verify it on-chain. Since the pool mines blocks itself, payout transactions are usually included in one of the pool's own next blocks. The transaction fee (200 base units) is paid by the pool, not deducted from you.

7 · Mining in a Browser — Why It Works

The Argon2id implementation is compiled to WebAssembly and runs at near-native speed. Hashing happens in Web Workers — background threads that can't block the page — so the tab stays responsive while mining.

Each worker allocates its own 32 MB Argon2id buffer. The auto power setting uses every logical core except one (kept free so your system stays smooth) — the same full-speed default as the official BrowserCoin miner: 

// Auto thread selection (runs on page load).
const logicalCores = navigator.hardwareConcurrency || 4;

// All cores minus one — full speed while the OS + browser stay responsive.
const optimalThreads = Math.max(1, logicalCores - 1);

Because the algorithm is memory-bandwidth-bound, throughput can stop scaling before all cores are busy — typically around 6–8 concurrent workers on consumer hardware. If you care about efficiency (hashes per watt), drag the slider down manually; the last few threads often add little hashrate.

Note: some browsers deliberately report a lower hardwareConcurrency for fingerprinting protection (Safari caps it at 8, Brave randomizes it), so the detected value can differ between browsers on the same machine.

8 · Fairness & Trust

Pool Address (the block miner / payout sender) loading…
Total Paid Out
— BRC
to — miners, lifetime
Paid Last 24h
— BRC
on-chain payouts
Blocks Found
—
all time
Avg Block Time
—
last — pool blocks
Next Block Est.
—
at current hashrate
Pool Luck
—
avg effort, last — blocks

Pool vs Network Hashrate last 24h

Connected Miners last 24h

Recent Share Split PPLNS window

Blocks Found Per Hour last 24h

BRC Paid Per Hour last 24h

Time Between Pool Blocks recent blocks

Recent Payouts

Address Amount Time
No payouts yet.