Open-source Rust firmware for BM1370/BM1373 miners (Bitaxe, NerdQAxe++, NerdOctaxe, NerdAxe Gaia, BitForge Nano): AxeOS-compatible API, Stratum V1 + V2, signed online updates, one image for all boards. https://warppool.org/warpaxe
  • Rust 75.3%
  • HTML 17.5%
  • C 5.4%
  • Python 1.2%
  • Shell 0.5%
Find a file
dvb-projekt ea0c1f7ccc
All checks were successful
CI / Rust checks (push) Successful in 2m19s
CI / Regulator scenarios (push) Successful in 1m0s
README: screenshot of the clock per chip on the dashboard
Taken on a NerdQAxe++ on v0.1.47 through a read-only proxy that added
example offsets and replaced the worker address.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 15:00:21 +01:00
.github/workflows New crate warpaxe-drivers (MIT OR Apache-2.0): the eight board drivers that follow no GPL reference code 2026-11-16 12:19:34 +01:00
crates Merge branch 'feat/chip-clock-display': clock per chip on the dashboard, with who set it and when 2026-11-19 10:20:48 +01:00
docs README: screenshot of the clock per chip on the dashboard 2026-11-19 15:00:21 +01:00
firmware Prepare v0.1.47: version bump, README status and badge 2026-11-19 10:34:41 +01:00
tools Prepare v0.1.47: version bump, README status and badge 2026-11-19 10:34:41 +01:00
web/flasher flasher: board version and chip only stop the install when no model is stored 2026-11-19 12:10:38 +01:00
.gitignore feat(avalon): decaying MHS 15m, write verification in the bench, A/B live 2026-09-23 09:17:28 +02:00
Cargo.lock EMC2101: emc2101 crate 4.2 – set_fan_power reads Fan Config once, not on every fan write 2026-11-16 18:47:24 +01:00
Cargo.toml New crate warpaxe-drivers (MIT OR Apache-2.0): the eight board drivers that follow no GPL reference code 2026-11-16 12:19:34 +01:00
LICENSE feat: workspace, CRC-5/16 and BM13xx framing with golden vectors 2026-09-23 06:43:59 +02:00
README.md README: screenshot of the clock per chip on the dashboard 2026-11-19 15:00:21 +01:00

dvb-WarpAxe

Open-source Rust firmware for BM1370, BM1373 and BM1397 Bitcoin miners
Runs on Bitaxe Gamma · NerdQAxe++ · NerdOCTAXE-γ · NerdAxe Gaia · BitForge Nano · NerdNOS · Bitaxe Naja Duo
profiles for 6 more boards · experimental on the T-Display-S3 · Stratum V1 + V2 · AxeOS-compatible API · Signed online updates

License Rust Tests Chip Release

Source on git.warppool.org · Mirror on GitHub (issues and pull requests welcome)


dvb-WarpAxe is a from-scratch firmware for ESP32-S3 miners with BM1370, BM1373 and BM1397 ASICs, written in Rust. It replaces AxeOS (Bitaxe), NerdOS (the Nerd boards), ForgeOS (BitForge Nano) and the NerdNOS's NerdMiner-based firmware on the device and speaks their HTTP API, so dashboards, tuners and fleet tools that talk to a Bitaxe keep working — including WarpTune, the clock-and-voltage tuner of dvb-WarpPool.

It does what the stock firmware does — Stratum V2 with the pool's authority key checked, Stratum V1 over TLS (a pool on its own certificate after one click), a fallback pool that hands back to the main pool — and differs where it counts for running a fleet: signed online updates the miner fetches and checks itself, one image for every board with the board found on the first start and Wi-Fi and pool taken over from the previous AxeOS, NerdOS or ForgeOS settings, a password-protected setup hotspot when there is no network to join, a regulator and sensor layer that rejects implausible readings instead of acting on them, the web UI over the USB cable as well as over Wi-Fi, and one web UI in eight languages for the Bitaxe and the Nerd series. The device display has animated special screens (yes, a found block gets a warp jump), and the web UI shows a found block in a banner. See Compared with the stock firmware for where it is ahead and where it is not.

The chip protocol, the chain driver and the board drivers are no_std crates that run under cargo test against a simulated chain and a scripted I²C bus, so most of the firmware is tested on a laptop before it touches a miner.

Status: early (v0.1.47). It mines 24/7 under WarpTune on five boards, one of each: Bitaxe Gamma (since 25 September), NerdQAxe++ (Rev 6.1, on Stratum V2), NerdOCTAXE-γ (Rev 3.1, 6-phase regulator, since 28 September), NerdAxe Gaia and BitForge Nano (since 29 September); since 8 October also a NerdNOS (BM1397), its clock set by hand, and since 12 November a Bitaxe Naja Duo. Six more boards have a profile; of these the Bitaxe Gamma Duo and Gamma Turbo have run it at a user's; so has a NerdOCTAXE-γ v2.2 with the 4-phase regulator — see Supported boards before you flash.

Compared with the stock firmware

