SolScript vs Solang vs Neon EVM: 3 Ways to Write Solidity on Solana
There are three tools that let Ethereum developers use Solidity on Solana: SolScript, Solang, and Neon EVM. Each takes a fundamentally different approach. This guide compares all three so you can choose the right one.
TL;DR
- SolScript compiles Solidity to readable Anchor/Rust code. Automatic PDA mapping, browser playground, auditable output. Best for new Solana projects.
- Solang compiles Solidity to BPF bytecode directly via LLVM. Hyperledger-backed, Solidity 0.8 compatible. Requires understanding Solana's account model.
- Neon EVM runs a full Ethereum Virtual Machine on Solana. Existing contracts work with minimal changes, but adds emulation overhead.
How Each Tool Works
SolScript: Solidity → Anchor/Rust → BPF
SolScript parses your Solidity code, performs type checking, and generates human-readable Rust/Anchor source code. Solidity mapping types are automatically converted to Solana PDAs. The generated Anchor code is standard — you can inspect, modify, audit, and deploy it with existing Solana tools. SolScript also offers a direct LLVM-to-BPF mode for faster compilation.
Solang: Solidity → LLVM IR → BPF
Solang (by Hyperledger) is a Solidity compiler that uses LLVM to compile directly to Solana BPF bytecode. It supports Solidity 0.8 syntax with Solana-specific modifications. Solang doesn't abstract away Solana's account model — developers must understand the differences between EVM storage and Solana accounts. No intermediate Rust code is generated.
Neon EVM: Full EVM Emulation on Solana
Neon EVM runs a complete Ethereum Virtual Machine as a Solana program. You deploy standard EVM bytecode — the same contracts you'd deploy to Ethereum — and Neon executes them on Solana's infrastructure. This means existing dApps work with minimal changes (just switch the RPC endpoint), but the emulation layer adds overhead.
Feature Comparison
| Feature | SolScript | Solang | Neon EVM |
|---|---|---|---|
| Approach | Transpiler | Compiler | VM Emulation |
| Output | Readable Rust/Anchor | BPF bytecode | EVM bytecode |
| Auditable output | Yes (Rust source) | No (binary only) | No (EVM bytecode) |
| Auto PDA mapping | Yes | Manual | N/A (EVM storage) |
| Browser playground | Yes (WASM) | No | No |
| Existing ETH contracts | Rewrite needed | Modifications needed | Minimal changes |
| Native Solana perf | Yes | Yes | Emulation overhead |
| Solidity version | Solidity-style | 0.8 compatible | Full EVM compat |
| Anchor integration | Native output | Supported | No |
| SPL Token built-in | Yes | Via libraries | ERC-20 only |
| VS Code extension | Yes (LSP) | Basic | Standard Solidity |
| Maturity | Beta | Stable | Production |
| Backing | Open source | Hyperledger | Neon Labs ($40M raised) |
When to Choose Each Tool
Choose SolScript When
- You want readable, auditable output
- You need automatic PDA handling
- You want a browser playground
- You're building new contracts for Solana
- You prefer Anchor-compatible code
Choose Solang When
- You need strict Solidity 0.8 compat
- You want direct BPF compilation
- You prefer Hyperledger ecosystem
- You understand Solana's account model
- You need a stable, established tool
Choose Neon EVM When
- You have existing ETH contracts
- You want minimal code changes
- You need full EVM compatibility
- You use Hardhat/Foundry tooling
- Emulation overhead is acceptable
Performance Considerations
SolScript and Solang both produce native Solana programs that execute directly on the Solana runtime. There is no emulation layer, so performance matches hand-written Rust/Anchor programs.
Neon EVM adds an emulation layer — an EVM interpreter running as a Solana program. This means every EVM opcode is translated at runtime, which adds compute unit overhead. For simple operations this is negligible, but for complex DeFi protocols the difference can matter.
For new projects targeting Solana, native compilation (SolScript or Solang) is recommended over EVM emulation. For porting existing Ethereum dApps quickly, Neon EVM trades performance for convenience.
Frequently Asked Questions
What is the difference between SolScript, Solang, and Neon EVM? ▼
All three let you use Solidity on Solana, but they work differently. SolScript compiles Solidity to Anchor/Rust code with automatic PDA mapping and a browser playground. Solang compiles Solidity directly to Solana BPF bytecode using LLVM. Neon EVM runs a full Ethereum Virtual Machine on Solana, so existing Ethereum contracts work with minimal changes but run in an emulated environment.
Which is the best Solidity compiler for Solana? ▼
It depends on your needs. SolScript is best if you want readable Anchor output, automatic PDA handling, and a browser-based playground for rapid development. Solang is best if you want direct Solidity-to-BPF compilation with Hyperledger backing. Neon EVM is best if you need to deploy existing Ethereum contracts unchanged.
Is Solang still maintained in 2026? ▼
Solang is maintained by Hyperledger (Linux Foundation). It supports Solidity 0.8 syntax and integrates with Anchor. However, development pace has slowed compared to its early days. Check the Solang GitHub repository for the latest activity.
Can I use Neon EVM for new Solana projects? ▼
You can, but Neon EVM is primarily designed for porting existing Ethereum dApps to Solana. For new projects, native Solana development (via SolScript, Solang, or Anchor) gives you better performance and lower overhead since there is no EVM emulation layer.
Does SolScript generate auditable code? ▼
Yes. SolScript generates standard Rust/Anchor source code that you can read, modify, and audit before deployment. This is a key advantage over direct bytecode compilation — you can verify exactly what the compiler produced.
Which tool has the lowest learning curve for Ethereum developers? ▼
Neon EVM has the lowest learning curve since it runs Ethereum contracts almost unchanged. However, SolScript offers a better balance: familiar Solidity syntax with native Solana performance and no emulation overhead. Solang requires understanding Solana's account model differences from Ethereum.
Can I try Solidity on Solana without installing anything? ▼
Yes. SolScript offers a browser-based playground at solscript.cryptuon.com/playground with a WASM compiler that compiles Solidity-style code instantly in your browser. Neither Solang nor Neon EVM offer a comparable browser IDE — Solang requires local installation, and Neon EVM requires deploying to their network.
No installation needed. Write Solidity, compile to Solana, instantly.