P
BrowserCoin Pool
browser-based mining
disconnected height —
Pool Hashrate
0.0 H/s
0 miners connected
Blocks Found
0
by this pool
Network Share
— %
of total network hashrate
Current Block #—
—
since last block
Round Shares
0
difficulty-weighted · resets each block

Mine

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

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

Address Connections Hashrate Round Shares Share % Est. Reward Last Share Connected
No miners connected yet.

Blocks Found

Height Hash Reward 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 starts when the pool begins working on a new block and ends when a valid block-level hash is found. All shares submitted during a round are tracked. When the pool finds a block, the round closes and rewards are calculated from those shares.
Reward Distribution & Fee
Rewards are split proportionally: if you contributed 10% of the round's score, you earn 10% of the block reward. This is the standard PROP payout scheme used by most pools. 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 · Rounds & Reward Distribution (PROP)

A round is the period spent working on one block height. Every accepted share adds its difficulty weight to your address's round score. When a share beats the network target, the pool seals the block, adds it to the chain, broadcasts it — and splits the reward proportionally to the scores in that round: 

// PROP 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;

for (const [addr, score] of currentRound.shares) {   // score = weighted shares
  const payout = (minerReward * BigInt(score)) / BigInt(currentRound.totalShares);
  pendingBalances.set(addr, (pendingBalances.get(addr) ?? 0n) + payout);
}
your payout = (block reward − 2% fee) ×  your round scoretotal round score

PROP is the simplest honest scheme: no luck-smoothing, no debt — each round stands on its own. If you contributed 10% of the round's score, you get 10% of the miner reward. When the round closes (block found by us or by someone else on the network), scores reset and a new round begins at the next height.

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. Because the algorithm is memory-bandwidth-bound, throughput stops scaling once your RAM is saturated — typically around 6–8 concurrent workers on consumer hardware. That's exactly what the auto power setting computes: 

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

// Half the cores (leave room for OS + browser), capped at 8 because
// memory bandwidth — not core count — is the real limit for Argon2id.
const optimalThreads = Math.min(Math.max(1, Math.floor(logicalCores / 2) - 1), 8);

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
Blocks Found
—
all time
Avg Time Between Blocks
—
last — pool blocks
Est. Time To Next Block
—
at current pool hashrate

Pool vs Network Hashrate last 24h

Connected Miners last 24h

Current Round Share Split

Blocks Found Per Hour last 24h

Time Between Pool Blocks recent blocks