One Language. Every High-Performance Chain.
SolScript compiles Solidity into native Solana BPF programs. Bring the largest smart-contract developer base — the millions who write Solidity — to Solana without a Rust rewrite. As on-chain activity consolidates onto a few fast chains, you write in one language and ship across them.
What is SolScript?
Chain-abstraction tooling: Solidity in, native Solana out.
SolScript is an open-source (MIT) compiler framework that lets you write
Solana smart contracts in familiar Solidity syntax. It parses Solidity-style source, type-checks it, and
generates standard Rust/Anchor code — or compiles directly to Solana BPF via LLVM. Solidity
mappings become Solana Program Derived Addresses
(PDAs) automatically, so you never touch seed or bump derivation by hand.
As on-chain activity consolidates onto a few high-performance chains, teams want one language across them instead of a rewrite per runtime. Solana is fast and cheap, but native development requires Rust — and the smart-contract talent pool is overwhelmingly Solidity-native. SolScript lets the millions of developers who already know Solidity build on Solana with the knowledge they have, and the generated Anchor code is fully auditable and deployable with standard Solana tooling.
- ◆ Familiar syntax. Write contracts in Solidity — state variables, mappings, events, modifiers, inheritance.
- ◆ Auditable output. Generates readable Rust/Anchor source you can inspect, modify and audit before deploying.
- ◆ Zero install. A browser WASM compiler compiles and deploys to devnet from the playground — no backend.
Problem → solution
Closing the gap between the Solidity talent pool and Solana.
Four friction points stop Solidity developers from shipping on Solana. SolScript removes each one — so language, not runtime, is where your team's skills live.
A new chain means a new language
The problem
Solana is fast and cheap, but native development is in Rust and Anchor. Most smart-contract developers know Solidity from Ethereum — that knowledge does not transfer, so expanding to Solana usually means retraining or rehiring an entire team.
SolScript's approach
Write contracts in Solidity syntax you already know. SolScript compiles them to native Solana programs, so one team and one language reach more chains — no Rust rewrite.
SolScript vs Anchor →Solidity has no mappings on Solana
The problem
Solana has no mapping type — it uses Program Derived Addresses (PDAs). Porting a Solidity mapping by hand means managing seeds and bump derivation for every key.
SolScript's approach
SolScript converts mapping(address => uint256) into PDA-based account lookups automatically, deriving the correct seeds and bumps for you.
How PDA mapping works →Compiled binaries are opaque
The problem
Tools that compile Solidity straight to BPF bytecode give you a binary you cannot read or audit line by line before it holds value.
SolScript's approach
SolScript generates standard, human-readable Rust/Anchor source. Inspect it, modify it, and audit it with the tools your team already trusts.
How compilation works →Setup gets in the way of learning
The problem
Toolchains, local validators and wallet config are a wall between "I want to try this" and a deployed contract.
SolScript's approach
The browser playground runs a WASM-compiled SolScript compiler client-side — compile instantly and deploy to devnet with Phantom or Solflare, no install.
Open the playground →Solidity Syntax, Solana Performance
Write a token contract in Solidity. Deploy it to Solana.
contract Token {
string public name;
string public symbol;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor(string memory _name, string memory _symbol, uint256 _supply) {
name = _name;
symbol = _symbol;
_mint(msg.sender, _supply);
}
function transfer(address to, uint256 amount) public returns (bool) {
balanceOf[msg.sender] -= amount;
balanceOf[to] += amount;
emit Transfer(msg.sender, to, amount);
return true;
}
}What SolScript Does
- 1. Parses your Solidity-style contract
- 2. Converts
mappingto Solana PDAs - 3. Generates Rust/Anchor code
- 4. Deploys to Solana devnet, testnet, or mainnet
Features
A complete Solidity-to-Solana toolchain.
Compiler, playground, CLI and editor tooling — everything you need to build on Solana with Solidity.
Solidity syntax
State variables, mappings, functions, modifiers, events, custom errors, constructors, single inheritance and interfaces — all compile to Solana.
Automatic PDA mapping
Solidity mappings compile to Solana Program Derived Addresses automatically — correct seeds and bump derivation, no manual account management.
Anchor compatible
Generated code is standard Rust/Anchor. Inspect it, modify it, audit it, and deploy with the Solana tooling you already use.
Browser WASM compiler
The playground runs a full WASM-compiled SolScript compiler client-side. Compile instantly with no backend or install.
SPL Token built-in
Token transfers, minting and burning are first-class operations — SolScript emits the correct SPL Token CPI calls for you.
VS Code extension
Language Server Protocol support with real-time diagnostics, syntax highlighting and build/check commands right in your editor.
CLI toolchain
solscript build, check and build --bpf give you type-checking and both output modes from the terminal, ready for CI.
Direct BPF mode
Optionally compile straight to Solana bytecode via LLVM 18 for a faster path when you do not need to read the Rust.
How it works
From Solidity source to a Solana program.
SolScript parses your contract, type-checks it, and generates either readable Anchor/Rust or BPF bytecode — ready to deploy to devnet, testnet or mainnet.
How SolScript Compares
Choose the right tool for your Solana development workflow.
| Feature | SolScript | Solang | Anchor (Rust) | Neon EVM |
|---|---|---|---|---|
| Language | Solidity | Solidity | Rust | Solidity |
| Approach | Transpiler | LLVM Compiler | Native | EVM Emulation |
| Auto PDA Mapping | Yes | Manual | Manual | N/A |
| Auditable Output | Rust source code | Binary only | Native Rust | EVM bytecode |
| Browser Playground | Yes (WASM) | No | No | No |
| Native Solana Perf | Yes | Yes | Yes | Emulated |
Frequently Asked Questions
What is SolScript? ▼
Can I deploy Solidity contracts to Solana? ▼
Is SolScript free to use? ▼
Do I need to know Rust to use SolScript? ▼
How do Solidity mappings work on Solana? ▼
What Solidity features are supported? ▼
Why does a Solidity-to-Solana compiler matter in 2026? ▼
Is SolScript the same as a cross-chain bridge or messaging layer? ▼
Explore
Everything you can dig into.
Docs, guides, examples, tutorials and comparisons — the full SolScript library, one click away.
Documentation
Installation, language guide, tutorials and API reference for the Solidity-to-Solana compiler.
Features
Full Solidity language support, automatic PDA mapping, Anchor and BPF output, and browser/CLI/VS Code tooling.
How It Works
The full compile pipeline — parse, type-check, map to PDAs, generate Anchor or BPF, and deploy — plus a quickstart.
Examples
Token, AMM, staking, multisig, escrow, voting and counter contracts — open any one directly in the playground.
Tutorials
Step-by-step builds from your first token contract to escrow and multi-sig wallets, beginner to advanced.
Use Cases
Migrating Ethereum apps to Solana, building SPL tokens in Solidity, and learning Solana development.
Comparisons
How SolScript stacks up against Solang, Neon EVM, Anchor and Seahorse, with side-by-side breakdowns.
Blog
Articles on Solidity-to-Solana development, smart-contract patterns and the SolScript toolchain.
Start Building on Solana Today
No Rust required. Write your first Solana contract in Solidity syntax.