Rand Protocol
Build from source

Compile it yourself

Every Rand Wallet client is built from one public repository, randprotocol/clients, under GPL-3.0-only. The published downloads are made by the commands on this page and nothing else, so you can make the same packages on your own machine. Version 0.8.0 is tag v0.8.0.

Start Source archive Or download a build
Before you start

What to install

Only the rows for the client you want. The first build of any client compiles the prover and takes several minutes; after that a rebuild is quick.

Every client
git, rustup and Node 22 or later. rustup installs Rust 1.98.1, the version the repository pins, the first time cargo runs in the checkout.
Desktop, any OS
tauri-cli 2: cargo install tauri-cli --version "^2" --locked
Desktop on Linux
sudo apt install build-essential libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf rpm file (Debian and Ubuntu names; other distributions carry equivalents)
Desktop on Windows
Visual Studio Build Tools with “Desktop development with C++”, and Git for Windows, whose Git Bash runs the scripts
Desktop on macOS
Xcode Command Line Tools: xcode-select --install
Chrome, Firefox, web wallet
Nothing more. The build installs wasm-bindgen-cli itself.
Android
JDK 17 or later, and the Android SDK with platform 36, build-tools 36 and NDK 27
iOS
A Mac with Xcode 16 or later

1. Get the source

Clone the repository with its one submodule, the full node, whose code is the wallet's cryptography. Check out the release tag to build exactly what was published, or stay on main for the latest. No GitHub account or SSH key is needed.

Get the source
bash 
git clone --recurse-submodules https://github.com/randprotocol/clients.git
cd clients
git checkout v0.8.0 && git submodule update --init   # the release, rather than main

Without git: download rand-wallet-0.8.0-source.tar.gz from the release and unpack it. It has the submodule inside, which GitHub's own “Source code” archives leave out.

2. Test the core (optional)

The core is the Rust library every client wraps. Its tests make a real proof and check it with the chain's own verifier, which takes about a minute after the first compile.

Test the core (optional)
bash 
cd core && cargo test --release && cd ..

3. Desktop: Linux, Windows, macOS

One script builds the packages of the OS it runs on, under the names the releases use. On Linux: an AppImage, a .deb, an .rpm and the bare binary in a .tar.gz. On Windows, from Git Bash: the .msi and the -setup.exe. On macOS: the .dmg. A platform builds only its own packages.

More on Linux, Windows, macOS.

Desktop: Linux, Windows, macOS
bash 
cargo install tauri-cli --version "^2" --locked   # once
scripts/release/build-desktop.sh   # → dist/release/v<version>/
scripts/release/build-desktop.sh --target x86_64-apple-darwin   # the Intel .dmg, from an Apple-silicon Mac

cd desktop/src-tauri && cargo tauri dev   # or just run it, without packaging

The first build compiles the prover and takes several minutes.

4. Chrome and Firefox extensions

The core is compiled to WebAssembly, then each browser's pack script copies the files into dist/ and zips them. There is no bundler and no minifier: apart from the WebAssembly module, the files you load are the files in the repository.

More on Chrome, Firefox.

Chrome and Firefox extensions
bash 
core/scripts/build-wasm.sh   # → extension/shared/core/
chrome/pack.sh   # → dist/chrome/ and dist/rand-wallet-chrome-<version>.zip
firefox/pack.sh   # → dist/firefox/ and dist/rand-wallet-firefox-<version>.zip

Chrome: chrome://extensions → Developer mode → Load unpacked → dist/chrome. Firefox: about:debugging → This Firefox → Load Temporary Add-on… → dist/firefox/manifest.json.

5. Android

The core is built as a native library for arm64 and x86_64, then Gradle builds the app around it. A debug build installs on any phone or emulator; a release build is signed with a key you create yourself.

More on Android.

Android
bash 
core/scripts/build-android.sh   # → android/app/src/main/jniLibs/
cd android
echo "sdk.dir=$HOME/Android/Sdk" > local.properties   # wherever your SDK is
./gradlew assembleDebug   # → app/build/outputs/apk/debug/app-debug.apk
adb install -r app/build/outputs/apk/debug/app-debug.apk

6. iOS

The core is built as an XCFramework for device and simulator, and the app is an ordinary Xcode project. Running it on your own iPhone needs your Apple ID in Xcode → Settings → Accounts and your team chosen under Signing & Capabilities.

More on iOS.

iOS
bash 
core/scripts/build-ios.sh   # → ios/Frameworks/RandWalletCore.xcframework
open ios/RandWallet.xcodeproj   # choose a simulator or your device, then Run

7. The local web wallet

The same wallet in a browser tab, served to you by a small server that listens on 127.0.0.1 only.

More on Web.

The local web wallet
bash 
web/wallet/serve.sh   # builds, then serves http://127.0.0.1:8787/

8. Run the tests

The shared interface, the web wallet and the extension have one JavaScript suite; the desktop app and the Android app have their own.

Run the tests
bash 
npm ci --prefix ui
node --test "ui/test/**/*.test.mjs" "web/wallet/test/**/*.test.mjs" "extension/test/*.test.mjs"
( cd desktop/src-tauri && cargo test )
( cd android && ./gradlew testDebugUnitTest )
Releases

How the published files are made

On a release tag, GitHub's runners run the same scripts: the desktop app on macOS, Windows and Linux, both extension zips, and the source archive, attached to the release with SHA256SUMS. The workflow is .github/workflows/release.yml, and a Jenkinsfile runs the same pipeline elsewhere. The Android package is built and signed on a maintainer's machine, because its signing key is in no CI.

What a checksum tells you

And what it does not

A download that matches its SHA-256 is the file that was published. The builds are not reproducible bit for bit yet, so your own build will not have the same sum as the published one, and a matching sum is not proof of what source a file came from. If that is the question, the answer is this page: build it, and run what you built.