Skip to content

About

Fast CUDA vanity address generator for 12 coins: start and end patterns, keys made and checked on your machine. Windows and Linux.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

2 Commits

Folders and files

Repository files navigation

VanityPlate

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.py lets 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 -benchmark for 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.

Speed (on an RTX 5080)

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 :)

Coins

-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.

Patterns

  • _ = any character. X is a normal character.
  • Short patterns are padded: 1Moon = starts with 1Moon.
  • One . = the address end: .moon ends with moon, 1Moon.moon both. 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.

Quick start

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, …).

How it stays safe

  • 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. -logfile writes them in plain text: keep that file safe (the repo ignores *.txt and *.pem).
  • Import a key into its wallet and check the address before you send real funds to it.

Check it yourself

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.

Bring your own public key

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.

Monero end patterns

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).

Building

One set of sources (Source/src/), one build script per system:

  • Windows: Source/Win/build.sh (Git Bash, MSVC + CUDA 13) builds Release/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++) builds Release/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.

Status

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.

Credits

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.

License

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).

About

Fast CUDA vanity address generator for 12 coins: start and end patterns, keys made and checked on your machine. Windows and Linux.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Contributors

Languages