Every row names the engineering log entry or the job it came from. "Measured by the team" means our own hardware and our own log. "Reported by the fleet" means a machine we do not own, read from the status lines its miner uploads.
', 'MH per watt needs the card\'s power draw during the run. The app reads it on NVIDIA cards through the driver. Rows get the figure when a run records it.
', - 'There is no other Igneum miner to compare with yet, so this table compares cards, not miners.
', + 'There is no other Igneum miner to compare with yet, so this table compares cards, not miners. The app that produces these rows: the miner page.
', `Rows: ${rows.length}. Source file: site/miner-bench.json in the repository.
One client switches the card between hashing and proving by itself.
+Igneum Ember finds your GPU, makes a wallet for you and runs the node, the miner and the prover as one app.
80% of emission to the miner who wins the block.
20% of emission plus a share of every block's gas.
Rollups and bridges pay for proofs in their own money.
One click: install, press start, the card mines and proves to a wallet it makes for you. Public testnet first.
The protocol carries no fee. The Igneum Miner software takes an optional 1% dev fee, like other GPU miners, off with one flag.
Download only from this domain. Nobody from Igneum will ask for your seed.
+ The protocol carries no fee. The Ember software takes an optional 1% dev fee, like other GPU miners, off with one flag. Download only from this domain. Nobody from Igneum will ask for your seed.
+What the app sends home. The app version, a random machine id made at install, your operating system, the node version, the hash rate, and the app, node and miner logs (which name the address the card mines to). They go to the project's log intake, a service Igneum runs on Vercel, and are read by the maintainers to find faults. Never your seed phrase, never a key, never a file you did not make with the app. Nothing is sold or shared.
Wallet set-up for MetaMask: chain id, RPC and the one-click button. The miner software takes an optional 1% fee, off with one flag; the protocol carries no fee to anyone.
+Wallet set-up for MetaMask: chain id, RPC and the one-click button. The miner software takes an optional 1% fee, off with one flag; the protocol carries no fee to anyone.
+Igneum Wallet holds the key the miner makes for you and verifies finality itself. MetaMask works too.
+macOS first, Windows next. Public testnet first. Download only from this domain. Nobody from Igneum will ask for your seed.
+
+ The devnet has run since 3 October 2026 on several machines, with cards from all three GPU vendors. Coins on it have no value and the chain may be reset. What is on it today:
+| Layer | State | Since |
|---|---|---|
| Mining lottery | A new program every hour on Apple, NVIDIA and AMD cards, compiled ahead, no pause and no rejected block at the boundary | 4 Oct 2026, first live swap |
| Blocks | About one a second | genesis, 3 Oct 2026 |
| Difficulty | Rule v2, a 600-second reference window, switched on by height under the running chain with no fork and no restart of the chain | DAA 33,000, 4 Oct 2026 |
| Finality | Rule v2: a checkpoint every 30 s of chain, locked at two thirds of all 30-day weight. First live lock: checkpoint 242 at 77.4% of all weight, 17 vote keys | 4 Oct 2026 |
| Proving | v0 active: shards are assigned to miners' keys, proven on their cards, and the records are carried in blocks | DAA 84,100, 5 Oct 2026 |
| Ember | The one-click miner on the fleet, version 0.3.5; 0.3.6 staged | 4 Oct 2026, first install |
| Wallet | Igneum Wallet 0.1.1 on macOS | 5 Oct 2026 |
Measured: engineering log, "first hourly program swap on the live devnet", "difficulty rule v2 activated on the live devnet at DAA 33,000", "first finality lock on the live devnet" (4 October 2026); the 0.3.6 release plan (5 October 2026). The block rate is the devnet record in the evidence table, row 7.
+Two caveats, stated here before anyone else states them. On 5 October the verifier that checks a proof record before a producer pays it ran on one node; the other nodes stored proofs and did not pay them, and 0.3.6 ships the verifier with the app. And the devnet is the project's own machines plus two outside laptops. Nothing here has been reproduced by anyone outside the project yet; the evidence page says so row by row.
Blocks carry transactions only and make no claim about state. Every node executes the ordered transactions natively at once, so users see their transaction land in about a second. The execution is then split into shards of a fixed proving cost. Shards are assigned by lot to eight provers for ten seconds, then open to anyone; there is no bond. Provers run them on consumer cards, and the shard proofs are folded by recursive aggregation into one proof for the block. That proof lands on-chain within about a minute at launch. Because the proof computes the state from the ordered sequence, a block with a wrong state cannot exist. Invalid transactions are skipped by rule, the way Kaspa skips conflicting spends.
Gas prices execution. Proving cost is a different number, so Igneum meters it separately: every transaction pays in both dimensions, and each block has a proving-cost budget set in consensus from measured prover throughput. A transaction that is cheap to run and expensive to prove pays for what it costs the provers. Shard size will be set so a 12 GB card proves one shard in about 20 seconds. That number is the first gate on the roadmap and is not measured yet. The first proofs exist: on 4 October 2026 an RTX 5090 proved a small two-transaction block in 1.4 seconds (2.7 seconds compressed), verified in 0.22 and 0.038 seconds, and a laptop CPU proved a three-shard block end to end in 19 minutes; a shard at the provisional size is the next run, and nothing is proven on the chain itself yet. Once the gate is measured, the budget rises by schedule as hardware improves. The proof system is hash-based, which is what runs on consumer cards, and sits behind a versioned interface, so Igneum can adopt a better proof system when one exists by a miner-signalled release, and runs for ever on the current one if none is adopted.
+Gas prices execution. Proving cost is a different number, so Igneum meters it separately: every transaction pays in both dimensions, and each block has a proving-cost budget set in consensus from measured prover throughput. A transaction that is cheap to run and expensive to prove pays for what it costs the provers. Shard size will be set so a 12 GB card proves one shard in about 20 seconds. That number is the first gate on the roadmap and is not measured yet. The first proofs exist: on 4 October 2026 an RTX 5090 proved a small two-transaction block in 1.4 seconds (2.7 seconds compressed), verified in 0.22 and 0.038 seconds, and a laptop CPU proved a three-shard block end to end in 19 minutes. Later that day the same card proved a full shard at the provisional size, 6.75 million prover gas, which executed in 60.8 million cycles: core proof 8.3 seconds, compressed proof 10.9 seconds, verified in 0.040 seconds; a four-shard block took 44.5 seconds of GPU stages end to end. Since 5 October 2026 shards are assigned and proven on the live devnet. The gate asks for a mid-range card, and an RTX 5090 is not one, so the gate stands open. Once the gate is measured, the budget rises by schedule as hardware improves. The proof system is hash-based, which is what runs on consumer cards, and sits behind a versioned interface, so Igneum can adopt a better proof system when one exists by a miner-signalled release, and runs for ever on the current one if none is adopted.
The same miners accept proving jobs from other chains. Rollups post a job, a miner wins it, proves it, and is paid. The job market is permissionless. Jobs taken through Igneum's own market are paid in IGN and 10% of each fee is burned. The Igneum miner client also bids on other proving networks, where jobs are paid in those networks' currencies, and takes the best price. The proving market is small today. Igneum does not depend on it. No other proof-of-work chain has a seat in it.
The dataset starts at 2 GB and grows by half a gigabyte a year, so a 4 GB card mines for about four years and an 8 GB card for more than a decade, approximate. 12 GB or more proves full shards. NVIDIA and AMD both work, because the mining program is generated for the architecture both share and the proof system is hash-based. Apple's chips are GPUs with unified memory, so Macs mine too. There is no CPU mining lane, on purpose, because CPU mining is what botnets farm. Nodes, wallets and exchanges need no GPU at all.
The card hashes the lottery continuously. When the client sees a shard or an external job it can win, it switches the card to proving for a few seconds, posts the proof, and goes back to hashing. The client does the switching and the miner sees one balance.
-The protocol carries no fee: no dev fund, no cut to any team. The Igneum Miner software takes an optional 1% dev fee, the way other GPU miners do. One block template in 100 is requested with the dev address instead of yours, by a counter, not a random draw, so it is exactly 1 in 100 and anyone can check it from the source or from the chain. One flag turns it off (--dev-fee 0, a switch in the app, a line in the HiveOS config). The miner prints the fee and the address when it starts. Any other client is welcome.
The protocol carries no fee: no dev fund, no cut to any team. Ember, the miner software, takes an optional 1% dev fee, the way other GPU miners do. One block template in 100 is requested with the dev address instead of yours, by a counter, not a random draw, so it is exactly 1 in 100 and anyone can check it from the source or from the chain. One flag turns it off (--dev-fee 0, a switch in the app, a line in the HiveOS config). The miner prints the fee and the address when it starts. Any other client is welcome.
Farm operators get HiveOS support on day one. Everyone else gets the Igneum app: install it on Windows, macOS or Linux, press one button, and the card is mining and proving to a wallet the app made for you, with earnings shown in IGN and in your currency, and mining paused while you game. It is the same client with a face on it. The app shows you the seed phrase and has you confirm it before mining starts. The address it makes is an ordinary Ethereum account: MetaMask holds it today (chain id, RPC and the one-click button) and the Igneum Wallet, with the Apps tab and the explorer built in, follows. The app updates only when you accept a release signed by the key published in the genesis block, and is downloaded only from this domain or the repository with its hash shown beside the button. Nobody from Igneum will ever ask for your seed. Mining never runs in a browser, because browser compute is slow and browser mining has meant malware since Coinhive. The browser is for the dashboard, and for verifying the chain.
+Farm operators get a HiveOS package. Everyone else gets Igneum Ember: install it on Windows, macOS or Linux, press one button, and the card is mining and proving to a key the app made for you, with earnings shown in IGN and in your currency, and mining paused while you game. It is the same client with a face on it. The app shows you the key and has you save it before mining starts, offers a hardware wallet for your earnings, updates itself from releases signed by the project's release key with a switch to turn that off, and is downloaded only from this domain or the repository with its hash shown beside the button. The next section says what is shipped and what is still a design. Nobody from Igneum will ever ask for your seed. Mining never runs in a browser, because browser compute is slow and browser mining has meant malware since Coinhive. The browser is for the dashboard, and for verifying the chain.
Launch date and miner software published a month ahead. Pools live on testnet. HiveOS support on day one. The founders mine from genesis like everyone else, with disclosed addresses and the same software. Nobody has coins before block one.
+Igneum Ember is the one-click miner. It runs the node, mines the hourly program, proves shards and keeps your key, on Windows, macOS and Linux.
+Ember is a supervisor with a face. It starts a node, waits until it is synced, starts one miner per card, reads every line they print into the dashboard, and restarts what fails. It has run the devnet's cards since 4 October 2026. Everything in the first table is in the shipped app. The second table is the six levers set on 4 October 2026 to make it the fastest miner for this chain, each with its state and what has been measured.
+| Feature | What happens |
|---|---|
| One click | Install, press Start. Ember runs its own node, syncs it, and starts one miner per card. Windows, macOS and Linux. Farms get a HiveOS custom-miner package with the same binaries |
| Any card | NVIDIA, AMD and Apple silicon are detected with their real names. CUDA on NVIDIA, OpenCL on AMD and Intel, Metal on Apple. No toolchain on the machine: the GPU program is compiled at run time from the pack the node hands over |
| A key made for you | A payout key is made on your machine and kept in a file only your user can read. Ember shows it once and has you save it before mining starts. Paste your own address instead if you have one |
| Hashing and proving in one client | The same app mines the lottery and proves the shards the chain assigns to its keys, on the same card. Proving is a switch in Settings. The tile shows assigned, proving, submitted and paid |
| Several identities per card | Each card carries as many vote keys as you choose, so a large card holds the finality weight its blocks earn. The HiveOS config suggests 8 on a large card and 2 on a small one |
| Signed updates | Ember checks a signed manifest hourly, downloads the release, checks its hash, and installs it at a quiet moment: node synced, no hour boundary within 3 minutes, no worker starting. Machines take turns, one minute of the hour each. A release that fails to start twice is rolled back. One switch turns the automatic install off |
| Signed remote jobs | The project's own machines take jobs signed by the release key and addressed to named machines: a benchmark, a build, a restart. A job runs once per id and never on a machine it does not name. A switch in Settings turns them off |
| Watchdog | A miner that prints nothing for 90 s, or reports zero for 60 s while the node is synced, is restarted. A worker that reports work it did not do, or returns a hash the CPU re-check rejects, is restarted by the miner itself. A node that stops answering is restarted |
| Dashboard | Per card: rate, accepted and rejected blocks, temperature, draw, MH per watt, the kernel variant in use, the proving state, and every event. Served on this machine only, behind a per-launch token |
Source: the app's engine, detection, keys, prover, updater, jobs and watchdog modules (app/igneum-app/src), the HiveOS package (packaging/hive). Design, not yet measured on a real card: the watchdog rules and the fault guards, which were measured against a fake worker only (engineering log, "miner fault guards and the app watchdog", 4 October 2026).
| Lever | What it does | State, 5 Oct 2026 | Measured |
|---|---|---|---|
| 1. Compiler race every hour | At every hourly program the worker compiles up to 17 variants of the kernel (unroll, load path, register budget, threads per block), checks each bit for bit against the base kernel, times each for 2 s with mining paused, and keeps the fastest for the hour. The hash never changes | Shipped in the Metal and CUDA workers | +17.3% on the genesis seed and +21.2% on the hourly seed, Apple M5 Max, Metal, 14 variants, under load, ratios only. The RTX 5090 race is built and not yet run |
| 2. Per-card auto-tune from the fleet | Every race writes a record to the fleet log. The best variant per card model is aggregated and sent back to every machine inside the signed update manifest, so a new card starts from the fleet's best and keeps racing | Shipped. The fleet is small, so no table yet | No fleet table yet |
| 3. Hash per watt | Steps an NVIDIA card's power cap from 100% to 50% of its default in 10% steps, holds each for 60 s, and keeps the best MH per watt. The tile shows live MH per watt. The sweep never restarts the worker, so the hour's program is never lost | In the app for NVIDIA cards. AMD and Apple: not supported | The first sweep on a card is pending. The RTX 5090 drew 290 W at p95 under a 460 W cap, so the cap did not bind |
| 4. Template latency | The miner subscribes to new templates instead of polling, the node builds the next template ahead, and the workers switch without draining the batch. Target under 50 ms from a new block to the card working on it, solo against the local node | In 0.3.6 | Switched p50 46 to 52 ms, p90 118 to 130 ms, 3-node fast-time network, CPU miners, 0 rejected |
| 5. Never lose a second | The next hour's program is compiled ahead and swapped in place. The watchdog, the restarts, the CPU re-check of every found hash and per-worker health on every tile keep the card hashing | Shipped | Swap 0.01 ms on the Mac and 0.00 ms on the RTX 5090, 0 rejected, live devnet. Fake-worker guards: trip 0.0 s, worker back in 2.0 s; a silent worker restarted at 60 s |
| 6. Prove it in public | Every measured rate, with the card, the miner version, the date and the log entry it came from, on one page | Live | The bench table |
Measured: engineering log, "miner performance: variant racing" (lever 1), "first hourly program swap on the live devnet" and "miner fault guards and the app watchdog" (lever 5), 4 October 2026; the 0.3.6 release plan, the miner-latency gate (lever 4), 5 October 2026; the efficiency-sweep plan, the RTX 5090 log of 4 October 2026 (lever 3). Levers 2 and 3 are shipped code with no fleet measurement yet.
+The protocol is fee-free: no dev fund, no fee to any team, foundation or fund. Ember takes a 1% software dev fee, the norm for GPU miners. One block template in 100 is requested with the dev address instead of yours, by a counter, never a random draw, so it is exactly 1 in 100 and anyone can check it from the source or from the chain. A fee block still carries your vote key, so it still adds to your finality weight. Ember prints the fee and the address when it starts, shows it in Settings next to a switch, and --dev-fee 0 turns it off, as does DEV_FEE=0 in a HiveOS flight sheet. Any other client is welcome.
Measured: engineering log, "the software dev fee measured on a test network", 4 October 2026: 9 fee blocks in 785 from two fee-paying miners, 0 from the control at --dev-fee 0, the chain and the miners' counters equal.
Igneum Wallet is a desktop wallet, macOS first. It holds the key, signs, reads your own node, and checks finality with the node's own code.
+| Feature | What happens |
|---|---|
| Create or import | 24 words on the Ethereum derivation path, so the same words open the same account in MetaMask. Or import the raw key Ember made for you |
| The vault | The key is sealed on your disk with XChaCha20-Poly1305 under a key derived from your password by Argon2id (64 MiB, 3 passes). The password is never written anywhere. Nothing leaves the machine |
| Send | The fee is shown before you confirm |
| Receive | A QR code drawn on your machine, with no image service and no call across the network |
| History | Block rewards, proving payouts and transfers in one list |
| Final means final | The wallet fetches the finality certificate from the blocks that carried it and verifies the BLS signatures itself with the node's own finality code. Every entry shows pending, in a block, or final with its checkpoint index. A failed execution is never shown as final |
| MetaMask | The network parameters export in one click |
| Your node | The wallet reads Ember's node on this machine when it is there, so nobody else sees your balance. Without it, a public endpoint serves balances and sending, and a bundled node can be started by the wallet. Finality is verified only against a node's own interface; on a public endpoint entries stay "in a block" |
| Updates | Signed over-the-air updates, installed by themselves when no send is in flight, with rollback when the new version does not start |
| Next | Touch ID and Windows Hello to unlock. In progress, not live. Windows build: next |
Source: Igneum Wallet 0.1.1, 5 October 2026 (app/igneum-wallet: the vault, HD key, finality, QR and updater modules and the README). Verified: the over-the-air path end to end on one Mac against a test manifest. Not yet run: the Windows path, the rollback paths, a Developer ID signature.
Igneum is governed by the people who power it, and by nobody else.
@@ -561,14 +648,28 @@ body.all .pager{display:none}Phase two decides everything. If consumer GPUs cannot prove shards fast enough, Igneum says so and does not launch on promises.
+The proving activation of 5 October 2026 set the next release. Each item is in the 0.3.6 plan; none is on the fleet yet.
+| Item | Why |
|---|---|
| Ember's node runs the proof verifier | On 5 October no node on the network ran one, so a producer stored proofs and never paid them. The app now points its node at the shipped prover host |
| The Windows package ships the prover host | A PC needed a 20-minute setup by hand before it could prove |
| The proving tile shows the verifier state | A node that relays proofs but never pays them says so, on the tile and on the live page |
| Template latency | Lever 4 above: subscribe, pre-warm, switch without draining. Switched p50 46 to 52 ms on the gate run |
| Instant jobs | A job published to the fleet reached a machine up to 10 minutes later. The app now holds an outbound connection and fetches the moment a job is published, 3 to 6 s expected, not yet measured |
| Testnet parameters behind a height switch | The testnet identity and the fee floors adopted on 5 October 2026, so the devnet is never forked by a node update |
Source: the 0.3.6 release plan, 5 October 2026. The latency number is the plan's gate run on a 3-node fast-time network with CPU miners; the instant-jobs latency is an estimate until the first measured row.
The founders mine from genesis with disclosed addresses and the same software as everyone else, and hold no coins before block one. The team page is published at public testnet, with the people, the mining addresses and the code history.
Benchmark in January 2027. Miner client with the devnet in spring. One-click app on Windows, macOS and Linux at public testnet in August 2027. All of it before any coin exists. Nothing is asked of a miner before they can run something.
+On the devnet now. Igneum Ember runs on Windows, macOS and Linux, a HiveOS package exists, and the devnet's coins have no value. The public benchmark with a leaderboard by card model is January 2027. Pools and the public testnet are August 2027. All of it before any coin exists. Nothing is asked of a miner before they can run something. The Ember section says what is shipped and what is still owed.
Block reward and in-chain proving move with the price. Proving for other chains is priced in the customer's money, and it is a small market today. What Igneum can promise is that its miners have the lowest cost in that market, because the card is already running on domestic power, so they are the last to switch off. That is an edge and nothing more.
Igneum runs the Ethereum virtual machine, so MetaMask and every other Ethereum wallet work unchanged. The wallet needs four things: the chain id, an RPC URL, the symbol IGN and 18 decimals. The button below sends them to the wallet with the standard wallet_addEthereumChain request; the wallet shows them to you and asks before adding anything. Nothing on this page asks for a seed phrase or a key. Nobody from Igneum will ask for your seed.
The network the one-click miner app joins at public testnet. Coins on it have no value and the chain resets with notice (testnet terms).
+The button switches on when the public RPC is live.
+The Igneum Miner app runs a full node on your machine and serves the Ethereum RPC on it. Point the wallet at that node. The devnet is a developer network: it resets without notice and its coins have no value.
+If the wallet has no one-click support, or you prefer to type: MetaMask, Settings, Networks, Add a network manually. Enter the values from the card above. Any wallet that supports custom EVM networks takes the same four fields.
+The same request from your own page or app, so your users land on the right chain:
+await window.ethereum.request({
+ method: 'wallet_addEthereumChain',
+ params: [{
+ chainId: '0x116e', // 4462, the Igneum testnet (0x116f = 4463, the devnet)
+ chainName: 'Igneum Testnet',
+ nativeCurrency: { name: 'Igneum', symbol: 'IGN', decimals: 18 },
+ rpcUrls: ['https://rpc.testnet.igneum.network'],
+ blockExplorerUrls: []
+ }]
+});
+Igneum signs transactions with the Ethereum rules (EIP-155, EIP-1559 and legacy envelopes). A transaction signed for another chain id is refused. Gas has two dimensions on Igneum, execution and proving, and the node folds the second into the price it quotes, so eth_gasPrice and eth_estimateGas work as they do on Ethereum. The litepaper has the differences.
The Igneum Miner app makes an address for your earnings and shows you its seed phrase once. That address is an ordinary Ethereum account: import the seed into MetaMask and the balance is there. An Igneum Wallet with the Apps tab and the explorer built in is in the roadmap; until it ships, MetaMask is the wallet.
+ +Chain ids 4461 (mainnet), 4462 (testnet) and 4463 (devnet) are fixed in the node. The testnet RPC URL above is a placeholder until the testnet opens; this page is updated the day it does.
+Ember finds your GPU, makes a wallet for you and runs the node, the miner and the prover as one app. Every hour it compiles the next program while the current one mines, so the card never stops.
+
+ One client. The card hashes the lottery, proves the shards the chain assigns to it, and every block pays one address.
+A new random program every hour. 80% of each block to the card that finds it.
+The client switches to the shards the chain assigns to its keys, posts the proof, and goes back to hashing.
+Block rewards and proving payouts land on the address the app made for you. The wallet shows them.
+What the app does today on the live devnet, and what is built but not yet measured on a card. Each number links to its engineering log entry.
+Five steps from download to the first block on a friend's laptop: drag to Applications, open, Get started, Make me an address, Start mining.
One button starts the node, waits for sync, starts one miner per card and the prover. Quit stops them in order.
NVIDIA through the driver, AMD and Intel through OpenCL, Apple silicon through Metal. Real card names, one worker per card.
A payout key made on your machine and locked to your user, with a backup step before mining starts. Or paste an address you already hold.
Every block this machine finds pays one address in IGN. The dashboard counts them per run, per hour and for life. The wallet shows the balance.
An installer on Windows, a disk image on macOS, a package on Linux. No toolchain, no driver work: the GPU workers are prebuilt.
A custom miner for farms: the Linux miner, node and both GPU workers with the four Hive hooks. Hive itself is untested: report what breaks.
An Apple silicon laptop, no instructions beyond the five steps: 33 accepted blocks in 7 minutes, 0 rejected, 21.0 MH/s average.
log · 4 Oct 2026An RTX 5090 on Windows from the installer: 117 to 119 MH/s, 34 accepted blocks in the first minute, CPU re-check OK on every share.
log · 4 Oct 2026The lottery and the proving are kept apart on purpose. The client runs both and the miner sees one balance.
Proving is a switch. On, the client proves the shards the chain assigns to this machine's keys, submits the record to its own node and goes back to hashing. The tile shows assigned, proving, submitted, paid.
Identities take turns on the card and each one votes and pays separately. 8 suits a big card, 2 a small one, 1 an integrated GPU.
The node announces the next seed early. The worker compiles the next program in the background and swaps at the boundary while the current one mines.
log · 4 Oct 2026| Card | Compile, ahead of time | Swap at the boundary | Rate before / after | Rejected |
|---|---|---|---|---|
| Apple M5 Max, Metal | 82 ms | 0.01 ms | 26.7 / 26.7 MH/s | 0 |
| RTX 5090, CUDA | 1,285 ms | 0.00 ms | 121.8 / 123.4 MH/s | 0 |
| AMD Radeon integrated, OpenCL | prepared | no restart | 2.74 / 2.74 MH/s | 0 |
Every app updates itself. This is also how a consensus upgrade reaches every node before its activation height.
The manifest is signed with an Ed25519 key compiled into the app. The app verifies the bytes before it reads them, then checks the download's size and hash.
Node synced, no hourly boundary within 3 minutes, no worker starting. Machines take turns, each in its own minute of the hour, and never while the network lost over 30% of its identities in 10 minutes.
The download and the staging run while the card mines. The swap itself takes seconds. If the new version fails to start twice, the previous one comes back by itself.
At once when a consensus activation is within 1,800 blocks or the version is below the minimum supported, or when you click Install now.
Nothing here changes the hash. Every variant is the same program in a different shape for the compiler, checked bit for bit before it is timed.
At every hourly prepare the worker compiles the program in several shapes (unroll, load path, register budget, threads per group), times each for 2 seconds and keeps the fastest for the hour. Base keeps its place unless beaten.
log · 4 Oct 2026On the M5 Max, 256-thread groups ran 17.3% and 21.2% faster than base on two programs, under load from other work. The NVIDIA race is built and has not yet run on a GPU.
log · 4 Oct 2026, ratios under contentionEvery race is one record in the app log. The fleet's best variant per card model goes back out inside the signed update manifest, so a card starts from the known best and keeps racing.
Hash per watt, the number miners compare. The app steps an NVIDIA card's power cap from 100% to 50%, holds each step for 60 seconds on the live kernel and leaves the cap at the best MH per watt. Built and unit-tested; not yet run on a card.
A block built on a stale tip earns less. The miner is moving from polling to a template subscription and shorter jobs, so a new tip reaches the card in milliseconds. In progress, no number published yet.
Our own fleet only. A switch, "Allow remote jobs from Igneum (signed)", with the key's fingerprint beside it. Off aborts the running job and stops polling. Jobs run at most once each and only on the machines they name.
Measured against a worker that misbehaves on command: these are recoveries in seconds, not hash rates.
No status line for 90 seconds, or a hash rate of 0 for 60 seconds while synced: the miner is restarted once. If it recurs, that card is marked faulted with the reason and the other cards keep mining.
log · 4 Oct 2026A node that answers nothing for 120 seconds is restarted by the app, with a growing delay when it repeats. Measured: silent node to mining again in 160.0 s.
log · 4 Oct 2026Miners first, then the node, on quit and on update. What crashes comes back. A worker that restarts itself is left alone, so nothing is restarted twice.
A clock 60 seconds slow kept a node silently dead for 12 minutes. Now the app reads block times and an HTTPS Date header: over 5 seconds a warning, over 10 seconds Start is blocked and a Sync clock button appears.
log · 4 Oct 2026| What the worker did | What the app did | Back to mining |
|---|---|---|
| Reported 0 hashes | Restarted the miner once after the 60 s rule | 91.0 s |
| The same again inside five minutes | Marked the card faulted, no further restart; Resume cleared it | 75.4 s to faulted |
| The miner process stopped | Killed and restarted it after the 90 s rule | 101.4 s |
| The node process stopped | Restarted the node, which synced; mining resumed | 160.0 s |
Every number on this page has a row. Prototype numbers say so.
Every benchmark and test the project has made, with the hardware and the commands. Newest at the bottom.
/benchOne row per card, generator version and miner version: best MH/s, MH per watt where measured, the date and the log entry behind each number.
/minersThe app uploads its status lines once a minute under a per-install id. Rows marked "reported by the fleet" come from machines we do not own.
Six levers, set on 4 October 2026. Each one is an idea in one line and a measured state. Nothing here claims fastest: the bench table says that, or it does not.
+| Lever | The idea | Measured state |
|---|---|---|
| 1 · Race the compiler every hour | For each new program, five to ten kernel variants are compiled, benched for two seconds each, and the winner is kept for the hour. | Measured on the Mac's Metal worker: the winning variant +17.3% on the genesis seed and +21.2% on the hourly seed over the base compile, under load from other work. The RTX 5090 race is prepared and not yet run. Log, 4 Oct 2026 |
| 2 · Auto-tune that learns from the fleet | Apps report the race per card and program class. The best settings come back down through the signed update manifest as defaults, so the miner gets faster for everyone as the fleet grows. | Shipped. The fleet is still small, so no fleet table yet. |
| 3 · Hash per watt, not hash | A sweep per card finds the power point with the best MH per watt and holds it. Miners pay for electricity; that is the number they compare. | Shipped for NVIDIA cards through the power cap. Not yet run on a card; the first sweep on a 5090 is the owed measurement. Clocks are the next lever. |
| 4 · Template latency | Solo against the local node, a new template within 50 ms of a new tip, because a late block on a BlockDAG goes red and earns nothing. | Approximate, from the 0.3.6 release plan and not yet in the engineering log: switched p50 46 to 52 ms on a three-node CPU run, 5 Oct 2026. Ships in 0.3.6. |
| 5 · Never lose a second | Zero-loss hourly program swaps, fault guards, automatic restart, a CPU re-check of every found hash, per-worker health. | Shipped. Swap 0.01 ms on Metal and 0.00 ms on CUDA with 0 rejected blocks; recoveries in the table above. Log, 4 Oct 2026 |
| 6 · Prove it in public | The bench table per card, fed from the job channel. We claim fastest only when the table says so. | Live at /miners, one row per card, generator version and miner version, each with its log entry. |
The dev fee is the software's 1%, visible and switchable. The protocol carries no fee. The fee, in full view.
+The protocol carries no fee: no dev fund, no fee to any team, foundation or fund. The software fee is the miner app's, like every other GPU miner's, and one flag turns it off.
+The Ember software takes a visible, switchable 1% dev fee, the norm for GPU miners. One block template in 100 is requested with the dev payout address instead of yours. The choice is a template counter, never a random draw, so it is exactly 1 in 100 and anyone can audit it from the source or from the chain. A fee block still adds to your finality weight; the only thing that moves is who the execution layer pays for that one block.
+| Where | Off with |
|---|---|
| The app, Settings | the switch beside the rewards address |
| The command line | --dev-fee 0 |
| HiveOS, extra config | DEV_FEE=0 |
Measured on a test network, 4 Oct 2026: 9 fee blocks in the 785 blocks of two fee-paying miners (1.146%); the control miner at --dev-fee 0 paid none; the miners' counters and both nodes agree. The log entry.
+The miner software's fee, the same way every GPU miner takes one. The protocol takes none. This switch turns it off.
+dev fee 1% (1 block in 100) to 0x<address>; --dev-fee 0 turns it off+
dev fee off (--dev-fee 0); the default is 1% (1 block in 100) to 0x<address>+
Each fee block is logged as it is accepted. igneum-miner payouts lists blocks per payout address over every block the node holds, with the dev address tagged.
+Public testnet first. Until then the devnet runs on machines we invite. Download only from this domain. Nobody from Igneum will ask for your seed.
+Any 4 GB card. The dataset starts at 2 GB and grows by half a gigabyte a year, approximate. Updates arrive signed; the app installs them itself. The wallet reads this machine's node when the miner is installed.
+ Read more in the litepaper +The engineering log holds the commands and the hardware behind each one. The bench table compares cards, not miners, because there is no other Igneum miner yet.
+Every row names the engineering log entry or the job it came from. "Measured by the team" means our own hardware and our own log. "Reported by the fleet" means a machine we do not own, read from the status lines its miner uploads.
MH per watt needs the card's power draw during the run. The app reads it on NVIDIA cards through the driver. Rows get the figure when a run records it.
-There is no other Igneum miner to compare with yet, so this table compares cards, not miners.
+There is no other Igneum miner to compare with yet, so this table compares cards, not miners. The app that produces these rows: the miner page.
Rows: 6. Source file: site/miner-bench.json in the repository.
Generated from the repository at build time. Times are UTC. Machine names are model names.
@@ -205,13 +205,20 @@ th{font-family:var(--f-mono);font-size:12px;letter-spacing:.12em;text-transform: Engineering log Evidence +Igneum runs the Ethereum virtual machine, so MetaMask and every other Ethereum wallet work unchanged. The wallet needs four things: the chain id, an RPC URL, the symbol IGN and 18 decimals. The button below sends them to the wallet with the standard wallet_addEthereumChain request; the wallet shows them to you and asks before adding anything. Nothing on this page asks for a seed phrase or a key. Nobody from Igneum will ask for your seed.
The network the one-click miner app joins at public testnet. Coins on it have no value and the chain resets with notice (testnet terms).
-The button switches on when the public RPC is live.
+A desktop wallet that holds the key the miner made for you, or one you make here from 24 words. It sends, receives and reads your history, and it verifies every finality certificate itself with the node's own code. No confirmation counts, no trusting the node.
+ +
+ The Igneum Miner app runs a full node on your machine and serves the Ethereum RPC on it. Point the wallet at that node. The devnet is a developer network: it resets without notice and its coins have no value.
-Every transfer in the history is pending, in a block, or final. The third one is the wallet's own verdict.
+Signed on this machine and handed to the node. Nothing has carried it yet.
A block carries it and the chain's height passed it. It can still be reorganised until a checkpoint covers it.
Its block sits under a 30-second checkpoint whose certificate this wallet verified: the voter list, the aggregate BLS signature, two thirds of all weight.
+ The same steps the browser verifier on the home page runs, with the node's own finality code compiled into the wallet. The node's own "locked" field is never read.
+If the wallet has no one-click support, or you prefer to type: MetaMask, Settings, Networks, Add a network manually. Enter the values from the card above. Any wallet that supports custom EVM networks takes the same four fields.
-Version 1, built on the miner's bones: the same local server, the same signed update manifest, the same key code.
+The same request from your own page or app, so your users land on the right chain:
-await window.ethereum.request({
- method: 'wallet_addEthereumChain',
- params: [{
- chainId: '0x116e', // 4462, the Igneum testnet (0x116f = 4463, the devnet)
- chainName: 'Igneum Testnet',
- nativeCurrency: { name: 'Igneum', symbol: 'IGN', decimals: 18 },
- rpcUrls: ['https://rpc.testnet.igneum.network'],
- blockExplorerUrls: []
- }]
-});
-Igneum signs transactions with the Ethereum rules (EIP-155, EIP-1559 and legacy envelopes). A transaction signed for another chain id is refused. Gas has two dimensions on Igneum, execution and proving, and the node folds the second into the price it quotes, so eth_gasPrice and eth_estimateGas work as they do on Ethereum. The litepaper has the differences.
The password is never written anywhere. The plaintext only ever exists in the engine's memory and is zeroed when the wallet locks.
256 bits of entropy from the operating system, as 24 English words. The wallet asks for three of them typed back before it goes on.
Your 24 words, a raw private key, or the miner's own payout key file. One click brings the key the miner pays to into the wallet.
Argon2id (64 MiB, 3 passes) turns the password into a key; XChaCha20-Poly1305 seals the secret under it. The vault is one file in your user folder.
Keys follow BIP-39 and BIP-44 at the Ethereum path, so the same 24 words open the same account in MetaMask.
The Igneum Miner app makes an address for your earnings and shows you its seed phrase once. That address is an ordinary Ethereum account: import the seed into MetaMask and the balance is there. An Igneum Wallet with the Apps tab and the explorer built in is in the roadmap; until it ships, MetaMask is the wallet.
+Signing happens in the engine, in Rust. Nothing on the window side ever holds the key.
Read from your node every few seconds, in IGN, with the block it was read at.
An EIP-1559 transfer. The review shows the amount, the fee at most as base fee plus tip, and what leaves the wallet at most. The zero address and more than the balance are refused.
The code is drawn on your machine as SVG. No image service, no call across the network.
Transfers in and out, block rewards from the execution records, one per blue block, and proving payouts when a block carries a proof record.
Pending, in a block, or final with the checkpoint index, verified here. How it checks.
One button locks the wallet and zeroes the key in memory. The password opens it again.
Chain ids 4461 (mainnet), 4462 (testnet) and 4463 (devnet) are fixed in the node. The testnet RPC URL above is a placeholder until the testnet opens; this page is updated the day it does.
+When the miner is installed, the wallet uses its node on this machine. Nobody else sees your balance.
Found on this machine and used as it is. Nothing is started.
Balances, sending and history work without a local node. Finality verification needs a node, so transfers stay "in a block" until one is there, and the wallet says so.
The wallet starts its own copy of the node on its own ports, no mining, and stops it when the wallet quits.
The same Ed25519 key as the miner's manifest, checked an hour apart. The download is checked against the manifest's hash before Install now opens it.
For people who already live in MetaMask. The key leaves this app only when you copy it.
One click adds the Igneum network with its chain id and RPC. Copy network settings puts the same values on the clipboard.
Behind the password, behind a warning: a copied key can be stolen from the clipboard, a screenshot or a notes app. Paste it straight into MetaMask and clear the clipboard.
macOS now, as a disk image. The Windows host is written and untested. No browser extension and no phone app yet.
A private test network, 5 Oct 2026: one node, one CPU miner paying to wallet A, wallet A sending to wallet B. The log entry ships with the wallet.
+| Step | From the node's start | What was seen |
|---|---|---|
| Wallet A created, 24 words, three typed back | 0.3 s | an address |
| Wallet B: a wrong word refused, then created | 0.4 to 0.5 s | "word 1 is not right" |
| A's balance from block rewards | 3.5 s | 10.14 IGN at block 4 |
| Zero address, 999,999,999 IGN, a short address | 4.5 s | all three refused by the quote |
| Quote for 1.5 IGN to B | 4.6 s | gas 25,380; base fee 1 gwei; tip 1 gwei; fee at most 0.00007614 IGN |
| In a block | 5.6 s | chain block 8 |
| First locked checkpoint on the network | about 170 s | index 5 |
| Final in wallet A | 175.2 s | under checkpoint 5, certificate verified by the wallet: 1 of 1 voters, 100% of total weight |
| B's view of the same transfer | 175 s | 1.5 IGN, final |
Send to final: 170.6 s, all of it the network's first lock on a fresh chain. On the live devnet checkpoints lock every 30 seconds once the weight window is full. 13 unit tests cover the words, the path, the vault, the signing and the finality state machine.
+Public testnet first. Download only from this domain. Nobody from Igneum will ask for your seed.
+The wallet reads this machine's node when the miner is installed. Without it, a public RPC for balances and sending, or the bundled node for everything.
+ Read more in the litepaper +Install the miner, press Start, and the address it makes is the one this wallet imports with one click.
+