TON for developers: FunC, Tact and Tolk in 2026

For a developer used to Solidity, TON is a separate universe. Different languages, different concepts (asynchrony, cells, message-passing), different tools. This guide is a map of the terrain: what exists, what to pick, in what order to learn it.

One important disclaimer: below we discuss smart contracts, i.e. code that lives on-chain. For front-end integration (a JS/React dApp, a bot, a mini-app) the languages are different — TypeScript, Python — and they are standard.

Three TON languages

TON has three actively maintained languages for smart contracts in 2026:

• FunC — low-level, historically the first, written by Nikolai Durov.
• Tact — high-level, introduced in 2023, syntax close to TypeScript/Kotlin.
• Tolk — newest (2024–2025), positioned by TON Foundation as the recommended default.

There’s also Fift — a stack-oriented language, but it’s used only for deployment and low-level utilities. Production contracts are not written in it.

All three languages compile to TVM bytecode, which is what runs on the network.

FunC: the classic

FunC is a functional, low-level language with explicit work over TON memory primitives (cells, slices, dictionaries). Its syntax resembles a hybrid of C and Lisp:

• Explicit typing (int, cell, slice).
• Direct TVM instructions when needed.
• Minimal abstractions — you write close to the metal.

Pros:

• Full control over gas spend.
• All examples in the TON docs were historically in FunC — the base language.
• The majority of existing mainnet contracts are written in FunC.

Cons:

• High entry barrier: you need to understand cells and the low-level model.
• Lots of boilerplate (serialisation, message handling, authorisation — all manual).
• Easy to mistype or get the operation order wrong.

FunC is still supported, but TON Foundation is gradually shifting focus to Tolk. Pure-FunC new projects in 2026 are rare.

Tact: the friendly one

Tact was conceived as “Solidity for TON” — a high-level language that hides most of the TVM complexity. The syntax is close to TypeScript:

contract Counter {
    val: Int as uint32 = 0;

    receive("increment") {
        self.val = self.val + 1;
    }

    get fun value(): Int {
        return self.val;
    }
}

Pros:

• Low barrier for developers with TypeScript/Java/Kotlin background.
• Automatic message serialisation.
• Built-in patterns for jettons, NFTs, ownership.
• Excellent documentation at tact-lang.org.

Cons:

• Less control over gas — the compiler generates “safe” code, not always optimal.
• Some scenarios still require embedded FunC fragments.
• Smaller community than FunC.

Tact is actively used in production — many 2024–2025 projects migrated from FunC to it.

Tolk: the new recommended default

Tolk is TON Foundation’s freshest work. Launched in 2024–2025 and by 2026 the recommended default language.

fun main(in_msg: cell, in_msg_full: cell, my_balance: int): int {
    var counter: int = read_counter();
    counter += 1;
    save_counter(counter);
    return 0;
}

The Tolk idea:

• Modern, type-safe syntax (TypeScript-like).
• A FunC core under the hood — full TVM control.
• Automatic packing of structures into cells.
• Pattern matching, null safety, generics.

Pros:

• 30–50% gas savings versus FunC, per TON Foundation’s own benchmarks.
• Auto-inlining of functions (manual in FunC).
• Modern type system: type aliases, union types, generics, null safety.
• Still close to TVM, low-level flexibility preserved.

Cons:

• Young — the ecosystem is still forming.
• Fewer ready-made examples and audited cases.
• Documentation is still being written.

In 2026 TON Foundation is actively rewriting examples and templates in Tolk. New developers should look at Tolk first.

What to choose

Scenario	Recommendation
New project, no legacy code	Tolk
Gas optimisation is critical	Tolk or FunC
Team comfortable with TypeScript/Solidity	Tact
Maintaining an existing FunC project	FunC
Learning, understanding TON internals	First FunC for the basics, then Tolk

For an absolute beginner the path is:

1. Learn the TON base model — cells, async messages, account-as-contract.
2. Build the first contract in Tolk via Blueprint.
3. As needed — peek into FunC for deep control.

Blueprint: the main tool

Blueprint is the framework for TON development, the analogue of Hardhat in Ethereum. Built by TON Foundation, supports all three contract languages.

What’s inside

