igneum-network/igneum
1
0
Fork 0
Code Issues Pull requests Releases Activity

Site: homepage with animations and live journey, litepaper page, Vercel config; commit email matched to GitHub

Browse source 
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
igneum-labs 2026-10-03 15:45:37 +00:00
parent 739868e1ea
commit 105354a2ce
6 changed files with 1172 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

209
proto-metal/main.swift
View file

@ -25,7 +25,14 @@ struct Options {
var determinism = false // --determinism: 5 identical GPU runs + double compile
var memcheck = false // --memcheck: static mask check + 4 MiB run with wrapping nonces
// Shortcut measurement (bench variant, not a test): compute dataset elements inline instead of loading them.
// Closed-form mode: every load computes ds_elem. Memory-hard mode: every load derives the item from the cache.
var inlineDataset = false
// Dataset construction (added 3 October 2026). Default is the memory-hard cache construction (MEMHARD.md);
// --closed-form selects the original six-operation closed form so the two can be compared.
var closedForm = false
// Generator levers (MEMHARD.md section 7). Defaults reproduce the original generator exactly.
var loadWeight = 25 // --load-weight W: percent weight of the load op (default 25)
var wideFrac = 0 // --wide-frac P: percent of load instructions emitted as warp-coalesced wide loads
var anyTest: Bool { fuzz != nil || edge || stats || determinism || memcheck }
}
@ -52,10 +59,16 @@ func parseArgs() -> Options {
case "--determinism": o.determinism = true
case "--memcheck": o.memcheck = true
case "--inline-dataset": o.inlineDataset = true
case "--closed-form": o.closedForm = true
case "--load-weight": o.loadWeight = Int(take()) ?? o.loadWeight
case "--wide-frac": o.wideFrac = Int(take()) ?? o.wideFrac
case "-h", "--help":
print("""
igneum-bench [--seed <string>] [--hours N] [--batch-log2 22] [--batches 4]
[--dataset-log2 28] [--verify-warps 3] [--dump <dir>] [--day <string>]
[--closed-form] original closed-form dataset (default: memory-hard cache construction, see MEMHARD.md)
[--load-weight W] generator lever (a): percent weight of the load op (default 25)
[--wide-frac P] generator lever (b): percent of loads emitted as warp-coalesced 128-byte loads (default 0)
[--export-pack <dir>] write the CUDA program pack for --seed, then exit
hardening tests (run instead of the bench; several may be combined; exit 0 only if all pass):
[--fuzz N [--fuzz-seed <string>]] N random programs, GPU vs CPU, 4 random warps each,
@ -130,9 +143,197 @@ struct SplitMix64 {
mutating func below(_ n: Int) -> Int { Int(next() % UInt64(n)) }
}
// MARK: - Memory-hard dataset (added 3 October 2026, spec in MEMHARD.md)
//
// Cache: 2^26 words (256 MiB) = 2^22 lines of 16 words, in 2^16 segments of 64 lines. Each segment is a
// sequential chain of ChaCha12 blocks with feed-forward: in_j = prev_line ^ (sigma || K || seg || j || tag),
// line_j = core(in_j) + in_j, prev_0 = 0. Recomputing line j costs j + 1 block evaluations.
// Item t (16 words = 64 bytes): s = (K[0..7], t * MUL[i] + RC[i]), then 8 rounds of
// s = M_r(s); a = s[0] & (2^22 - 1); s ^= cache line a
// and a final M_8. M_r is the seed-parameterised mixer: per word (s ^ (RC + (r+1) * 0x9E3779B9)) * MUL,
// then one ChaCha-shaped column round and diagonal round with seed-drawn rotations.
// Dataset word w = item(w >> 4)[w & 15]. The hash kernel is unchanged: it still does dataset[r & MASK].
let cacheLog2Words = 26
let cacheSegmentLog2Lines = 6
let cacheWords = 1 << cacheLog2Words
let cacheLines = cacheWords >> 4
let cacheLinesPerSegment = 1 << cacheSegmentLog2Lines
let cacheSegments = cacheLines >> cacheSegmentLog2Lines
let cacheLineMask = UInt32(cacheLines - 1)
let itemRounds = 8
let chachaRounds = 12
let chachaSigma: [UInt32] = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574]
let cacheTag: [UInt32] = [0x49676e65, 0x756d4d48] // "Igne", "umMH"
// Rotation without the n == 0 check: every caller passes 1..31.
@inline(__always) func rotlc(_ x: UInt32, _ n: UInt32) -> UInt32 { (x << n) | (x >> (32 - n)) }
@inline(__always) func qr(_ s: UnsafeMutablePointer<UInt32>, _ a: Int, _ b: Int, _ c: Int, _ d: Int,
_ r1: UInt32, _ r2: UInt32, _ r3: UInt32, _ r4: UInt32) {
s[a] = s[a] &+ s[b]; s[d] ^= s[a]; s[d] = rotlc(s[d], r1)
s[c] = s[c] &+ s[d]; s[b] ^= s[c]; s[b] = rotlc(s[b], r2)
s[a] = s[a] &+ s[b]; s[d] ^= s[a]; s[d] = rotlc(s[d], r3)
s[c] = s[c] &+ s[d]; s[b] ^= s[c]; s[b] = rotlc(s[b], r4)
}
// y = ChaCha12 core(x) + x. Standard quarter-round rotations 16, 12, 8, 7; column then diagonal.
@inline(__always) func chachaBlock(_ x: UnsafePointer<UInt32>, _ y: UnsafeMutablePointer<UInt32>) {
for i in 0..<16 { y[i] = x[i] }
for _ in 0..<(chachaRounds / 2) {
qr(y, 0, 4, 8, 12, 16, 12, 8, 7); qr(y, 1, 5, 9, 13, 16, 12, 8, 7)
qr(y, 2, 6, 10, 14, 16, 12, 8, 7); qr(y, 3, 7, 11, 15, 16, 12, 8, 7)
qr(y, 0, 5, 10, 15, 16, 12, 8, 7); qr(y, 1, 6, 11, 12, 16, 12, 8, 7)
qr(y, 2, 7, 8, 13, 16, 12, 8, 7); qr(y, 3, 4, 9, 14, 16, 12, 8, 7)
}
for i in 0..<16 { y[i] = y[i] &+ x[i] }
}
// Mixer parameters drawn from the day key. Draw order: ROT[0..7] (1..31), MUL[0..15] (odd), RC[0..15].
final class MixParams {
let key: UnsafeMutablePointer<UInt32> // 8
let rot: UnsafeMutablePointer<UInt32> // 8
let mul: UnsafeMutablePointer<UInt32> // 16
let rc: UnsafeMutablePointer<UInt32> // 16
let keyWords: [UInt32]
var rotWords: [UInt32] { (0..<8).map { rot[$0] } }
var mulWords: [UInt32] { (0..<16).map { mul[$0] } }
var rcWords: [UInt32] { (0..<16).map { rc[$0] } }
init(key k: [UInt32]) {
precondition(k.count == 8)
keyWords = k
key = UnsafeMutablePointer<UInt32>.allocate(capacity: 8)
rot = UnsafeMutablePointer<UInt32>.allocate(capacity: 8)
mul = UnsafeMutablePointer<UInt32>.allocate(capacity: 16)
rc = UnsafeMutablePointer<UInt32>.allocate(capacity: 16)
for i in 0..<8 { key[i] = k[i] }
var rng = SplitMix64(s: UInt64(k[0]) | (UInt64(k[1]) << 32))
for i in 0..<8 { rot[i] = UInt32(1 + rng.below(31)) }
for i in 0..<16 { mul[i] = UInt32(truncatingIfNeeded: rng.next()) | 1 }
for i in 0..<16 { rc[i] = UInt32(truncatingIfNeeded: rng.next()) }
}
}
// M_r on 16 words in place. rk = (r + 1) * 0x9E3779B9 mod 2^32.
@inline(__always) func mixer(_ s: UnsafeMutablePointer<UInt32>, _ rk: UInt32, _ mp: MixParams) {
let mul = mp.mul, rc = mp.rc, R = mp.rot
for i in 0..<16 { s[i] = (s[i] ^ (rc[i] &+ rk)) &* mul[i] }
qr(s, 0, 4, 8, 12, R[0], R[1], R[2], R[3]); qr(s, 1, 5, 9, 13, R[0], R[1], R[2], R[3])
qr(s, 2, 6, 10, 14, R[0], R[1], R[2], R[3]); qr(s, 3, 7, 11, 15, R[0], R[1], R[2], R[3])
qr(s, 0, 5, 10, 15, R[4], R[5], R[6], R[7]); qr(s, 1, 6, 11, 12, R[4], R[5], R[6], R[7])
qr(s, 2, 7, 8, 13, R[4], R[5], R[6], R[7]); qr(s, 3, 4, 9, 14, R[4], R[5], R[6], R[7])
}
@inline(__always) func roundKey(_ r: Int) -> UInt32 { UInt32(r + 1) &* 0x9E3779B9 }
// One segment of the cache: 64 chained lines written at cache[seg * 1024 ...].
func cpuFillSegment(_ cache: UnsafeMutablePointer<UInt32>, seg: Int, key: UnsafePointer<UInt32>) {
var inp = [UInt32](repeating: 0, count: 16)
inp.withUnsafeMutableBufferPointer { ib in
let x = ib.baseAddress!
var prev: UnsafePointer<UInt32>? = nil
for j in 0..<cacheLinesPerSegment {
let line = cache + ((seg << cacheSegmentLog2Lines) + j) * 16
for i in 0..<4 { x[i] = chachaSigma[i] }
for i in 0..<8 { x[4 + i] = key[i] }
x[12] = UInt32(seg); x[13] = UInt32(j); x[14] = cacheTag[0]; x[15] = cacheTag[1]
if let p = prev { for i in 0..<16 { x[i] ^= p[i] } }
chachaBlock(x, line)
prev = UnsafePointer(line)
}
}
}
// The whole 256 MiB cache on one CPU core. Returns wall milliseconds.
func cpuFillCache(_ cache: UnsafeMutablePointer<UInt32>, key: [UInt32]) -> Double {
let t0 = nowNs()
key.withUnsafeBufferPointer { kb in
for seg in 0..<cacheSegments { cpuFillSegment(cache, seg: seg, key: kb.baseAddress!) }
}
return Double(nowNs() - t0) / 1e6
}
// Derive `n` items (indices ts[0..n)) into out[k * 16 ...], all n chains interleaved round by round so the
// cache-line misses of independent items overlap in the memory system. This is how the verifier reaches
// memory-level parallelism without threads: the 32 lanes of a warp are independent.
func deriveItems(_ ts: UnsafePointer<UInt32>, _ n: Int, _ mp: MixParams, cache: UnsafePointer<UInt32>, out: UnsafeMutablePointer<UInt32>) {
let key = mp.key, mul = mp.mul, rc = mp.rc
for k in 0..<n {
let s = out + k * 16
let t = ts[k]
for i in 0..<8 { s[i] = key[i] }
for i in 0..<8 { s[8 + i] = t &* mul[i] &+ rc[i] }
}
for r in 0..<itemRounds {
let rk = roundKey(r)
for k in 0..<n { mixer(out + k * 16, rk, mp) }
for k in 0..<n {
let s = out + k * 16
let line = cache + Int(s[0] & cacheLineMask) * 16
for i in 0..<16 { s[i] ^= line[i] }
}
}
let rk = roundKey(itemRounds)
for k in 0..<n { mixer(out + k * 16, rk, mp) }
}
func deriveItem(_ t: UInt32, _ mp: MixParams, cache: UnsafePointer<UInt32>) -> [UInt32] {
var out = [UInt32](repeating: 0, count: 16)
var tt = t
out.withUnsafeMutableBufferPointer { ob in deriveItems(&tt, 1, mp, cache: cache, out: ob.baseAddress!) }
return out
}
// The CPU verifier's view of the memory-hard dataset: the 256 MiB cache and nothing else.
final class MemhardCPU {
let mp: MixParams
let cache: UnsafeMutablePointer<UInt32>
let fillMs: Double
private let items = UnsafeMutablePointer<UInt32>.allocate(capacity: 64 * 16)
private let uniq = UnsafeMutablePointer<UInt32>.allocate(capacity: 64)
private let slot = UnsafeMutablePointer<Int>.allocate(capacity: 64)
var derivations = 0 // items derived so far (statistics)
init(key: [UInt32]) {
mp = MixParams(key: key)
cache = UnsafeMutablePointer<UInt32>.allocate(capacity: cacheWords)
fillMs = cpuFillCache(cache, key: key)
}
func word(_ w: UInt32) -> UInt32 { deriveItem(w >> 4, mp, cache: UnsafePointer(cache))[Int(w & 15)] }
// out[k] = dataset[idx[k]] for k < n (n <= 64). Equal items are derived once.
func fetch(_ idx: UnsafePointer<UInt32>, _ n: Int, _ out: UnsafeMutablePointer<UInt32>) {
var u = 0
for k in 0..<n {
let t = idx[k] >> 4
var found = -1
for j in 0..<u where uniq[j] == t { found = j; break }
if found < 0 { uniq[u] = t; found = u; u += 1 }
slot[k] = found
}
deriveItems(UnsafePointer(uniq), u, mp, cache: UnsafePointer(cache), out: items)
derivations += u
for k in 0..<n { out[k] = items[slot[k] * 16 + Int(idx[k] & 15)] }
}
}
// What the CPU interpreter reads dataset words from. Closed form (day words d0, d1) or the memory-hard cache.
final class DatasetSource {
let mask: UInt32
let day: (UInt32, UInt32)
let memhard: MemhardCPU?
init(mask: UInt32, day: (UInt32, UInt32), memhard: MemhardCPU?) { self.mask = mask; self.day = day; self.memhard = memhard }
var modeName: String { memhard == nil ? "closed-form" : "memory-hard" }
func word(_ w: UInt32) -> UInt32 { memhard?.word(w & mask) ?? datasetElem(w & mask, day.0, day.1) }
func fetch(_ idx: UnsafePointer<UInt32>, _ n: Int, _ out: UnsafeMutablePointer<UInt32>) {
if let m = memhard { m.fetch(idx, n, out) }
else { for k in 0..<n { out[k] = datasetElem(idx[k], day.0, day.1) } }
}
}
// MARK: - Program
enum Op: String { case add, sub, mul, mulhi, xor, or, rotl, rotr, mad, shfl, load }
// wload (added 3 October 2026, lever b): warp-coalesced load. All 32 lanes read consecutive words of one
// 128-byte block whose address comes from lane 0's source register. Never emitted unless --wide-frac > 0.
enum Op: String { case add, sub, mul, mulhi, xor, or, rotl, rotr, mad, shfl, load, wload }
struct Instr {
var op: Op
@ -152,7 +353,11 @@ struct Program {
let instrs: [Instr]
static let iterations = 8
static let count = 64
var loadsPerHash: Int { instrs.filter { $0.op == .load }.count * Program.iterations }
var loadsPerHash: Int { instrs.filter { $0.op == .load || $0.op == .wload }.count * Program.iterations }
var wideLoadsPerHash: Int { instrs.filter { $0.op == .wload }.count * Program.iterations }
var hasWide: Bool { instrs.contains { $0.op == .wload } }
// Distinct dataset items a 32-lane warp touches per hash: 32 per plain load, 2 per wide load (128 B = 2 items).
var itemsPerWarp: Int { (loadsPerHash - wideLoadsPerHash) * 32 + wideLoadsPerHash * 2 }
var histogram: [(String, Int)] {
var d = [String: Int]()
for i in instrs { d[i.op.rawValue, default: 0] += 1 }

2
site/.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
.vercel
.env*

478
site/index.html Normal file
View file

@ -0,0 +1,478 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<title>Igneum</title>
<meta name="description" content="Igneum is a GPU-mined layer 1 whose miners prove every block. Mined by GPUs. Proven by fire.">
<meta property="og:title" content="Igneum">
<meta property="og:description" content="Mined by GPUs. Proven by fire. The first chain built so no chip can ever take your place.">
<meta name="theme-color" content="#0C0C0E">
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Cpolygon points='50,4 74,34 67,58 80,54 61,96 39,96 20,54 33,58 26,34' fill='%23F2541B'/%3E%3Cpolygon points='50,42 59,58 50,82 41,58' fill='%230C0C0E'/%3E%3C/svg%3E">
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Unbounded:wght@500;700;900&family=IBM+Plex+Sans:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap">
<style>
:root{--obsidian:#0C0C0E;--graphite:#16161A;--line:#2A2A30;--line-2:#3A3A42;--ember:#F2541B;--molten:#FFB35C;--bone:#F4F1EC;--ash:#9A9A9E;--ink-2:#C9C7C2;--ember-ink:#0C0C0E;
--fs-hero:clamp(40px,7vw,76px);--fs-h2:clamp(28px,4.2vw,44px);--fs-h3:clamp(18px,2vw,22px);--gutter:clamp(16px,4vw,32px);--max:1200px}
*{box-sizing:border-box}
html{scroll-behavior:smooth}
@media (prefers-reduced-motion:reduce){html{scroll-behavior:auto}}
body{margin:0;background:var(--obsidian);color:var(--bone);font-family:'IBM Plex Sans',system-ui,-apple-system,sans-serif;font-size:17px;line-height:1.55;-webkit-font-smoothing:antialiased;overflow-x:hidden}
a{color:inherit;text-decoration:none}
a:hover{color:var(--molten)}
a:focus-visible,button:focus-visible{outline:2px solid var(--ember);outline-offset:3px;border-radius:6px}
img,svg,canvas{max-width:100%}
.wrap{max-width:var(--max);margin:0 auto;padding-inline:var(--gutter)}
.mono{font-family:'IBM Plex Mono',monospace}
.eyebrow{font-family:'IBM Plex Mono',monospace;font-size:12px;letter-spacing:.18em;text-transform:uppercase;color:var(--ash)}
.eyebrow.ember{color:var(--ember)}
h1,h2,h3{font-family:'Unbounded',sans-serif;margin:0;line-height:1.08;text-wrap:balance}
h1{font-weight:900;font-size:var(--fs-hero);letter-spacing:-.01em}
h2{font-weight:700;font-size:var(--fs-h2)}
h3{font-weight:700;font-size:var(--fs-h3)}
p{margin:0}
.btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:48px;padding:12px 22px;border-radius:10px;font-weight:600;font-size:16px;border:1px solid var(--line-2);color:var(--bone);background:transparent;cursor:pointer;transition:transform .15s ease,background .15s ease,border-color .15s ease}
.btn:hover{transform:translateY(-1px);border-color:var(--ash);color:var(--bone)}
.btn.primary{background:var(--ember);color:var(--ember-ink);border-color:var(--ember)}
.btn.primary:hover{background:#FF6A2B;border-color:#FF6A2B;color:var(--ember-ink)}
.btn.dark{background:var(--obsidian);color:var(--bone);border-color:var(--obsidian)}
.btn.dark:hover{background:#222226;color:var(--bone)}
.card{background:var(--graphite);border:1px solid var(--line);border-radius:18px;padding:28px}
.grid{display:grid;gap:24px;grid-template-columns:repeat(auto-fit,minmax(min(100%,300px),1fr))}
.reveal{opacity:0;transform:translateY(18px);transition:opacity .7s ease,transform .7s ease}
.reveal.in{opacity:1;transform:none}
@media (prefers-reduced-motion:reduce){.reveal{opacity:1;transform:none;transition:none}}
/* nav */
.nav{position:sticky;top:0;z-index:20;background:rgba(12,12,14,.82);backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);border-bottom:1px solid rgba(42,42,48,.6)}
.nav .wrap{display:flex;align-items:center;justify-content:space-between;gap:16px;min-height:68px}
.brand{display:flex;align-items:center;gap:10px}
.brand .word{font-family:'Unbounded',sans-serif;font-weight:900;font-size:20px;letter-spacing:.06em}
.links{display:flex;align-items:center;gap:26px;font-size:15px;font-weight:500}
.links .btn{min-height:42px;padding:10px 16px;font-size:15px}
.burger{display:none;background:none;border:1px solid var(--line-2);color:var(--bone);border-radius:10px;width:44px;height:44px;align-items:center;justify-content:center;cursor:pointer}
@media (max-width:900px){
.links{display:none;position:absolute;left:0;right:0;top:68px;background:var(--obsidian);border-bottom:1px solid var(--line);padding:16px var(--gutter) 24px;flex-direction:column;align-items:stretch;gap:6px}
.links a{padding:12px 6px;border-radius:8px}
.links .btn{width:100%;margin-top:6px}
.links.open{display:flex}
.burger{display:inline-flex}
}
/* hero */
.hero{position:relative;padding-block:clamp(56px,9vw,112px) clamp(40px,6vw,72px);overflow:hidden}
.hero canvas{position:absolute;inset:0;width:100%;height:100%;opacity:.55;pointer-events:none}
.hero .wrap{position:relative;display:grid;gap:40px;grid-template-columns:1fr;align-items:center}
@media (min-width:980px){.hero .wrap{grid-template-columns:1.15fr .85fr;gap:56px}}
.hero-copy{display:flex;flex-direction:column;gap:24px}
.hero p.lead{font-size:clamp(17px,2vw,20px);color:var(--ink-2);max-width:56ch}
.cta{display:flex;flex-wrap:wrap;gap:12px}
.verify{display:flex;flex-direction:column;gap:18px}
.verify-head{display:flex;justify-content:space-between;align-items:center;gap:12px}
.live{display:inline-flex;align-items:center;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:var(--molten)}
.dot{width:8px;height:8px;border-radius:50%;background:var(--molten);display:inline-block;animation:pulse 2s ease-in-out infinite}
@keyframes pulse{0%,100%{box-shadow:0 0 0 0 rgba(255,179,92,.5)}50%{box-shadow:0 0 0 8px rgba(255,179,92,0)}}
.verify-row{display:flex;align-items:center;gap:16px}
.tick{width:56px;height:56px;border-radius:50%;background:var(--ember);display:flex;align-items:center;justify-content:center;flex:0 0 56px}
.tick svg path{stroke-dasharray:30;stroke-dashoffset:30;animation:draw 1s .4s ease forwards}
@keyframes draw{to{stroke-dashoffset:0}}
.verify-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}
.cell{background:var(--obsidian);border-radius:12px;padding:14px;display:flex;flex-direction:column;gap:4px}
.cell .k{font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:.12em;color:var(--ash)}
.cell .v{font-family:'IBM Plex Mono',monospace;font-size:15px}
/* stats */
.stats{border-top:1px solid var(--line);border-bottom:1px solid var(--line)}
.stats .wrap{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:20px 40px;padding-block:28px}
.stat .v{font-family:'Unbounded',sans-serif;font-weight:700;font-size:clamp(24px,3vw,30px);color:var(--ember);line-height:1.1}
.stat .k{margin-top:6px;font-size:14px;color:var(--ash)}
section{padding-block:clamp(56px,8vw,96px)}
.sec-head{display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:16px;margin-bottom:32px}
.sec-head p{font-size:16px;color:var(--ash);max-width:46ch}
/* dag */
.dag{overflow-x:auto;padding:32px}
.dag-rows{display:flex;flex-direction:column;gap:14px;min-width:640px}
.dag-row{display:flex;gap:14px;align-items:center}
.blk{width:34px;height:34px;border-radius:8px;border:2px solid var(--line-2);transition:background .5s ease,border-color .5s ease,transform .3s ease}
.blk.proving{background:var(--molten);border-color:var(--molten)}
.blk.proven{background:var(--ember);border-color:var(--ember)}
.blk.lock{border-color:var(--ember);background:transparent;display:flex;align-items:center;justify-content:center}
.blk.new{animation:pop .4s ease}
@keyframes pop{from{transform:scale(.4);opacity:0}to{transform:scale(1);opacity:1}}
.legend{display:flex;flex-wrap:wrap;gap:20px;margin-top:24px;font-size:14px;color:var(--ink-2)}
.legend span{display:inline-flex;align-items:center;gap:8px}
.sw{width:14px;height:14px;border-radius:4px;display:inline-block}
pre{margin:0;font-family:'IBM Plex Mono',monospace;font-size:13px;line-height:1.6;color:var(--ink-2);white-space:pre-wrap;min-height:9.6em}
.caret::after{content:'▍';color:var(--ember);animation:blink 1s steps(1) infinite}
@keyframes blink{50%{opacity:0}}
.feed{display:flex;flex-direction:column;gap:10px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:var(--ink-2)}
.feed div{display:flex;justify-content:space-between;gap:12px;border-bottom:1px solid var(--line);padding-bottom:8px}
.feed div:last-child{border-bottom:0}
/* jobs cards */
.jobs{display:grid;gap:24px;grid-template-columns:repeat(auto-fit,minmax(min(100%,300px),1fr))}
.job{display:flex;flex-direction:column;gap:14px;border:1px solid var(--line);border-radius:18px;padding:28px;transition:border-color .2s ease,transform .2s ease}
.job:hover{border-color:var(--line-2);transform:translateY(-2px)}
.job p{font-size:15px;color:var(--ink-2)}
.job a.more{color:var(--ember);font-weight:600;font-size:15px}
/* miners */
.light{background:var(--bone);color:var(--obsidian)}
.light .card{background:#fff;border-color:#E4E0D8}
.light .sec-head p{color:#55534F}
.light .eyebrow{color:#7A776F}
.light .job p{color:#3D3B37}
/* journey */
.journey{display:grid;gap:14px;grid-template-columns:repeat(auto-fit,minmax(min(100%,170px),1fr))}
.phase{border:1px solid var(--line);border-radius:14px;padding:18px;display:flex;flex-direction:column;gap:6px;position:relative;transition:border-color .2s ease}
.phase .w{font-family:'IBM Plex Mono',monospace;font-size:11px;color:var(--ash)}
.phase .n{font-weight:600;font-size:15px}
.phase .g{font-size:12px;color:var(--ash);line-height:1.4}
.phase.done{border-color:var(--line-2)}
.phase.done .n::after{content:' ✓';color:var(--molten)}
.phase.active{border:2px solid var(--ember);box-shadow:0 0 0 0 rgba(242,84,27,.35);animation:glow 2.4s ease-in-out infinite}
@keyframes glow{50%{box-shadow:0 0 0 10px rgba(242,84,27,0)}}
.phase.active .w{color:var(--ember)}
.now{display:inline-flex;align-items:center;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px;color:var(--ember);letter-spacing:.12em}
.log{display:flex;flex-direction:column;gap:0;margin-top:28px;border:1px solid var(--line);border-radius:18px;background:var(--graphite);padding:8px 24px}
.log div{display:flex;gap:18px;padding:14px 0;border-bottom:1px solid var(--line);font-size:15px;color:var(--ink-2)}
.log div:last-child{border-bottom:0}
.log .d{font-family:'IBM Plex Mono',monospace;font-size:12px;color:var(--ash);flex:0 0 92px;padding-top:3px}
/* economics */
.bar{display:flex;height:22px;border-radius:8px;overflow:hidden}
.bar div{transition:width 1.2s ease}
.tiles{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:16px}
.tile{background:var(--graphite);border:1px solid var(--line);border-radius:16px;padding:22px}
.tile .v{font-family:'Unbounded',sans-serif;font-weight:700;font-size:26px}
.tile .k{font-size:14px;color:var(--ash);margin-top:6px}
.band{background:var(--ember);color:var(--ember-ink)}
.band .wrap{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:24px;padding-block:56px}
.band h2{font-weight:900;font-size:clamp(26px,3.5vw,36px)}
.band p{font-size:16px;max-width:56ch}
footer .wrap{display:flex;flex-wrap:wrap;justify-content:space-between;align-items:center;gap:20px;padding-block:40px 48px;font-size:14px;color:var(--ash)}
footer .fl{display:flex;flex-wrap:wrap;gap:20px}
</style>
</head>
<body>
<nav class="nav" aria-label="Main">
<div class="wrap">
<a href="#top" class="brand" aria-label="Igneum home">
<svg viewBox="0 0 100 100" width="30" height="30" aria-hidden="true"><polygon points="50,4 74,34 67,58 80,54 61,96 39,96 20,54 33,58 26,34" fill="#F2541B"></polygon><polygon points="50,42 59,58 50,82 41,58" fill="#0C0C0E"></polygon></svg>
<span class="word">IGNEUM</span>
</a>
<button class="burger" id="burger" aria-expanded="false" aria-controls="links" aria-label="Menu"><svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M4 7h16M4 12h16M4 17h16"></path></svg></button>
<div class="links" id="links">
<a href="#mine">Mine</a>
<a href="#prove">Prove</a>
<a href="#build">Build</a>
<a href="#randomx">vs RandomX</a>
<a href="#journey">Journey</a>
<a href="#economics">Economics</a>
<a href="/litepaper">Litepaper</a>
<a href="#mine" class="btn primary">Get the miner</a>
</div>
</div>
</nav>
<header class="hero" id="top">
<canvas id="bg" aria-hidden="true"></canvas>
<div class="wrap">
<div class="hero-copy">
<div class="eyebrow ember">GPUs are back · for good</div>
<h1>Mined by GPUs.<br>Proven by fire.</h1>
<p class="lead">The first chain built so no chip can ever take your place. A mining program that rewrites itself every hour, so no chip can be built for it. The same card proves every block and gets paid for it. No premine, no stake, no foundation, no merge to anything else, ever.</p>
<div class="cta">
<a href="#mine" class="btn primary">Start mining</a>
<a href="/litepaper" class="btn">Read the litepaper</a>
</div>
</div>
<div class="card verify reveal">
<div class="verify-head">
<div class="eyebrow">This tab · light client</div>
<div class="live"><span class="dot"></span>PREVIEW</div>
</div>
<div class="verify-row">
<div class="tick"><svg viewBox="0 0 24 24" width="30" height="30" fill="none" stroke="#0C0C0E" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12.5l4.5 4.5L19 7"></path></svg></div>
<div>
<h3 style="font-size:20px">Your browser will verify Igneum</h3>
<p style="font-size:14px;color:var(--ash)">One proof checked here, in milliseconds. No node, no trust, no middleman. Live at testnet.</p>
</div>
</div>
<div class="verify-grid">
<div class="cell"><div class="k">BLOCK PROOF</div><div class="v">prototype</div></div>
<div class="cell"><div class="k">CHECKPOINT</div><div class="v">locked by miners</div></div>
<div class="cell"><div class="k">PROOF SYSTEM</div><div class="v">version 1</div></div>
<div class="cell"><div class="k">VERIFIED TODAY</div><div class="v" style="color:var(--molten)">at testnet</div></div>
</div>
</div>
</div>
</header>
<div class="stats">
<div class="wrap">
<div class="stat reveal"><div class="v" data-count="1" data-suffix=" / s">1 / s</div><div class="k">blocks, rising to 10</div></div>
<div class="stat reveal"><div class="v">~60 s</div><div class="k">to a verified proof at launch</div></div>
<div class="stat reveal"><div class="v" data-count="0">0</div><div class="k">premine, pre-sale, allocation</div></div>
<div class="stat reveal"><div class="v" data-count="4" data-suffix="B">4B</div><div class="k">IGN hard cap, ever</div></div>
<div class="stat reveal"><div class="v" data-count="100" data-suffix="%">100%</div><div class="k">of emission to miners and provers</div></div>
</div>
</div>
<section id="prove">
<div class="wrap">
<div class="sec-head reveal">
<h2>Watch the chain prove itself</h2>
<p>Blocks arrive every second. Miners prove them in shards. A checkpoint locks every 30 seconds. All of it will be on this page, live.</p>
</div>
<div class="card dag reveal" aria-label="Animated block DAG">
<div class="dag-rows" id="dag"></div>
<div class="legend">
<span><i class="sw" style="background:var(--ember)"></i>proven</span>
<span><i class="sw" style="background:var(--molten)"></i>being proven by miners</span>
<span><i class="sw" style="border:2px solid var(--line-2)"></i>just mined</span>
<span><i class="sw" style="border:2px solid var(--ember)"></i>checkpoint locked by sustained miners</span>
</div>
</div>
<div class="grid" style="margin-top:24px">
<div class="card reveal" style="display:flex;flex-direction:column;gap:16px">
<div class="verify-head"><div class="eyebrow">This hour's mining program</div><div class="mono" style="font-size:12px;color:var(--molten)">next in <span id="countdown">59:59</span></div></div>
<pre id="program" class="caret"></pre>
<p style="font-size:14px;color:var(--ash)">A new random program every hour. A GPU compiles it in seconds. A chip designed for last hour's program is already obsolete.</p>
</div>
<div class="card reveal" style="display:flex;flex-direction:column;gap:16px">
<div class="eyebrow">Proofs sold to other chains</div>
<div class="feed">
<div><span>rollup · batch proof</span><span style="color:var(--molten)">at testnet</span></div>
<div><span>bridge · state proof</span><span style="color:var(--molten)">at testnet</span></div>
<div><span>rollup · fault proof</span><span style="color:var(--ash)">at testnet</span></div>
<div><span>IGN burned from jobs</span><span style="color:var(--ember)">at launch</span></div>
</div>
<p style="font-size:14px;color:var(--ash)">The same cards that secure Igneum sell proofs to rollups and bridges. 10% of every job fee is burned.</p>
</div>
</div>
</div>
</section>
<section id="randomx" style="padding-top:0">
<div class="wrap">
<div class="sec-head reveal">
<h2>Monero's idea, finished for GPUs</h2>
<p>RandomX has kept chips off Monero since 2019 by making the mining program random. Igneum takes the same principle to graphics cards and adds the parts RandomX never had.</p>
</div>
<div class="card reveal" style="overflow-x:auto;padding:0">
<table style="border-collapse:collapse;width:100%;min-width:640px;font-size:15px">
<thead><tr style="background:var(--obsidian)"><th style="text-align:left;padding:14px 20px" class="eyebrow">Property</th><th style="text-align:left;padding:14px 20px" class="eyebrow">RandomX, Monero</th><th style="text-align:left;padding:14px 20px" class="eyebrow" ><span style="color:var(--ember)">Igneum</span></th></tr></thead>
<tbody>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Hardware it is built for</td><td style="padding:12px 20px;border-top:1px solid var(--line)">CPUs. GPUs run it badly on purpose</td><td style="padding:12px 20px;border-top:1px solid var(--line)">GPUs. Any card, any vendor. Bit-exact on Apple and NVIDIA, measured</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Random program</td><td style="padding:12px 20px;border-top:1px solid var(--line)">Per hash, interpreted in a virtual machine</td><td style="padding:12px 20px;border-top:1px solid var(--line)">Per hour, compiled to native GPU code, with a per-hash random data path</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Dataset</td><td style="padding:12px 20px;border-top:1px solid var(--line)">About 2 GB, the same size since 2019, approximate</td><td style="padding:12px 20px;border-top:1px solid var(--line)">2 GB at genesis, growing every year past any chip's memory</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Light verification</td><td style="padding:12px 20px;border-top:1px solid var(--line)">256 MB cache on a CPU, milliseconds</td><td style="padding:12px 20px;border-top:1px solid var(--line)">256 MB cache on a CPU, one warp under 10 ms, the measured gate</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Changes over time</td><td style="padding:12px 20px;border-top:1px solid var(--line)">None. A fixed design, unchanged for seven years</td><td style="padding:12px 20px;border-top:1px solid var(--line)">Automatic era draws and a reserve of instruction families that unlock by height. Nobody touches it</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Seed grinding</td><td style="padding:12px 20px;border-top:1px solid var(--line)">Not applicable, the program comes from the hash input</td><td style="padding:12px 20px;border-top:1px solid var(--line)">Closed by a verifiable delay between seed and program</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Useful work</td><td style="padding:12px 20px;border-top:1px solid var(--line)">None. Hashing only</td><td style="padding:12px 20px;border-top:1px solid var(--line)">The same card proves every block and sells proofs to other chains</td></tr>
<tr><td style="padding:12px 20px;border-top:1px solid var(--line)">Track record</td><td style="padding:12px 20px;border-top:1px solid var(--line)">No chip in seven years</td><td style="padding:12px 20px;border-top:1px solid var(--line)">Zero years. Every number above is measured, published, and reproducible from the repository</td></tr>
</tbody>
</table>
</div>
<p class="reveal" style="margin-top:20px;font-size:15px;color:var(--ash);max-width:72ch">RandomX proved that a random program beats a chip when the only hardware that runs it well is the hardware everyone already owns. Igneum does the same for the card in your PC, and makes the program keep moving without a human. Run the benchmark on your own card from the repository and post the number.</p>
</div>
</section>
<section id="build" style="padding-top:0">
<div class="wrap">
<h2 class="reveal" style="margin-bottom:28px">One chain, three jobs</h2>
<div class="jobs">
<div class="job reveal">
<svg viewBox="0 0 24 24" width="32" height="32" fill="none" stroke="#F2541B" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="3" y="5" width="18" height="12" rx="2"></rect><path d="M7 9h4M7 13h2M15 9v4M18 9v4M9 21h6"></path></svg>
<h3>Mine</h3>
<p>Any card with 4 GB today, 8 GB for the next decade. A random program every hour, so there is nothing for a chip to be built for. 80% of every block to the miner who finds it, from block one.</p>
<a href="#mine" class="more">Get the miner</a>
</div>
<div class="job reveal">
<svg viewBox="0 0 24 24" width="32" height="32" fill="none" stroke="#F2541B" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 3l8 4v5c0 5-3.5 8-8 9-4.5-1-8-4-8-9V7l8-4z"></path><path d="M9 12l2 2 4-4"></path></svg>
<h3>Prove</h3>
<p>The same card proves shards of every block and sells proofs to other chains. A proof is right or it is not, so nobody has to trust a miner, ever.</p>
<a href="#prove" class="more">How proving pays</a>
</div>
<div class="job reveal">
<svg viewBox="0 0 24 24" width="32" height="32" fill="none" stroke="#F2541B" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M8 7l-5 5 5 5M16 7l5 5-5 5M14 4l-4 16"></path></svg>
<h3>Build</h3>
<p>Ethereum bytecode, wallets and tools, unchanged. One-second inclusion, finality in about two minutes, a prover network any contract can call, and 15% of the priority fees your code earns paid back to you every block.</p>
<a href="/litepaper#builders-ask" class="more">Deploy on Igneum</a>
</div>
</div>
</div>
</section>
<section id="mine" class="light">
<div class="wrap">
<div class="sec-head reveal">
<h2>Three ways a card gets paid</h2>
<p>One client, one balance. The miner software switches the card between hashing and proving by itself.</p>
</div>
<div class="jobs">
<div class="card reveal" style="display:flex;flex-direction:column;gap:10px"><div class="eyebrow">01</div><h3 style="font-size:20px">Block reward</h3><p style="font-size:15px;color:#3D3B37">80% of emission to the miner who wins the block. Half of all IGN is mined in the first two years.</p></div>
<div class="card reveal" style="display:flex;flex-direction:column;gap:10px"><div class="eyebrow">02</div><h3 style="font-size:20px">Proving the chain</h3><p style="font-size:15px;color:#3D3B37">20% of emission plus a share of every block's gas, paid to the cards that prove shards and aggregate them.</p></div>
<div class="card reveal" style="display:flex;flex-direction:column;gap:10px"><div class="eyebrow">03</div><h3 style="font-size:20px">Proving for others</h3><p style="font-size:15px;color:#3D3B37">Rollups and bridges pay for proofs in their own money. Small market today, growing with every chain that moves to proofs. Upside, not a promise.</p></div>
</div>
<div class="cta reveal" style="margin-top:32px;align-items:center">
<a href="#journey" class="btn dark">Windows</a>
<a href="#journey" class="btn dark">macOS</a>
<a href="#journey" class="btn dark">Linux</a>
<a href="#journey" class="btn" style="color:#0C0C0E;border-color:#0C0C0E">HiveOS</a>
<p style="font-size:14px;color:#55534F">One click: install, press start, the card mines and proves to a wallet the app makes for you. Available at public testnet. Open source, 1% dev fee like every miner you already run.</p>
</div>
</div>
</section>
<section id="journey">
<div class="wrap">
<div class="sec-head reveal">
<div>
<h2>Where Igneum is right now</h2>
<div class="now" style="margin-top:12px"><span class="dot" style="background:var(--ember)"></span><span id="stage-label">LOADING</span></div>
</div>
<p>Thirteen months, four public gates. Every gate is a measurement, published whether it passes or fails. Miss it and the phase repeats or Igneum stops.</p>
</div>
<div class="journey reveal" id="phases"></div>
<div class="log reveal" id="log"></div>
</div>
</section>
<section id="economics" style="padding-top:0">
<div class="wrap" style="display:grid;gap:48px;grid-template-columns:repeat(auto-fit,minmax(min(100%,380px),1fr));align-items:center">
<div class="reveal" style="display:flex;flex-direction:column;gap:20px">
<h2>Every coin, mined</h2>
<p style="color:var(--ink-2)">Hard cap of 4 billion IGN. Emission halves every two years for ever. Not one coin to a founder, a fund or a stake. Development is paid from fees by the people who use the chain, and spent only when miners signal yes.</p>
<div style="display:flex;flex-direction:column;gap:10px">
<div class="bar" id="bar"><div style="width:0;background:var(--ember)" data-w="80%"></div><div style="width:0;background:var(--molten)" data-w="20%"></div></div>
<div class="legend mono" style="margin-top:4px;font-size:13px">
<span><i class="sw" style="background:var(--ember)"></i>80% miners</span>
<span><i class="sw" style="background:var(--molten)"></i>20% provers</span>
<span><i class="sw" style="border:1px solid var(--line-2)"></i>0% anyone else</span>
</div>
</div>
</div>
<div class="tiles reveal">
<div class="tile"><div class="v">0</div><div class="k">premine</div></div>
<div class="tile"><div class="v">0</div><div class="k">stake in consensus</div></div>
<div class="tile"><div class="v">0</div><div class="k">admin keys</div></div>
<div class="tile"><div class="v">90%</div><div class="k">of blocks must signal before any upgrade</div></div>
</div>
</div>
</section>
<div class="band">
<div class="wrap">
<div style="display:flex;flex-direction:column;gap:8px">
<h2>Read what Igneum does not claim.</h2>
<p>The litepaper states the limits before anyone else does. Proof lag, chip economics, the market size, and the one rule external review will try hardest to break.</p>
</div>
<a href="/litepaper" class="btn dark">Litepaper</a>
</div>
</div>
<footer>
<div class="wrap">
<div class="brand"><svg viewBox="0 0 100 100" width="22" height="22" aria-hidden="true"><polygon points="50,4 74,34 67,58 80,54 61,96 39,96 20,54 33,58 26,34" fill="#F2541B"></polygon><polygon points="50,42 59,58 50,82 41,58" fill="#0C0C0E"></polygon></svg><span class="word" style="font-size:14px;color:var(--bone)">IGNEUM</span><span>· nothing on this page is an offer to sell anything</span></div>
<div class="fl">
<a href="/litepaper">Litepaper</a>
<a href="https://github.com/[second-owner-login]/igneum" rel="noopener">GitHub</a>
<a href="#journey">Journey</a>
</div>
</div>
</footer>
<script>
(function(){
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
// nav
var burger=document.getElementById('burger'),links=document.getElementById('links');
burger.addEventListener('click',function(){var o=links.classList.toggle('open');burger.setAttribute('aria-expanded',o?'true':'false');});
links.querySelectorAll('a').forEach(function(a){a.addEventListener('click',function(){links.classList.remove('open');burger.setAttribute('aria-expanded','false');});});
// reveal on scroll
var io=new IntersectionObserver(function(es){es.forEach(function(e){if(e.isIntersecting){e.target.classList.add('in');io.unobserve(e.target);}});},{threshold:.12});
document.querySelectorAll('.reveal').forEach(function(el){io.observe(el);});
// emission bar
var bar=document.getElementById('bar');
var bio=new IntersectionObserver(function(es){es.forEach(function(e){if(e.isIntersecting){bar.querySelectorAll('div').forEach(function(d){d.style.width=d.getAttribute('data-w');});bio.disconnect();}});},{threshold:.4});
bio.observe(bar);
// hero background: drifting DAG
var cv=document.getElementById('bg'),ctx=cv.getContext('2d'),nodes=[],W,H,dpr=Math.min(window.devicePixelRatio||1,2);
function size(){W=cv.clientWidth;H=cv.clientHeight;cv.width=W*dpr;cv.height=H*dpr;ctx.setTransform(dpr,0,0,dpr,0,0);}
size();window.addEventListener('resize',size);
function spawn(){nodes.push({x:-20,y:H*(0.15+Math.random()*0.7),vx:0.25+Math.random()*0.35,age:0,proven:false,parents:nodes.slice(-3).filter(function(){return Math.random()<0.7;})});if(nodes.length>70)nodes.shift();}
var last=0;
function frame(t){
if(!reduce){
if(t-last>900){spawn();last=t;}
ctx.clearRect(0,0,W,H);
nodes.forEach(function(n){n.x+=n.vx;n.age++;if(n.age>140&&!n.proven)n.proven=true;});
ctx.lineWidth=1;
nodes.forEach(function(n){n.parents.forEach(function(p){if(nodes.indexOf(p)<0)return;ctx.strokeStyle='rgba(154,154,158,0.25)';ctx.beginPath();ctx.moveTo(n.x,n.y);ctx.lineTo(p.x,p.y);ctx.stroke();});});
nodes.forEach(function(n){ctx.beginPath();ctx.arc(n.x,n.y,n.proven?5:4,0,Math.PI*2);ctx.fillStyle=n.proven?'rgba(242,84,27,0.9)':(n.age>60?'rgba(255,179,92,0.85)':'rgba(12,12,14,1)');ctx.fill();if(!n.proven&&n.age<=60){ctx.strokeStyle='rgba(154,154,158,0.7)';ctx.stroke();}});
requestAnimationFrame(frame);
}
}
if(!reduce){for(var i=0;i<30;i++){spawn();nodes[nodes.length-1].x=Math.random()*W;nodes[nodes.length-1].age=Math.floor(Math.random()*200);}requestAnimationFrame(frame);}
// DAG animation in the prove section
var dag=document.getElementById('dag');
var rows=[[],[],[]];
function render(){dag.innerHTML='';rows.forEach(function(r,i){var d=document.createElement('div');d.className='dag-row';d.style.paddingLeft=(i*24)+'px';r.forEach(function(b){var e=document.createElement('div');e.className='blk '+b.state+(b.fresh?' new':'');if(b.state==='lock'){e.innerHTML='<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="#F4F1EC" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="5" y="11" width="14" height="9" rx="2"></rect><path d="M8 11V7a4 4 0 0 1 8 0v4"></path></svg>';}b.fresh=false;d.appendChild(e);});dag.appendChild(d);});}
var tick=0;
function step(){
tick++;
rows.forEach(function(r){r.forEach(function(b){b.age++;if(b.state==='mined'&&b.age>3)b.state='proving';else if(b.state==='proving'&&b.age>7)b.state='proven';});});
var ri=tick%3;rows[ri].push({state:'mined',age:0,fresh:true});
if(tick%10===0){var r=rows[1];for(var i=r.length-1;i>=0;i--){if(r[i].state==='proven'){r[i].state='lock';break;}}}
rows.forEach(function(r){while(r.length>9)r.shift();});
render();
}
for(var k=0;k<24;k++){step();}
rows.forEach(function(r){r.forEach(function(b){b.fresh=false;});});render();
if(!reduce)setInterval(step,1000);
// hourly program ticker
var ops=['rotl','rotr','xor','add','sub','mul','mulhi','mad','or'];
function hex(){return '0x'+Math.floor(Math.random()*0xFFFFFFFF).toString(16).toUpperCase().padStart(8,'0');}
function reg(){return 'r'+Math.floor(Math.random()*8);}
function line(){var o=ops[Math.floor(Math.random()*ops.length)];var r=Math.random();
if(r<0.25)return reg()+' ^= load(ds, '+reg()+' & MASK)';
if(r<0.35)return reg()+' = shfl_xor('+reg()+', '+[1,2,4,8,16][Math.floor(Math.random()*5)]+')';
if(o==='mad')return reg()+' = mad('+reg()+', '+reg()+' | 1, '+reg()+')';
if(o==='rotl'||o==='rotr')return reg()+' = '+o+'('+reg()+', '+Math.floor(Math.random()*31+1)+')';
if(o==='mulhi')return reg()+' = mulhi('+reg()+', '+hex()+')';
return reg()+' = '+reg()+' '+({xor:'^',add:'+',sub:'-',mul:'*',or:'|'})[o]+' '+(Math.random()<0.5?reg():hex());}
var pre=document.getElementById('program');
function program(){var ls=['// seed from a locked checkpoint, through a 10 minute delay'];for(var i=0;i<5;i++)ls.push(line());ls.push('// 64 instructions x 8 iterations, regenerated every hour');return ls;}
function type(ls){pre.textContent='';var i=0,j=0,out='';function t(){if(i>=ls.length)return;if(j<=ls[i].length){out=ls.slice(0,i).join('\n')+(i?'\n':'')+ls[i].slice(0,j);pre.textContent=out;j++;setTimeout(t,reduce?0:14);}else{i++;j=0;t();}}t();}
type(program());
if(!reduce)setInterval(function(){type(program());},16000);
var cd=document.getElementById('countdown');
function countdown(){var n=new Date();var s=3599-(n.getMinutes()*60+n.getSeconds());cd.textContent=String(Math.floor(s/60)).padStart(2,'0')+':'+String(s%60).padStart(2,'0');}
countdown();setInterval(countdown,1000);
// journey
fetch('/journey.json').then(function(r){return r.json();}).then(function(j){
var ph=document.getElementById('phases'),lg=document.getElementById('log'),lab=document.getElementById('stage-label');
var active=j.phases.filter(function(p){return p.status==='active';});
lab.textContent=('NOW · '+active.map(function(p){return p.name;}).join(' and ')+' · updated '+j.updated).toUpperCase();
j.phases.forEach(function(p,i){var d=document.createElement('div');d.className='phase '+p.status;d.innerHTML='<div class="w">'+p.when.toUpperCase()+'</div><div class="n">'+(i+1)+'. '+p.name+'</div>'+(p.gate?'<div class="g">gate: '+p.gate+'</div>':'<div class="g">'+p.line+'</div>');ph.appendChild(d);});
j.log.forEach(function(e){var d=document.createElement('div');d.innerHTML='<span class="d">'+e.date+'</span><span>'+e.text+'</span>';lg.appendChild(d);});
}).catch(function(){document.getElementById('stage-label').textContent='PHASE 2 · PROVE THE PROVING';});
})();
</script>
</body>
</html>

19
site/journey.json Normal file
View file

@ -0,0 +1,19 @@
{
"updated": "2026-10-03",
"stage": "phase-2",
"phases": [
{ "id": "phase-1", "name": "Specification", "when": "Oct to Nov 2026", "status": "active", "line": "Mining generator, shard proving, finality rules, written for external review" },
{ "id": "phase-2", "name": "Prove the proving", "when": "Nov 2026 to Jan 2027", "status": "active", "line": "Mining program prototype on GPU and CPU, shard proving benchmark on consumer cards", "gate": "A mid-range GPU proves a shard in under 20 s and a CPU verifies a hash in 10 ms" },
{ "id": "phase-3", "name": "Devnet", "when": "Feb to Mar 2027", "status": "next", "line": "BlockDAG node with the new mining program and EVM execution, 20 nodes", "gate": "1 block a second held with proofs under 60 s behind the tip" },
{ "id": "phase-4", "name": "Finality and job market", "when": "Apr to Jul 2027", "status": "next", "line": "Sustained-mining finality, external proving jobs, miner client with auto-switching", "gate": "Finality design passes external review and one rollup signs for testnet" },
{ "id": "phase-5", "name": "Public testnet", "when": "Aug to Oct 2027", "status": "next", "line": "One-click miner app on Windows, macOS and Linux, HiveOS, pools, the first rollup as a proving customer, no coin yet", "gate": "1,000 independent miners run 30 days and rollup proofs are delivered on time" },
{ "id": "phase-6", "name": "Mainnet fair launch", "when": "Nov 2027", "status": "next", "line": "Genesis with no premine, 30-day ramp, exchange listings after" }
],
"log": [
{ "date": "2026-10-03", "text": "RTX 5090 ran two generated programs and matched the Apple M5 Max hash for hash, 192 of 192. Vendor independence measured on two vendors." },
{ "date": "2026-10-03", "text": "Fuzzing: 10,200 random programs, 1.3 million hashes, zero GPU to CPU mismatches on Apple silicon." },
{ "date": "2026-10-03", "text": "Second hostile review of the finality rule. Two fatal flaws found and fixed. Rule version 2 published in the design doc." },
{ "date": "2026-10-03", "text": "First prototype of the random-program lottery hash ran on an Apple M5 Max. GPU and CPU agreed bit for bit." },
{ "date": "2026-10-03", "text": "Igneum named. Litepaper, brand and wallet designs published." }
]
}

453
site/litepaper.html Normal file
View file

@ -0,0 +1,453 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<meta name="description" content="The Igneum litepaper: a GPU-mined chain whose miners prove every block.">
<title>Igneum Litepaper</title>
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Unbounded:wght@500;700;900&family=IBM+Plex+Sans:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap">
<style>
:root{
--ground:#F4F1EC; --surface:#FFFFFF; --surface-2:#ECE8E0; --line:#DAD5CB;
--ink:#0C0C0E; --ink-2:#3D3B37; --quiet:#6E6B65;
--ember:#D9430F; --ember-ink:#FFFFFF; --molten:#B9741C; --tint:#FBE9E0;
--code:#16161A; --code-ink:#E6E2DA;
}
@media (prefers-color-scheme: dark){
:root:not([data-theme="light"]){
--ground:#0C0C0E; --surface:#16161A; --surface-2:#1E1E23; --line:#2A2A30;
--ink:#F4F1EC; --ink-2:#C9C7C2; --quiet:#9A9A9E;
--ember:#F2541B; --ember-ink:#0C0C0E; --molten:#FFB35C; --tint:#2A1A12;
--code:#0C0C0E; --code-ink:#C9C7C2;
color-scheme:dark;
}
}
:root[data-theme="dark"]{
--ground:#0C0C0E; --surface:#16161A; --surface-2:#1E1E23; --line:#2A2A30;
--ink:#F4F1EC; --ink-2:#C9C7C2; --quiet:#9A9A9E;
--ember:#F2541B; --ember-ink:#0C0C0E; --molten:#FFB35C; --tint:#2A1A12;
--code:#0C0C0E; --code-ink:#C9C7C2;
color-scheme:dark;
}
*{box-sizing:border-box}
body{margin:0;background:var(--ground);color:var(--ink);font-family:'IBM Plex Sans',system-ui,-apple-system,sans-serif;font-size:17px;line-height:1.6;padding-inline:16px;padding-block:0}
a{color:var(--ember);text-decoration:none}
a:hover{text-decoration:underline}
a:focus-visible,button:focus-visible{outline:2px solid var(--ember);outline-offset:3px}
.wrap{max-width:1180px;margin:0 auto}
.cover{padding-block:48px 40px;border-bottom:1px solid var(--line);display:flex;flex-wrap:wrap;gap:32px;align-items:flex-end;justify-content:space-between}
.brand{display:flex;align-items:center;gap:14px}
.brand .word{font-family:'Unbounded',sans-serif;font-weight:900;font-size:26px;letter-spacing:.06em}
.eyebrow{font-family:'IBM Plex Mono',monospace;font-size:12px;letter-spacing:.18em;text-transform:uppercase;color:var(--quiet)}
.cover h1{margin:12px 0 10px;font-family:'Unbounded',sans-serif;font-weight:900;font-size:clamp(34px,6vw,64px);line-height:1.02;letter-spacing:-.01em;text-wrap:balance}
.cover .tag{font-size:20px;color:var(--ink-2);max-width:40ch}
.meta{display:flex;flex-direction:column;gap:6px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:var(--quiet);text-align:right}
.meta b{color:var(--ink);font-weight:500}
.layout{display:grid;grid-template-columns:minmax(0,1fr);gap:40px;padding-block:40px 80px}
@media (min-width:960px){.layout{grid-template-columns:240px minmax(0,1fr);gap:64px}}
.toc{align-self:start}
@media (min-width:960px){.toc{position:sticky;top:calc(env(safe-area-inset-top,0px) + 24px)}}
.toc ol{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:2px;counter-reset:s}
.toc li a{display:flex;gap:10px;padding:7px 10px;border-radius:8px;color:var(--ink-2);font-size:14px;counter-increment:s}
.toc li a::before{content:counter(s,decimal-leading-zero);font-family:'IBM Plex Mono',monospace;font-size:12px;color:var(--quiet);min-width:22px;padding-top:2px}
.toc li a:hover{background:var(--surface-2);text-decoration:none;color:var(--ink)}
.toc .dl{margin-top:18px;padding-top:18px;border-top:1px solid var(--line);font-size:13px;color:var(--quiet)}
article{max-width:72ch}
section{padding-block:34px;border-top:1px solid var(--line)}
section:first-of-type{border-top:0;padding-top:0}
h2{margin:0 0 18px;font-family:'Unbounded',sans-serif;font-weight:700;font-size:clamp(24px,3.2vw,32px);line-height:1.15;text-wrap:balance}
h3{margin:28px 0 8px;font-family:'Unbounded',sans-serif;font-weight:500;font-size:17px;line-height:1.3}
p{margin:0 0 16px}
.lead{font-size:20px;line-height:1.5;color:var(--ink-2)}
ul,ol{margin:0 0 16px;padding-left:22px}
li{margin-bottom:8px}
strong{font-weight:600}
.pull{margin:24px 0;padding:22px 26px;border-left:4px solid var(--ember);background:var(--tint);border-radius:0 12px 12px 0;font-family:'Unbounded',sans-serif;font-weight:500;font-size:19px;line-height:1.4}
.tbl{overflow-x:auto;margin:18px 0 22px;border:1px solid var(--line);border-radius:12px;background:var(--surface)}
table{border-collapse:collapse;width:100%;min-width:560px;font-size:15px}
th,td{padding:12px 14px;text-align:left;vertical-align:top;border-bottom:1px solid var(--line)}
th{font-family:'IBM Plex Mono',monospace;font-size:12px;letter-spacing:.12em;text-transform:uppercase;color:var(--quiet);font-weight:500;background:var(--surface-2)}
tr:last-child td{border-bottom:0}
td.num{font-family:'IBM Plex Mono',monospace;font-variant-numeric:tabular-nums;white-space:nowrap}
.figure{margin:22px 0 26px;padding:22px;background:var(--surface);border:1px solid var(--line);border-radius:14px;overflow-x:auto}
.figure svg{display:block;width:100%;height:auto;max-width:100%}
.figure .cap{margin-top:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:var(--quiet)}
.stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:12px;margin:8px 0 22px}
.stat{padding:16px;background:var(--surface);border:1px solid var(--line);border-radius:12px}
.stat .v{font-family:'Unbounded',sans-serif;font-weight:700;font-size:26px;color:var(--ember);line-height:1.1}
.stat .k{margin-top:6px;font-size:13px;color:var(--quiet)}
pre{margin:0 0 16px;padding:16px 18px;background:var(--code);color:var(--code-ink);border-radius:12px;font-family:'IBM Plex Mono',monospace;font-size:13px;line-height:1.6;overflow-x:auto}
.foot{padding-block:28px 48px;border-top:1px solid var(--line);display:flex;flex-wrap:wrap;gap:16px 32px;justify-content:space-between;font-size:14px;color:var(--quiet)}
.mark{flex:0 0 auto}
@media (prefers-reduced-motion:no-preference){.pull{transition:transform .2s}}
</style>
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Cpolygon points='50,4 74,34 67,58 80,54 61,96 39,96 20,54 33,58 26,34' fill='%23F2541B'/%3E%3C/svg%3E">
</head>
<body>
<div class="wrap">
<header class="cover">
<div>
<div class="brand">
<svg class="mark" viewBox="0 0 100 100" width="40" height="40" role="img" aria-label="Igneum mark"><polygon points="50,4 74,34 67,58 80,54 61,96 39,96 20,54 33,58 26,34" fill="var(--ember)"></polygon><polygon points="50,42 59,58 50,82 41,58" fill="var(--ground)"></polygon></svg>
<span class="word">IGNEUM</span>
</div>
<div style="margin-top:10px"><a href="/" style="font-size:14px">← igneum.network</a></div>
<div class="eyebrow" style="margin-top:26px">Litepaper · version 0.1</div>
<h1>Mined by GPUs.<br>Proven by fire.</h1>
<div class="tag">A proof-of-work chain whose miners also prove every block, run Ethereum's apps, and built so no chip can ever take your place.</div>
</div>
<div class="meta">
<span>Published <b>3 October 2026</b></span>
<span>Coin <b>IGN</b> · cap <b>4,000,000,000</b></span>
<span>Status <b>pre-specification, pre-testnet</b></span>
<span>This is not an offer to sell anything</span>
</div>
</header>
<div class="layout">
<nav class="toc" aria-label="Contents">
<ol>
<li><a href="#abstract">Abstract</a></li>
<li><a href="#firsts">What has never been done</a></li>
<li><a href="#problem">The problem</a></li>
<li><a href="#glance">Igneum at a glance</a></li>
<li><a href="#mining">Mining</a></li>
<li><a href="#randomx">vs RandomX</a></li>
<li><a href="#proving">Proving</a></li>
<li><a href="#finality">Speed and finality</a></li>
<li><a href="#building">Building on Igneum</a></li>
<li><a href="#economics">Economics</a></li>
<li><a href="#miners">For miners</a></li>
<li><a href="#governance">Governance</a></li>
<li><a href="#roadmap">Roadmap</a></li>
<li><a href="#miners-ask">Questions miners ask</a></li>
<li><a href="#builders-ask">Questions builders ask</a></li>
<li><a href="#limits">What Igneum does not claim</a></li>
</ol>
<div class="dl">Latin igneum: fiery. A cupel is the vessel in which metal is proven by fire.</div>
</nav>
<article>
<section id="abstract">
<h2>Abstract</h2>
<p class="lead">Igneum is a proof-of-work blockchain mined on graphics cards, where the same cards prove every block with zero-knowledge proofs and sell proving to other chains.</p>
<p>It runs the Ethereum virtual machine, so anything built for Ethereum runs on Igneum unchanged. Transactions are included in about one second, proven within about a minute at launch, and locked by miners within about two. There is no premine, no pre-sale, no treasury taken from emission, no stake anywhere in consensus, and no dependence on any other chain. Mining stays open to anyone with a GPU because the mining program itself changes every hour, so there is nothing for a specialised chip to be built for. Nothing in it ever needs a human to keep it that way.</p>
<div class="stats">
<div class="stat"><div class="v">1 / s</div><div class="k">blocks at launch, rising to 10</div></div>
<div class="stat"><div class="v">~60 s</div><div class="k">to a verified proof at launch</div></div>
<div class="stat"><div class="v">0</div><div class="k">premine, pre-sale, allocation, stake</div></div>
<div class="stat"><div class="v">100%</div><div class="k">of emission to miners and provers</div></div>
</div>
</section>
<section id="firsts">
<h2>What has never been done before</h2>
<p>Every piece of Igneum has a precedent somewhere. The combination has none, and six of the pieces are firsts on their own.</p>
<div class="tbl"><table>
<thead><tr><th>First</th><th>Closest precedent</th><th>What Igneum adds</th></tr></thead>
<tbody>
<tr><td>A mining program that regenerates itself, for GPUs</td><td>RandomX does it for CPUs on Monero, since 2019</td><td>The GPU version. Designed, discussed, never shipped</td></tr>
<tr><td>The mining card does paid, useful, verifiable work</td><td>Primecoin's prime chains in 2013 were not useful. Aleo's proving-as-consensus centralised</td><td>Proving is useful, verifiable in milliseconds, and kept apart from the lottery</td></tr>
<tr><td>A proof-of-work chain where every block is proven</td><td>zkEVMs exist only as rollups on top of proof-of-stake Ethereum</td><td>Ethereum apps on a GPU-mined chain whose state cannot be wrong</td></tr>
<tr><td>Finality held by miners and immune to hour-long rentals</td><td>Decred votes with stake. Horizen penalises hidden chains. Kaspa limits depth</td><td>Sustained-mining weight: hashrate that appeared today has no vote</td></tr>
<tr><td>100% of emission to the people running the hardware</td><td>Kaspa's fair launch, with no utility. Zcash and Decred fund developers from emission</td><td>Fair launch, utility, and a development fund paid by outsiders and spent by miners</td></tr>
<tr><td>A chain your browser verifies by itself</td><td>Light clients trust a committee</td><td>One proof plus one locked checkpoint, no trust</td></tr>
</tbody>
</table></div>
<div class="pull">GPU mining lost its home in 2022. Igneum is the first chain built so that it can never be taken away again: not by a chip, not by a merge to proof of stake, not by a rental attack, and not by a foundation.</div>
</section>
<section id="problem">
<h2>The problem</h2>
<p>Three things are wrong at once, and Igneum is built where they meet.</p>
<h3>GPU mining has no home</h3>
<p>Ethereum left proof of work in 2022 and stranded the largest fleet of general-purpose compute ever assembled. Every chain that tried to take it in since has either been captured by specialised chips within two years, as Kaspa was, or has stayed too small to pay the power bill. Miners burn electricity on a lottery and are paid in inflation. When the price falls they switch off, and the chain's security goes with them.</p>
<h3>Proving is centralised</h3>
<p>Rollups, bridges and soon Ethereum itself need zero-knowledge proofs of every batch and every block. Today those proofs come from a few private GPU clusters run by the rollup teams or by a handful of proving companies. The work is a commodity, a proof is correct or it is not, and the cheapest correct proof should win. It does not, because the people with the cheapest GPUs are not in the market.</p>
<h3>Small proof-of-work chains get attacked</h3>
<p>When rental markets can hire more hashrate than a chain has for an hour, double-spends against exchanges are cheap. Ethereum Classic, Bitcoin Gold and Vertcoin were all hit this way. Every one of them let hashrate that appeared a minute ago rewrite history.</p>
<p>Igneum gives the GPU fleet paid, useful, verifiable work. It gives the proving market its cheapest supplier. And it makes the right to rewrite history something that must be earned over a month of public mining, not rented for an hour.</p>
</section>
<section id="glance">
<h2>Igneum at a glance</h2>
<p>Five layers. The lottery decides who makes blocks. Proving decides nothing about consensus, which is what keeps the fastest prover from owning the chain. The two are kept apart on purpose.</p>
<div class="figure">
<svg viewBox="0 0 760 560" role="img" aria-label="A block is mined, ordered, executed, proven, then locked by miners" font-family="IBM Plex Sans, system-ui, sans-serif" font-size="12">
<defs><marker id="ar" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M0 0L10 5L0 10z" fill="var(--quiet)"></path></marker></defs>
<g fill="none" stroke="var(--quiet)" stroke-width="1.25">
<path d="M250 120V156" marker-end="url(#ar)"></path><path d="M250 224V260" marker-end="url(#ar)"></path><path d="M250 328V364" marker-end="url(#ar)"></path><path d="M250 432V468" marker-end="url(#ar)"></path><path d="M504 400H452" marker-end="url(#ar)"></path>
</g>
<g>
<rect x="50" y="48" width="400" height="72" rx="8" fill="var(--surface)" stroke="var(--line)" stroke-width="1.25"></rect>
<text x="66" y="72" font-size="13" font-weight="600" fill="var(--ink)">1. Mining lottery</text>
<text x="66" y="90" fill="var(--ink)">A random GPU program picks who makes the next block</text>
<text x="66" y="106" fill="var(--quiet)">New program every hour, so only a GPU runs it well</text>
</g>
<g>
<rect x="50" y="152" width="400" height="72" rx="8" fill="var(--surface)" stroke="var(--line)" stroke-width="1.25"></rect>
<text x="66" y="176" font-size="13" font-weight="600" fill="var(--ink)">2. BlockDAG ordering</text>
<text x="66" y="194" fill="var(--ink)">Parallel blocks are ordered, about one block a second</text>
<text x="66" y="210" fill="var(--quiet)">A transaction is included in roughly one second</text>
</g>
<g>
<rect x="50" y="256" width="400" height="72" rx="8" fill="var(--surface)" stroke="var(--line)" stroke-width="1.25"></rect>
<text x="66" y="280" font-size="13" font-weight="600" fill="var(--ink)">3. EVM execution</text>
<text x="66" y="298" fill="var(--ink)">Blocks carry transactions only; the proof computes the state</text>
<text x="66" y="314" fill="var(--quiet)">Solidity, wallets and tooling work unchanged</text>
</g>
<g>
<rect x="50" y="360" width="400" height="72" rx="8" fill="var(--tint)" stroke="var(--ember)" stroke-width="2"></rect>
<text x="66" y="384" font-size="13" font-weight="600" fill="var(--ink)">4. Miners prove the block</text>
<text x="66" y="402" fill="var(--ink)">Shards proven on consumer GPUs, aggregated into one proof</text>
<text x="66" y="418" fill="var(--quiet)">Lands within about a minute at launch, paid from gas</text>
</g>
<g>
<rect x="50" y="464" width="400" height="72" rx="8" fill="var(--surface)" stroke="var(--line)" stroke-width="1.25"></rect>
<text x="66" y="488" font-size="13" font-weight="600" fill="var(--ink)">5. Sustained-mining finality</text>
<text x="66" y="506" fill="var(--ink)">Miners lock a checkpoint every 30 s, weighted by 30-day history</text>
<text x="66" y="522" fill="var(--quiet)">Fresh rented hashrate has no vote; nothing outside the chain</text>
</g>
<g>
<rect x="504" y="360" width="232" height="72" rx="8" fill="var(--surface)" stroke="var(--line)" stroke-width="1.25"></rect>
<text x="520" y="384" font-size="13" font-weight="600" fill="var(--ink)">External proving jobs</text>
<text x="520" y="402" fill="var(--ink)">Rollups and bridges pay Igneum</text>
<text x="520" y="418" fill="var(--quiet)">Same GPUs, same proof format</text>
</g>
<g fill="var(--quiet)"><text x="260" y="142">winning block</text><text x="260" y="246">ordered blocks</text><text x="260" y="350">state transitions</text><text x="260" y="454">aggregated proof</text></g>
</svg>
<div class="cap">Five layers plus the external proving market. A block flows down the column; outside demand feeds the same miners from the side.</div>
</div>
</section>
<section id="mining">
<h2>Mining: a program that never holds still</h2>
<p>Every GPU chain that promised ASIC resistance shipped a fixed algorithm, and a fixed algorithm gets a chip the moment the prize pays for one. Igneum does not have a fixed algorithm.</p>
<p>Each hour the chain derives a seed from a locked checkpoint one epoch back, passes it through a ten-minute verifiable delay so no miner can see which program a seed implies before choosing whether to publish a block, and feeds it to a deterministic generator. The generator emits a random integer program built from what graphics cards are uniquely good at: wide parallel integer maths, shuffles between the 32 lanes of a warp, and random reads over a multi-gigabyte dataset that changes daily, so the program is bound by memory bandwidth. The memory footprint and instruction count are fixed and only the maths sequence is random, so no hour favours one vendor's cards and nobody gains by grinding the seed. Miners compile the program once per hour. Anyone running a node, a wallet or an exchange checks a hash on an ordinary CPU in about ten milliseconds by simulating one warp, so nobody needs a GPU except to mine.</p>
<div class="tbl"><table>
<thead><tr><th>Clock</th><th>What changes</th><th>Miner update needed?</th></tr></thead>
<tbody>
<tr><td>Every hash</td><td>The data path depends on the nonce, so no two hashes run the same sequence</td><td>No</td></tr>
<tr><td>Every hour</td><td>A new random program</td><td>No, the miner compiles whatever arrives</td></tr>
<tr><td>Every day</td><td>A new dataset</td><td>No</td></tr>
<tr><td>Every six months</td><td>A new instruction mix and memory pattern drawn by the chain from rules fixed at genesis, and a new family of instructions unlocked from a reserve written at genesis, so the program space widens every era</td><td>No</td></tr>
<tr><td>Continuously</td><td>The dataset grows on a schedule fixed at genesis, slowly enough that consumer cards keep up for years. A chip is built with fixed memory, so it is on a countdown from the day it ships. Ethereum's growing dataset killed Bitmain's E3 miner in 2020 this way, with nobody doing anything</td><td>No</td></tr>
</tbody>
</table></div>
<p>Everything above is automatic. Nobody writes a new program, nobody schedules a fork, and Igneum runs for ever on the generator fixed at genesis, exactly as Monero has run on RandomX since 2019 with no chip built. The generator is designed so that the best hardware for any program it can emit is a graphics card. A chip that dropped the graphics parts and kept the parallel cores and the memory would gain under 2x, approximate, which is below what pays for a tapeout, and that is the same margin that has protected Monero for seven years. On top of that, the widening program space and the growing dataset mean a chip designed for this year's Igneum meets a harder Igneum next year without anyone lifting a finger.</p>
<p>One thing takes a person, here and on every chain that exists: writing new code. A chain cannot safely write its own generator, and it cannot safely tell a chip from a wave of honest new cards by hashrate alone. If the design above ever failed, anyone could publish a new generator and miners would switch it on by signalling, as Monero's community can fork. Igneum is built so that day never comes, and it does not depend on it.</p>
</section>
<section id="randomx">
<h2>Monero's idea, finished for GPUs</h2>
<p>RandomX has kept chips off Monero since 2019 by making the mining program random, so the only hardware that runs it well is the hardware everyone already owns. Igneum takes the same principle to graphics cards and adds what RandomX never had.</p>
<div class="tbl"><table>
<thead><tr><th>Property</th><th>RandomX, Monero</th><th>Igneum</th></tr></thead>
<tbody>
<tr><td>Hardware it is built for</td><td>CPUs. GPUs run it badly on purpose</td><td>GPUs. Any card, any vendor. Bit-exact on Apple and NVIDIA, measured</td></tr>
<tr><td>Random program</td><td>Per hash, interpreted in a virtual machine</td><td>Per hour, compiled to native GPU code, with a per-hash random data path</td></tr>
<tr><td>Dataset</td><td>About 2 GB, the same size since 2019, approximate</td><td>2 GB at genesis, growing every year past any chip's memory</td></tr>
<tr><td>Light verification</td><td>256 MB cache on a CPU, milliseconds</td><td>256 MB cache on a CPU, one warp under 10 ms, the measured gate</td></tr>
<tr><td>Changes over time</td><td>None. A fixed design, unchanged for seven years</td><td>Automatic era draws and a reserve of instruction families that unlock by height. Nobody touches it</td></tr>
<tr><td>Seed grinding</td><td>Not applicable, the program comes from the hash input</td><td>Closed by a verifiable delay between seed and program</td></tr>
<tr><td>Useful work</td><td>None. Hashing only</td><td>The same card proves every block and sells proofs to other chains</td></tr>
<tr><td>Track record</td><td>No chip in seven years</td><td>Zero years. Every number above is measured, published, and reproducible from the repository</td></tr>
</tbody>
</table></div>
<p>Measured so far: the same hourly program, generated on an Apple M5 Max, compiled by Apple's Metal and NVIDIA's CUDA on an RTX 5090, produced identical hashes on both, 192 of 192 across two programs. On a 1 GB dataset the 5090 ran at about 228 million hashes a second and the Mac at about 45 million, both bound by random memory access rather than arithmetic. Inside the 5090's 96 MB cache the same program ran nearly six times faster, which is why the dataset starts at 2 GB and grows. AMD is the next test.</p>
</section>
<section id="proving">
<h2>Proving: the miners are the provers</h2>
<p>Every Igneum block is proven with a zero-knowledge proof, and the miners produce it. Proving is the one useful GPU workload that is cheaply verifiable by construction. A proof is right or it is not, and a phone can check it in milliseconds.</p>
<h3>How a block gets proven</h3>
<p>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. Miners claim shards with a small bond, prove 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.</p>
<h3>The proving budget</h3>
<p>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 is set so a 12 GB card proves one shard in about 20 seconds, measured on a mid-range card before launch and raised 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.</p>
<h3>Proving for everyone else</h3>
<p>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, the Igneum miner client also bids on other proving networks and takes the best price, and 10% of every job fee is burned. The proving market is small today. Igneum does not depend on it. No other proof-of-work chain has a seat in it.</p>
</section>
<section id="finality">
<h2>Speed and finality, powered by miners alone</h2>
<h3>Speed</h3>
<p>Igneum orders blocks with GHOSTDAG, the BlockDAG consensus proven on Kaspa. Blocks arrive in parallel and are ordered rather than orphaned, so the chain runs at one block a second at launch with scheduled steps to four and ten. A transaction is included in about one second, against twelve on Ethereum, and locked in about two minutes against roughly thirteen. Emission is paid per unit of difficulty-adjusted work, never per block, so a faster chain never means more coins.</p>
<h3>Finality</h3>
<p>Every 30 seconds of chain a checkpoint forms, deep enough past the tip that the DAG will not reorder it. Every miner with at least 100 blocks in the last 30 days signs it, and the checkpoint locks when signatures representing two thirds of the active mining weight arrive. A locked checkpoint overrides the heaviest chain, so no amount of fresh hashrate can reorganise past it.</p>
<div class="pull">The word sustained is the whole defence. Block rewards go to whoever mines, new or old. The right to lock history is earned.</div>
<p>A miner's vote weight is simply the blocks it has mined over the trailing 30 days, measured by work, so splitting into many keys buys nothing and joining a pool costs nothing. Hashrate that arrived today holds almost none of it. Even an attacker who brought the whole network's hashrate would need ten days of mining in public to hold a third of the weight, and twenty days to hold two thirds. At 51% of the network they never reach two thirds at all while the honest miners keep mining. Rental is priced by the hour. The only route left is to drive honest miners off the chain and hold two thirds for a month on the public hashrate charts, which is the same limit Bitcoin lives with, with a month's warning attached.</p>
<p>Two further rules close the gaps. Only miners who are present count: a key that stops signing drops out of the denominator within two hours, so a silent minority cannot freeze finality and a lock never waits for miners who have left. And Kaspa's one-hour merge-depth bound limits any reorganisation beneath the latest lock. Signing two different checkpoints at the same height is equivocation, provable by anyone, and it strips the key of its vote for 30 days.</p>
<h3>What is not here</h3>
<p>No stake. No coin-holder class votes on anything. No anchoring into Bitcoin or any other chain. Nothing in Igneum's consensus depends on anything outside Igneum.</p>
</section>
<section id="building">
<h2>Building on Igneum</h2>
<p>Anything that runs on Ethereum runs on Igneum unchanged. Same Solidity, same bytecode, same wallets, same tools, a different chain id. Builders get Ethereum semantics with one-second inclusion, finality in about two minutes, and gas priced for a chain that is not congested.</p>
<p>Three things run on Igneum that run nowhere else.</p>
<ol>
<li><strong>Proving as a native primitive.</strong> A contract can request a proof of any computation and pay for it in gas, and the miners produce it. A game proves a fair shuffle. A lending market proves its solvency. A rollup elsewhere posts a job and gets its proof back. No other EVM chain has a prover network in its base layer.</li>
<li><strong>Trustless light clients.</strong> Because every block is proven, a phone or a browser verifies Igneum's state by checking one proof and the latest locked checkpoint. Bridges built on that need no multisig, the piece that has failed in the biggest bridge hacks.</li>
<li><strong>Rollups that settle here.</strong> A rollup posting to Igneum gets its proofs from the same miners that secure it, in the same flow. Settlement and proving in one place costs less than paying a proving network and a settlement layer separately.</li>
</ol>
<p>The first apps, a DEX, a lending market and an Ethereum bridge, ship at genesis so there is somewhere to use the coin from day one.</p>
<h3>What a builder gets for being early</h3>
<ul>
<li><strong>Apps earn the gas they generate.</strong> 15% of every transaction's priority fee goes to the contracts whose code ran, by gas consumed inside each, paid every block to the developer address registered at deployment. Canto and Blast proved builders come for this. On Igneum it comes out of fees, never out of miner emission.</li>
<li><strong>Stablecoins at genesis.</strong> USDC and USDT bridged through the proof bridge, canonical versions on Igneum, the way Arbitrum and Base launched. Native USDC is requested from Circle during public testnet. Igneum issues no stablecoin of its own.</li>
<li><strong>Liquidity from the people who are there.</strong> The DEX is seeded by the founders' own mined coins and by miners, and every miner is a funded wallet from day one.</li>
<li><strong>Launch grants.</strong> Paid from the founders' own mined coins, never from emission, to the first apps that bring users.</li>
<li><strong>A minute of proof lag costs you nothing.</strong> Execution is immediate, the block is locked by miners in about two minutes, and the proof is a guarantee on top. A bridge withdrawal waits for the lock, about two minutes, against seven days on an optimistic rollup.</li>
</ul>
</section>
<section id="economics">
<h2>Economics</h2>
<p>The coin is IGN. It is gas, it is the proving currency, and it is what every outside customer pays in. Part of every payment is burned.</p>
<h3>Supply</h3>
<p>Fair launch. No premine, no pre-sale, no allocation to anyone. Hard cap of 4 billion IGN, approached and never reached, because emission starts at 1 billion a year and halves every two years for ever. Nearly a quarter of all supply is mined in the first year and half in the first two, so the people who show up early get the most. Emission ramps from 10% to 100% over the first 30 days so that nobody takes the first month before the rest of the world hears about it.</p>
<div class="figure">
<svg viewBox="0 0 760 300" role="img" aria-label="Half of the 4 billion cap is mined in the first two years" font-family="IBM Plex Mono, monospace" font-size="12">
<text x="40" y="26" font-family="IBM Plex Sans, system-ui, sans-serif" font-size="15" font-weight="600" fill="var(--ink)">Half of the 4 billion cap is mined in the first two years</text>
<text x="40" y="46" fill="var(--quiet)">Millions of IGN issued per year, halving every two years for ever</text>
<line x1="40" x2="720" y1="250" y2="250" stroke="var(--line)"></line>
<g fill="var(--ember)">
<rect x="51" y="70" width="34" height="180" rx="3"></rect><rect x="108" y="70" width="34" height="180" rx="3"></rect>
</g>
<g fill="var(--surface-2)" stroke="var(--line)">
<rect x="164" y="160" width="34" height="90" rx="3"></rect><rect x="221" y="160" width="34" height="90" rx="3"></rect>
<rect x="278" y="205" width="34" height="45" rx="3"></rect><rect x="334" y="205" width="34" height="45" rx="3"></rect>
<rect x="391" y="227.5" width="34" height="22.5" rx="3"></rect><rect x="448" y="227.5" width="34" height="22.5" rx="3"></rect>
<rect x="504" y="238.7" width="34" height="11.3" rx="3"></rect><rect x="561" y="238.7" width="34" height="11.3" rx="3"></rect>
<rect x="618" y="244.4" width="34" height="5.6" rx="3"></rect><rect x="674" y="244.4" width="34" height="5.6" rx="3"></rect>
</g>
<g fill="var(--ink)" text-anchor="middle">
<text x="68" y="62">1000</text><text x="125" y="62">1000</text><text x="181" y="152">500</text><text x="238" y="152">500</text><text x="295" y="197">250</text><text x="351" y="197">250</text><text x="408" y="220">125</text><text x="465" y="220">125</text><text x="521" y="231">63</text><text x="578" y="231">63</text><text x="635" y="237">31</text><text x="691" y="237">31</text>
</g>
<g fill="var(--quiet)" text-anchor="middle">
<text x="68" y="270">1</text><text x="125" y="270">2</text><text x="181" y="270">3</text><text x="238" y="270">4</text><text x="295" y="270">5</text><text x="351" y="270">6</text><text x="408" y="270">7</text><text x="465" y="270">8</text><text x="521" y="270">9</text><text x="578" y="270">10</text><text x="635" y="270">11</text><text x="691" y="270">12</text>
</g>
<text x="720" y="290" text-anchor="end" fill="var(--quiet)">Year after launch</text>
</svg>
<div class="cap">Emission schedule, fixed in consensus. 3,938M IGN in the first 12 years of a 4,000M cap.</div>
</div>
<h3>Where every coin of emission goes</h3>
<div class="tbl"><table>
<thead><tr><th>Share</th><th>Goes to</th><th>Why</th></tr></thead>
<tbody>
<tr><td class="num">80%</td><td>The miner who wins the block</td><td>Pays the hashrate that secures the chain</td></tr>
<tr><td class="num">20%</td><td>The proving pool: shard provers and aggregators</td><td>Pays a standing prover population that does not have to hash</td></tr>
<tr><td class="num">0%</td><td>Treasury, foundation, team or stake</td><td>There is no coin-holder class in consensus and no tax on emission</td></tr>
</tbody>
</table></div>
<h3>Where the price comes from</h3>
<p>The base fee of every transaction is burned in full, Ethereum's rule, so a miner cannot fill blocks with its own transactions for free. The priority fee splits four ways: 65% to the miner and provers of that block, 15% to the apps whose code ran, by gas consumed inside each, 15% burned, 5% to the development fund. External proving fees burn 10%. The hard cap fixes supply. Demand comes from use of the chain and from outsiders buying proofs, and both reduce supply as they happen. Emission is untouched by any of this: every coin minted still goes to miners and provers.</p>
<h3>Development, paid by outsiders and controlled by miners</h3>
<p>5% of gas and 5% of external job fees go to a development fund held in a contract. Not one coin of emission goes to it, so miners are never taxed. Spending from it needs 60% of hashrate signalling yes over two weeks. Miners hold the purse. The users and rollups who want Igneum to keep improving fill it.</p>
</section>
<section id="miners">
<h2>For miners</h2>
<p>Igneum is built for the GPU fleet that has had no home since 2022. Here is what it offers and what it asks.</p>
<h3>Three income streams, one balance</h3>
<div class="tbl"><table>
<thead><tr><th>Stream</th><th>Paid by</th><th>Moves with the IGN price?</th></tr></thead>
<tbody>
<tr><td>Block reward</td><td>Emission, 80% to the winner</td><td>Yes</td></tr>
<tr><td>In-chain proving</td><td>The 20% proving pool plus the proving share of every block's gas</td><td>Yes, mostly</td></tr>
<tr><td>External proving jobs</td><td>Rollups and apps on other chains, priced in their money</td><td>No, but the market is small today and is upside, not a promise</td></tr>
</tbody>
</table></div>
<p>The honest bear-market case rests on cost. A miner's card is already running and the power is often domestic, so Igneum miners have the lowest marginal cost in the proving market and are the last provers to switch off.</p>
<h3>Hardware</h3>
<p>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.</p>
<h3>What a miner's hour looks like</h3>
<p>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 official client is open source and charges a 1% dev fee, like every miner you already run, and any other client is welcome.</p>
<h3>One click, for everyone else</h3>
<p>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. 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.</p>
<h3>Fair launch, announced</h3>
<p>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.</p>
</section>
<section id="governance">
<h2>Governance</h2>
<p>Igneum is governed by the people who power it, and by nobody else.</p>
<ul>
<li><strong>Nothing needs a scheduled upgrade.</strong> The mining program, the dataset and the finality rules run themselves for ever. If the community ever ships an improvement, a better proof system or a block-rate step, it is published with test vectors at least three months ahead and activates only when 90% of blocks signal readiness. Developers can write code. Only miners can turn it on.</li>
<li><strong>The development fund is spent by miners.</strong> Every proposal passes or fails on 60% of hashrate signalling over two weeks, and the fund is filled by fees, never by emission.</li>
<li><strong>Pools cannot censor.</strong> Igneum uses Stratum v2 from day one, so each miner chooses its own transactions even inside a pool.</li>
<li><strong>There are no admin keys.</strong> Nothing in consensus can be paused, upgraded or reversed by any key. There is no foundation allocation to vote with and no stake to buy.</li>
<li><strong>The chain runs without its founders.</strong> Blocks, proofs and finality need no one. Upgrades need a second independent node client, funded from the development fund as its first priority.</li>
</ul>
</section>
<section id="roadmap">
<h2>Roadmap</h2>
<p>Thirteen months from specification to a fair launch, with four public gates. Each gate is a measurement published whether it passes or fails. Miss it and the phase repeats or the project stops.</p>
<div class="tbl"><table>
<thead><tr><th>Phase</th><th>When</th><th>What</th><th>Gate to pass</th></tr></thead>
<tbody>
<tr><td>1. Specification</td><td class="num">Oct to Nov 2026</td><td>Mining generator, shard proving, finality rules, written for external review</td><td></td></tr>
<tr><td>2. Prove the proving</td><td class="num">Nov 2026 to Jan 2027</td><td>Mining program prototype on GPU and CPU, shard proving benchmark on consumer cards</td><td>A mid-range GPU proves a shard in under 20 s and a CPU verifies a hash in 10 ms</td></tr>
<tr><td>3. Devnet</td><td class="num">Feb to Mar 2027</td><td>BlockDAG node with the new mining program and EVM execution, 20 nodes</td><td>1 block a second held with proofs under 60 s behind the tip</td></tr>
<tr><td>4. Finality and job market</td><td class="num">Apr to Jul 2027</td><td>Sustained-mining finality, external proving jobs, miner client with auto-switching</td><td>Finality design passes external review and one rollup signs for testnet</td></tr>
<tr><td>5. Public testnet</td><td class="num">Aug to Oct 2027</td><td>One-click miner app on Windows, macOS and Linux, HiveOS, pools, the first rollup as a proving customer, no coin yet</td><td>1,000 independent miners run 30 days and rollup proofs are delivered on time</td></tr>
<tr><td>6. Mainnet fair launch</td><td class="num">Nov 2027</td><td>Genesis with no premine, 30-day ramp, exchange listings after</td><td></td></tr>
</tbody>
</table></div>
<p>Phase two decides everything. If consumer GPUs cannot prove shards fast enough, Igneum says so and does not launch on promises.</p>
</section>
<section id="miners-ask">
<h2>Questions miners ask</h2>
<h3>Kaspa said ASIC resistant too, and IceRiver shipped a chip in eighteen months.</h3>
<p>Kaspa's hash was one fixed function, simple enough to put on silicon. Igneum's program is different every hour, its dataset grows past any fixed memory, and its program space widens every era, with no human involved. In January 2027 the benchmark tool is public, so you run it on your own card and post the number to a leaderboard by card model. A standing bounty pays anyone who can show a chip design that beats a GPU by more than 2x. And if a chip ever appears, miners are the ones who signal the response.</p>
<h3>Finality weighted by mining history is new. New gets attacked.</h3>
<p>Correct, and it is the first thing the external review is paid to break. The specification is public, the review is gate 3 with named reviewers and a bounty, and the chain runs on plain GHOSTDAG without it, so the rule can be fixed without stopping the chain.</p>
<h3>Who are you?</h3>
<p>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.</p>
<h3>Where is the miner?</h3>
<p>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.</p>
<h3>Will my card still pay in a bear market?</h3>
<p>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.</p>
</section>
<section id="builders-ask">
<h2>Questions builders ask</h2>
<h3>Proof of work, in 2027?</h3>
<p>Igneum's miners are paid for proving, not only for hashing, so the energy buys a proof of every block as well as the ordering of it. Proof of work also gives what stake cannot: no stake to capture, no builder cartel between you and the block, no foundation that can change the rules, and a chain whose state is proven at the base layer, which Ethereum does not have today.</p>
<h3>What does a one-minute proof mean for my app?</h3>
<p>Nothing you wait for. Your transaction executes in about a second. A miner lock arrives in about two minutes and that is the finality your contract sees. The proof follows and makes the state unforgeable. Liquidations and trades act on executed state at once, as on any chain. Bridge withdrawals wait for the lock, about two minutes.</p>
<h3>Which stablecoin, and is there liquidity?</h3>
<p>USDC and USDT, bridged through the proof bridge at genesis as the canonical versions on Igneum. Native USDC is requested from Circle during testnet. The DEX is seeded at launch by the founders' own mined coins and by miners, and every miner is a funded wallet.</p>
<h3>What do I get for being early?</h3>
<p>15% of the priority fee on every transaction that runs your code, paid to you every block. Launch grants from the founders' mined coins. A place in the wallet's Apps tab and the explorer from day one. And the only user base a new chain has ever had that did not have to be paid to arrive.</p>
<h3>How do I deploy?</h3>
<p>Point Hardhat or Foundry at an Igneum node with the chain id and deploy the same bytecode. Verify the source in the explorer. Register a developer address for the gas share. The afternoon is the hard part.</p>
</section>
<section id="limits">
<h2>What Igneum does not claim</h2>
<p>Here are the limits, stated before anyone else states them.</p>
<ul>
<li><strong>A proof in seconds.</strong> Not at launch. Proving a full block today needs a cluster of 100 to 200 consumer GPUs, approximate, so Igneum launches with proofs within about a minute and tightens as hardware improves. Users still see their transaction land in one second.</li>
<li><strong>A chip is impossible.</strong> No. A chip is pointless, because the target moves before it ships. The honest efficiency ceiling for a fixed chip on a memory-bound program is under 2x, approximate, and Igneum's generator changes under it every hour.</li>
<li><strong>A guaranteed income floor.</strong> No. External proving is a small market today. Igneum's miners have the lowest cost in it, which is an edge and nothing more.</li>
<li><strong>Finality that no amount of hardware can break.</strong> No. A miner holding a third of the last 30 days of blocks can split finality during a network partition, and two thirds can lock a bad checkpoint for a double-spend bounded to one hour. Reaching a third takes at least ten days of the whole network's hashrate, in public. That is harder than attacking Bitcoin, where a majority can reorganise at once, and it is the limit of proof of work without stake or an outside chain. Igneum chose those limits on purpose.</li>
<li><strong>A finished protocol.</strong> The sustained-mining finality rule is the newest piece and the one that external review will try hardest to break. The specification, the review and the benchmarks are published as they happen.</li>
</ul>
<p>Everything in this document is subject to the gates on the roadmap. Nothing in it is an offer to sell anything.</p>
</section>
</article>
</div>
<footer class="foot">
<div class="brand"><svg viewBox="0 0 100 100" width="22" height="22" aria-hidden="true"><polygon points="50,4 74,34 67,58 80,54 61,96 39,96 20,54 33,58 26,34" fill="var(--ember)"></polygon><polygon points="50,42 59,58 50,82 41,58" fill="var(--ground)"></polygon></svg><span style="font-family:'Unbounded',sans-serif;font-weight:700;font-size:14px;letter-spacing:.06em;color:var(--ink)">IGNEUM</span></div>
<div>Litepaper v0.1 · 3 October 2026 · Mined by GPUs. Proven by fire.</div>
</footer>
</div>
</body>
</html>

13
site/vercel.json Normal file
View file

@ -0,0 +1,13 @@
{
"cleanUrls": true,
"trailingSlash": false,
"headers": [
{ "source": "/(.*)", "headers": [
{ "key": "X-Content-Type-Options", "value": "nosniff" },
{ "key": "X-Frame-Options", "value": "DENY" },
{ "key": "Referrer-Policy", "value": "strict-origin-when-cross-origin" },
{ "key": "Strict-Transport-Security", "value": "max-age=63072000; includeSubDomains; preload" }
] },
{ "source": "/journey.json", "headers": [ { "key": "Cache-Control", "value": "public, max-age=300" } ] }
]
}