Galene

A local Sui sandbox, filled with real state from any network.

Website • Docs • Installation • Quickstart • Cheatcodes

Run your code against real on-chain state, locally.

Galene forks a live Sui network and copies state in as you touch it, so a PTB that hits real pools and packages just works. No manual object dumping. Then bend that state however your test needs: mint any coin, impersonate any address, jump epochs. Mainnet is the default, and you can point it at testnet, devnet, localnet, or a private fullnode instead.

Features

• Copy-on-read fork. Real objects and packages, fetched on demand and cached. How it works
• Cheatcodes. Mint any coin, impersonate any address, overwrite objects, hot-swap packages, travel through epochs and time. Reference
• Real execution. A real Move VM runs every transaction, auto-forking what it needs. Dry runs roll back cleanly.
• Every Sui interface. gRPC (sui.rpc.v2), JSON-RPC, and WebSocket pubsub, so existing apps and SDKs connect unchanged. gRPC guide
• Replay and time-travel. Replay any past transaction and step through its object graph, command by command. Replay
• Studio. A local dashboard: object-graph debugger, faucet, transaction inspector. Studio

Also: publish your own Move packages, snapshot and revert in place, dump and reload a fork, and declare a starting sandbox in galene.toml. Configuration

Installation

Prebuilt binary, no toolchain required. Installs to ~/.local/bin:

curl -fsSL https://raw.githubusercontent.com/ariessa/galene/main/install.sh | sh

Supported platforms

Platform	Install
macOS (Apple Silicon and Intel)	Install script (prebuilt binary)
Linux (x64 and ARM64)	Install script (prebuilt binary)
Windows (x64 and ARM)	WSL2, then the install script inside the WSL shell

WSL2 forwards localhost to the Windows host, so a Windows browser and Windows-side SDKs reach the fork normally.

Build from source

Requires Rust and pnpm. make release builds the Studio export first, then the optimized binary with the dashboard embedded:

git clone https://github.com/ariessa/galene
cd galene
make release          # -> target/release/galene

For a debug build, run cargo build (needs a one-time cd studio && pnpm install).

Quickstart

# 1. Boot the fork. gRPC on :9000, JSON-RPC on :9123, Studio on :9124
galene start

In another shell. Reflection is on, so grpcurl needs no .proto files:

# 2. See what the fork serves
grpcurl -plaintext localhost:9000 list

# 3. Read a real object. It isn't local yet, so the fork fetches it on demand
grpcurl -plaintext -d '{"object_id":"0x<a live object id>"}' \
  localhost:9000 sui.rpc.v2.LedgerService/GetObject

# 4. Mint USDC to any address
grpcurl -plaintext -d '{
  "coin_symbol": "USDC",
  "amount": 1000000000,
  "recipient": "0x<address>"
}' localhost:9000 galene.v1.CheatcodeService/Faucet

# 5. Read the balance back
grpcurl -plaintext -d '{"owner":"0x<address>"}' \
  localhost:9000 sui.rpc.v2.StateService/ListBalances

The same fork answers over JSON-RPC on :9123 if you prefer it. galene studio opens the dashboard, galene replay <tx-digest> replays a past transaction. See the quickstart and the gRPC guide.

Architecture

Galene is a Nereid of the calm sea. Each part is named for one of her kin:

Name	Role
Poseidon	Runs transactions against forked state on a real Move VM.
Oceanus	Fetches objects and packages from the source chain on demand, caches them locally.
Plouto	Mints any Coin<T> with an arbitrary balance as a real, spendable object.
Proteus	Steps through a PTB command by command and shows the object graph shift.
Thalassa	Applies a declarative starting sandbox on boot.
Triton	Serves the sui.rpc.v2 gRPC services over the same fork, with reflection.

Cheatcodes

Custom methods that bend the rules of a local fork, available over JSON-RPC and gRPC:

Method	What it does
galene_faucet	Mint a known coin (SUI, USDC, USDT, WAL, DEEP) or any full type.
galene_impersonate	Execute as any address, auto-funded with gas.
galene_forkObject	Fork a real on-chain object, or a package and its whole dependency closure.
galene_overridePackage	Hot-swap a published package's bytecode, preserving linkage and types.
galene_warpEpoch / galene_setClock	Travel through epochs and time.
galene_snapshot / galene_revert	Capture fork state and roll back in place.

See all cheatcodes.

Contributing

Issues and pull requests are welcome at ariessa/galene. The documentation lives in ariessa/galene-docs and the website in ariessa/galene-landing-page.

License

Apache-2.0. See LICENSE and NOTICE.