TypeSOL

the TypeSOL Performance Report is out. TypeSOL against Anchor, native Rust and Pinocchio, on identical programs: 17.9% of Anchor's compute units binaries 10.7x smaller than Anchor's cheaper than hand-tuned Pinocchio on 9 of 9 instructions 61% less compute than Anchor on mainnet, every transaction linked no number counts until all four reach the same final state and refuse the same hostile calls. typesol.com/report

New toolchains lose people in the first five minutes. TypeSOL v0.26.0 is built for those minutes. typesol doctor checks Node, the platform-tools, the Solana CLI, your keypair, the RPC and your balance, and prints the exact command that fixes each problem. deploy checks the RPC and the rent before it sends anything. Same compiler output, smoother start.

A compiler's promises should be written down. TypeSOL now has a security model: 15 guarantees every instruction it compiles can rely on, from the first account check to the last close, each with the error code it returns. Stricter than Anchor where it counts: any two writable parameters naming one account are refused. And it's packaged for an external audit: scope, evidence and fuzzing in one place.

npm says 1,085. That's how many times the TypeSOL CLI was downloaded from npm in its first 16 hours there (Oct 27 UTC). Every version published that day was pulled 140+ times, the last one within 4 hours of going live. npm hasn't counted day two yet. We've shipped 10 more releases since, up to 0.25.0. Word is getting around.

The Anchor escrow from Solana's program-examples, ported to TypeSOL end to end. 10 files and 398 lines of Rust became one TypeScript file under 100 lines. Same account bytes, so an Anchor client reads it unchanged. Same 21 offers, same end state. Same refusals, now checked in Anchor's order. take_offer: 7,053 compute units vs Anchor's 29,235. The full case study ships with v0.25.0.

Solana accounts are fixed-size until you resize them yourself. In TypeSOL you declare entries: Vec<Entry> and call push(entry, payer). The compiler emits the realloc: the account grows by exactly one entry and the payer covers the new rent. One ledger entry here is 61 bytes, so each push adds 424,560 lamports of rent. No space math, no realloc constraints.

Solana Developers want you to learn Solana by building apps. We agree, so we're shipping one. Oct 30 UTC: our first test dApp goes live, its on-chain program written in TypeScript and compiled by TypeSOL. A framework proves itself by what ships on it. This dApp is built to strengthen the token ecosystem around TypeSOL. First of many.

The cheapest Solana bug is the one that never builds. TypeSOL refuses 105 mistakes at compile time, each with its own test: an unpinned CPI target, a signer that never signed, a reference into data you just replaced, two instructions whose discriminators overlap. Every error points at file:line:col and tells you the fix.

signature checks are easy to get wrong in a Solana program. TypeSOL makes the safe way the only way. Ed25519: the runtime's precompile verifies the signature, and verifyEd25519 checks through the Instructions sysvar that it covered this signer and this message. secp256k1: the compiler only accepts a hash the program computes itself. a hash handed in by the caller could be forged, so it doesn't compile. Merkle proofs: sorted-pair keccak, the same rule as OpenZeppelin's.

how do you trust a compiler you didn't write? you check what it builds against four things it didn't write: BigInt, for every integer operation from u8 to u128 a TypeScript model, under random honest and hostile actions Anchor twins of the same programs, step by step Solana's own official examples, failure paths included every random run prints its seed, so any failure replays exactly.

the checks you'd forget in a Solana program, TypeSOL writes from your types. authority: Signer → it must have signed counter: Mut<Counter> → writable, owned by this program, really a Counter two Mut accounts → never the same account twice count += by → an overflow aborts when one fails you get Anchor's own error number, so existing clients and explorers read it as-is.

most teams YC funds already ship in TypeScript. with TypeSOL, the same people write the Solana program too: TypeScript in, native SBF out, an Anchor-compatible IDL and a typed client alongside. idea to on-chain program, without hiring a Rust team first.

what you can build with TypeSOL right now, all in TypeScript: vaults and escrows on SPL Token and Token-2022 NFTs and collections on Metaplex, Core and Bubblegum Token-2022 transfer hooks apps that read Pyth and Switchboard signature checks and Merkle allowlists ports of existing Anchor programs, accounts kept byte for byte npx @typesol/cli init --template escrow

the same counter program, written twice. Anchor: 67 lines of Rust TypeSOL: 28 lines of TypeScript same instructions, same PDA, same account layout. same authority check, same overflow check. in TypeSOL every + is checked, so that guard costs you zero lines. both run the same tests and have to end in the same state.

institutions are picking the chain. next come the builders, and most of them already write TypeScript. that's who TypeSOL is for: Solana programs written in TypeScript, compiled to native SBF, Anchor-compatible from day one.

and if your team already writes TypeScript, that move just got a lot shorter. TypeSOL compiles TypeScript straight to Solana programs: native SBF, an Anchor-compatible IDL, a typed client. no Rust to learn first. npx @typesol/cli init, and you're writing a program.

real work, and every line of it is public. the compiler is MIT and on npm. 14 releases since launch, every pull request in the open. the dev wallet's whole allocation is locked on chain until May 2027. the mint has no mint authority and no freeze authority. as for the Anchor question: all 46 of Solana's official Anchor examples already run as TypeSOL. and that's the plan. keep building in public, bring Solana devs in, hand it to the Foundation.

the first 28 hours after TypeSOL launched: 13 releases 67 pull requests merged test files: 49 → 91 9,156 lines added to the compiler v0.23.0 is on npm now. this is what building a language in public looks like.

give TypeSOL a program address, get a typed TypeScript client. npx typesol client --address <program id> --url <rpc> it reads the IDL from chain, so it works for Anchor programs too, zero-copy accounts included. resolve fills in what you used to pass by hand: signers, has_one accounts, PDAs. and in tests, the same client runs over LiteSVM.

TypeSOL is going for this. Solana's application-only room for the people pushing the network, and we want in, with a compiler that turns TypeScript into SBF. since launch: 12 releases, all 46 official Anchor examples ported, a playground in the browser. see you in London.