Everything you need to
build on BuildArena

BuildArena is a full Solana development environment that runs in your browser. You sign in, create a project, and the platform spins up a sandboxed workspace with all the toolchains you need (Rust, cargo, anchor, solana, spl-token, and more) preinstalled.

You don't have to install anything locally. If your machine can run a modern browser, it can build, test, and deploy Solana programs with BuildArena.

Your first 5 minutes

1. 1

   Sign in

   Use a Solana wallet, GitHub, Google, or email. Wallet sign-in is the fastest if you already have Phantom or Solflare installed.

2. 2

   Create a project

   From the dashboard, pick a template (Anchor, Native Rust, Seahorse, or Solidity) or fork an existing community project.

3. 3

   Open the editor

   Your workspace opens in the IDE. The file tree, editor, terminal, and output panes are all there. Start typing.

4. 4

   Build and deploy

   Hit the Build button to compile, then Deploy to push to devnet, testnet, or mainnet-beta. Sign the transaction with your wallet.

Anatomy of the editor

• File tree on the left for your project structure
• Editor panes in the center with multi-tab and split-view support
• Integrated terminal at the bottom, persistent across reloads
• Output, problems, and deploy panels on the right
• Command palette (Ctrl/Cmd + K) to jump anywhere

Keyboard shortcuts

Most VS Code shortcuts work as you'd expect. Multi-cursor (Alt + click), fuzzy file search (Ctrl/Cmd + P), and quick command access (Ctrl/Cmd + Shift + P) are all there.

Anchor (Rust)

Anchor is the most common framework for writing Solana programs. We provide ready-made workspaces with anchor.toml, IDL generation, and the standard test scaffolding.

rust
use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWxqSWnpufR7N4t9SsT8Bk5Vxxxx");

#[program]
pub mod hello {
    use super::*;

    pub fn greet(ctx: Context<Greet>, name: String) -> Result<()> {
        msg!("hello, {}", name);
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Greet<'info> {
    pub user: Signer<'info>,
}

A minimal Anchor instruction

Native Rust

For programs that need full control or sit below the Anchor abstraction, native Rust is fully supported. cargo, rustfmt, and clippy all behave as you'd expect.

Seahorse (Python)

Seahorse lets you write Anchor programs in Python. The compiler turns your Python into idiomatic Anchor for you, so you get the productivity of Python with the safety of Anchor.

python
from seahorse.prelude import *

declare_id('Fg6PaFpoGXkYsidMpWxqSWnpufR7N4t9SsT8Bk5Vxxxx')

class Counter(Account):
  count: u64
  owner: Pubkey

@instruction
def increment(counter: Counter, signer: Signer):
  assert counter.owner == signer.key(), 'not the owner'
  counter.count += 1

A Seahorse program

Solidity (Solang)

If you're porting contracts from EVM chains, Solang lets you compile Solidity to Solana. We bundle the toolchain and provide starter templates.

Forgeflow is a visual program designer. You drop nodes for accounts, instructions, PDAs, and CPIs onto a canvas, connect them, and the platform turns the result into idiomatic Anchor source.

It's especially useful for whiteboarding new programs with the team or onboarding teammates who think better in diagrams.

What Forgeflow gives you

• Drag-and-drop nodes for accounts, instructions, and PDAs
• Auto-generated Anchor code that compiles cleanly
• Round-trip editing between code and canvas
• Visual hints for common Solana patterns (init, close, realloc, signer seeds)

Surfpool gives every workspace a personal Solana validator. You can fork mainnet, devnet, or testnet state on demand, replay any signature, and step through transactions without touching the real network.

Because every sandbox runs in its own container, your test state never bleeds into anyone else's session.

bash
# Boot a fresh local validator
surfpool start

# Fork mainnet state at the latest slot
surfpool fork --cluster mainnet-beta

# Replay a signature against the local fork
surfpool replay <SIGNATURE>

# Show full CPI tree for the last transaction
surfpool inspect --last

Common Surfpool commands from the integrated terminal

Need a custom crate? Add it to your Cargo.toml the way you would locally. The platform fetches, caches, and compiles it inside your sandbox. Lockfiles are respected, so your builds are reproducible.

toml
[dependencies]
anchor-lang = "0.30"
solana-program = "1.18"
my-helper = { git = "https://github.com/your-org/my-helper", tag = "v0.1.0" }
serde = { version = "1", features = ["derive"] }

Adding crates in Cargo.toml

Things worth knowing

• Builds are cached per project for fast incremental compiles
• Private Git crates work if you authorize the platform with your provider
• A curated registry of Solana-friendly crates is available from the Add Crate UI
• You can pin versions or use tags for reproducibility

What it can do

• Inline completions and multi-line suggestions while you type
• Context-aware chat that knows your file tree
• Generate tests, account validators, and CPI scaffolding
• Explain compile errors and propose fixes
• Summarize what a function or module does

How to invoke it

Open the AI panel from the right sidebar, or press Ctrl/Cmd + I to ask a quick question about the file you're in. Inline suggestions show up as ghost text — accept with Tab.

Every project is multi-player by default. Invite teammates by link, and they can edit alongside you in real time. The editor uses CRDTs under the hood, so two or twenty people can type at once without conflicts.

Collaboration features

• Real-time cursors and selections with name labels
• Per-user undo history
• Threaded inline comments anchored to lines
• Voice and video rooms attached to the project
• Role-based permissions (owner, editor, viewer)

Connect your GitHub

1. 1

