huashu-bird-sticker
花叔开源的全球鸟类贴纸库 · AI-generated stickers for 11,000+ bird species (AviList v2026), CC BY 4.0, with names in 43 languages and structured data
- 804
- 1 d ago
A Bitcoin node, 100% AI-generated: hand-authored assembly with a C orchestration layer, for Linux x86-64 (NASM) and macOS on Apple silicon (AArch64). Fully verifies consensus from genesis; UTXO set MuHash-identical to Bitcoin Core; follows mainnet live; serves most of Core's RPC surface. No independent human audit — do not run this.
Repo BobClawblaw/bitcoinmachinecode, read from GitHub 15 min ago. BobClawblaw has not joined Take My Repo.
BobClawblaw/bitcoinmachinecode is a public repo on GitHub by BobClawblaw. A Bitcoin node, 100% AI-generated: hand-authored assembly with a C orchestration layer, for Linux x86-64 (NASM) and macOS on Apple silicon (AArch64). Fully verifies consensus from genesis; UTXO set MuHash-identical to Bitcoin Core; follows mainnet live; serves most of Core's RPC surface. No independent human audit — do not run this. It declares the Apache-2.0 license on GitHub. It is written mainly in C, has 3 stars and last changed on 2026-11-21. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Bitcoin Machine Code (bmc) is a full validating Bitcoin node for Linux on
x86-64 and macOS on Apple silicon (Darwin, arm64), written in hand-authored
assembly (NASM for x86-64, AArch64 for Apple silicon) with a C orchestration
layer shared by both. Both build from main. The same x86-64 code also runs
natively on Windows through a Linux syscall emulation layer (port/win/,
see Windows).
Every line of assembly and C in the tree is AI-authored. It downloads and
verifies the chain from genesis (with Core's assumevalid default;
assumevalid=0 evaluates every script), maintains a chain-scale UTXO set that matches Bitcoin Core's
chainstate entry for entry, runs a Core-style mempool and transaction relay,
serves Bitcoin Core's JSON-RPC surface, maintains the optional txindex,
coinstatsindex and blockfilterindex indexes, and includes an HD wallet
with at-rest encryption. It speaks the Bitcoin P2P protocol over IPv4, IPv6,
Tor, I2P and CJDNS, with BIP324 encrypted transport, and runs on mainnet,
testnet4, signet (public or custom) and regtest.
Status: experimental. The code has been through internal and external security review (see
docs/audits/), most recently the 2026-10-23 review and a formal verification of four areas (docs/history/2026-10-23-the-review/). It has not received an independent human audit of its consensus and cryptographic assembly. Run it for study and evaluation, on a machine you can afford to lose, with no funds near it. For a production node, run Bitcoin Core.
Consensus and validation
MAX_MONEY range checks, and exact nBits schedule enforcement
(bad-diffbits) including testnet4's min-difficulty rules and BIP94.validation/gen_script_flags.py), including the historical exception
blocks matched by hash.assumevalid follows Core: the chain's built-in assumed-valid block (mainnet
938343 in Core v31) unless overridden; script evaluation is skipped at and
below it, every other check runs. assumevalid=0 evaluates every signature
in every block, and a mainnet sync run that way completed on 2026-09-27:
8 h 0 m to the tip at nice 10, with the UTXO set's per-height MuHash equal
to Core's at every height checked
(docs/releases/2026-09-27-crypto-parity-and-the-full-verification-sync.md).rev*.dat files like Core's (2026-09-08), so fees and prevouts
are available for the whole chain and a reorg is bounded only by the
chain, not by a window.Initial block download
bmc.catchupworkers,
Core's preferred-download set), each fetching a 16-block chunk
(bmc.dlcchunk) with one getdata per chunk, with blocks placed by hash
as they arrive. Requests stay inside Core's 1,024-block window above the
connected tip (BLOCK_DOWNLOAD_WINDOW). A chunk a worker gives up on goes
to a retry ring, never a hole left behind. Core's stall rule judges the
window's tail: while the window is full, the holder of its oldest missing
chunk has 2 s (doubling to 64 s). Then it is disconnected and the chunk
goes to an idle worker at once. A peer that stalls a second time is banned
for the run. Workers stage each verified chunk to a file, and one committer
process appends the archive in height order, so the block files are laid
out monotonically and the archive never holds a hole (unlike Core's
arrival-order blk*.dat). bmc.dlshape=core downloads by Core's own rules
instead, for benchmarks.docs/ENGINEERING_RULES.md rule 11).DD:HH:MM:SS at the last ten minutes' rate),
what is in flight, and how old the oldest gap is.headers.dat ahead of the archive
is the normal state) and resumes; a fresh datadir has genesis seeded on
every chain.Storage
blk*.dat + positional index.datheaders.dat + chainwork.dat) per chain.gettxoutsetinfo muhash at the same height as the
parity check, both sides pinned to that height.prune=<MiB>), with whole-file-granular deletion and a refusal to
delete anything below a sync hole.checkblocks/checklevel) at Core's defaults;
reindex and reindex-chainstate.Mempool (Core policy)
maxmempool) shared across all node processes, with
Core's TrimToSize feerate eviction, blob compaction, and a dynamic
mempoolminfee.replacement-failed). Acceptance is bounded by Core v31's cluster limits
(64 transactions / 101 kvB) alone, measured on the post-replacement
diagram, and every cluster is linearized optimally (since 2026-10-01).submitpackage with
child-pays-for-parent effective feerate, and 1-parent-1-child (1p1c)
package relay.datacarrier/datacarriersize,
permitbaremultisig, dustrelayfee, minrelaytxfee,
incrementalrelayfee, mempoolexpiry, acceptnonstdtxn.mempool.dat persistence in Core's format (persistmempool,
savemempool, importmempool); estimatesmartfee/estimaterawfee on a
port of Core's block-policy fee estimator (three horizons, feerate
buckets, fee_estimates.dat), byte-identical to Core on regtest.P2P and relay
notfound memory, and
MSG_TX/MSG_WITNESS_TX getdata service.wtxidrelay, BIP144 witness transport with witness-only peer
preference, stripped-block serving to legacy peers, sendheaders,
feefilter.MSG_CMPCT_BLOCK getdata and getblocktxn, negotiates sendcmpct, and
reconstructs announced blocks from its mempool with a getblocktxn round
trip for what it lacks (daemon/cmpct_recv.c; the receive path completed
its first reconstruction on 2026-09-09 — a 5-byte command compare had
swallowed every blocktxn until then). Every reconstruction is checked
against the witness commitment before it is stored (2026-09-27): a mutated
one — a witness-stripped coinbase, a changed nonce — is fetched in full and
never marked invalid, as Core's BLOCK_MUTATED. bmc.cmpctrecv=0 makes
every outbound leg request full blocks.getcfilters, getcfheaders,
getcfcheckpt) backed by the whole-chain filter index.v2transport, default on).addrv2 with a version-2 address book covering all five networks
(IPv4, IPv6, Tor onion v3, I2P, CJDNS), getaddr gossip ingest, self-
address advertisement, addpeeraddress.setban/listbanned/clearbanned,
bantime), whitelist (noban) and whitebind, asmap bucketing,
minimumchainwork, maxuploadtarget, blocksonly.Wallet
getnewaddress hands out bech32 addresses; signs
P2PKH, P2SH multisig, P2WPKH, P2WSH and P2TR spends.encryptwallet, walletpassphrase,
walletpassphrasechange, walletlock) using AES-256-CBC under Core's
BytesToKeySHA512AES key derivation.createpsbt, decodepsbt, converttopsbt, combinepsbt,
joinpsbts, analyzepsbt, finalizepsbt, utxoupdatepsbt,
walletprocesspsbt.importdescriptors, listdescriptors,
createwalletdescriptor, addhdkey, exportwatchonlywallet.createwallet, loadwallet, unloadwallet,
restorewallet, listwallets; bumpfee/psbtbumpfee with Core's
feebumper arithmetic; branch-and-bound coin selection; external signer
(signer=, HWI-style); message signing.RPC, indexes and notifications
help, which is
generated from those tables rather than hand-maintained). Three of the 162
are listed but refuse with an explanation: getopenrpcinfo and
rpc.discover (no OpenRPC service description is published) and
exportasmap (this node uses no asmap). help itself answers with the
method list, not Core's per-method usage text. Otherwise Core's result
shapes, error codes and messages. See
docs/RPC_LIVE_NODE.md.txindex, txospenderindex, coinstatsindex (incremental MuHash, so gettxoutsetinfo
answers without a UTXO walk) and blockfilterindex (BIP158 basic filters
plus the filter-header chain), all tip-following; getindexinfo.addrindex (an extension with no Core equivalent): getaddressbalance
and getaddresstxids.docs/devlog/INDEX_RUNS.md.bmc.esploraport, 2026-09-08) answers
mempool.space's BACKEND: "esplora" in-process from the same RPC
dispatch: blocks, transactions with fees and prevouts, outspends, merkle
proofs, the mempool, fee estimates, and address pages from a native
address history index (about 200 GB on mainnet, built during the sync).
mempool.space runs against the node unpatched; see
docs/MEMPOOL_SPACE.md. The listener sends no
wildcard CORS header, bounds its batches, and serves from a fixed thread
pool with total deadlines.getblocktemplate/submitblock/submitheader,
prioritisetransaction, dumptxoutset (assumeutxo snapshot export).hashblock, hashtx, rawblock, rawtx and Core's
mempool sequence topic, with per-topic high-water marks; blocknotify,
alertnotify, startupnotify, shutdownnotify shell hooks.Chains
main, testnet4, signet (public, or a custom signetchallenge whose
network magic is derived from the challenge) and regtest. Legacy
testnet3 is refused rather than run under the wrong rules.nasm, gcc, GNU ld, make, and python3 (build tooling,
audits and test oracles).port/osx/, built with Apple clang and
python3 only (no NASM, no GNU toolchain). See
macOS / Apple silicon below.port/win/winsys/. See Windows
below.dbcache, default 450 MiB, Core's) grows
to multiple GB in bulk catch-up mode during initial sync.tor daemon (SOCKS and control port), an I2P router with the
SAM bridge (i2pd), and cjdroute for the respective networks.asm/cuda/ batch-hash
tier; the dispatcher falls back to CPU without it.On Linux / x86-64 (for macOS see macOS / Apple silicon):
cd asm
make daemon/bmcbitcoind # the node daemon (asm/daemon/bmcbitcoind; was bitcoind until 2026-09-07)
make test # the full gate: audits + every test harness
make with no target is make test. The gate builds 353 test binaries and
makes 348 harness invocations (crypto vectors, consensus differentials against
Bitcoin Core, mempool policy, P2P codecs, BIP324 vectors, RPC shapes, storage
and crash-recovery cases) after a set of static audits. BLD-5 (2026-09-05):
this said "about 290 test binaries"; the live figure is
grep -cP '^\t\./tests/' asm/Makefile.
| audit | checks |
|---|---|
abi-check / callee-saved-check |
every C-to-asm call site honours the SysV stack-alignment and callee-saved contract |
prereq-check |
no Makefile recipe reads a file it does not declare as a prerequisite |
link-check |
every rule links the object that defines each symbol its sources need |
runlist-check |
every test is either in the gate or declared manual with a reason |
gate-log-check LOG=<file> |
a saved gate log shows make exiting 0 and every gated test actually executed |
Other binaries built under asm/daemon/: bmc_cli (Core-compatible
JSON-RPC client), cli (query the stored chain directly), wallet_cli,
and the archive tools (check_chain, verify, dumpblock, unified_ibd,
chainctl).
main builds the node natively on Apple silicon (since 2026-11-05, PR
#453): every x86 assembly module the daemon runs has an AArch64 / Mach-O
counterpart in port/osx/ (the same exported symbols, so the shared C —
daemon, RPC, tests — is one source for both platforms), and the repo's own
test harness runs natively. The Mac work happens on the bmc_osx branch and
reaches main through PRs, as x86 work does.
port/osx/build_daemon.sh # bmcbitcoind + the tools, into port/osx/daemon_out/
port/osx/build_wallet_cli.sh # bmc_wallet_cli
port/osx/run_tests.sh # the full gate, natively (--no-build to skip the build; names to run a subset)
port/osx/fetch_fixtures.sh # the large gitignored fixtures, from a local Bitcoin Core
Requirements: Apple clang (cc -arch arm64), python3; the daemon and the
tools link against the system libc, so no NASM, no GNU toolchain. The daemon
compiles with -Wall -Werror, the same bar as the x86 build, and a file that
fails to compile stops the build before the link. The Mac's gate runs 480
commands. On a fresh clone of main (2026-11-05) it gives 448 PASS,
16 SKIP, 16 N/A, 0 FAIL. The N/A rows are the x86-only differential tests of shadow twins
that no daemon links. Both a mainnet and a signet node run
from bmc_osx on an M-series Mac, at Bitcoin Core's tip, with the mainnet
UTXO set identical to Core's on every gettxoutsetinfo field
(docs/PARITY_ATTESTATION.md).
| document | contents |
|---|---|
port/OSX_STATE.md |
the port's dated state: what landed, how it was proven, the numbers (read first) |
port/OSX_ROADMAP.md |
per-module status and verification method; a status summary at its top |
port/OSX_PORT.md |
the branch model, how main is merged in, the layout |
port/OSX_STRATEGY.md |
the plan of record, written before the port began |
port/osx/BENCHMARKS_OSX.md |
timings on Apple silicon |
worklog/*-osx.md, worklog/*-note-for-x86*.md |
the Mac side's daily trail and its notes to the x86 side |
The node also builds and runs natively on Windows 10/11 x86-64, with no
WSL, no Cygwin and no MSVC runtime. The x86-64 assembly and the shared C
are the code Linux runs. The C is compiled for Linux to LLVM IR and
retargeted to Windows, the NASM modules are assembled -f win64, and
port/win/winsys/ emulates the Linux syscalls they make on Win32/NT,
fork included. So a change to main needs no Windows counterpart; it
builds on Windows as it is. The Windows work happens on the windows-port
branch and reaches main through PRs, the same model as the Mac's.
python port\win\build.py daemon:bmcbitcoind daemon:bmc_cli daemon:bmc_wallet_cli
python port\win\run_tests.py :: the Windows gate: asm/Makefile's test list + the port's tests
port\win\out\bin\bmcbitcoind.exe serve C:\bmc-data
Requirements: LLVM/clang (with lld-link), NASM, the Windows SDK import
libraries (Visual Studio Build Tools or a standalone SDK), Python 3, and Git
for Windows for the gate's shell-script tests. The gate runs the
./tests/... lines of asm/Makefile's test: recipe, so a test added on
main is in the Windows gate without a change. Four tests are N/A on
Windows, each for a reason the platform imposes (a pty, page-cache
residency, ptrace, ELF headers; listed in
port/WIN_PORT.md). A signet node runs from
windows-port natively on Windows, synced to the tip.
| document | contents |
|---|---|
port/WIN_STATE.md |
the port's dated state: what landed, how it was proven, the numbers (read first) |
port/WIN_PORT.md |
the design, the build, the gate, the branch model |
worklog/*-win.md |
the Windows side's daily trail |
Create a configuration. Copy the reference file and edit it:
cp config/bitcoin.sample.conf config/bitcoin.conf
The daemon reads <datadir>/bitcoin.conf, then <datadir>/../config/bitcoin.conf,
or the path in $BITCOIN_CONF. The file is shared by every chain; keep
it at the datadir root, not inside a chain subdirectory.
The copy above lands in the repository's config/, which the daemon
only finds when the datadir is <repo>/data. With a datadir anywhere
else, put the file at <datadir>/bitcoin.conf (or export
BITCOIN_CONF). A daemon that finds no file logs [config] no config file at ... -- using compiled defaults and runs on the defaults: P2P
port 8333, RPC on loopback, dbcache=450 (1024 until 2026-09-29). The fresh-install acceptance
test (validation/fresh_install_ibd.sh) hit exactly this on its first
run, 2026-09-02.
Run the daemon.
asm/daemon/bmcbitcoind serve /path/to/datadir [port] [nwant] [workers]
serve is the production mode: it binds the P2P listener, discovers
peers, syncs headers, fills any archive gap with parallel download
workers (default 10, Core's preferred-download set: the 8 full-relay and
2 block-relay-only outbound peers; bmc.catchupworkers overrides), builds
the UTXO set with full script verification, then follows the tip while
serving inbound peers and RPC. A first mainnet sync on the benchmark box
(Ryzen 9 9950X3D, 16 cores, 123 GiB RAM, NVMe; default settings, so
assumevalid on) reached the tip with every index in 4 h 2 m (run 44,
2026-10-08); Core v31.1 took 9 h 50 m there. With assumevalid=0 it took
8 h 0 m. Expect longer on fewer cores, a slower disk or a slower link. The [dl] heartbeat: log line reports tip height, live peers, UTXO count and uptime.
The daemon honours SIGTERM and the stop RPC.
Talk to it. Cookie authentication is on by default:
<datadir>/<chain>/.cookie is written (mode 0600) at startup and deleted
at shutdown. bmc_cli resolves the port and cookie from the datadir:
asm/daemon/bmc_cli -datadir=/path/to/datadir getblockchaininfo
asm/daemon/bmc_cli -datadir=/path/to/datadir -signet getblockcount
Any JSON-RPC client works, including Bitcoin Core's bitcoin-cli and
curl:
curl --user "$(cat /path/to/datadir/main/.cookie)" \
--data '{"jsonrpc":"2.0","id":1,"method":"getblockcount","params":[]}' \
http://127.0.0.1:8332/
Datadir layout. Every chain lives in its own subdirectory, mainnet included:
<datadir>/
bitcoin.conf shared configuration (optional location)
main/ one directory per chain: main, testnet4, signet, regtest
blk*.dat index.dat headers.dat chainwork.dat block archive
utxo.dat utxo_run_*.dat utxo_manifest.dat ... LSM UTXO store
txindex.* txospender.* addr_hist.* bfilters.* coinstats.* optional indexes:
sorted runs + a bounded tail each, built during the sync
peers2.dat address book (all networks)
bmcwallet.enc | bmcwallet.dat, *.txlog wallet store and journal
mempool.dat mempool persistence
.cookie RPC cookie (while running)
debug.log the daemon's own leveled log (Core's name and place)
Running under systemd. A minimal unit:
[Unit]
Description=Bitcoin Machine Code daemon
After=network-online.target
[Service]
User=bitcoin
WorkingDirectory=/path/to/repo/asm
ExecStart=/path/to/repo/asm/daemon/bmcbitcoind serve /path/to/datadir
StandardOutput=append:/path/to/repo/logs/main/bitcoin.main.log
StandardError=append:/path/to/repo/logs/main/bitcoin.main.log
Restart=on-failure
KillSignal=SIGTERM
TimeoutStopSec=300
[Install]
WantedBy=multi-user.target
The console log (boot banner, [config] echo, [net]/[rpc]/[tor]
state, heartbeats) goes wherever the unit sends stdout/stderr; the
convention is logs/<chain>/bitcoin.<chain>.log under the repository, with
config/logrotate-bmc.conf as the logrotate configuration. A boot takes a
couple of minutes (archive reload, UTXO load, tx-validation snapshot) before
RPC answers; give shutdown time for a UTXO flush. To create an onion service
the service account needs read access to tor's control cookie
(SupplementaryGroups=debian-tor on Debian-family hosts).
config/bitcoin.sample.conf lists every key
the node reads at its default value and is the reference. Keys are Bitcoin
Core's names and units; unknown keys are ignored with a message, and any
Core option the node does not implement is named at startup as having no
effect. An error Core's reader stops on (a parse error, an unknown chain, an
invalid rpcport or bind, a failed includeconf) stops the boot here too, and
RPC credentials apply only to their own chain's section, as in Core
(2026-10-23). Values are read once at startup. The [config] block in the console
log echoes the resolved values.
| key | default | meaning |
|---|---|---|
chain |
main |
main, testnet4, signet, regtest; testnet4=1 / signet=1 / regtest=1 are the boolean forms |
signetchallenge |
public signet | hex challenge for a custom signet; determines the network magic |
listen / port / bind |
1 / chain default / all interfaces |
inbound P2P; ports 8333 main, 48333 testnet4, 38333 signet, 18444 regtest. IPv6 listens alongside IPv4 |
connect / addnode / seednode / dnsseed |
— / — / — / 1 |
outbound peer policy; connect= disables discovery |
maxconnections / timeout / peertimeout |
200 / 5000 ms / 60 s |
connection budget and timeouts |
rpcport |
chain default | 8332 main, 48332 testnet4, 38332 signet, 18443 regtest |
rpccookiefile / rpcauth / rpcuser+rpcpassword |
cookie | authentication; rpcauth is Core's salted-HMAC format, repeatable |
rpcbind / rpcallowip |
loopback / none | listener address (IPv4) and per-connection allow list; rpcbind is ignored without rpcallowip, as in Core |
proxy / onion / proxyrandomize |
— / proxy / 1 |
SOCKS5 proxy for all networks / for .onion only; per-connection credentials for stream isolation |
torcontrol / torpassword / listenonion |
127.0.0.1:9051 / — / 1 |
control port used to create the node's own onion service |
i2psam / i2pacceptincoming |
— / 1 |
SAM bridge address; empty disables I2P |
cjdnsreachable |
0 |
declare the host's CJDNS fc00::/8 interface reachable |
onlynet / discover / externalip / dns |
— / 1 / — / 1 |
network restriction (repeatable), self-address learning, resolver use |
v2transport |
1 |
BIP324 encrypted transport inbound and outbound |
maxmempool / mempoolexpiry |
300 MiB / 336 h |
mempool budget and age limit |
minrelaytxfee / incrementalrelayfee / dustrelayfee |
Core defaults | relay floors, BTC/kvB |
limitclustercount / limitclustersize |
64 (maximum 64) / 101 kvB |
the acceptance limits, as Core v31.1 |
limitancestorcount / limitdescendantcount |
25 / 25 |
deprecated in Core v31.1 (wallet coin selection only); refuse nothing |
limitancestorsize / limitdescendantsize |
— | no effect; Core's warning is logged |
mempoolfullrbf |
— | not an option in Core v31.1 (full RBF is unconditional); logged as an unknown configuration value |
datacarrier / datacarriersize / permitbaremultisig / acceptnonstdtxn |
1 / 100000 / 1 / 0 |
relay policy |
bytespersigop |
20 |
fee rate is judged against max(vsize, sigops * bytespersigop / 4) |
dbcache |
450 MiB |
UTXO memtable sizing (Core v31.1's default since 2026-09-29; it was 1024). Like Core's, it is the total: with bmc.asyncflush=1 the live memtable and the flush writer's frozen copy get half each (2026-10-08, plan M2) |
par |
0 (auto) |
script-verification threads |
prune |
0 |
0 off, 1 manual-only, >=550 target size in MiB |
txindex / txospenderindex / addrindex / blockfilterindex / coinstatsindex |
0 |
optional indexes, all built by the daemon during the sync; addrindex must be set BEFORE syncing (historic spends need undo) |
bmc.indexrunblocks |
20000 |
heights per sorted run for the trailing index builders |
checkblocks / checklevel / stopatheight / minimumchainwork |
6 / 3 / 0 / chain default |
startup verification and sync bounds |
persistmempool |
1 |
reload mempool.dat at boot, write it at shutdown |
walletpassfile |
— | absolute path, outside the datadir, to the wallet passphrase; refused if world-readable, group-writable or inside the datadir |
disablewallet |
0 |
1 loads no wallet; wallet RPCs report that none is loaded |
walletdir |
chain directory | directory holding the wallet files and the wallets/<name>/ subdirectories of named wallets; absolute, or relative to the chain directory; created if absent |
debuglogfile |
debug.log |
the daemon's own leveled log, relative to the chain directory or absolute; 0 disables it |
signer |
— | external signer command |
zmqpubhashblock / zmqpubhashtx / zmqpubrawblock / zmqpubrawtx / zmqpubsequence (+hwm) |
— | ZMQ endpoints; tcp://* is refused, name an interface |
blocknotify / alertnotify / startupnotify / shutdownnotify |
— | shell hooks; %s is sanitised before substitution |
whitelist / whitebind / asmap / bantime / maxuploadtarget / blocksonly |
— / — / — / 86400 / 0 / 0 |
peer permissions, AS bucketing, bans, upload budget, no tx relay |
bmc.dialratelimit / bmc.downloadratelimit / bmc.uploadratelimit |
0 / 0 / 0 |
node-wide ceilings, off by default: outbound connection attempts per second; KB/s the sync may pull; KB/s the node may send (Core has only maxuploadtarget, a MiB-per-day budget, which is implemented too) |
rest |
0 |
1 serves Core's REST interface (/rest/...) on the RPC listener, unauthenticated; keep the listener on loopback |
bmc.esploraport / bmc.esplorabind |
0 / 127.0.0.1 |
the Esplora facade for mempool.space: a second, unauthenticated listener; keep it on loopback or behind a proxy |
bmc.coinstatshistrepair / bmc.coinstatshistworkers |
1 / 0 |
the coinstats history base (gettxoutsetinfo at any height) is checked once a heartbeat and rebuilt by a supervised, niced child when missing or broken: never during initial block download, three attempts per boot; skipped on a node synced from block 0, whose live rows already start at genesis; workers 0 = cores/4 (2..8), pass 3 sizes itself by free RAM |
bmc.utxocompactthreshold / bmc.bootcatchup |
12 / 0 |
project-specific: UTXO runs that trigger compaction; run the parallel downloader inside the BOOT phase. bmc.bootcatchup defaults to 0 since 2026-09-24: with 1 the RPC server does not start until that download finishes, so a fresh node answers no RPC for its whole first sync. The worker's far-behind trigger still runs the downloader. Every published benchmark used 0 |
bmc.benchlog |
0 |
project-specific (2026-10-04): 1 writes [bench] stage-timing lines for benchmark runs -- per connected block (UTXO apply split), per block's index work (txindex, txospender, bfilter, addr, zmq), per UTXO memtable flush, per download chunk; Core's counterpart is debug=bench + debug=coindb. The [ready] line (every enabled index at the tip after IBD) prints regardless |
bmc.asyncflush |
1 |
project-specific (2026-10-06, plan B3): the UTXO memtable flush (sort, run file, Bloom filter, fsync) runs in a forked writer while the applier continues; the applier pays a copy of the memtable. The copy and the live memtable share the dbcache (half each); the copy keeps its pages between flushes (releasing them, as plan M2 did on 2026-10-08, made every freeze wait on the kernel's memory compaction: 2.4 s a freeze against 0.2 s). 0 runs the flush inline in the applier with the whole dbcache for one memtable, as before. Core's counterpart is its own background flush of the dbcache |
bmc.lsmreads |
mmap |
project-specific (2026-10-11): how the UTXO run lookups read records. mmap is the mapped fast path; pread reads the records with pread() into a per-thread window (the Bloom filter and the sparse index stay mapped), one syscall per run a lookup reaches, so the run files stay page cache and leave the process's PSS -- run 46's worker held ~49 GB of mapped run pages before a full compaction. The answers are identical (tests/test_lsm_reads_pread). An opt-in low-memory mode, with bmc.dropappends=1: a from-genesis sync with both (run 51, 2026-10-25) peaked at 22.1 GB PSS against run 46's 56.3, but took 5:52 against 3:17, the lookups 4.4x slower. |
bmc.dropappends |
0 |
project-specific (2026-10-11, plan B16): drop the blk and rev append streams from the page cache behind the applier (sync_file_range + POSIX_FADV_DONTNEED, once per 16 MB of undo and once per 128 MB block file). Those streams, 400 GB in the first 650,000 blocks, share the kernel's inactive list with the UTXO run files, and with bmc.lsmreads=pread they evicted the run pages the lookups read (run 49: 76% of the run bytes resident at block 650,000, 212 GB re-read from disk). 0 leaves the page cache to the kernel. The bytes on disk are the same either way (tests/test_drop_appends). |
bmc.memtableanon |
1 |
project-specific (2026-10-07, plan B11): the live UTXO memtable's table and blob in anonymous memory (huge-page eligible, never written back) instead of MAP_SHARED file mappings; the files are kept at their sizes and the table's header page is shared, so the offline tools and the tx-validation snapshot's writer-count cross-check read what they always did. 0 restores the file mappings. |
listen=1 the node opens a
v6-only listener beside the IPv4 one and dials IPv6 peers when the host has
a global IPv6 route (probed at startup; a link-local or ULA-only host dials
none, and the boot log says so). Restrict with onlynet..onion peers needs a SOCKS5 port (onion=127.0.0.1:9050
or proxy=). With listenonion=1 and a reachable torcontrol port the
node creates its own ephemeral v3 onion service (ED25519 key persisted in
the datadir) that targets a loopback-only listener, keeps the control
connection open for the daemon's lifetime, and announces the onion address
to onion peers only. Control-port authentication follows Core: with
torpassword set, HASHEDPASSWORD or nothing; otherwise NULL when offered,
then SAFECOOKIE. The plain cookie is never sent (2026-10-23). Setting proxy= also stops
the node using the system resolver for peer hostnames (names are handed to
the proxy), skips the DNS seeds, gives every proxied connection its own
SOCKS5 credentials (proxyrandomize) so Tor isolates circuits, and never
advertises a clearnet address to an onion or I2P peer. A Tor-only node is
onion=127.0.0.1:9050, onlynet=onion, discover=0.i2psam=127.0.0.1:7656 points at a router's SAM 3.1 bridge. The
node keeps one destination across restarts (i2p_private_key in the
datadir), dials I2P peers through it and, with listen=1, accepts inbound
I2P streams on that destination (i2pacceptincoming=0 turns that off).fc00::/8 IPv6 address on cjdroute's
tun interface, so it needs working IPv6 on the host. The node cannot detect
the interface; set cjdnsreachable=1 to enable dialing and accepting CJDNS
peers.getnetworkinfo reports the real per-network reachability, the onion
service hostname and the I2P destination under localaddresses; all five
networks are stored in the address book, relayed via addrv2, and
returned by getaddr.rpcbind +
rpcallowip to change that), speaks Core's HTTP/JSON-RPC 1.0/2.0
envelopes, and serves Bitcoin Core's method set with Core's field shapes,
error codes and messages. help is generated from the dispatch tables.__cookie__:<hex> format), rpcauth
entries produced by Core's share/rpcauth/rpcauth.py, or
rpcuser/rpcpassword. The server refuses to start with no credential
available.getpeerinfo, getmempoolinfo,
sendrawtransaction, gettxout, submitblock, ...) are bridged across the
daemon's fork boundary through shared memory and control channels; the
design and the per-category method notes are in
docs/RPC_LIVE_NODE.md, and the method-by-method
verification record is in docs/PARITY_PLAN.md.rest=1, 2026-09-08): the fourteen /rest/
routes on the RPC listener, unauthenticated as in Core, in .json,
.hex and .bin, with Core's status codes and error texts; every
route is answered from the node's own RPC handlers.bmc.esploraport) serves Esplora's REST contract
in-process for mempool.space; it takes the RPC lock per dispatch, so a
batch route cannot starve JSON-RPC callers. Address routes need the
history index; /scripthash is refused (501) until it exists.hashblock, hashtx, rawblock, rawtx and sequence (A/R with Core's
mempool sequence, C/D per block; getrawmempool's mempool_sequence
answers from the same counter; where it is not Core's:
docs/CORE_DIVERGENCES.md); getzmqnotifications lists the endpoints.
Subscribers that observe a sequence gap resynchronise via RPC, as with
Core./BitcoinMachineCode:0.0.1/, protocol version
70016, defined once in asm/version.inc.Intentional differences and known gaps, each documented at its call site or
in docs/FEATURE_GAPS.md:
blk*.dat + LevelDB. Core
datadirs are not interchangeable with this node's. reindex=1 rebuilds
the block index from the archive files and reindex-chainstate=1 the UTXO
set, each as a one-shot request.TrimToSize evicts the lowest-feerate
leaf transaction and works inward, where Core evicts by linearization
chunk. TRUC sibling eviction landed 2026-09-03 (see FEATURE_GAPS).assumevalid uses Core v31's built-in block (938343 on mainnet); newer
Core releases move it, this node's table is updated with the oracle.gettxoutsetinfo defaults to muhash; hash_serialized_3 is refused,
and the coinstats "extras" beyond the core fields are omitted (stated in
the result).addrindex and the getaddressbalance/getaddresstxids methods are
an extension with no Core equivalent.bmcbitcoind, the CLI bmc_cli, the standalone
RPC daemon bmc_rpcd, and the pid file defaults to bmcbitcoind.pid
(Core: bitcoind.pid) — nothing this node ships or writes carries a
Bitcoin Core file name, so both can live on one box. Every other config
default matches Core's (docs/audits/CONFIG_DEFAULTS_VS_CORE_2026-09-06.md).createwalletdescriptor
adds legacy (pkh, 44'), p2sh-segwit (sh(wpkh), 49') and bech32m (tr, 86'),
after which getnewaddress/getrawchangeaddress accept that address type,
the rescan window covers those keys and the wallet signs for them (P2PKH,
P2SH-P2WPKH, P2TR key path). Descriptors are otherwise general: the engine parses
and expands pk/pkh/wpkh/combo, multi/sortedmulti, sh/wsh, tr with script
trees, rawtr, addr and raw over hex, x-only, WIF and xpub/xprv keys with
origins, paths and ranges (proven byte-identical to Core on its own test
vectors). Miniscript (miniscript.c, Core's script/miniscript.h in C:
parser, type system, resource limits, script emission and decoding, the
non-malleable satisfier) is accepted inside wsh() and as tr() leaves
with Core's sanity errors verbatim, proven on all 97 of Core's
miniscript_tests.cpp vectors in both contexts against this node's own
interpreter (tests/test_miniscript, 44,921 checks) and on a 48-descriptor
regtest differential where Core mines every witness this node signs
(validation/miniscript_core_diff.py). musig() (BIP390) keys of
tr()/rawtr() and their leaves aggregate, derive and print as Core's do
(Core's own vectors), and descriptorprocesspsbt is their Updater as well
as their signer.
descriptorprocesspsbt signs from the keys a descriptor carries.
signrawtransactionwithkey and the descriptor signer cover P2PKH, P2WPKH,
P2SH-P2WPKH, P2SH multisig, P2WSH and P2SH-P2WSH (CHECKMULTISIG, a single
CHECKSIG, or any miniscript witnessScript -- the satisfier signs with the
keys held, the PSBT's preimages and the tx's timelocks), P2TR key-path
spends of tr(KEY) and of tr(KEY,{...}) (internal key + merkle root),
and P2TR script-path spends of pk(), multi_a() and miniscript leaves
(leaf + control block). PSBTs carry the BIP371 taproot fields
(leaf scripts, control blocks, internal key, merkle root, bip32 origins
with leaf hashes, key-path and script-path partial signatures); the signer
tries the key path first and then each leaf, carries partials other
signers left, and decodepsbt names every field as Core does.
MuSig2 (BIP327 in C, musig2.c,
proven on the BIP's vectors; BIP373 PSBT fields): walletprocesspsbt /
descriptorprocesspsbt run Core's rounds for any P2TR key-path aggregate
the PSBT names -- direct, BIP32-derived via the synthetic xpub, or
taproot-tweaked -- publishing our pubnonce, then our partial signature,
then the aggregated signature; decodepsbt prints the musig2_* fields
with Core's names; secret nonces never leave the process and are erased
on use. Proven by validation/musig_core_diff.py: 3-of-3 sessions with
two Core wallets and this node as the third signer, judged by Core's
finalizepsbt, testmempoolaccept and a mined block (110/110).
BIP340
signing is in C and proven on Core's test vectors; every signed form is
checked against Core's script engine by validation/signer_core_diff.sh.getblocktemplate fills the block with whole linearization
chunks in feerate order (Core v31's cluster-mempool block assembly; a chunk
that does not fit skips its cluster) and reports a lower-bound sigops;
a stratum/pool interface is absent.sendtxrcncl negotiation is implemented and
tested but not emitted on the wire. Reconciliation rounds are not built;
Bitcoin Core itself ships only the negotiation (its -txreconciliation is
off by default and its message processing has no reqrecon/sketch).peerbloomfilters), GUI, loadtxoutset (assumeutxo import; export via
dumptxoutset works), and settings (values set over RPC are not
persisted). Each option that has no effect here is named in the startup
log when set, with the reason (k_noeffect in asm/daemon/node_config.c).testnet=1, chain=test) is refused.| document | contents |
|---|---|
docs/README.md |
index of everything under docs/ |
docs/OPERATIONS.md |
operations guide: running, configuring, monitoring, upgrading and recovering the node |
docs/RPC_LIVE_NODE.md |
the embedded JSON-RPC server and its methods |
docs/MEMPOOL_SPACE.md |
running mempool.space against the node: the Esplora facade, the address history index, the backend configuration |
docs/FEATURE_GAPS.md |
what the node does and does not implement, against Bitcoin Core |
docs/PARITY_PLAN.md |
how parity with Core is established and checked, method by method |
docs/ENGINEERING.md |
architecture, binaries and command lines, on-disk formats, validation gates |
docs/ENGINEERING_RULES.md |
the rules the codebase is written under |
docs/ABI_STACK_ALIGNMENT.md |
the SysV stack-alignment contract and the audit that enforces it |
SECURITY.md |
how to report a vulnerability |
docs/audits/ |
security audits and reviews, and the project's responses |
docs/history/ |
long-form accounts of the larger pieces of work, each with a PDF edition |
docs/devlog/ |
development log: incident log, plans, benchmarks, assessments |
worklog/ |
dated development action logs (*-osx.md the Mac side's, *-win.md the Windows side's; *-note-for-osx*.md / *-note-for-x86*.md / *-note-for-win*.md the sides' notes to each other) |
port/OSX_STATE.md |
the macOS / Apple silicon port: state, roadmap and branch model under port/ |
port/WIN_STATE.md |
the Windows x86-64 port: state, design and branch model under port/ |
config/bitcoin.sample.conf |
every configuration key at its default |
validation/ |
differential test corpus and oracle scripts against Bitcoin Core |
Experimental software, AI-authored throughout, verified differentially against Bitcoin Core rather than independently audited by humans. It is not a replacement for Bitcoin Core and should not hold funds.
Fresh-sync benchmarks against Bitcoin Core v31.1 on the same box ran through
September 2026. The clean pair (2026-09-21): Core 19 h 32 m 54 s, this node
18 h 24 m 02 s, with the UTXO set identical by MuHash. A full-verification
sync (assumevalid=0, every script of every block) completed on 2026-09-27
in 8 h 0 m at nice 10 on the benchmark box, its per-height digests equal to
Core's throughout. The release report's latest default sync (run 46, 2026-10-10)
reached the tip with every index in 3 h 17 m 55 s against Core rerun #7's
9 h 50 m 04 s, with a heap peak of 13.3 GB against Core's 12.0 and a mean of
8.2 against 10.0
(docs/releases/2026-10-07-faster-than-core-in-every-stage-of-the-sync.md,
addendum).
Signature verification is level with libsecp256k1 on one
core (2026-09-27). The landing notes in docs/releases/
record each change and the run that measured it; the daily record is in
worklog/.
mempool.space runs against the production node through the Esplora facade
(docs/MEMPOOL_SPACE.md).
The 2026-10-23 review found 9 HIGH, 18 MEDIUM and 36 LOW findings, five of
the HIGHs consensus splits from Core. Formal verification of the consensus
arithmetic, the secp256k1 assembly, the UTXO store's crash consistency and
the untrusted-input parsers found more. Every finding is fixed (PRs #424 to
#435), and the fixed build passed the full test gate and a from-genesis
sync with its UTXO set MuHash-identical to Core v31.1's at 972,848. What is
still open, and what changed for operators, are the review's two appendices
(docs/history/2026-10-23-the-review/).
Production ran that build from 2026-10-24; since 2026-11-05 it runs main
with the macOS port merged in (deploy-20261105b), and every deploy is listed
in docs/devlog/DEPLOYMENT_HISTORY.md.
BobClawblaw/bitcoinmachinecode is a public repo on GitHub by BobClawblaw. A Bitcoin node, 100% AI-generated: hand-authored assembly with a C orchestration layer, for Linux x86-64 (NASM) and macOS on Apple silicon (AArch64). Fully verifies consensus from genesis; UTXO set MuHash-identical to Bitcoin Core; follows mainnet live; serves most of Core's RPC surface. No independent human audit — do not run this.
It declares the Apache-2.0 license on GitHub.
Its maker tagged it for macOS and Linux. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
花叔开源的全球鸟类贴纸库 · AI-generated stickers for 11,000+ bird species (AviList v2026), CC BY 4.0, with names in 43 languages and structured data

Its last change on GitHub was on 2026-11-21. GitHub counts 0 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
LLM inference server with continuous batching & SSD caching for Apple Silicon — managed from the macOS menu bar

Run compilers interactively from your web browser and interact with the assembly

world.execute(me); — an unofficial fan-made lyric MV told as a chat with Claude, rendered frame by frame from code. Prompts included; no music or lyrics. 非官方同人歌詞 MV:以程式碼逐幀渲染,附完整提示詞,不含歌曲與歌詞。
macOS menu bar app that tells you, in plain English, what each USB-C cable plugged into your Mac can actually do

A FREE comprehensive reverse engineering tutorial covering x86, x64, 32-bit/64-bit ARM, 8-bit AVR and 32-bit RISC-V architectures.
DeepSeek-V4.1-Flash-1017 (2/3-bit experts) on one 256 GB M5 Ultra: the full 1M context, DSpark drafts, int8 x int8 prompt experts, up to four streams, images, tools, JSON. TensorFold native Metal.
DeepSeek-V4.1-Flash-1017 on native TensorFold, 2x DGX Spark (TP=2): prose 55 / code 104 tok/s at 1 stream, 135 / 203 at 8, 0.2 s first token · text, images, video · EXL3 2.9 bpw
Qwen3.8-27B on native TensorFold 1.2.4, 1x RTX 5090: turboderp EXL3 4.00 bpw, prose 214 / code 454 tok/s at 1 stream with DFlash2 drafts, 0.03 s first token · text, images, 262k context, 3 streams · fp8 KV
GLM-5.3-Flash on native TensorFold, 2x DGX Spark (TP=2): prose 48 / code 70 tok/s at 1 stream, 145 / 202 at 16, 0.2 s first token · text, images, DFlash2 drafts, 1M context · EXL3 4 bpw
GLM-5.3-Flash MLX 4-bit on one 256 GB M5 Ultra with TensorFold 1.2.5 native Metal: the full 1M window for three streams, MTP drafts, thinking on, memory guard
Superseded as the default by minimax-m31-flash-exl3-m5-ultra (closer to the release). MiniMax-M3.1-Flash as MLX conversions on one M5 Ultra, TensorFold native Metal, decode ~43 tok/s
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/BobClawblaw/bitcoinmachinecodeTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.