A whole network,
earned not purchased
Astrolune is a network with its own consensus, virtual machine, two-tier contract language system and coin. A node's standing comes from uptime and observable behaviour — there is no hashrate to buy and no stake to outbid.
Pre-mainnet — the consensus core is written and tested; the networking layer has not been started.
Measured in milliseconds,
earned in days
/ 01
0 ms
BLOCK TIME
…up to 1 s with a real VDF
/ 02
0
COMMITTEE SIZE
10% rotated every block
/ 03
0 day
EPOCH LENGTH
Trust graph recomputed
/ 04
0 / 100
QUORUM
⌊2n/3⌋ + 1 signatures
Block time is an honest range, not a promise: the light-randomness branch lands near 400 ms, a proper VDF nearer a second. Which one ships is decided by measurement.
One system,
built in layers
Astrolune is not a single idea but a stack: a consensus that cannot be bought, a deterministic virtual machine, a two-tier language system, and a coin with no floating point anywhere near it. Each layer is documented — including where the specification admits a hole.
Two language tiers,
one bytecode
Trocto closes the common contract vulnerability classes at the compiler level and compiles into Regol. Regol is both the low-level tier and the intermediate representation, so nothing is hidden from an author who needs control.
1contract Token {2 state {3 name: string,4 total_supply: u64,5 balances: map<address, u64>,6 }78 // called once, at deployment9 init(name: string, initial_supply: u64) {10 self.name = name;11 self.total_supply = initial_supply;12 self.balances.insert(sender(), initial_supply);13 }1415 pub fn transfer(&mut self, to: address, amount: u64) -> Result<(), Error> {16 require(self.balances[sender()] >= amount, Error::InsufficientBalance);17 require(to != address::zero(), Error::InvalidAddress);1819 self.balances[sender()] -= amount; // overflow-checked by default20 self.balances[to] += amount;2122 emit Transfer { from: sender(), to, amount };23 Ok(())24 }25}Lune pays for
block space
Amounts are unsigned 64-bit integers with nine decimals — balances need no wide arithmetic and no floating point exists anywhere in execution or accounting.
TICKER
LUNE
DECIMALS
9
BASE UNIT
10⁻9 LUNE
AMOUNT TYPE
u64
Block reward split
The operational bond buys a share of one bucket and nothing else. It carries no consensus weight — that is the line that keeps PoTB from quietly becoming Proof of Stake.
What the network
gives you
Every entry below is a working page, served from a local fixture until an RPC endpoint exists to serve it for real.
Five steps,
honestly stated
The plan of record, with each step's real state rather than its intended one.
STEP 01
01 / 05
PoTB consensus core in C
In progressThe complete weight formula, committee selection with partial rotation, commit-reveal seeds, slashing relative to the network median, rewards. Pure functions, no clock read, ~29,800 assertions over the arithmetic.
STEP 02
02 / 05
VM, state and transaction layers
BlockedPresent and plausible rather than verified: 16 opcodes, gas metering, accounts, state root, encode/decode/apply. The word size is still open, and an interpreter written before it is settled gets rewritten.
STEP 03
03 / 05
C++23 tooling — the Trocto compiler
BlockedThe C/C++ boundary check landed first: eleven public headers compiled as C++23, 172 symbols pinned, the layout contract asserted in both languages.
STEP 04
04 / 05
Build system, tests and CI
Partly doneCMake with six presets, layering enforced as link edges, ten suites. CI does not exist yet, and coverage for the VM and state layers is thin — the tree says so out loud.
STEP 05
05 / 05
Documentation and the language spec
Partly doneEverything that exists is documented, including seven code-versus-spec divergences. The Trocto specification is the remaining piece.
Questions,
answered plainly
Written to match the specification, including where the specification admits a hole.
Weight is not purchasable. Stake buys consensus weight in PoS; in PoTB the only inputs are uptime, correctness, the trust graph, ASN diversity and a correlation penalty. A voluntary operational bond exists, and it deliberately affects one reward bucket while carrying no weight at all.
No, by design. The network has its own virtual machine and its own two-tier language system. EVM compatibility would import both the 256-bit word and the EVM gas schedule, and neither fits a core built on 64-bit amounts and integer-only arithmetic.
Not in the sense that phrase usually means. There is no delegation market and no APY on capital. Rewards go to committee members: 60% split equally, 25% by earned weight, 15% by operational bond. The bond is evidence of infrastructure spend, not a claim on consensus.
Four things, recorded as open in the specification: non-domination is not mathematically proven; the trust graph and the correlation dampener are heuristics; time as a barrier can be bought in advance by starting a farm early and waiting; and network diversity is evadable with a proxy budget.
No. The consensus arithmetic is implemented and tested, the VM and state layers exist and are thinly tested, and the networking layer has not been started. The signature backend compiled in today is an insecure stub and reports itself as one.
In this docs section, generated from the same source the core is built against. Where a header and a document disagree, the header is correct — and every known disagreement is listed rather than quietly fixed.
RUN A NODE
Weight is earned.
Start earning it.
Build the client, start relaying, and let the trust graph do the rest. No capital required at any level.
https://rpc.testnet.astrolune.networkAstrolune has not launched. Every figure below is a fixture for interface work, not network telemetry.