Emission

Every PRL that exists was created by a block. The first transaction of each block, the coinbase, may create a fixed amount of new coins out of nothing and pay them to the miner. That amount is the subsidy, and the schedule it follows is Pearl’s emission.

Bitcoin’s schedule is a staircase: 50 coins a block, then 25, then 12.5, a step down every four years or so. Pearl’s is a ramp. The subsidy shrinks a little with every single block, along one smooth curve that heads toward 2.1 billion PRL and never quite gets there.

The whole curve fits in one fraction.

Try it

Drag across the heights. Watch the reward per block slide down and the total issued climb, and compare with a halving schedule.

Emission curve

The reward shrinks a little every block: no halvings

Pearl: subsidy(h) = S·C / ((h + C)(h − 1 + C)) Made-up halving schedule, same cap, halves every C blocks

Height drag the chart or use this slider

Block: 130,827; nominal date 2027-02-15
Reward per block: 2,238.32513878 PRL; halving schedule: 1,614.82 PRL
Issued so far: 351,751,674 PRL; 16.750% of 2.1 billion

The curve is the most that can exist by each height: S·h ÷ (h + C). Miners may claim less than the full subsidy, and fees come on top. Dates assume exactly 194 seconds per block, so they are nominal: real blocks drift around that.

Runs in your browser · nothing is sent src/lib/emission.ts · C = 650,226

What is the formula?

After block h, the most PRL that can have been created is:

\text{issued}(h) = S \cdot \frac{h}{h + C}

Cumulative emission

S = 2.1 billion PRL, C = 650,226 blocks.

The fraction h ÷ (h + C) starts at 0, is exactly ½ at h = C, and creeps toward 1 forever. The genesis block even spells it out: “Cumulative emission h/(h+650226)”.

Each block’s subsidy is simply how much the curve rises at that block:

\text{subsidy}(h) = \left\lfloor \frac{S \cdot C}{(h + C)(h - 1 + C)} \right\rfloor \text{ grains}, \qquad \text{subsidy}(0) = 0

CalcBlockSubsidy

S = 2.1 × 10¹⁷ grains. Rounded down to a whole grain.

Pearl’s code computes this with big integers for every block, so the numbers are exact:

Height	Subsidy	Issued through this block	Share of 2.1 B
1	3,229.64134063 PRL	3,229.64134063 PRL	0.0002%
1,000	3,219.74020196 PRL	3,224,686.98 PRL	0.15%
100,000	2,426.05131516 PRL	279,915,652.08 PRL	13.33%
130,827 (20 Oct 2026)	2,238.32513878 PRL	351,751,673.70 PRL	16.75%
650,226 (about 4 years)	807.41219776 PRL	1,049,999,999.997 PRL	50%
1,000,000	501.41467282 PRL	1,272,552,971.53 PRL	60.60%

The live total is 351.8 million PRL.

Why the subsidies add up to the curve exactly (telescoping)

Write the curve as f(h) = S·h ÷ (h + C). The rise from block h − 1 to block h is

f(h) - f(h-1) = S\left(\frac{h}{h+C} - \frac{h-1}{h-1+C}\right) = S \cdot \frac{h(h-1+C) - (h-1)(h+C)}{(h+C)(h-1+C)} = \frac{S \cdot C}{(h+C)(h-1+C)}

The numerator collapses because h(h − 1 + C) − (h − 1)(h + C) = C. That’s the subsidy formula. Now add the subsidies of blocks 1 to h: every middle term cancels with its neighbor, like a telescope folding up, and only f(h) − f(0) = f(h) is left.

The real sum is a hair smaller, because each subsidy is rounded down to a whole grain. Through block 130,827 the exact sum is 351,751,673.70138799 PRL against 351,751,673.70204070 on the curve: 65,271 grains of rounding dust, less than one grain per block.

Why 650,226?

It’s four years of blocks. Pearl’s code computes it from the target block time, with 365-day years:

C = \left\lfloor \frac{4 \times 365 \times 86{,}400}{194} \right\rfloor = \lfloor 650{,}226.8 \rfloor = 650{,}226

So at exactly 194 seconds per block, the curve has a lovely shape in years. After t years,

\text{share issued} \approx \frac{t}{t + 4}

Nominal: assumes every block takes exactly 194 seconds.

One year in: 20%. Four years: 50%. Twelve years: 75%. Thirty-six years: 90%. Every further step takes longer.

How does it compare with halvings?

Both schedules issue half their coins in about four years. After that they part ways.

Share of the total supply issued after t years. Pearl: t ÷ (t + 4), a smooth curve. Bitcoin: a halving every four years (nominal), so straight segments that bend at each halving. Same numbers in the table below.

Years (nominal)	Pearl issued	Bitcoin issued
4	50%	50%
8	66.7%	75%
12	75%	87.5%
20	83.3%	96.9%
36	90%	99.8%

Pearl front-loads less and keeps paying miners for much longer. Bitcoin’s subsidy is halved again and again until it rounds to zero; Pearl’s keeps shrinking but, within any height the software can count, never reaches zero (see supply and grains).

How fast does the reward shrink?

Slowly, and a little less each year. For large h, the subsidy behaves like S·C ÷ (h + C)²: it falls with the square of the distance from block −C.

Per block, on 20 October 2026: from 2,238.32513878 PRL at block 130,827 to 573,155 grains less at the next block, about 0.00026%.
Per day (445 blocks at the target pace): about 0.11%.
Half of block 1’s subsidy is first reached at block 269,334, about 1.66 years in. A quarter, at block 650,228, about four years in.

There is no cliff anywhere. Miners never wake up to half the income they had yesterday.

Make a guess

Blocks run faster than 194 seconds for a year. Does the emission curve change?

Think of your answer first, then check it.

Answer No. The curve is fixed in blocks; it just arrives earlier on the calendar.

The formula takes only the height h. If blocks average less than 194 seconds, heights are reached sooner and coins arrive ahead of the “t ÷ (t + 4)” calendar. On 20 October 2026 the last 144 blocks had averaged 174.3 seconds, so the schedule was running a little early. Difficulty pulls the pace back toward 194 seconds over time; see WTEMA.

Code: CalcBlockSubsidy

From validate.go (node/blockchain/validate.go:160-190 at v1.5.2, on GitHub). The constant is recomputed from the chain’s TargetTimePerBlock, so it is 650,226 on every network that uses 194-second blocks:

node/blockchain/validate.go Go

if height == 0 {
	return 0
}
targetTimePerBlockSeconds := int64(chainParams.TargetTimePerBlock / time.Second)
emissionConstant = (4 * 365 * 24 * 60 * 60) / targetTimePerBlockSeconds
h := int64(height)
numerator := new(big.Int).Mul(big.NewInt(totalSupply), big.NewInt(emissionConstant))
denominator := new(big.Int).Mul(big.NewInt(h+emissionConstant), big.NewInt(h-1+emissionConstant))
subsidy := new(big.Int).Div(numerator, denominator)
return subsidy.Int64()

In JavaScript, with BigInt:

JavaScript

const S = 210_000_000_000_000_000n, C = 650_226n;
const subsidy = (h) => (h === 0n ? 0n : (S * C) / ((h + C) * (h - 1n + C)));
subsidy(1n); // 322964134063n grains = 3,229.64134063 PRL