Character Substitution

📋 Overview

Mode 4 is designed for passphrases that were originally words or phrases but with some characters replaced by look-alike characters (leet-speak style). You provide a dictionary file containing your candidate words or phrases (one per line). wrecover automatically generates all possible character-substitution variants of each entry and tests every variant against the target address.

For example, if the dictionary contains password, wrecover will also try p@ssword, passw0rd, p@ssw0rd, P@55w0rd, and every other combination of common substitutions.

💡 GPU Supported

Mode 4 fully supports GPU acceleration (CUDA and OpenCL) in the Pro version.

💡 How substitutions work

wrecover builds an index of all substitution variants for each character in each word (e.g. a → a/@/4/A, o → o/0/O, etc.), then generates the Cartesian product. The total variant count depends on the dictionary entries and how many substitutable characters they contain.

📄 Dictionary File Format

The dictionary file is a plain text file (.txt), one candidate word or phrase per line. The file is converted internally to a binary index for fast processing.

# dictionary.txt — one entry per line

password

bitcoin

satoshi

MySecret

Summer2023

hodl

⚠️ File extension

The dictionary file must have a .txt extension when starting a new search (-ws). During resume (-wi), wrecover expects the .bin version (automatically generated alongside the .txt at first run). You must supply the .bin path with -pps when resuming.

🚀 Commands

New search — CPU

wrecover -m 4 -mf "word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12" -pps dictionary.txt -addr "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa" -wlang en -ws -wf recovery.wrec "this workfile password"

New search — GPU (Pro)

wrecover -m 4 -mf "word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12" -pps dictionary.txt -addr "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa" -wlang en -ws -wf recovery.wrec "this workfile password" -gpu -grid 2048 -gblock 256

Resume (provide the .bin file generated at first run)

 # CPU

            wrecover -wi -wf recovery.wrec -wp "this workfile password" -pps dictionary.bin

            # GPU (Pro)

            wrecover -wi -wf recovery.wrec -wp "this workfile password" -pps dictionary.bin -gpu -grid 2048 -gblock 256

📖 Parameter Reference

Option	Description	Required
`-m 4`	Select Mode 4	Yes
`-mf "<full mnemonic>"`	Complete, known seed phrase (all words)	Yes
`-pps <file.txt>`	Dictionary file (.txt for new search, .bin for resume)	Yes
`-addr <address>`	Target blockchain address	Yes
`-wlang <code>`	BIP39 wordlist language	Yes
`-ws`	New search	Yes*
`-wi`	Resume from work file	Yes*
`-wf <file.wrec>`	Work file path	Yes
`-dpath <path>`	Override derivation path	No
`-t <N>`	CPU threads (Free: max 10; Pro: unlimited)	No
`-gpu`	Enable GPU (Pro only)	No
`-grid <N>`	GPU grid size (Pro, default 256)	No
`-gblock <N>`	GPU threads/block (Pro, default 256, max 256)	No
`-wp <password>`	Encrypt work file	No
`-save-only`	Create work file only	No
`-startp <N>`	Start at offset N (Pro only)	No
`-endp <N>`	Stop at offset N (Pro only)	No

* Use either -ws (new search) or -wi (resume) — not both.

🌎 Languages & Address Types

Languages (`-wlang`)

Code	Language
`en`	English
`es`	Spanish
`fr`	French
`it`	Italian

Address types (auto-detected)

Address format	Type	Default derivation path
Starts with `1`	Bitcoin Legacy (P2PKH)	`m/44'/0'/0'/0`
Starts with `3`	Bitcoin SegWit P2SH	`m/49'/0'/0'/0`
Starts with `bc1q`	Bitcoin Native SegWit	`m/84'/0'/0'/0`
Starts with `0x`	Ethereum	`m/44'/60'/0'/0`

⚡ Performance

The total number of variants depends on the dictionary content. A word like password (8 chars, many substitutable characters) can generate hundreds of thousands of variants on its own. Performance scales with the total variant count across all dictionary entries.

Hardware	Passphrase throughput
CPU — per thread (Free & Pro)	700–1,200 passphrases/sec
NVIDIA Tesla T4 (Pro)	~187,000 passphrases/sec
NVIDIA RTX PRO 6000 (Pro)	~1,750,000 passphrases/sec
N× GPUs (Pro)	Linear: N × single-GPU throughput

💡 Free vs Pro

Free version: CPU only, max 10 threads. Pro: unlimited threads + GPU. Throughput scales linearly with thread count on CPU.