Do we have a game changer in the #Solana space?
@Type_SOL (solana:Fek7BGWxw9MabKejxFdhEftygFkJXcQjezk99fkTmKaX ), ca: Fek7BGWxw9MabKejxFdhEftygFkJXcQjezk99fkTmKaX is a brand-new developer tool that lets people write Solana smart contracts in TypeScript instead of Rust. It compiles straight to native Solana bytecode. No VM, no interpreter, no generated Rust. It also spits out an Anchor-compatible interface so existing tools still work.
TypeSOL is an ultra-early microcap bet on the “language layer” of Solana. MC is swinging in the $100–150K range with a couple hundred holders. If it becomes the way a meaningful number of people write Solana programs, the upside is huge.
My fresh conviction play. NFA
Do you jeeters even realise what @repodoting is building? Y'all jeeted it from 300k to 74k within 2 days, just because the dev makes 1 post per 1-2 days?
Smh y'all ngmi.
Inference gacha markets. Open source markets. Few.
59PXVfJ28HLYpdYLz8rt8ziE9EWbK4mS8xvq38NUQ1Be
Is this not a game changer for token launchpads etc?
@Type_SOL now allows developers to write Token-2022 transfer hooks in TypeScript, enabling tokens to enforce custom rules on every transfer, such as transfer limits, allowlists, blocklists and fees.
All six official Solana transfer-hook examples have been ported.
Why it matters: $TS is proving it can handle real token-level infrastructure, not just basic smart contracts. It makes programmable token behaviour more accessible without requiring developers to write Rust.
Study bringing their infrastructure to mainnet $MMO
TypeSOL 0.38.0 is on npm.
All of Raydium CLMM and Jito's three MEV programs now ship as examples in the release, each checked against the binary running on mainnet. The compiler learned what the Jito programs needed: a PDA bump stored in a nested field, error variants without messages, and Anchor's naming for an argument that shares an account's name.
A program that uses none of that compiles to the same bytes as in 0.37.0. The 29th release since Oct 27.
Tldr:
$TS is relatively new and specialized, most AI models don’t know it well from training data. Now, when an agent is helping you write a TypeSOL program and hits something @Type_SOL has already solved (account checks, PDAs, error handling, Metaplex examples, etc.), it can pull the actual TypeScript source as a worked example instead of inventing an answer.
It’s a recognition that TypeSOL’s code is useful reference material for AI agents, and it improves the quality of AI assistance for people building Solana programs in TypeScript.
I think this is just start for many to come!.
TypeSOL was selected for the XERJ Corpus Hub, the open reference memory AI coding agents search before they write code.
The whole typesol repository is indexed as a corpus. When an agent writing a Solana program hits a problem TypeSOL already solved, it gets the real TypeScript source back as a worked example, with the repository attached, instead of answering from memory.
Solana programs in TypeScript, now part of what AI agents read before they write.
Beside @osaidbk
You also try the tech and proof that is real, big thanks for doing it,
This is huge and it getting eyes, only matter of times before this going skyrocket into millies, or 10M 👀
$TS
Fek7BGWxw9MabKejxFdhEftygFkJXcQjezk99fkTmKaX
Gm.
I audited TypeSOL solana:Fek7BGWxw9MabKejxFdhEftygFkJXcQjezk99fkTmKaX end to end:
cloned it, built it, ran the tests, rebuilt programs and compared them to mainnet, and sent attack transactions at it.
Short version: the tech is real. Though i am betting on an anon dev.
What works:
• 719 tests pass
• The npm package builds and deploys on a local chain
• Published benchmarks reproduce within ~0.5%
• All 16 mainnet transaction figures in the README match on-chain
• The escrow program rebuilds byte for byte against mainnet
Security: I wrote a test program and sent 24 hostile transactions at it (fake signers, wrong owners, fake PDAs, overflows, reuse after closing an account).
All 24 were rejected and all 7 honest calls went through. The core safety checks are solid.
Overstated: "beats hand-tuned Pinocchio on every instruction."
It only holds against Pinocchio code the same dev wrote. On Solana's official examples, TypeSOL wins 13 of 26 instructions, and Pinocchio is up to ~10x cheaper on some.
Unproven: the native and Anchor comparison programs were built on macOS and can't be reproduced from source on Linux. The Anchor source also declares a different program ID than the deployed one.
There's no independent audit, which the README admits.
Red flags:
• Anonymous dev with accounts 4–5 days old
• The token launched the day after the GitHub org appeared
• The first commit is a single 24,650-line dump
• 354 commits in 5 days
• A single key can upgrade the demo programs
• The "4k npm downloads" are mostly bot and CI traffic
Verdict:
Code 7/10
Trust in $TS 7/10
Real, working software. If they keep shipping & start listening to the community, this may be a gem
This is why I think $TS is just getting started.
Data from major developer platforms highlights that TypeScript is not just relevant in 2026 but has effectively become the default standard for writing professional JavaScript applications.
Imo we are seeing something with much demand like $REPOING here too!
From a 28-line counter to all of Raydium CLMM in 5,721 lines: every example in the TypeSOL repository is TypeScript, built by the same compiler.
The four in green run side by side with their programs on Solana mainnet.
Pick one, read it, change it. typesol init gets you started.
How a Jito tip moves, written in TypeScript:
Searchers tip into eight tip accounts. Each change of receiver or block builder pays out what was collected, the builder's commission first. The rest lands in the validator's tip distribution account, and after the epoch a Merkle root decides who claims what.
All three programs, rebuilt in TypeSOL and checked against the ones on mainnet.
Interesting question here. If $TS offers 90% less less sol for deployment versus rust and anchor why wouldn't businesses explore this? Why wouldn't builders and developers explored this?
Raydium CLMM, now with swaps, matched to the program on mainnet.
TypeSOL's port covers the 8 instructions a pool lives on: pools, positions, swaps and fee collection. 166 transactions, including swaps through limit orders, dynamic fees and the live USDC/CC pool: same outcome, same bytes, same events.
A swap: 49,023 → 22,504 compute units.
Next week, TypeSOL goes to the Solana ecosystem.
Starting next week we're reaching out to the people behind Solana's developer ecosystem and applying to Solana's developer programs.
We're not bringing a pitch deck. We're bringing a compiler shipping several times a day, every official example ported to TypeScript, and live mainnet programs matched side by side.
Solana programs, written in TypeScript, by anyone.
TypeSOL v0.31.0 ports the trading core of Raydium CP-Swap: swaps both ways, deposit, withdraw, fee collection and the admin instructions (9 of its 24).
It runs next to the binary dumped from mainnet, under the same program id: 59 transactions, same outcome, same account bytes, same events.
swap_base_input: 24,142 → 7,478 compute units.
The real advantage is cost. TypeSOL's benchmarks show 0.334 SOL for deployment vs 0.783 SOL with Rust and 3.53 SOL with Anchor across 3 programs. That's up to 90% less SOL tied up in deployment rent. Why wouldn't builders explore this? solana:Fek7BGWxw9MabKejxFdhEftygFkJXcQjezk99fkTmKaX
TypeScript lowers the barrier to @solana development because millions of developers already know it, unlike Rust, which has a steeper learning curve. With @Type_SOL, developers can write programs in familiar syntax while compiling to native Solana bytecode. Combined with Anchor compatibility, integrated testing and simpler tooling, this could accelerate development, attract more builders and expand Solana’s ecosystem.