A quite fast CUDA vanity address generator for 12 coins, with start and end patterns and wallet-importable keys. Personalized plates for your wallets.
- 12 coins in one: Bitcoin (legacy and SegWit), Ethereum and every EVM chain, Tron, Litecoin, Dogecoin, Cosmos chains, Monero, Solana, Stellar, Algorand and MultiversX.
- Start and end patterns: the beginning, the end or both, with
_wildcards anywhere. Ends include the checksum characters, so you get real address ends. Monero too: its end is searched with a view key of its own, so start + end costs about the sum of the two, not the product. - Fast: ~7 Gkey/s for Bitcoin and ~10 for Monero on an RTX 5080 (table below).
- Your keys stay yours: secrets come from your operating system's cryptographic generator, and for most coins (all but Solana, Stellar, Algorand and MultiversX) the GPU only ever sees a public key. Or bring your own public key and keep the secret on another machine.
- Every match double-checked: a separate, plain check module re-derives each
found address before it's shown, and
verify.pylets you check any key yourself. - Wallet-ready output: WIF, Electrum, Phantom/Solflare, Keplr, Algorand's 25 words, MultiversX PEM, Monero "restore from keys".
- Multi-GPU support: every GPU at once (
-allgpus) or the ones you pick (-devices 0,2); the CPU can help too (-usecpu). - Windows and Linux: native builds from the same source with the same GPU code, prebuilt packages, nothing else to install. RTX 20xx through 50xx.
- Tells you how long: the odds before it starts, the expected time at your
GPU's measured speed, the search time of every match, and
-benchmarkfor your GPU's numbers. - Automatic keyspace hopping: every 2 minutes (
-hoptime <s>to change it) the search jumps to a fresh random key, so it keeps moving through random parts of the keyspace instead of walking one long stretch from a single key.
vanityplate -benchmark (one key = one private key whose address was checked;
start: 8-12 fixed chars, end: 8-11), the same on Windows and Linux within 1%:
--------------------------------------------
Coin Start End
--------------------------------------------
BTC 7.020 Gkey/s 6.106 Gkey/s
BC1Q 6.951 Gkey/s 7.033 Gkey/s
ETH 3.007 Gkey/s (as start)
TRX 3.048 Gkey/s 2.695 Gkey/s
LTC 7.047 Gkey/s 6.150 Gkey/s
DOGE 7.043 Gkey/s 6.150 Gkey/s
ATOM 6.942 Gkey/s 7.021 Gkey/s
XMR 10.11 Gkey/s 9.118 Gkey/s
SOL 535.9 Mkey/s 517.3 Mkey/s
XLM 535.8 Mkey/s 520.3 Mkey/s
ALGO 535.4 Mkey/s 520.3 Mkey/s
EGLD 535.6 Mkey/s 512.1 Mkey/s
--------------------------------------------
Shorter end patterns run slower but are found in seconds anyway: the Base58 coins at about half speed up to 6 end characters (the checksum decides those), Monero at ~55% with 7 and ~2 Gkey/s up to 6.
Your GPU's numbers: vanityplate -benchmark measures every coin, start and end
patterns, and prints a table to share (10 s per test, about 5 minutes in all;
-coin btc for one coin, -seconds 30 for longer tests, -allgpus for every
GPU at once). Its keys are random and thrown away.
Please do feel free to share the speeds on your GPU :)
-coin |
addresses | example pattern | you get (import) |
|---|---|---|---|
btc |
Bitcoin legacy 1… |
1Moon, .K8 |
private key (WIF, hex) |
bc1q |
Bitcoin SegWit bc1q… |
cafe, .cafe |
private key (WIF; Electrum p2wpkh:) |
eth |
Ethereum and every EVM chain (BNB, Polygon, Arbitrum, Base, …) | dead, .beef |
private key |
trx |
Tron T… |
TMoon |
private key |
ltc / doge |
Litecoin L… / Dogecoin D… |
LMoon, D.Wow |
private key (WIF, hex) |
xmr |
Monero 4… |
4AMoon, .cafe |
spend + view keys |
sol |
Solana | Moon, Moon.moon |
Phantom/Solflare private key, keypair JSON |
xlm |
Stellar G… |
GAMOON, .MOON |
secret key S… |
algo |
Algorand | MOON, MOON.CAFE |
25-word mnemonic |
egld |
MultiversX erd1… |
cafe, .cafe |
PEM file (web wallet) |
atom |
Cosmos cosmos1…; other Cosmos chains with -hrp osmo etc. |
cafe, .cafe |
private key (Keplr) |
USDT / USDC live at the address of their chain: ERC-20 / BEP-20 → eth,
TRC-20 → trx, SPL → sol, and so on.
_= any character.Xis a normal character.- Short patterns are padded:
1Moon= starts with 1Moon. - One
.= the address end:.moonends with moon,1Moon.moonboth. Every coin; real ends, checksum characters included (Monero: the first 11 and the last 18 characters, see below). - Base58 coins match letters in either case. Fixed leads (
bc1q,erd1,cosmos1) are optional.
vanityplate prints the odds before it starts and, a few seconds in, the expected time at your GPU's actual speed.
Needs an NVIDIA GPU with compute capability 7.5 or newer (RTX 20xx / GTX 16xx and up) and a current driver. Nothing else to install.
Download the package for your system from the Releases page, check it against
the SHA-256 sums published with it (Windows: certutil -hashfile <file> SHA256;
Linux: sha256sum -c --ignore-missing SHA256SUMS), and unpack it. Or build it yourself (see
Building below).
Windows (vanityplate-v<version>-windows-x64.zip):
vanityplate -coin btc -matching 1Moon
vanityplate -coin sol -matching Moon.moon
vanityplate -coin atom -hrp osmo -matching cafe
Linux (vanityplate-v<version>-linux-x64.tar.gz; needs glibc 2.38 or newer:
Ubuntu 24.04, Debian 13 or later; on older systems, build it):
./vanityplate -coin btc -matching 1Moon
./vanityplate -coin sol -matching Moon.moon
./vanityplate -coin atom -hrp osmo -matching cafe
vanityplate -help lists every option (-count, -logfile, -allgpus, -pubkey, …).
- The secret is created on your machine, from the operating system's cryptographic random generator, and never leaves it. For the secp256k1 coins and Monero the GPU only ever sees a public key and searches offsets from it (the split-key scheme); the program adds the offset to the secret itself.
- Every result is re-derived before it's printed by a separate, deliberately
plain check module (
Source/src/verify/) that shares no code with the search; a mismatch is reported loudly and not counted. - Found keys are private keys.
-logfilewrites them in plain text: keep that file safe (the repo ignores*.txtand*.pem). - Import a key into its wallet and check the address before you send real funds to it.
verify.py, next to the program, is a second check you can read in a few
minutes: one file, plain Python 3, no packages. Give it any key VanityPlate
printed, in any of the formats it prints:
python verify.py btc <WIF or hex> -address 1Moon...
python verify.py algo "the 25 words"
python verify.py egld wallet.pem
With -address it says MATCH or NO MATCH.
To keep the secret on another machine: vanityplate -coin btc -matching 1Moon -pubkey <your public key> searches from your public key and prints an offset;
python verify.py combine btc <your secret> <offset> <n>, run where the secret
is, gives the vanity address's private key. For the secp256k1 coins and Monero
(its public spend key, also with end patterns); the seed coins (Solana, Stellar, Algorand, MultiversX)
hash the secret itself, so they can't.
A Monero address is built from two keys: the spend key (the start of the
address) and the view key (the end). For 4AMoon.cafe VanityPlate searches
the start with the spend key, then the end with a view key of its own, so the
two difficulties add up instead of multiplying. Import the result with your
wallet's "restore from keys" (address + spend key + view key; Monero GUI, CLI,
Feather and others). There is no 25-word seed for such an address: a seed would
fix the view key. Works with -pubkey too (the view key is made here; a view
key shows incoming funds but can't spend them).
One set of sources (Source/src/), one build script per system:
- Windows:
Source/Win/build.sh(Git Bash, MSVC + CUDA 13) buildsRelease/Win/vanityplate.exe. The MSVC and Windows SDK versions at the top of the script may need adjusting to yours. - Linux:
Source/Linux/build.sh(bash, CUDA 13 + g++) buildsRelease/Linux/vanityplate.
Both build for sm_75 … sm_120 with the same GPU code, and put verify.py next
to the program. Everything they need is included, also the 21 UltrafastSecp256k1
files they use (third_party/).
Source/src/precomp.cpp, the table of multiples of G the GPU's start points are
built from, is generated by Source/tools/gen_precomp.py (plain Python, no
packages): run it and compare if you'd like to check the table.
Started life as an experiment in swapping profanity2's secp256k1 math for UltrafastSecp256k1's. Then one thing led to another, and here we are.
A hobby project, shared as is: no support, no guarantees, use at your own risk.
Built by zeroxbee together with Claude (Anthropic). Inspired by profanity2's split-key design; secp256k1 field arithmetic and hash160 from UltrafastSecp256k1. Details and licenses: THIRD-PARTY-NOTICES.md.
Copyright (C) 2026 zeroxbee. VanityPlate is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. It is distributed WITHOUT ANY WARRANTY; see LICENSE for the full text.
In short: use it, study it, change it. If you share a modified version, or let people use one over a network, you share its source under the same license. The included UltrafastSecp256k1 files keep their own MIT license (THIRD-PARTY-NOTICES.md).