A Verus wallet that needs no full node.

Self-custodial, one binary, nothing to sync. Your keys are generated and stay on your machine — the chain data comes from a node somebody else already runs.

0 GB to download
no verusd
no runtime
Rust + Slint
Windows · macOS · Linux

A laptop showing the Pecu dashboard: a total balance, a breakdown into spendable and maturing, an asset list, a market panel and recent activity.

The difference

Running a node is a commitment. Holding coins should not be.

A full node is the right tool if you want to validate the chain yourself. It is a poor tool if you want to check a balance on a laptop. Pecu is a light client: it asks a node the same questions your wallet would have asked its own, and it does not keep one.

Wallet with a bundled node

Tens of gigabytes of chain to download
An initial sync measured in hours or days
Re-syncs every time you have been away
A daemon running beside the wallet
Disk and memory a laptop notices

Pecu

Open it and it is ready
Nothing to sync, nothing to catch up on
One binary — no runtime, no daemon, no installer for a language
Endpoints for Verus, vARRR, CHIPS and vDEX ship with it
Point it at your own node instead, if you have one

If you do run verusd, nothing is wasted. Pecu will use your node as its endpoint, and for shielded transactions it looks for the Sapling proving parameters your node already downloaded before it considers fetching its own.

Screens

What it looks like

Not mockups. Every image here is a reference screenshot the test suite renders and compares on each run — 150 of them, in both themes. A layout change nobody looked at fails the build.

The send form: a source key, a recipient, an amount, and a panel describing the payment. — **Send**Pay an address or a VerusID by name. The fee and the total on the next step are read back from the transaction that was signed, not estimated here.

The receive screen: an address, a QR code, and the names that point at it. — **Receive**An address and a QR code — and the names that point at it, if you hold any.

The convert screen: a pay currency, a receive currency and a quote. — **Convert**Verus' on-chain conversions, quoted from the reserve state the chain publishes.

The markets screen, listing currencies with prices, changes and reserves. — **Markets**Prices and reserves, with the window labelled — a column headed differently would look precise and not be.

The activity screen, listing transactions grouped by day. — **Activity**What happened, kept locally, with a detail sheet per transaction.

Built in

The careful parts

Most of what matters in a wallet is where it declines to be clever on your behalf.

Keys never leave the machine

Generated locally, encrypted on disk with Argon2id at roughly three and a half times the OWASP interactive minimum. The interface crate cannot even name the type that carries a private key — that is a compile error, not a rule.

You confirm the real transaction

The review screen is decoded from the signed bytes: the outputs, the fee and the change as they actually are, not re-rendered from what you typed into the form.

It never guesses which money you meant

A key can hold transparent and shielded funds. Choosing for you would decide whether a payment is traceable, silently. It asks.

Spending real money is deliberate

Anything that could move value sits behind a typed confirmation — not only the main chain. Only the one chain positively known to be worthless is exempt.

Zero and “we don't know” are different

An unknown price is a dash. A pool nobody has scanned says so. A zero is a number somebody measured. The wallet would rather admit a gap than fill it.

Nothing secret reaches the logs

A test walks the log files on every run and fails the build if a key, a passphrase or a recovery phrase appears in one.

The trade

What you give up, and what is done about it

Not running a node means asking somebody else's. That is a real trade and it deserves a plain answer rather than a footnote.

Your keys: Not part of the trade. They are generated on your machine, encrypted there, and never sent anywhere. A remote node signs nothing.
Your balances: Come from the node. A wrong answer shows you a wrong number — which is why the wallet distinguishes a figure it measured from one it could not.
Your transactions: Built and signed locally, then handed over to be broadcast. The node cannot alter one: the signature commits to every output.
Which chain you are on: The sharp edge, because addresses look identical across Verus chains. A node's word about its own identity is treated as a claim, not a fact — and where a second endpoint is available, the coins a payment is funded from are held against it before anything is signed.
Your privacy: The node sees which addresses you ask about. Pointing Pecu at your own verusd removes that, and is one setting.

Status

Under active development, in the open

Built in public, with the reasoning written down as it goes. Here is what runs today and what is being worked on next.

Working today

Wallet creation, recovery phrase, encrypted keystore
Balances, send, receive and transaction history
Paying a VerusID by name
On-chain conversions and live market data
Several chains, and several keys per chain
Shielded balances and spends on testnet

On the way

Sending tokens — today they can be received and converted
Identity and currency management, already built and being validated
Payment and login links, opened straight from a QR code
Shielded support beyond testnet

Every decision, including the ones deliberately postponed, is written down in the repository. Releases will land here when they are ready to install.

Follow on GitHub Open issues The roadmap