As of 2026-11-16, against ESP-Miner/AxeOS v2.15.4, ESP-Miner-NerdQAxePlus (NerdOS) v1.1.2 and ForgeOS v1.8 (the BitForge Nano's firmware, built on ESP-Miner), from their source. All three move fast; corrections welcome.

AxeOS NerdOS ForgeOS WarpAxe
Stratum V2 (Noise, authority key, "require authentication") yes yes yes (since v1.8; standard or extended channel, not in dual-pool mode) yes
Stratum V1 over TLS, certificate checked yes yes yes (on in the factory settings) yes
Pool on a self-signed certificate over TLS (WarpPool on Umbrel) yes: "TLS (Custom CA)", the certificate is uploaded no (TLS on or off, checked against the built-in bundle only) over the API only: a TLS mode with a pasted certificate (stratumCert); its entry on the Pool page is commented out in the source yes: the miner shows the fingerprint of the pool's key, one click on the Pool page trusts it; a pool whose own certificate changes its key never connects until confirmed again
TLS trust store after the eMudhra incident (October 2026) curl's pinned extract of 2026-10-20 since v2.15.4 (not yet on the main branch) curl's pinned extract of 2026-10-20 since v1.1.1; a cross-signed copy of one of its roots accepted since v1.1.2 ESP-IDF's bundle without the eMudhra/emSign roots since v1.8; certificate dates checked (TLS waits up to 15 s for NTP, no connection without a clock) curl's pinned extract of 2026-10-20 since v0.1.40, checked in the release build; since v0.1.41 without the last eMudhra root emSign Root CA - G1 (117 roots left), and certificate dates checked once NTP has set the clock (TLS waits up to 15 s for it in the first five minutes; without a clock Stratum V1 over TLS connects with the dates unchecked, Stratum V2 with "require authentication" waits for the clock)
Fallback pool, back to the main pool on its own yes yes (plus dual-pool mode) yes (plus dual-pool mode) yes
IPv6 for pool connections an IPv6 address from the router (SLAAC); a pool name with both A and AAAA records goes over IPv4 (issue #1472); IPv6 first with IPv4 fallback is PR #2105, on hold not checked not checked yes, since v0.1.46: IPv6 first, IPv4 at most a quarter second later (Happy Eyeballs), IPv6 literals with or without brackets, a switch on the Network page; over IPv6 the web UI answers only the local network (docs/17)
Chips switched off while no pool is reachable yes: once every configured pool has failed its retries (core voltage 0, held in reset, fans at 30 %); a pool is probed every 30 s and mining resumes when one answers not found (with no share answer for an hour, the watchdog restarts the miner) yes since v1.8: after three failed attempts on each pool (core voltage 0, held in reset); a pool is probed every 30 s, the chips are set up again when one answers; poolsUnavailable in the API and a notice on the dashboard yes since v0.1.42: after two failed attempts on each configured pool and a minute (core voltage 0, held in reset, fans at their lowest duty); both pools are probed in turn every 30 s, the chips are set up again when one sends work; poolsUnavailable in the API, a notice on the dashboard and the display; not while a self-test runs
Update: miner fetches the release itself no (download, then upload) yes (from GitHub) yes (from GitHub) yes (from the release page, install on a click)
Update image signature-checked before flashing no no no yes (BIP-340, key built into the firmware)
An update that does not start falls back to the previous version no (the bootloader's rollback option is off) no no yes, from the bootloader of v0.1.22 on (one reinstall over USB writes it)
Images factory image per board version (update image shared) one per board one factory image (one board), plus a firmware and a web-UI image for updates one for all boards
Board set in NVS at the factory per image set in NVS at the factory (one board) found on the first start (factory NVS, read-only I²C probe); a board chosen by hand is checked against the bus before any of its pins is driven, and its chips are counted at a cautious voltage before the choice is confirmed (docs/11)
Settings on an update or reinstall kept on online update; web flasher can keep them kept with the update's "keep settings" option kept on online update; reinstalling the factory image resets them kept on online update and web-flasher reinstall; taken over from AxeOS, NerdOS and ForgeOS when switching (Wi-Fi, pools including AxeOS 2.15's saved list, hostname, clock and voltage, fans and temperature limits, display)
Pool changes without a restart no (the page asks for a restart; instant switching is on ESP-Miner's main branch) yes no (the page asks for a restart) yes
Saved pools (more than main + fallback) yes (up to 8; main and fallback picked from the list, then a restart) no (main + fallback) no (main + fallback) yes (up to 8, each with its coin; one click makes one the main pool, no restart; AxeOS 2.15's list taken over)
Who a found block pays (coinbase outputs, your share) yes, partly (up to six outputs and the total; your share; Bitcoin addresses only, matched as text, unit BTC) opt-in (your share and a fee check; Bitcoin addresses only, unit BTC) yes, partly (up to six outputs and the total; your share not marked; Bitcoin addresses only, unit sats) yes (up to 32 outputs, yours first, the rest summed; your share; the address decoded for any SHA-256 coin, CashAddr included, unit the pool's coin; "paid by the pool" for a pool account; job lines up to 512 KiB since v0.1.41)
A found block a banner ("Today is your lucky day!") with the count until dismissed, for every browser (the dismiss is stored on the miner); blockFound since the start and a showNewBlock flag; nothing kept across a restart; "!!! BLOCK FOUND !!!" on the display nothing in the web UI (an opt-in Discord/webhook alert); foundBlocks since the start and totalFoundBlocks all time in the API, the total kept in NVS, no height or time; a full-screen image on the display until a key press since v1.8 a banner with the block's status (waiting, built on by the pool, or left behind by the chain), time and a mempool.space link, until cleared in the settings; blocksFound, lastBlockHash, lastBlockStatus, lastBlockTime in the API, kept in NVS a banner with height, coin and time (gold confetti) until dismissed in that browser, also after a restart; the all-time count in the best-difficulty tile; blockFound since the start, blocksFoundTotal and lastBlock (height, time, coin, and since v0.1.42 hash and status: pending, confirmed once the pool's next work builds on it, orphaned when the work for the next height builds on another block, unknown when the miner was offline in between) in the API, kept in NVS; the banner shows the status and the hash, with a mempool.space link for Bitcoin; entries in the event log for the find and for the status; a warp jump on the display; a block whose height does not fit Bitcoin (below 900,000) while the coin setting says BTC is flagged with a hint to check the Coin setting (since v0.1.45; coins that share Bitcoin's history, such as BCH, have similar heights and are not flagged, while regtest, signet and testnet4 always are)
Chip error rate on the dashboard yes (next to the hashrate) no (per chip in the API since v1.1.1: errorHashRate in /api/v2/dashboard) no yes (next to the hashrate; per chip and domain optional)
Chips that stop returning nonces reported per chip (hashrateMonitor), no reaction, also not when all stop reported per chip; with no share answer from the pool for an hour, a watchdog restarts the miner not found all chips silent for a minute: the chain is restarted; one chip silent for ten minutes while the others hash: the chain is restarted too (at most once an hour, the chip left alone after three restarts that do not hold; since v0.1.40)
One hash domain of a chip stuck while the chip hashes reported per domain (hashrateMonitor), judged in the self-test only reported per domain, no reaction not found a domain under 25 % of the chip's other domains for ten minutes, or since v0.1.42 under 5 % three minutes after the chain came up: the chips are switched off and on (at most one intervention an hour, shared with the silent-chip restart; the domain left alone after three that do not hold, until a new clock or voltage or the next boot; since v0.1.41)
Self-test yes, instead of mining: after a factory flash (NVS flag) or with the boot key held; a mock job, 30 s hashrate and per-domain counters, core and input voltage, power, fan, temperature; stops at the first failure; PASS/FAIL on the display only factory flash only (NVS flag), at boot before Wi-Fi: chips found vs expected; input power and core voltage as warnings; hashrate not checked; result on the display only factory flash only (NVS flag), instead of mining: PSRAM, input, regulator, reference voltages, chips found vs expected, 5 s hashrate (at least 40 % of expected), core voltage, power; result on the two LEDs only yes, while mining, on a click (without work from a pool the hash checks are skipped, not failed): ten checks with their figures (chips, hash counters per chip and domain, error rate, core voltage, regulator, each phase of a stacked regulator, fan, temperatures, input) in the web UI, on the display and in the API (docs/10)
Diagnostics file for support no (log download, up to 512 KB kept on the device) no (log download of what the open log view received) no (log download of what the open log view received) yes: one JSON with state, settings (no passwords, addresses masked), self-test, events and the last log lines; the core dump as a second download (passwords, Wi-Fi name and worker names masked since v0.1.38, MAC addresses down to the maker's prefix since v0.1.43)
Event log across restarts no (last reset reason; the log survives a soft restart, not a power cycle) no (last reset reason; optional Discord alert after a no-share reboot) no yes: the last 32 events with time (restarts with reason, overheat and regulator stops, pool switches, updates, rollbacks, silent chips, self-tests, board checks, found blocks) in NVS, shown in the web UI's language
Notice after a crash no (reset reason on the System page) no (reset reason on the System page) no yes: a banner after a panic or watchdog, with the reason, the time, the diagnostics file and the core dump if this crash wrote one, until dismissed
Overheat stop lines chip 75 °C, regulator 105 °C, fixed chip 70 °C (a setting, 50–90), regulator 70 °C on the two-fan boards, none on the one-fan NerdAxe boards chip 75 °C (either of the two chips), regulator 105 °C, fixed the stock firmware's lines per board (docs/08); the chip line a setting (50 °C up to the board's line; on the NerdOS boards up to 90), the regulator's fixed per board (105 °C on the Bitaxe boards, the BitForge Nano and the one-fan NerdAxe boards, 70 °C on the two-fan Nerd boards as NerdOS); the Nano's chips read on ForgeOS's diode scale since v0.1.36
Back on after an overheat stop yes (≥ 30 s, regulator 10 °C cooler, then voltage 100 mV and clock 100 MHz lower) no (board error until reboot) yes (restarts at once, without a cool-down, at 1000 mV and 50 MHz with the fans at 100 %; clock and voltage set back by hand) yes (≥ 60 s, chip and regulator 10 °C cooler, at the configured point; the third stop within an hour stays off)
Regulator fault (PMBus STATUS_WORD) reported (power_fault), no reaction read once at init, logged reported (power_fault), no reaction reported (power_fault with codes, display and web UI) and treated like an overheat stop: core voltage off, faults cleared and retried after a minute, the third within an hour stays off
Wi-Fi setup without a network open hotspot (Bitaxe_XXXX), or Bluetooth open hotspot (Nerdaxe_XXXX) open hotspot (Nano_XXXX) for seven minutes after every start, even with Wi-Fi set up; or Bluetooth in the same window WPA2 hotspot, password shown only on the device display
Implausible sensor/regulator readings partly ignored (fan loop) not found partly ignored (fan loop and overheat check skip a failed chip-sensor read) rejected before the control loops see them
Chip hash counters (per chip, per domain, errors) yes (hashrateMonitor; on the BM1373 four of eight domains, doubled; all eight on ESP-Miner's main branch) total only total only (counted per chip and domain, errors too, but not shown) yes, AxeOS's fields plus a one-minute error rate; all eight BM1373 domains
Found by name on the network (mDNS <hostname>.local, _http._tcp with the _axeos subtype) yes yes no (DHCP hostname only) yes (from v0.1.28)
Web UI over the USB cable not found not found not found yes (USB network adapter, 192.168.7.1)
ASICs off and on again without a restart yes (pause / resume) off only; on again needs a restart no yes
Clock no NTP; set from the pool's job time NTP with fixed servers and a fixed time zone (Berlin), no status shown NTP (pool.ntp.org, fixed) since v1.8, also set hourly from the pool's job time; no status shown NTP server and time zone in the settings; the web UI shows whether and when the clock was synchronised and how far it is from the browser's
Power supply's rating no (a fixed maximum per board family) no (a fixed maximum per board) no (a fixed 60 W) set in the settings (psuWatts), so a tuner can keep below it; the dashboard asks for it while it is unknown
What the device display shows fixed pages; settable are the panel type, rotation, inverted colours and screen-off time fixed pages; settable are flip, inverted colours and screen-off no display; two status LEDs (the share blink can be switched off) choosable: which LCD pages the key steps through, their order and start page, the cockpit's large number, its three places and its footer line, which OLED slides rotate and for how long; a live view of the screen in the settings
Clock and night mode on the display no (no clock page); the display always on, off, or off after a timeout; the backlight on or off, no dimming no (uptime only); the screen on or off, an optional automatic screen-off, no dimming no display yes since v0.1.45: a clock page on the LCD and a clock slide on the OLED (not among the factory pages); night mode (off by default, 22:00–07:00) dims to its own brightness (OLED contrast, the Nerd boards' AW9364 in 16 steps, PWM on the Naja Duo and Gamma Hex), on the LCD with the clock above weekday, date, hashrate and temperature; a key press brings the full display back for 30 s, an alert shows at full brightness
Protection against OLED burn-in no pixel shift; a screen-off timeout (factory setting: always on) no pixel shift no display the picture moves by one pixel every ten minutes through twelve positions; every OLED screen leaves room for it, so nothing is cut off (since v0.1.45)
Input voltage sagging under load "Danger: Low Voltage" on the dashboard while the input reads below 94.9 % of nominal (not compared with the input with the chips off) the input-voltage bar turns yellow outside voltageMin–voltageMax (default 11.5–12.6 V) "Input voltage is low" on the dashboard below 87 % of nominal plus 0.5 V the input with the chips off compared with the input under load (median of the last minute); a drop of 8 % of nominal or more for a full minute shows a warning with the drop in volts on the System page, gone again below 6 %; only reported (since v0.1.45; vinIdle, vinLoad, vinSag, psuSagWarning)
Other makers' miners on the swarm page AxeOS devices only (the browser reads /api/system/info) AxeOS devices only (the browser reads /api/system/info and /api/system/asic) AxeOS devices only (the browser reads /api/system/info and /api/system/asic) AxeOS, NerdOS, ForgeOS, WarpAxe — and an Avalon over the cgminer API, found by the network search and read by the miner, read-only
Web UI languages English 9 English 8
Language, tests C; unit tests (Stratum, ASIC) in CI C++/C C; unit tests (Stratum, mining) in QEMU in CI Rust; chip, chain and board drivers host-tested against a simulated chain and I²C bus
Supported boards ~20 board versions 11 boards, plus the NerdAxe Gaia since v1.1.1 1 (BitForge Nano) 7 run, 6 more with a profile (see below)

What the stock firmware offers in addition: AxeOS and NerdOS support far more boards and have years of use by a large community; AxeOS has a scoreboard, themes, the BAP accessory port and Wi-Fi setup over Bluetooth; NerdOS has two-factor login for updates, dual-pool mining, InfluxDB/Grafana export and alerts; ForgeOS has dual-pool mining, Wi-Fi and pool setup over Bluetooth, and share and self-test signals on the Nano's two LEDs. WarpAxe is early; if you need any of that, stay with the stock firmware.

With WarpTune

WarpTune, the clock-and-voltage tuner of dvb-WarpPool, works fully on the stock firmware — it talks the AxeOS API, and WarpAxe keeps that API. The difference is what the firmware says about itself: WarpAxe reports these states explicitly, so WarpTune does not have to guess them from the power draw:

  • Overheat stop: overheat_mode while it lasts, overheatTrips and overheatCause (hot, a lost sensor, or a regulator fault: power, with the conditions in powerFaultCodes). WarpTune holds during the stop, and after a hot stop takes the clock one step down (two from the second stop in an hour); a lost sensor is no reason to step down.
  • ASICs off or the chain still coming up: chainStopped and chainPhase, so a chain that is powering up is not taken for a dead chip.
  • Fallback pool and reject reasons, as on current AxeOS.
  • No pool reachable (poolsUnavailable, since v0.1.42, under the name AxeOS and ForgeOS use): the firmware has switched the ASICs off until a pool answers; a tuner holds its hand meanwhile.
  • Chip error rate over a minute (errorPercentage1m), from the chips' own counters: a voltage that is too low shows in minutes, not after hundreds of pool shares.
  • One chip silent (silentChips, chipSilentRestarts, lastChipSilentRestart, chipsGivenUp, since v0.1.40): WarpTune (from v1.47.0) judges the hashrate on the chips that run instead of taking the shortfall for a weak clock, and after the firmware's chain restart for that chip settles afresh without a verdict on the step.
  • A stuck hash domain (domainLatchResets, lastDomainLatchReset, domainsGivenUp, since v0.1.41): the firmware switches the chips off and on for it; WarpTune waits while the domain is not given up, and only then takes its own path (a short voltage lift).
  • Who regulates (selfHeals and externalRegulator, since v0.1.41): the firmware lists the cases it heals on its own (chain_silent, chip_silent, domain_latch), so WarpTune waits on those and acts itself on the rest, by the list rather than the version number. WarpTune's heartbeat (POST /api/v1/regulator {"ttl_s": 600}, RAM only: no flash write, no display wake) says it is regulating the miner; the firmware's own base regulation, a later block, will stand back while externalRegulator.active holds.
  • A clock of its own per chip (chipFreqOffsets, asicFrequencies, chipFreqOffsetsSupported, voltageDomains, chipFreqOffsetSpread: the boards with more than one chip; since v0.1.44): the chips of a board differ, and the weakest one sets the voltage for all. The offsets are set by hand for now; a later WarpPool release lets WarpTune give the one or two chips that hold the voltage up a lower clock and take the board's voltage down on boards whose chips run in parallel. The firmware carries the offsets out and reports each chip's clock (docs/15).
  • A running self-test (selfTest.state): WarpTune (from v1.42.1) holds its writes while one runs, and a clock or voltage change during the test ends it rather than spoiling it.

The table on the WarpPool side lists, firmware by firmware, what WarpTune gets from AxeOS, NerdOS, ForgeOS and WarpAxe.

Screenshots

Web UI

Dashboard: type plate with chip grid, hashrate, efficiency, shares, best difficulty, history, temperatures, fans, power, pool, hash counters per chip and domain
Dashboard — chip grid and series colour, the hashrate with its share of the expected rate, efficiency, power, shares and best difficulty (since start and all-time), the 1 h / 3 h history; below, temperature, fans and power, and the pool with the payout of a found block; at the bottom the hash counters per chip and domain (off by default, switched on in Settings).

Dashboard with clock per chip: the Fans card reads Clock (base) and lists each chip's clock with the offset in yellow and who set it; the hash counters show each chip's clock under its name
Clock per chip (since v0.1.47) — while any chip runs at a clock other than the chain's, the Fans card reads "Clock (base)" and lists every chip with its clock, the offset in yellow and who set it and when; the hash counters show each chip's clock under its name. Offsets here are example values on a NerdQAxe++.

Swarm: the fleet's hashrate, power, efficiency and record difficulty, each miner's share, and one card per miner with sparkline and temperatures
Swarm — every miner on the network, WarpAxe or stock firmware, read by your browser (an Avalon by this miner, over the Avalon's cgminer API): the fleet's hashrate and each miner's share of it, sparklines, chip and regulator temperatures against their limits.

Settings: clock and voltage presets, fans and temperature, display, pages with order, start page and live view, cockpit values, clock and night mode, dashboard
Settings — clock and voltage as the manufacturer's steps, the power supply's rating, fans (on the Nerd boards both linked to the chips by default), display, the pages the key steps through (order, start page, and a live view of the device's screen), the cockpit's values, clock and night mode (since v0.1.45), and the dashboard's hash-counter card (Wi-Fi, hostname and time are on their own Network tab); ?oc in the address unlocks free values and the expert section (fan PID, second fan output, suggested difficulty, job interval).

Network: Wi-Fi, hostname, time by NTP and time zone
Network — Wi-Fi with a list of networks found, hostname, USB address, time by NTP and time zone, and whether and when the clock was last synchronised.

System: online update, maintenance, self-test, diagnostics file and event log, way back to the stock firmware, live log
System — online update from the releases, upload, download mode for a reinstall with the web flasher, maintenance (switch the ASICs off while the device stays reachable, reset an overheat stop), the self-test with a ✓ or ✗ per check, the diagnostics file, the event log (in the web UI's language), the way back to the stock firmware and the live log.

First start: the boards that fit, with a Show all boards button
First start on a board WarpAxe cannot identify with certainty — only the boards that fit what answered on the bus are listed, the rest are behind "Show all boards"; the ASICs stay off until a board is chosen and, after the restart, has passed the bus check.

Pool page: connection, shares, coinbase payout and outputs, pool settings
Pool — the connection (protocol, Noise/TLS, fallback), shares with reject reasons, and who a found block pays: your share, the coinbase value and each output. Below, the saved pools (up to eight, one click makes one the main pool), then main and fallback pool with the coin the pool pays in, each Stratum V1 with optional TLS or Stratum V2 with the pool's authority key.

Pool page: a pool on a self-signed certificate, with the fingerprint of its key and a Trust this pool button
A TLS pool on a self-signed certificate, such as WarpPool on Umbrel (since v0.1.41) — the miner shows the SHA-256 fingerprint of the pool's key and a "Trust this pool" button; once you trust it, the miner connects with that key only and checks it on every connection.

Device display

NerdQAxe++ LCD pages: cockpit, Bitcoin, device, pool
NerdQAxe++ (320×170 LCD) — the cockpit and three of the four pages the page key steps through (a log page follows). Block height, halving and network difficulty come from the pool's job; the BTC price line appears only if you switch it on.

Clock page on the LCD with date, week, hashrate, block height, price and fee; night mode: the clock dimmed with date, hashrate and temperature
Clock slide on the Bitaxe OLED: time, weekday and short date, hashrate
Clock (since v0.1.45; not among the factory pages, night mode off by default) — the clock page with weekday, date, calendar week and hashrate, below them block height, BTC price and fee (pool and uptime instead while the price is off); night mode with the clock dimmed above date, hashrate and temperature; the Bitaxe OLED's clock slide.

Block found animation: warp jump
Block found — stars accelerate into a warp jump, a flash, then the height with shock rings until a key is pressed.

Special screens: overheat, ASICs off, no pool, firmware update
Special screens — overheat (pulsing frame), ASICs off (switched off by hand), no pool (since v0.1.42), firmware update with progress.

Self-test on the LCD: running with progress, PASS with nine marks, FAIL naming chip 2
Self-test — the running test, PASS, and a FAIL that names the chip and domain; the OLED shows the verdict and the first failed check (oled-selftest.png).

Wi-Fi setup screen on the NerdQAxe++ LCD: hotspot name and a ten-digit password Wi-Fi setup on the Bitaxe OLED: name, password and address take turns
Setup hotspot — name and password (new at every start, example shown) on the LCD; on the OLED they take turns with the address.

Bitaxe Gamma OLED rotation
Bitaxe Gamma (128×32 OLED) — hashrate large, rotating values, full-width info slides and the wordmark.

All display images are rendered from the firmware's own drawing code (tools/display-preview) with sample values; a device's screen can be read back at any time with GET /api/v1/display/frame.

Features

Mining

  • BM1370, BM1373 and BM1397 chain driver (the BM1397 does not roll the version itself: four midstates per job, computed on the ESP32-S3): enumeration, baud switch, PLL solved (not looked up) and ramped, work dispatch paced per board as its stock firmware does, nonce attribution (for 2 s after the ticket mask is raised, a nonce below the new mask counts at the old one, so a pool ramping up from difficulty 0.001 no longer inflates the hashrate), stale and duplicate filtering, per-chip silence watchdog. A clock of its own per chip where one is set, on boards with more than one chip (a BM1373 at its own address: both reference drivers shift it by two bits for a single-chip command, which reached no second chip on a Naja Duo, so its chip 1 also went without the domain-end IO strength of ESP-Miner's init; where the chips sit in series, as on that board, their clocks may lie 25 MHz apart at most, or 8 % of the chain's clock where that is less (voltageDomains, chipFreqOffsetSpread), since a slowed chip takes voltage from the other, and a chip that resets itself for want of it is counted, counterRestarts) (chipFreqOffsets, MHz added to the frequency per chip, since v0.1.44; no chip below half the chain's clock or above the board's highest, else the API refuses the list, and stored offsets that no longer fit the clock in force at a chain start are not applied): each chip is stepped to its clock by writes to that chip alone, without a chain restart, and no chip passes its own clock on the way; the expected hashrate, the self-test and the two policies below follow each chip's clock, a lower voltage that comes with new offsets waits for the chips' ramps, and without offsets the chain puts the same bytes on the wire as before; in the web UI under Clock per chip, below frequency and voltage (docs/15). All chips silent for a minute with work going out: the chain is started over. Since v0.1.40 also one chip silent for ten minutes while the others hash (seen once on a NerdOctaxe after five days at a steady clock; until then it stayed dark until the next boot): at most one such restart an hour over all chips, and a chip that is silent again before it has run an hour after each of three restarts is left alone until the next boot or a new clock or voltage. Both clocks stop while no work goes out, so a pool outage counts for nothing. On a board whose nonce-to-chip attribution has not been seen on a device (the Naja Duo, also after its first run in v0.1.44) the ten minutes are reported in the log and lastError, not acted on (Profile::silent_chip_restart). Since v0.1.41 also one hash domain stuck while its chip hashes (the NerdOctaxe's latch, until then seen only after a warm reboot and in the self-test): a domain under 25 % of the mean of the chip's other domains over ten minutes of fresh counter reads (the window as a whole, since the counters are noisy; a weak domain at 50 % is no latch, the self-test's limit is 67 %) has the chips switched off and on, the way /api/v1/chips/off and /on do it (chain into reset, core off, 500 ms, LDO off on the TPS5364x Nerd carriers — the Gaia's stays up —, 5 s down, back on; clock and voltage unchanged): the strongest re-init the firmware has short of a new clock or voltage, which stays WarpTune's (docs/04 found the warm-reboot latch was an init trim and a clock dip brought a dead domain back). In the field the reset has taken twice on a Bitaxe Gamma (a user's report, v0.1.41): a domain at 0 % right after the chain came up, whole after the reset ten minutes later. Since v0.1.42 such a domain does not wait that long: one that is under 5 % of the others three minutes after the chain came up is reset then (also after a chain restart or a reset of this kind); a domain between 5 and 25 %, or one that dies later, has the ten minutes. shutdown reads true and the phase OFF for the six seconds or so of the intervention, as for a chips-off by hand; the event and lastDomainLatchReset say why. The same limits as for the silent chip: one intervention an hour over both cases, three resets that do not hold and the domain is left alone until a new clock or voltage or the next boot. Four domains on a BM1370, eight on a BM1373; the BM1397 reports none and is not judged. A BM1370 on a Nerd carrier (NerdQAxe++, NerdOctaxe, NerdQX) is brought up with NerdOS's init, a Bitaxe with ESP-Miner's: the two differ in one core-clock trim and two writes since ESP-Miner's August 2026 change, and on a NerdOctaxe at 700 MHz the ESP-Miner init left one hash domain of a chip at 3% in four power-ups out of six, NerdOS's none in six (docs/04).
  • Stratum V2 per pool: Noise handshake (secp256k1 + EllSwift, ChaCha20-Poly1305), extended channel, the pool's certificate checked against its authority key (Base58Check, as pools publish it). "Require pool authentication" is on by default: without a key, or before the clock is set by NTP, there is no connection. Since v0.1.38, in the first five minutes after a start, the connect waits up to 20 s for NTP's first sync of the boot when NTP is on, and a certificate that fails before it does not count towards the fallback (a clock carried across a reset in RTC memory can be minutes off after a session in download mode). The TLS switch applies to V1 only; V2 is always encrypted. The display shows "V2" with the lock. Settings from NerdOS (sv2_proto, sv2_auth_pk, sv2_reqauth) are taken over on the first start.
  • Stratum V1 with version rolling (BIP 310), mining.suggest_difficulty, optional TLS (esp-tls, hostname checked). Since v0.1.42 the user agent in mining.subscribe names the board, warpaxe/0.1.42 (nerdaxe-gaia): its profile name, the one Stratum V2 sends in its hardware field (both empty until a first start has settled the board). Since v0.1.40 every TLS connection — the pool, the online update, the price fetch — is checked against one pinned CA bundle, curl's extract of the Mozilla store of 20 October 2026, which no longer has the eMudhra root emSign ECC Root CA - G3 nor AAA Certificate Services (ESP-IDF v5.3.3's own lists still carry both; firmware/warpaxe/certificates). Since v0.1.41 WarpAxe also leaves out emSign Root CA - G1, the last eMudhra root still in that extract, and checks each certificate's validity dates, as soon as NTP has set the clock this boot (in the first minutes after a start the miner waits up to 15 s for it before a TLS pool connection). Without NTP the dates are not checked, as before; with it an expired pool certificate no longer connects. A pool trusted by its pinned key is not judged by its dates. A root of the bundle that the server sends along, cross-signed by an older root the bundle no longer has (api.coingecko.com sends GTS Root R4 signed by GlobalSign Root CA), counts as that root when its name and key match; ESP-IDF's verifier alone rejects such a chain (crates/trust). A pool whose only chain runs to a removed root no longer connects. A pool the previous firmware ran on TLS with the owner's own certificate stays on TLS here, with the pinned CA bundle, rather than dropping to plain text. Since v0.1.41 a pool whose certificate no public authority issued, such as the self-signed one WarpPool creates on Umbrel, is refused at first: the Pool page then shows the fingerprint of the pool's key (SHA-256 of its public key, AB:CD:…:EF, the value WarpPool shows in its Connect window and openssl x509 -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -c prints), and one click trusts it, per pool (main and fallback apart; a saved pool carries its key along). With a trusted key the host name is not checked, so the pool's IP address works as its address. The key is only consulted once the bundle check fails (so a certificate the public PKI trusts for the host name still connects, whatever its key), so a pool on a public certificate is never affected, also not by its rotation; it never applies to the online update or the price fetch. A pool whose own certificate later presents another key does not connect until that key is confirmed on its own; "Forget" drops it (crates/trust, docs/14). A pool that asks for an extranonce2 size outside 1–16 bytes (V2: 1–32) is refused instead of trusted. A Stratum V1 line is read up to 512 KB; a longer one ends the session, and the miner reconnects (stratumLinesTooLong) instead of reading until the memory is gone. The coinbase is decoded once per job and hashed with each extranonce2 without being copied into the work for the chips, so a coinbase of tens or hundreds of KB no longer fills the internal RAM with copies of it (tested against a test pool sending up to 3,000 outputs). Stratum V2 accepts messages up to one Noise record, 65,519 bytes (8 KB until v0.1.40).
  • Fallback pool: after three failed attempts on the main pool; a probe every five minutes brings it back as soon as the main pool answers. Since v0.1.42 a fallback that fails twice in a row no longer keeps the miner to itself: both pools are tried in turn until one sends work. Since v0.1.43 an attempt made while Wi-Fi is not connected yet does not count towards the switch (a cold boot with a slow access point stays on the main pool), and shares on the fallback name the fallback's worker; before, they carried the main pool's, and a pool that checks the name (ckpool: "Worker mismatch") rejected them when the two differed.
  • No pool, no hashing (since v0.1.42): when neither the main pool nor (where one is set) the fallback pool answers — at least two failed attempts on each and a minute since the first, so a Wi-Fi or pool hiccup switches nothing — the ASICs go off: core voltage down, chain in reset, and the fans come down to their lowest duty (a fan set by hand at once, the automatic one as the chips cool). A session that brings no work at all counts as a failed attempt, however long it stays open. Both pools are then tried in turn every 30 s, and the first job from either brings the ASICs back at the clock and voltage they had, through the same path as a chain restart. poolsUnavailable in /api/system/info (AxeOS's and ForgeOS's name) says so, with chainStopped and chainPhase NOPOOL; the dashboard and the display show it, and the event log has an entry for going off and one for coming back (at most one pair in ten minutes, and the return from an outage of ten minutes or more in any case). No pool or no worker name configured counts the same. Nothing is written to flash per attempt. A chip temperature that cannot be read while the chips are off (a Bitaxe Gamma's diode needs the chip's power) is no lost sensor: the lost-sensor stop counts only with the core rail on, for every way the rail goes down, and after a hot stop on such a board the regulator and a minute off decide the restart, as on AxeOS (since v0.1.44 also after a regulator fault). Not during the first start of a newly chosen board, whose chips have to answer once for the choice to be confirmed, and not while a self-test runs: the chips stay on for it, and come on for one started while they were off. Without work from a pool the self-test skips the checks that count hashes (hashrate, domains, error rate) with the note "no work from the pool" and passes on the rest: chip count, voltages, regulator, fan and temperatures.
  • Saved pools: up to eight, each with a name and the coin it mines; the main pool as it is now is saved with one click, a saved one becomes the main pool with another, and the miner reconnects at once. Passwords stay on the miner (GET/POST /api/v1/pools). A first start from AxeOS 2.15 takes over the pools it had saved.
  • The Wi-Fi radio stays awake (no modem sleep), so a new job from the pool does not wait for the access point's next beacon (~100 ms). The NerdNOS is the exception: fanless next to the ESP32-S3, it keeps modem sleep on, as its stock firmware does, to keep the heat down.
  • Block height, network difficulty and the pool's coinbase tag read from the job; a nonce whose header hash meets the target of the header's own nbits is reported as a found block (since v0.1.42; before, a nonce at or above the rounded network difficulty). Since v0.1.39 the miner keeps the count and the last block (height, time, coin) in NVS and records each block in the event log, and the web UI shows a banner with confetti until it is dismissed in the browser. Since v0.1.42 the block is kept with its hash and its status — pending, confirmed once the pool's next work builds on it, orphaned when the work for the next height builds on another block, unknown when the miner missed the next height — shown in the banner (again when it changes) and in the event log.

Board

  • Regulators: TPS546 (Bitaxe boards, NerdAxe Gamma and Gaia, NerdQAxe++ Rev 7, BitForge Nano), TPS53647/TPS53667 (NerdQAxe++, NerdOctaxe, NerdQX); the core current and the regulator's warning line in the API where the regulator reports them. The NerdNOS has none to talk to: its rail is fixed by resistors, read on the ADC, and switched with the chip's run/stop line.
  • A lower voltage waits for the clock (since v0.1.42): a change to a lower clock and a lower core voltage in one PATCH /api/system used to set the voltage within a tenth of a second while the clock came down in PLL steps (6.25 MHz every 100 ms: 625 to 425 MHz takes 3.2 s), so the chips ran at the old clock on the new voltage for those seconds. The voltage drop is now held until the chips run at the clock asked for (30 s at the most; a clock the PLL has no setting for is refused by the API, as is one below 50 MHz). A higher voltage is set at once as before, and so are a voltage change on its own and the step from the bring-up voltage to the configured one after the chain init.
  • Both chips' temperatures on the two-chip Bitaxe boards (since v0.1.42): the Naja Duo and the Gamma Turbo carry a diode per chip on the EMC2103's two channels, and only the first was read, so the second chip had neither a fan control nor an overheat stop. Fan and stop line now act on the hotter of the two, as ESP-Miner does (either diode over 75 °C stops). A diode that read before and fails makes the temperature unknown, never cool: fans at full, and the lost-sensor stop after a minute; a chip that is already over the line stops at once whatever the other diode says. A diode that has never read since boot is left out of the temperature; after a minute of that the fans run at full (its chip has no stop line of its own, and a reboot must not take the protection away), with a line in the log and the board's notice (boardError), and the chips keep running. When the diode reads after all, everything is as normal. Since v0.1.44 neither diode counts until the chain has answered since the last reset or rail-on (with the chips off or in reset the EMC2103 reads both as nonsense: a user's Gamma Turbo stopped its start on chip 1 at 72.75 °C, 33.6 °C once the chip ran); until then they are no reading, not a lost sensor. Since v0.1.43 a diode stuck at the sensor's ceiling (127.875 °C, the EMC2103's highest raw value) counts as no reading, and in the first three readings after the chips start (rail on, reset, chain init) a second diode over the line is held with the fans at full instead of stopping the chips: while the chips are off, diode 1 reads the ceiling, and the EMC2103's own averaging over four conversions still carries those values for about a second after the start (a user's Gamma Turbo stopped on every boot until then; AxeOS never switches the rail off at boot, so it does not see them). A second diode still over the line after that stops as before; the first chip's diode keeps its stop on the first reading. temp is the hotter chip, temp2 the second chip's own (AxeOS's field, -1 without a reading) and asicTemps both. On the Gamma Hex the other diode (diode 1) is not taken for a chip.
  • Never a core voltage below the regulator's clean range: the TPS546 driver refuses anything under 0.25 V ÷ VOUT_SCALE_LOOP (TI's reference range), the API refuses it with 400 and publishes the floor as regulatorMinMv, and a request the regulator turned down is shown as coreVoltageRefused instead of counting as applied. The NerdAxe Gaia runs on the 0.5 divider (clean 0.5–1.5 V) so its 800–970 mV lie inside it — the divider the board's own straps set at power-up; the stock firmware's 0.25 put them below. vrProbe shows what the regulator held at boot, before the firmware wrote it.
  • Sensors and fans: EMC2101, EMC2103, EMC2302 (two outputs), TMP1075, INA260 (BitForge Nano), FXL6408 GPIO expander, an NTC thermistor on the ADC (NerdNOS).
  • Fan PID with ESP-Miner's gains; a second output linked to the chip fan by default, as on NerdOS (Link the fans off: it follows the regulator temperature instead, for a fan that cools only the regulator); minimum speed, polarity. After the core voltage comes on — at start and after an overheat stop — the fans stay at full until the chips are near their target, then the PID takes over from there instead of running them down on a cold board. Boards with one fan for chip and regulator (NerdAxe) run it for whichever of the two needs more (regulator target 80 °C).
  • Overheat shutdown of the core voltage at the stock firmware's lines (Bitaxe: chip 75 °C, regulator 105 °C as AxeOS stops; BitForge Nano the same, as ForgeOS stops, on ForgeOS's diode scale since v0.1.36; NerdQAxe/NerdOctaxe/Q13xx: 70 / 70 as NerdOS; NerdAxe Gamma 70 / 105 and NerdAxe Gaia 75 / 105 — NerdOS has no regulator stop on these one-fan boards, WarpAxe keeps AxeOS's 105 on the same TPS546; NerdNOS: 80; docs/08). The chip line is a setting: on the NerdOS boards up to 90 °C as NerdOS allows, on every other board only below its own line; the regulator's is fixed per board. There is also a guard for a lost chip sensor (60 s blind = off, once the chip temperature has been read; a board whose chip sensor never answers runs like NerdOS, on the regulator limit with the fans at full, and says so in the log). The chips start again on their own once chip and regulator are 10 °C below their limits (at least 60 s off; after a lost sensor only with real readings back; a chip diode that reads only with the rail on, as on the Gamma and the two-chip Bitaxes, is taken as cooled with the regulator after a hot stop and, since v0.1.44, after a regulator fault); the third stop within an hour stays off until it is cleared by hand.
  • Board-choice guard: a board is checked against the I²C bus before any of its pins is driven, by the parts its profile needs and the ones it must not see (the regulator's input voltage tells the NerdAxe Gaia from the NerdAxe Gamma); its first start runs at a cautious voltage and counts the chips, and a wrong count or chip type switches the rail off again. A missing sensor on a new choice is refused as well. PATCH /api/system {"boardModel": "<name>", "reverify": true} puts a verified board through the check again (docs/11).
  • Plausibility windows for every reading: a regulator that answers garbage while it powers up is reported as "no reading", never as a value a tuner could act on.
  • Switch the ASICs off and on again from the web UI or the API; the device stays reachable. On the Nerd carriers with an LDO for the chips' I/O rails (NerdQAxe++ Rev 6, NerdOctaxe, NerdQX) "off" — by hand, by an overheat stop, or before a restart — is the stock firmware's shutdown: chain in reset, core rail off, half a second, LDO off, and the chain's TX line parked low meanwhile; "on" is its bring-up order. A reboot that was not a power-on keeps the rails off for five seconds before the LDO comes back, the pause a power cycle gives them (docs/04-Octaxe-Warm-Reboot-Latch.md).

Web UI and API

  • One UI for every board, series colour and chip grid on the type plate; English, German, Spanish, French, Italian, Brazilian Portuguese, Japanese and Chinese, each translated and then proofread on its own as a whole (the device display in the six Latin-script ones).
  • Dashboard and Pool page in the warp design: one hero with the hashrate, its share of the expected rate and the 1 h / 3 h history (hashrate as a two-minute average, temperature in steps of at least 0.5 °C, so counting noise does not fill the chart), then temperature, fan/power and pool instruments — input voltage, core voltage and core current on rows of their own, the input current only where the board measures it (on the NerdAxe an estimate, marked ≈), so a Bitaxe's 40 A of core current does not read as drawn from the power supply; a notice asks for the power supply's rating (Settings, in watts) until it is set or dismissed; the best difficulty since the start next to the all-time best, which survives restarts, and, once the miner has found a block, the number of blocks found; the chips' error rate over the last minute next to the expected hashrate, as AxeOS shows it; live log. Optional (Settings → Dashboard, off by default): the hash counters per chip and domain, a weak domain marked in colour, and a total line on boards with several chips. The BM1373 has eight hash domains, not four: WarpAxe reads all eight counters (0x88–0x8B and 0xAC–0xAF), where AxeOS reads four and doubles them. Its error rate runs higher than the BM1370's (about 2.5% on a NerdAxe Gaia at its hand point, rising steeply at low core voltage) and is shown without a colour.
  • Coinbase payout of every job, as AxeOS shows it: the share of a found block that goes to your address (green from 95%, red below), the coinbase value and its outputs, over Stratum V1 and V2. The address in the worker name is decoded (base58, bech32/bech32m, CashAddr) and matched against the output scripts, so the split is right when solo mining another SHA-256 coin too (BCH, eCash, DigiByte, FixedCoin…); the outputs are written the way that coin writes addresses, and the amounts carry the coin set for the pool (Coin, default BTC). A worker name that is a pool account, not an address, shows "paid by the pool". Since v0.1.41 a coinbase that pays many outputs (a pool that pays its miners in the coinbase; ESP-Miner issue #2081) is listed as the worker's own output, the SegWit checksum and the largest others, at most 32, with the rest summed in one row (coinbaseOutputsHidden, coinbaseOutputsHiddenSatoshis); before, more than 64 outputs showed no payout at all.
  • Swarm page for the other miners on the network — AxeOS, NerdOS, ForgeOS or WarpAxe: fleet hashrate, power, J/TH and record difficulty, each miner's share, a card per miner with a sparkline and its temperatures. The browser reads every miner's /api/system/info directly (every 30 s by default, not while the tab is hidden, one request per miner at a time); this miner stores only the address list. Read-only: it never changes or restarts another miner. Add miners by address or by a search of the local /24. An Avalon (cgminer API on TCP 4028, which a browser cannot open) is found by that search as well: the miner walks its own /24 for port 4028, six connections at a time with a hard 30 s budget, asks a host that answers for its version and nothing else, and the hit shows as "Avalon · cgminer" beside the others; adding it (or typing it as "Avalon (cgminer API)") stores cgminer:<ip>. For the card the miner reads its summary, estats and pools — those reads and nothing else, one at a time, cached for 10 s, only for hosts on the list — and shows its work mode (Eco / Standard / Super), chip temperatures, fans, power, shares and best share (GET /api/v1/swarm/cgminer?host=, POST/GET /api/v1/swarm/cgminer/scan; docs/07).
  • Found by name: the miner announces itself over mDNS as <hostname>.local (letters, digits and - of the hostname; a name already taken gets -2) and as _http._tcp with AxeOS's _axeos subtype and TXT items (board, family, asic, asic_count, fw_version), so tools that discover Bitaxes that way find it; the router's DHCP sees the same name.
  • Tabs in the stock order: Dashboard, Swarm, Network, Pool, Settings, System; the starfield background of dvb-WarpPool. The browser tab names the miner ("NerdAxe Gaia · WarpAxe"), so several open tabs tell their miners apart.
  • AxeOS/NerdOS-compatible endpoints: /api/system/info, PATCH /api/system, /api/system/asic, /api/v2/settings, NerdOS's /api/v2/dashboard (its performance object: hash rates and, per chip, the hash rate and the error hash rate), restart, OTA upload.
  • WarpAxe's own: /api/v1/state, /api/v1/history, /api/v1/log, chips off/on, a tuner's heartbeat (POST /api/v1/regulator {"ttl_s": 600}; 60–3600 s, 600 without a value, 0 ends it; RAM only, reported as externalRegulator {active, expires_in_s}), overheat and best-difficulty reset, the self-test (POST/GET/ DELETE /api/v1/selftest), the diagnostics file (GET /api/v1/diagnostics), the event log (GET /api/v1/events), Wi-Fi scan, display frame / key / demo, online update, download mode for the web flasher, the swarm list (/api/v1/swarm), an Avalon read for it (/api/v1/swarm/cgminer?host=) and the search for one (/api/v1/swarm/cgminer/scan), the last crash's core dump (GET /api/v1/coredump, an ELF for espcoredump.py, secrets masked; DELETE erases it), and for diagnosis a read-only chip register scan (/api/v1/chip/regs?chip=0&from=0x80&to=0xbf) and the nonces per core (/api/v1/chip/cores).
  • States a tuner would otherwise have to guess from the power draw are in /api/system/info: chainStopped and chainPhase, overheat_mode, overheatTrips (stops in the last hour), overheatCause (hot, a lost sensor or a regulator fault), overheatLatched, power_fault (AxeOS's field and wording) with powerFaultCodes, isUsingFallbackStratum (also as NerdOS's stratum.usingFallback), sharesRejectedReasons, AxeOS's coinbaseOutputs, coinbaseValueTotalSatoshis and coinbaseValueUserSatoshis with coinbaseOwnAddress (the worker name is an address) and coinbaseBitcoin (it is a Bitcoin one) and the pool's coinTicker, overheat_temp (the chip stop in force) with overheatTempMax and vrOverheatTemp, temptarget (the fan target, under ESP-Miner's name) so a tuner keeps its own target above it, coreCurrentA with coreCurrentWarnA, faultCause (why the regulator stopped), regulatorMinMv and coreVoltageRefused (the regulator's floor and a request it refused), vrProbe (the regulator's window as found at boot), silentChips, chainSilentRestarts and chainSilentRestartsSameMv (chips without nonces, and chain restarts after a silent minute — in all, and in a row at the current core voltage: two or more mean the chips do not run at it), chipSilentRestarts, lastChipSilentRestart (chip from 0, mv, uptime_s; null until the first) and chipsGivenUp (chain restarts for one silent chip since v0.1.40, the last one, and the chips left alone after three that did not hold; chainSilentRestarts keeps counting only the all-chips case), domainLatchResets, lastDomainLatchReset (chip and domain from 0, percent the domain's share of the mean of the chip's other domains over the window: ten minutes, three for a domain dead from the chain's start; uptime_s; null until the first) and domainsGivenUp ([{chip, domain}]; chips off and on for a stuck hash domain since v0.1.41), selfHeals (the cases this firmware heals on its own: ["chain_silent", "chip_silent", "domain_latch"]) and externalRegulator ({active, expires_in_s}, a tuner's heartbeat; {false, 0} without one, also after every boot), on the boards with a diode per chip (Naja Duo, Gamma Turbo; since v0.1.42) temp2 (the second chip's own temperature, AxeOS's field, -1 without a reading as there) and asicTemps (both, chip 1 first, null for a diode without a reading), with temp the hotter of the two, gitHash (the commit the image was built from), blockFound (nonces since the start that met their block's target: blocks, except on a chain at minimum difficulty, where every nonce does), blocksFoundTotal (all time) and lastBlock (height, time as Unix time or 0 without a clock, coin, and since v0.1.42 hash as block explorers show it and status: pending, confirmed once work from the pool names the block as its parent, orphaned when the work for the next height names another one, unknown when the block was still pending and the first work seen is already two heights on (the miner was offline in between); both null for a block found before v0.1.42; lastBlock itself null until the first block; the count is stored in the form older versions read, hash and status in a second entry, and a block is stored once however many nonces meet its target: further ones on the parent of one of the last few recorded blocks, at a lower height, or at the same height unless the stored one was orphaned, only count in blockFound), both kept across restarts, poolsUnavailable (no pool answers, since v0.1.42; the chips are off for it, chainStopped, except on a board without chips, during a first start and while a self-test runs), and AxeOS's hashrateMonitor (per chip the hashrate from the chip's own counters, its domains — four, eight on the BM1373 — and the error counter, read once a second; since v0.1.44 also hashCount, the chip's raw total counter, and counterRestarts, the times it started over while the chain ran) with errorPercentage (AxeOS's per-second value) and errorPercentage1m (over the last full minute, for tuners). Also resetReason with resetCause (the raw RTC reset cause, since v0.1.38), otaState (the running image: valid, pending-verify, or aborted after a rollback), dieTempC (the ESP32-S3's own sensor), yieldPercent (the nonce-weighted 10-minute rate against small cores × clock, on chips without an error counter such as the BM1397), minerStackFree (since v0.1.44: the least stack the mining loop has had to spare since boot, of its 12 KB; its driver and policies live in PSRAM), vinIdle, vinLoad, vinSag and psuSagWarning (since v0.1.45: the input voltage with the chips off, under load as the median of the last minute, the drop between them, and a warning once the drop reaches 8 % of the nominal input for a full minute, gone again under 6 %; the System page shows it under Maintenance; only reported, nothing is switched), clockStep (a step down after an overheat on a board without a fan to drive), hasFan, hasVr and powerEstimated (what the board has to measure and drive), and ntpLastSync (when SNTP last set the clock; the Network tab shows it, and how far the miner's clock is from the browser's, since TLS and an authenticated Stratum V2 pool wait for the time), and psuWatts (the rated output of the miner's power supply, entered once in Settings, so WarpTune knows its 80% limit without its own configuration; several miners on one supply each get their share of its rating; null while unknown), boardDetect (on a board's first start: the board found or chosen, where its check stands, the cautious voltage, and why a board was refused), and mdnsHostname / fullHostname (the name the miner announces over mDNS, as AxeOS reports it).
  • Setup hotspot: with no network in the settings, or none reached within three minutes of a start, the miner opens WarpAxe-XXXX — WPA2, with a ten-digit password generated at every start and shown only on the device display. A phone that joins it gets the Wi-Fi setup page by itself (captive portal); after saving, the miner restarts, joins the network and closes the hotspot. The log names the address behind every restart, download-mode and overheat-reset request.

Device display

  • 320×170 LCD (Nerd boards, Bitaxe Naja Duo and Gamma Hex): cockpit with the last hour's hashrate, Bitcoin, device, pool and log pages, anti-aliased fonts (Space Grotesk, JetBrains Mono, Inter) pre-rendered at build time. On a board without regulator or fan (NerdNOS) the device page shows what it has instead: the ESP32-S3's temperature, the effective rate, the Wi-Fi signal, the clock after a restart and the shutdown temperature.
  • Bitaxe OLED: large hashrate, rotating values, info slides, share blink.
  • Boot screen: the WarpAxe logo, and on the colour-display boards the maker's wordmark under it (NerdQAxe++, NerdOctaxe, NerdAxe Gamma, NerdQX, NerdAxe Gaia, NerdNOS, Bitaxe Naja Duo and Gamma Hex), shown with the makers' consent (the Naja Duo, since v0.1.44, the Bitaxe logo as printed on its board, with "1201"); the small-OLED Bitaxes show the model name instead.
  • Special screens for block found, overheat, ASICs off (also "no pool") and firmware update; display language, time zone, screen timeout.
  • What the display shows is yours to choose (Settings → Display, with a live view of the screen): which LCD pages the key steps through, in what order and which is the start page; the cockpit's large number (hashrate, efficiency or power — the curve under it follows), its three places (chip or regulator temperature, power, J/TH, fan, shares, best difficulty, block height, BTC price, pool difficulty, uptime, input voltage) and its footer line; on the OLED which slides rotate and for how long. The factory layout is the one above; a value a board does not have shows as a dash. API: displayPages, displayStartPage, cockpitBig, cockpitSlots, cockpitFooter, oledSlides, oledInterval, displayKind (docs/07).
  • Optional BTC price and fee rates from mempool.space — off by default; with it off the miner talks to its pool and nothing else (plus the update check, which you can switch off too).

Self-test, diagnostics and event log

  • Self-test on a click under System, while the miner mines, about 80 s: chip count, every chip's and every domain's hash counter over a 60-second window, the error rate against a line per chip type (5% on the BM1370, 8% on the BM1373), the core voltage against the set value, the regulator's status, the fans' speed at 100% for 10 s (the step never lowers what the fan control wants, and the board task drops it by itself when the time is up), chip and regulator temperatures under their stop lines, the input voltage. On a stacked regulator that asks for it (Naja Duo, Gamma Hex) each phase's current on its own, under load, as ESP-Miner's factory test does: a phase under 1 A fails the check and switches the ASICs off, since the other phase then carries the whole current; since v0.1.44 a reading whose phases carry under 5 A in all (a chain restart, a pause in the pool's work) is skipped, not failed. Without work from a pool (since v0.1.42) the hash checks are marked skipped, "no work from the pool", not failed, and the rest is checked; the test switches the ASICs on while no pool answers, so a bench test works before a pool is set up. One PASS/FAIL with every check's figure in the web UI, on the display and in the API; a clock or voltage change during the test ends it. It also runs once by itself after a board's verified first start. The limits and where they come from: docs/10.
  • Diagnostics file (GET /api/v1/diagnostics): one JSON with the firmware, board, self-test result, hash counters, pool status, regulator and temperatures, memory, event log, settings and the last log lines. No passwords; the worker's address and the Wi-Fi name are masked, and every section is scrubbed of every secret the firmware knows before it is written.
  • Event log across restarts: the last 32 events (restart with its reason, overheat stop with its cause, regulator fault, pool switch, update or rollback, silent chip and a chain restart for it, a stuck domain reset, no pool and a pool back, self-test result, board check, found block and its status) with time and uptime, under System, in /api/v1/state, /api/v1/events and in the file. The web UI shows each event's details in its own language; the API and the file keep the English text in d, with a short code and the values beside it (c, p). Written on events only, never on a timer, from threads with an internal stack.
  • After a crash (panic or watchdog) the web UI shows a banner until it is dismissed: the reason and the time, a button for the diagnostics file and, if this crash wrote one, one for its core dump. A dump only counts as this crash's when the running image wrote it and no earlier boot reported it; otherwise the banner says no dump was written, and the Diagnostics card marks a dump left in flash as an older one. Since v0.1.37 a Rust panic also leaves its last words (task, file and line, message) in memory that survives the reset, and a stack overflow the name of its task; the next boot logs them and the diagnostics file carries them as lastWords, with or without a dump. Other crashes (a hardware exception, a watchdog) leave no last words, only the core dump. A crash during a restart (after an update, an upload, a restart from the web UI or on the way into download mode) becomes an event of its own that names the step, and a finished update or upload reports itself as installed on every bootloader, but not after a rollback; both need the restart to be begun by v0.1.37 or later. Up to v0.1.37 the way into download mode itself crashed every time (TinyUSB was shut down while the console still wrote to its serial port, an assert); since v0.1.38 the console goes back to USB-Serial/JTAG first. After the way into download mode a panic, or a task or interrupt watchdog the panic handler went through, is a crash of that restart; a watchdog reset without the panic handler is the flashing tool's way out of download mode (esptool's hard reset can arrive as a task watchdog) and is not. The boot line, /api/system/info and the diagnostics file carry the raw RTC reset cause as resetCause. The core dump partition is 256 KB since v0.1.37 (64 KB before, too small for most of this firmware's dumps); it arrives with one install from the browser (or over USB), not with an online update (docs/12).
  • Core dump download (GET /api/v1/coredump): since v0.1.38 the Wi-Fi password, the pool passwords, the hotspot password, the Wi-Fi name and the worker names and addresses are replaced with as many x, and the CRC32 is recomputed, so espcoredump.py still reads the file; the copy in flash stays as written.

Updates

  • Online update: the miner checks this repository's releases at start and every hour, the web UI shows the new version and its notes (and a pill in the header on every page), and one click downloads, verifies (SHA-256 and the release signature: BIP-340 Schnorr with the key built into the firmware, warpaxe.bin.sig) and installs it. A release without a signature still installs for now and is marked as unsigned; that tolerance ends once every release carries one. Nothing installs by itself: an update restarts the miner. While an install is queued, downloading, verifying or flashing, a second one is refused (409), and the web UI disables the button on the click (since v0.1.38; before, a second click could start the install again after a failed first attempt).
  • The writer needs no free memory: the online update, an upload, a restart and download mode are carried out by the firmware's main task, whose stack exists from boot on, so an update works however fragmented the internal heap is after days of mining (up to v0.1.31 an update could be refused with 45 KB free but no contiguous 16 KB block). A second image while one is queued or being written is refused at once (409 on the upload); largestFreeInternal in /api/system/info shows the largest free block (docs/09). From v0.1.33 the write runs at the priority the old writer thread had, so it no longer waits behind the mining and network threads: on a NerdQAxe++ an update takes about 60 s from upload to restart instead of 144 s.
  • Chips off before every restart: an update, a restart and download mode first switch the core voltage off and hold the chips in reset, and every boot does so before anything else. A TPS546 keeps its output on through an ESP reset, so the chips would otherwise sit powered and unwatched — a BitForge Nano reached 82 °C (on the diode scale of the time; regulator 95 °C) after three minutes in download mode. On boards with native USB a B on the USB console port (the serial port beside the USB network adapter) takes the same way as System → Download mode since v0.1.38 — before, it rebooted into the ROM with the chips still powered and no restart marker; if the firmware does not take the request within 10 s, it reboots into download mode directly.
  • Back to the stock firmware: System → Back to the stock firmware explains the way (over USB, with the backup the web flasher saved) and opens the flasher's restore section.
  • Rollback of an update that does not start: the new image boots on trial and marks itself good once the chips run (at the latest after three minutes up); a reset before that — a crash, the watchdog, a power cut — brings the previous version back, and the System page says so (otaState aborted). This needs the bootloader of v0.1.22 or later, which only a USB install writes: a reinstall with the web flasher (settings kept) gives it to a miner that has only ever been updated online.
  • Downloads are tried up to three times; the log names the address that started an install, an upload or an update check, and the last install (version and signature result) is kept across the restart. Every settings change is logged with the address it came from (/api/v1/state → config_patches). A web UI tab open during an update from elsewhere reloads itself once the miner answers with the new firmware.
  • Pool settings apply at once: a change to the main or fallback pool, the worker or the suggested difficulty closes the session and the miner reconnects with the new settings, no restart.
  • Upload a warpaxe.bin in the web UI, or curl --data-binary @warpaxe.bin http://<miner>/api/system/OTA — a manual upload is your own image and is not signature-checked.
  • The web UI and its fonts are part of the image: one file, one update.

Supported boards

Board ASICs Regulator Status
Bitaxe Gamma (601/602) 1× BM1370 TPS546 runs 24/7
NerdQAxe++ (every revision but Rev 7; NerdOS treats them alike) 4× BM1370 TPS53647 runs 24/7 (on a Rev 6.1)
NerdQAxe++ Rev 7 4× BM1370 TPS546 (two voltage domains) profile from NerdOS, recognised on the bus and offered for one click; not run yet
NerdOCTAXE-γ Rev 3.1 8× BM1370 TPS53667 (6-phase) runs since 2026-09-28; at 700 MHz / 1210 mV the pool counts 11.59 TH/s ±2.5% (NerdOS: 11.71) since v0.1.9 paces work as NerdOS does; a v2.2 board with the 4-phase TPS53647 runs at a user's since 2026-10-01 (it overheated until its second fan was linked to the chip fan, now the default)
BitForge Nano (800) 2× BM1370 TPS546 + INA260 runs since 2026-09-29 (ForgeOS's Medium preset 525 MHz / 1150 mV: 2.19 TH/s at 43–45 W; 625 MHz / 1160 mV: 2.53 TH/s at 37–38 A, just below ForgeOS v1.7's Power preset of 636 MHz / 1160 mV (610 MHz / 1200 mV since v1.8)); taken on the first start since v0.1.35 (its PCA9544 mux and INA260 exist on no other board); since v0.1.36 its regulator limits (38 / 40 A, 13.5 V input) and chip diode scale are ForgeOS's (docs/08)
Bitaxe Gamma Duo (650) 2× BM1370 TPS546 profile; runs at a user's since 2026-09-30 (v0.1.10), not on our bench; free clock values with ?oc as on the Gamma
Bitaxe Gamma Turbo (801) 2× BM1370 2× TPS546 profile; runs at a user's since 2026-10-01 (v0.1.11), not on our bench (a pair at 850 MHz / 1250 mV under AXP90 coolers; both chips' diodes read since v0.1.42, the start without a false overheat stop since v0.1.43, the diodes counted only once the chips run since v0.1.44); free clock values with ?oc as on the Gamma
Bitaxe Naja Duo (1201) 2× BM1373 2× TPS546 (two domains) runs since 2026-11-12 (v0.1.44, on our bench; the web UI marks it untested until it has run for some days); the chips come up with ESP-Miner's BM1373 init (3 MBaud, the IO strength for the end of each voltage domain), the same init at 1 MBaud and NerdOS's behind it as fallbacks (chipInit), the chip's 6860 small cores (both chips' counters read about 6900, as the Gaia's) and a 50 °C fan target; one silent chip is reported, not restarted, until the nonce-to-chip attribution has been seen on a device; the self-test reads both regulator phases; AxeOS's display rotation taken over the right way up since v0.1.44; clock options up to 550 MHz and the core voltage capped at 1120 mV since v0.1.45 (WarpTune's Max ceiling; a higher stored voltage is set to 1120 mV at start); free values up to 600 MHz, the maker's documented overclock (600 MHz / 1120 mV; on our bench it ran 2.6 h, with the regulator at 84 °C without a rear fan)
Bitaxe Gamma Hex (1300) 6× BM1370 4× TPS546 (two domains) profile only, not run yet; only the EMC2103's diode 2 is read as the chip temperature (ESP-Miner also acts on diode 1: to be settled before its first run)
NerdAxe Gamma 1× BM1370 TPS546 profile only, not run yet
NerdAxe Gaia 1× BM1373 TPS546 (12 V) runs since 2026-09-29; at 420 MHz / 960 mV the pool counts 102% of the expected rate, as with its stock firmware, but the core then draws 31–33 A against the regulator's 33 A limit, so ours runs at 380 MHz / 960 mV (31 A); clock and voltage capped at 420 MHz / 970 mV; since v0.1.16 its regulator runs in the range the board is strapped for (0.5–1.5 V); taken on the first start since v0.1.35 (TPS546 and EMC2101 on the Nerd pins with 12 V at the regulator; the same parts at 5 V are a NerdAxe Gamma)
NerdQX (Q1370 / Q1373) 4× BM1370 / BM1373 TPS53647 or, on the Q1373, the 6-phase TPS53667 profile only, not run yet
NerdNOS (T-Display-S3 carrier, rev 1.3) 1× BM1397 TPS566247, fixed by resistors (about 1.4 V), enabled by the firmware runs since 2026-10-08: at 300 MHz the pool counted ≈190 GH/s over an hour, the stock firmware ≈180 GH/s on the same pool and clock (±6–9% each); ours runs there, at about 73 °C with a case fan (the board has none of its own); after an overheat stop it comes back one clock step lower; the clock is set by hand, the temperature comes from a thermistor, the power is an estimate; taken on the first start when the thermistor on GPIO2 and the 1.4 V rail on GPIO3 both answer (the buck switched on for 150 ms for the reading, the chip held in reset); the chip runs only from the carrier's own USB-C. Details: docs/03
LilyGO T-Display-S3 (NerdMiner hardware) none: the ESP32-S3's SHA unit and one CPU core none (USB power) experimental, see below

Boards marked "profile only" have pins, regulator window and limits taken from their stock firmware, but nobody has run WarpAxe on one yet. Please don't flash them unless you can recover the stock firmware over USB.

The Bitaxes on other chips (Max with the BM1397, Ultra and Hex with the BM1366, Supra and Supra Hex with the BM1368) cannot run WarpAxe, nor can TinyChipHub's Zyber boards (8S, 8G, 8G+, 12G: one regulator for four voltage domains in series, no profile in WarpAxe). Since v0.1.47 the installer page recognises them from the settings their stock firmware keeps and stops before it writes anything, and the firmware names them on its first start and leaves their chips off.

Experimental: the T-Display-S3 without an ASIC

⚠️ Hot to the touch. Hashing all the time, the T-Display-S3 gets to about 60 °C on its back. Put it in a case before you leave it running, and don't hold it in your hand while it mines.

The LilyGO T-Display-S3, the board NerdMiner runs on, has no mining chip. WarpAxe hashes on the ESP32-S3 itself there: the chip's SHA unit on one core with a precomputed midstate, as NerdMiner v2 does (src/mining.cpp), and a software loop on the other, together about 340 kH/s on USB power (docs/06-Devkit-S3-SHA-Peripheral.md has the measurements). That is a lottery ticket, not a miner: at today's network difficulty the expected time to a block is far longer than the age of the universe. It is marked experimental. It takes online updates like every other board, but only releases that ran on a T-Display-S3 before they were published: a release lists the boards it was tested on in tested-on.txt, and the T-Display-S3 shows a newer one without it as "not yet released for this board" and does not install it.

  • Installed with the same image and the same web flasher as every other board. On the first start a board on which nothing answers on the I²C bus and that still holds a NerdMiner's settings becomes the T-Display-S3: Wi-Fi from the ESP's Wi-Fi storage and the wallet from NerdMiner's config.json are taken over, the worker is <wallet>.WarpMiner, the pool is WarpPool (Stratum V1, a share difficulty of 0.005, about 40 shares an hour). Without NerdMiner's settings it is offered in the board choice, never taken on its own.
  • Stratum V2 works too: WarpPool from v1.37.1 recognises the board by its agent string (warpaxe-cpu/… (nerdminer-class)) and opens its channel at the same small difficulty. Other Sv2 pools may start a channel far too high for a few hundred kH/s, so that no share ever arrives; stay on V1 there.
  • The web UI and the display show kH/s, the ESP32-S3's own temperature, shares per hour and the uptime; its Settings page has the display only (no clock, voltage or fans). At 85 °C the hashing pauses, at 75 °C it resumes.
  • The way back to NerdMiner is the web flasher's full backup, restored over USB (download mode: hold BOOT, press RST, release BOOT).

Install

New to WarpAxe? The user manual (PDF, in English, German, French and Spanish) walks through the install, the first start, every page of the web UI, the display, updates and the way back, step by step.

First install needs a USB cable once; after that the miner sets itself up and updates itself:

  1. Keep a way back — the web flasher saves the miner's whole flash (16 MB: stock firmware and settings) into a file you choose before it writes anything (on by default, about 2½ minutes, every block checked against the chip), and its Restore a backup section puts such a file back. Without the browser, tools/flash-backup.sh does the same with esptool. Or keep the stock firmware at hand (the Bitaxe and NerdQAxe web flashers put it back; for the other boards, the maker's own flasher or image).
  2. Install WarpAxe from the browser with the web flasher at warppool.org/warpaxe (Chrome or Edge on a computer). It writes bootloader, partition table and app and leaves the settings partition alone, so WarpAxe reads what AxeOS or NerdOS left there; it checks every part against the flash and restarts the miner when it is done. (A miner first installed with WarpAxe before v0.1.37 and since updated only online keeps its old partition table, whose core dump partition of 64 KB is too small for most of this firmware's crash dumps; one flash from the browser gives it the 256 KB table and keeps the settings, docs/12.) The flasher serves the current release; its image carries the same signature the online update checks. Coming from the stock firmware, the flasher usually puts the miner into download mode by itself; otherwise hold BOOT, press RST, release BOOT (on a miner that already runs WarpAxe: System → Download mode, or a B on its USB console port). A miner that stays dark after a cancelled install is still in download mode: take it off power completely — power supply and USB cable — for a few seconds. Without a browser: warpaxe-factory.bin from the release at offset 0 with esptool (this one starts with empty settings), or Build from source.
  3. On the first start WarpAxe takes Wi-Fi, pools, hostname, clock and voltage, fan settings, temperature limits and display orientation from the previous firmware (not the fan PID gains, which belong to its own loop; and not clock, voltage and fans if that firmware was in its overheat mode, whose emergency point no owner chose) and finds the board: from the model AxeOS stored at the factory, or from the chips that answer on the board's I²C bus (read-only probes on pins that switch nothing). A board found for sure (a Bitaxe Gamma, a BitForge Nano, a NerdAxe Gaia) starts at once. Otherwise — the NerdQAxe++ and the NerdOctaxe look alike on the bus, and a board that has never run WarpAxe is only offered — the web UI asks once which board it is, listing only the boards that fit, and the chips stay off until you answer. A core rail the stock firmware left on is switched off meanwhile; the display already runs, so the setup hotspot's name and password show while you choose. Every board, found or chosen, is checked against the bus before any of its pins is driven; its chips then come up at a cautious voltage (the lowest of the boards that look alike on the bus) and are counted. When their number and type match the profile, the board counts as verified, the configured voltage applies and the self-test runs once by itself; a board that does not fit is refused with the reason, and the chips stay off. A board set up by an earlier WarpAxe version is taken as verified on the update (docs/11).
  4. Open the web UI at the miner's address — or, on boards with native USB, at http://192.168.7.1 over the USB cable (the miner shows up as a USB network adapter; a second WarpAxe on the same computer needs another number in Network → USB address, e.g. 192.168.8.1). If there was no Wi-Fi to take over, or it cannot be reached, the miner opens its setup hotspot after three minutes: join WarpAxe-XXXX with the password on its display and choose your network.

Updates after that come from the web UI: System → Online update → Install (a bar under the header follows it on every page and says when the miner is back on the new version), or upload warpaxe.bin from the releases page. Every release carries warpaxe.bin (one image for all boards — the board is configuration), warpaxe.bin.sha256, warpaxe.bin.sig and tested-on.txt (the boards it ran on before it was published); for the first install also warpaxe-factory.bin (bootloader, partition table and app in one image) and web-flasher.tar.gz (the web flasher as published), with their checksums in install.sha256. tools/verify-release.py checks an image's signature without the Rust toolchain.

Build from source

Host crates and tests:

cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings
cargo build -p warpaxe-core -p warpaxe-chain -p warpaxe-board -p warpaxe-ota \
    -p warpaxe-inflate --target thumbv7em-none-eabihf          # proves no_std

Firmware (Xtensa, ESP-IDF 5.3 via esp-idf-svc; toolchain from espup; its export script must be sourced first, the C code in secp256k1-sys needs xtensa-esp32s3-elf-gcc on the PATH):

cd firmware/warpaxe
cargo build --release
espflash save-image --chip esp32s3 --flash-size 16mb \
    target/xtensa-esp32s3-espidf/release/warpaxe warpaxe.bin   # OTA image
espflash flash --partition-table partitions.csv \
    target/xtensa-esp32s3-espidf/release/warpaxe                # first install over USB

Display preview on the host (every page, special screen and OLED slide as PNG, from the firmware's own drawing code):

cargo run --release --manifest-path tools/display-preview/Cargo.toml -- /tmp/frames
for f in /tmp/frames/*.raw; do python3 tools/frame2png.py "$f" "${f%.raw}.png"; done

Fonts and the splash are generated from tools/fonts (SIL Open Font License) and docs/brand by tools/make-fonts.py and tools/make-splash.py (which also packs the splash pictures for the image: --pack does only that); releases are published with tools/release-firmware.sh. tools/image-breakdown.py says where the image's bytes are, from the last build's linker map (docs/16).

Repository

The main repository is git.warppool.org/dvb-projekt/dvb-WarpAxe; releases and the devices' online updates come from there. github.com/dvb-projekt/dvb-WarpAxe is a mirror, updated on every push. Issues and pull requests are welcome on either; pull requests opened on GitHub are carried over to the main repository and merged there.

Path What
crates/core BM13xx wire protocol: frames, CRCs, decoders, PLL solvers (ESP-Miner's and cgminer's gekko formula), register payloads, SHA-256 midstates for the BM1397, chip profiles with the init sequence as data — no_std, no alloc
crates/chain the chain driver over a Uart trait — no_std, the code the firmware runs
crates/board regulators, fans, fan PID, board profiles over an I2c trait — no_std, tested against a scripted bus
crates/drivers the part drivers crates/board builds on: embedded-hal's I2c re-exported, EMC2302 fan controller, INA260, TMP1075, PCA9544, SSD1306 OLED with its 5×7 font, PMBus number formats, NTC thermistor — no_std, MIT OR Apache-2.0 for use in other firmware
crates/stratum Stratum V1 without sockets: messages, jobs, coinbase reading and payout (the worker's address decoded — base58, bech32/bech32m, CashAddr — for any SHA-256 coin), tested against a captured WarpPool session
crates/sv2 Stratum V2 client: Noise handshake, framing, mining messages, release-signature tool; tested against WarpPool's Sv2 server
crates/ota the firmware writer's hand-off: one image (or restart) at a time to the main task, a second refused — no_std, host-tested
crates/inflate a small DEFLATE decoder: the boot screen's pictures are in the image packed and unpacked into the frame buffer when drawn (docs/16) — no_std, host-tested against the raw pictures
crates/jsonval serde_json's json! with each entry's code out of line: the API documents have several hundred keys, and the stock macro spends about 140 bytes of the image on each — host-tested against the original
crates/diag the diagnostics file's privacy rules (passwords never, addresses and the Wi-Fi name masked, every section scrubbed) and the event log's ring — host-tested
crates/avalon read-only cgminer API client for an Avalon (summary, estats, pools), translated to an AxeOS-like document
crates/cpuminer SHA-256 hashing without an ASIC for the T-Display-S3, NerdMiner settings import
crates/displaycfg the display's page, cockpit and slide names, defaults and PATCH checks
crates/sim, crates/simuart a simulated BM1370/BM1373/BM1397 chain and board with fault injection
crates/axeos, crates/cgminer AxeOS- and cgminer-compatible devices on top of the simulator, for testing tuners
crates/scenarios WarpTune's tuning loop, in-process, against the simulated devices (git dependency on dvb-WarpPool)
firmware/warpaxe the ESP32-S3 firmware: Wi-Fi and USB networking, Stratum, miner, board, web UI, display, updates
tools/ font and splash generators, display preview, flash backup, release script

Run the simulated AxeOS device, for example to test a tuner:

cargo run --release -p warpaxe-axeos -- --port 8811 --time-scale 30
curl -s http://127.0.0.1:8811/api/system/info | jq .
curl -s -X POST -d '{"board":{"SilentVrShutdown":{"above_hz":600000000}}}' http://127.0.0.1:8811/sim/fault

Design

  • docs/00-Design-BM1370.md — architecture, chip profiles, PLL, simulator, findings, the transport decision (USB-NCM + USB bridge) and the firmware's operating notes;
  • docs/01-Benefit-for-WarpTune.md — what this buys WarpTune, concretely;
  • docs/02-Demo-WarpTune-vs-Sim-2026-09-23.txt — the first run of WarpTune against the emulator, unedited;
  • docs/04-Octaxe-Warm-Reboot-Latch.md — the NerdOctaxe's hash domain that only a power cycle cleared: NerdOS against WarpAxe step by step, the bench that found the cause (a clock-delay trim, fixed in v0.1.24) and how it was tested;
  • docs/05-BM1373-init-NerdOS-vs-ESP-Miner.md — the BM1373's init on the wire, NerdOS (the Gaia's stock firmware and ours) against ESP-Miner's, and an A/B on the NerdAxe Gaia: the same rate and the same error count, so the Gaia keeps NerdOS's init; the Bitaxe Naja Duo, ESP-Miner's own board, gets ESP-Miner's by default, with the chipInit setting (espminer, espminer-1m, nerdos) to pick one by hand and a fallback down that list when a chain does not come up;
  • docs/06-Devkit-S3-SHA-Peripheral.md — the T-Display-S3's SHA peripheral measured cycle by cycle, and how writing the next block while the engine runs took the devkit from about 290 to about 340 kH/s (--features shabench builds the bench);
  • docs/07-Display-choices-and-Avalon-swarm.md — the display's choosable pages, cockpit places and OLED slides (names, defaults, why the curve follows the large number), and the Avalon on the swarm page: the cgminer fields and what each is used as, the read-only guard rails, the image size before and after;
  • docs/08-Temperature-stop-limits-against-the-stock-firmware.md — the lines AxeOS and NerdOS actually stop at (75/105, 70/70, none on the one-fan NerdAxe), board by board, and why WarpAxe up to v0.1.31 stopped later on a Bitaxe;
  • docs/09-Update-with-a-fragmented-heap.md — an update refused with 45 KB free but no contiguous 16 KB block, and why the main task writes the firmware now;
  • docs/10-Self-test-diagnostics-and-event-log.md — the self-test against ESP-Miner's, its checks and limits and the runs on four boards; the diagnostics file's privacy rules; the event log's flash wear; the crash banner;
  • docs/11-Board-choice-guard.md — how a found or chosen board is checked against the bus before its chips get power, the cautious first start and the chip count, every wrong pair of boards and what refuses it;
  • docs/12-Panic-without-a-core-dump-in-the-restart-after-an-update.md — the crash in the restart after an update that left no dump, the restart marker and last words, the 256 KB core dump partition, and the way into download mode that crashed up to v0.1.37;
  • docs/15-A-clock-of-its-own-per-chip.md — why the weakest chip sets a board's voltage, the offset per chip and its limits, the ramp that never takes a chip above its own clock, what follows a chip's clock, what the devices said on 2026-11-12, and the device tests still to run.

Short version: registers and init sequences are data, not code per chip; the PLL is solved, so the reported frequency is the real one; and the simulator exists to make field failures reproducible — including the one that started this project, a regulator that shut down silently while the stock firmware kept reporting full hashrate.

Provenance

The BM1370/BM1373/BM1397 have no public datasheet. What is known comes from reverse engineering, chiefly ESP-Miner (GPL-3.0) and, for the Nerd boards, ESP-Miner-NerdQAxePlus (GPL-3.0); for the BM1397 also ESP-Miner's Bitaxe Max driver, cgminer's driver-gekko.c (GPL-3.0), the NerdNOS hardware (WantClue/NerdNOS, rev 1.3) and its firmware, WantClue/NerdMiner_v2 branch nerdnos (MIT), compared step by step in docs/03. Every constant lifted from there says so in its doc comment; every test vector says where it came from. The Bitcoin whitepaper the web UI links to (on warppool.org, next to the installer) is Satoshi Nakamoto's bitcoin.pdf (SHA-256 b1674191…f553).

Earlier Rust work on the same chip family: GPTechinno/bm13xx-rs (MIT/Apache-2.0), a no_std driver for the BM1397, BM1366 and BM1370, split into crates for the protocol, the chain and each chip, with every register described as a typed struct with named fields. It came first and deserves the credit for showing that these chips can be driven cleanly from Rust. WarpAxe's chip layer was written separately and contains no code from it.

The EMC2101 fan and temperature chip (Bitaxe Gamma and Gamma Duo, NerdAxe Gamma and Gaia, BitForge Nano) is driven by the emc2101 crate by GPTechinno (MIT/Apache-2.0) since v0.1.46; WarpAxe's board code only sets it up for each board.

The Stratum V2 client uses the noise_sv2 crate from the Stratum V2 reference implementation for its Noise handshake; the messages and the channel logic are WarpAxe's own.

The makers' wordmarks on the boot screen come from the makers' own firmware: the Nerd boards' are cut from NerdOS and BitMaker's Gaia firmware themes, the NerdNOS lettering from WantClue's NerdNOS firmware, the Bitaxe wordmark is ESP-Miner's, unchanged, and the Naja Duo's is the logo and revision text of its board's silkscreen (bitaxeorg/naja-duo). They are shown with the consent of solomining.de (trade mark holder for the Nerd names), shufps, Bitronics (BitMaker, maker of the Gaia), WantClue (NerdNOS) and skot (Bitaxe). Sources and each consent are in docs/brand/nerd and docs/brand/bitaxe.

License

GPL-3.0-or-later (see LICENSE), for the reason above, except crates/drivers: MIT OR Apache-2.0 at your option (LICENSE-MIT, LICENSE-APACHE), so other firmware can use those drivers. They were written from the datasheets and published board schematics, and the font is a widely circulated 5×7 table. The drivers that follow ESP-Miner's or NerdOS's code in places stay GPL. The fonts in tools/fonts are under the SIL Open Font License. The makers' names and wordmarks remain their trade marks; the licence does not grant their use (see Provenance).