• Scaffolding — npm create ton@latest builds a project with an example.
• Compiler — built-in support for FunC, Tact, Tolk.
• Sandbox — local TVM emulator for unit tests.
• Deploy — scripts for testnet/mainnet via Tonkeeper or mnemonic.
• Testing — Jest-based, runs through @ton/sandbox.

Creating a project

npm create ton@latest my-contract
cd my-contract
npm install

Blueprint then asks: which contract language (FunC/Tact/Tolk), the main contract name, whether to scaffold an example. After that you have a ready structure with tests and a deploy script.

Running tests

npx blueprint test

Tests run in the local sandbox — no network calls, no TON spent. Time per test — milliseconds.

Deploying to testnet

npx blueprint run --testnet

The script asks how to authenticate (Tonkeeper via QR or mnemonic) and deploys the contract. Same with --mainnet for production.

Minimal development workflow

The typical contract development process:

1. Scaffold. npm create ton@latest my-token.
2. Local development. Write the contract, write tests in tests/MyToken.spec.ts.
3. Local tests. npx blueprint test — must be green.
4. Testnet deploy. npx blueprint run --testnet. The contract gets an address. From here you can connect to it with Tonkeeper on testnet.
5. Manual testing. Switch Tonkeeper to testnet, send transactions, inspect behaviour through TonScan testnet.
6. Audit. If the contract holds real funds — non-negotiable. TON audit firms: Certik, Trail of Bits, slowmist.com (TON-specialised), Tonbit.
7. Mainnet deploy. npx blueprint run --mainnet. Deployment costs 0.05–0.5 TON.

Field log · 2024–2026

In our team, the standard time from blank page to a production-ready jetton contract is 1–2 weeks for a developer with no TON experience. The bulk of that time isn’t writing code — it’s understanding the message model and testing edge cases involving bounce. Tolk + Blueprint in 2026 noticeably accelerated the cycle — earlier it took 3–4 weeks on FunC.

— TON Adoption

What to understand about the TON model

A few concepts that distinguish TON development from EVM:

Every account is a contract

Even an ordinary wallet is a smart contract (a wallet contract). It has code, state and a balance. When you “send TON”, you actually invoke a function on your wallet contract that emits a message to the recipient.

Asynchrony

Contracts do not “call” each other. They send messages, and the recipient processes them in the next block. There’s no “return value right now” — you have to design logic with callback messages.

Bounce

If the recipient cannot process the message, it bounces back with a bounced=true flag. The sender contract must know how to handle the bounce — otherwise funds get stuck.

Storage fee

A contract pays for storage out of its own balance. Leave a contract without TON, and over a few months its state is eaten by the storage fee and the contract becomes frozen.

Cells and Slices

All data on TON is stored in cells — structures with a fixed limit (1023 bits of data + 4 references to other cells). Large data becomes a tree of cells. Serialising into cells and back is its own skill.

More on the model — in the EVM-incompatibility article.

Frontend and dApp

If you’re not writing the contract itself but a dApp around it, frontend development is standard: TypeScript, React/Vue/Svelte, whatever.

Key libraries:

• @ton/ton — official SDK for talking to the TON network from JS/TS.
• @tonconnect/ui-react — a Connect Wallet button supporting every wallet. More — in the TON Connect article.
• @ton/core — types and low-level cell operations.
• @ton/crypto — cryptography (mnemonic, keys, signatures).

Where to learn

Free resources in 2026:

• docs.ton.org — official documentation. Updated regularly, has tutorials.
• tact-lang.org — Tact’s separate documentation.
• TON Hello World — step-by-step “your first contract” tutorial.
• GitHub TON-Foundation — repositories with examples and templates.
• Telegram channels — @toncontests, @tondevchat, @TONresearch.

Paid courses exist, but free materials plus your own practice are enough to get started.

What next

If you’d rather start with the architecture — the full TON guide. If you’re curious about how dApps talk to wallets — TON Connect. For risk-free experimentation — the testnet guide.

Sources

• docs.ton.org — official documentation
• tact-lang.org — Tact docs
• Tolk documentation on TON Docs
• Blueprint, GitHub ton-org
• TON Hello World tutorial