   Authorize

   In Settings → Integrations, click Connect GitHub and follow the OAuth flow.

2. 2

   Import a repo

   From the dashboard, click New Project → Import from GitHub. Pick a repo and the platform clones it into a fresh workspace.

3. 3

   Branch and commit

   Use the Source Control panel to stage, commit, and push. Branch creation is a single click.

4. 4

   Open a pull request

   When you're ready, hit Open PR. Diffs are preformatted and the PR opens in a new tab.

Deploying a program

1. 1

   Build

   Hit the Build button or run `anchor build` (or `cargo build-sbf` for native programs) from the terminal.

2. 2

   Pick a cluster

   Open the Deploy panel and choose devnet, testnet, or mainnet-beta.

3. 3

   Sign and deploy

   Connect your wallet if you haven't already, then approve the transaction. The program ID lands in the deploy log.

4. 4

   Verify

   Click Verify to prove the on-chain binary matches your source. The verification badge becomes public.

bash
# Build the program
anchor build

# Deploy to devnet
anchor deploy --provider.cluster devnet

# Deploy to mainnet-beta (be careful!)
anchor deploy --provider.cluster mainnet

# Run program tests against the local validator
anchor test

Common deploy commands

What's available

• Rust toolchain (cargo, rustc, rustfmt, clippy)
• Solana CLI (solana, solana-keygen)
• Anchor CLI (anchor)
• SPL Token CLI (spl-token)
• Surfpool local validator
• Standard Unix utilities (bash, grep, jq, curl)

Auth providers

• Solana wallets (Phantom, Solflare, and more)
• GitHub OAuth
• Google OAuth
• Email + magic link

Crypto-native billing

Paid plans are billed in USDT on Solana. Pick a plan on the Pricing page, connect your wallet, and approve the transfer. Your account upgrades as soon as the transaction confirms, usually within a few seconds.

How we keep your work safe

• Container-isolated build sandboxes per user
• Encrypted storage at rest
• Network policies that scope outbound traffic
• Auditable session boundaries
• Signed deploys via your wallet, never ours

The template registry has curated starters for Anchor, native Rust, Seahorse, and Solidity. Each one boots into a working build so you can focus on your idea, not on plumbing.

You can also browse public projects from other builders, fork them, and contribute back.

Where to look

• Dashboard → New Project → Templates for curated starters
• Community page for public projects from other builders
• Profile pages to see what someone has shipped
• Star and follow your favorite builders

Common issues

• Build fails with "linker `cc` not found": run `cargo clean` from the terminal and retry. The sandbox sometimes needs a fresh slate after a toolchain upgrade.
• Deploy hangs: check that your wallet is connected to the same cluster you picked in the Deploy panel.
• Tests pass locally but fail on Surfpool: try forking from the cluster you're targeting so the account state matches.
• AI suggestions feel off: open the chat panel and provide a short summary of what you're building. Context matters.
• Wallet balance shows zero: confirm the wallet is unlocked and on the correct network. Refresh the page if the balance was just funded.