Tact vs FunC vs Tolk: какой язык для TON-контракта

К середине 2026 TON-разработчик стоит перед выбором: на каком языке писать смарт-контракт? Не один, не два, а три актуальных языка — FunC, Tact, Tolk. Все три поддерживаются, все три производят валидный TVM-байткод, у всех своя ниша. Этот гайд — практическое сравнение head-to-head: синтаксис, gas, экосистема, hello-world jetton на каждом языке, decision matrix в конце.

Главный вопрос — не «какой язык лучше», а «какой подходит для твоего конкретного проекта». Универсального ответа нет. После этой статьи ты сможешь обоснованно выбрать сам.

TL;DR — короткое сравнение

• FunC — низкоуровневый функциональный язык. Максимальный контроль над gas, минимум абстракций. Высокий порог входа. ~70% mainnet-контрактов.
• Tact — высокоуровневый Solidity-подобный. Декларативные receive-блоки, traits, OOP. Низкий порог входа. ~20% mainnet-контрактов.
• Tolk 1.4 — современный язык TON Foundation (2024–2026). TypeScript-like синтаксис, ABI, TS-врапперы, source maps, gas-экономия 30–50% vs FunC. ~10% mainnet-контрактов, но доля растёт быстро.

Когда что:

• Прототип, быстрый старт, команда с TypeScript-бэкграундом → Tact.
• High-volume DEX, оракул, ядро протокола с критичным gas → FunC.
• Новый проект с фокусом на modern DX и tooling → Tolk.

Контекст: почему вообще три языка

TON — это уникальная архитектура. TVM (TON Virtual Machine) — стековая машина с собственной системой типов (cells, slices, ints, builders). Solidity сюда не портируется — концепция другая, EVM-байткод не запускается. Поэтому языки разрабатываются с нуля.

История:

• 2018–2021: FunC. Николай Дуров пишет первый язык для TON. Функциональный, низкоуровневый — это был осознанный выбор, чтобы дать разработчикам полный контроль.
• 2022–2023: Tact появляется. Сообщество запросило high-level язык. Tact приходит как Solidity-альтернатива.
• 2024–2025: Tolk запускается TON Foundation. Цель — закрыть gap между «слишком низкий FunC» и «слишком абстрактный Tact». Tolk заявляется как «новый рекомендованный язык».
• 2026, Tolk 1.4: появляется declarative contract блок, ABI-экспорт, TypeScript-врапперы, source maps. Tolk становится production-ready.

Это не «эволюция от плохого к хорошему» — это расширение спектра. Каждый язык остался в своей нише.

FunC — низкий уровень, максимум контроля

FunC — функциональный язык с явной работой со стеком TVM. Внешне напоминает гибрид C и Lisp. Кода больше, абстракций меньше.

Синтаксис

Hello-world Counter-контракт на FunC:

#include "imports/stdlib.fc";

global int total;

() recv_internal(int my_balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {
    if (in_msg_body.slice_empty?()) {
        return ();
    }
    int op = in_msg_body~load_uint(32);
    if (op == 1) {
        total = total + 1;
        return ();
    }
}

int get_total() method_id {
    return total;
}

Что видно:

• Явная типизация (int, cell, slice).
• Прямые TVM-инструкции через slice-операции (load_uint, slice_empty?).
• Импорт stdlib.fc обязателен — даже базовые функции там.
• Globals для state — нужно serialize/deserialize вручную.
• impure маркер для функций с side-effects.

Плюсы FunC

• Максимальный контроль над gas. Ты пишешь близко к байткоду, оптимизируешь руками.
• Полная совместимость с TVM. Любая фича TVM доступна напрямую.
• Огромная база примеров. STON.fi, DeDust, jetton-минтер, NFT-стандарт — всё на FunC. Можно копировать паттерны из проверенного кода.
• Audit-экосистема. Все TON-audit-firms имеют большой опыт с FunC. На FunC-контракт легче найти грамотный аудит.

Минусы FunC

• Высокий порог входа. Нужно понимать ячейки, slices, dictionaries, stack-machine concepts.
• Boilerplate. Сериализация, авторизация, обработка op-codes — всё руками.
• Легко ошибиться. Stack-management, порядок load/store, неправильный тип в dictionary — баги, которые сложно отловить.
• Нет современных абстракций. Pattern matching, generics, type aliases — отсутствуют.

Когда выбирать FunC

• Контракт с критичным gas-бюджетом: DEX-pool, оракул, lending-vault.
• Поддержка существующего проекта на FunC.
• Реализация низкоуровневой библиотеки, которая будет вызываться из других контрактов.
• Аудит критичен, нужна максимальная читаемость для аудиторов.

Tact — Solidity-подобный, дружелюбный

Tact задумывался как «Solidity для TON». Высокоуровневый, декларативный, с traits и контрактным синтаксисом.

Синтаксис

Hello-world Counter на Tact:

contract Counter {
    total: Int as uint32 = 0;

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

    receive("reset") {
        self.total = 0;
    }

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

Что видно:

• Декларативный contract блок.
• Поля автоматически серилизуются в storage.
• receive("increment") — string-based message handler.
• Type aliases (Int as uint32) для контроля сериализации.
• get fun — get-методы как в Solidity.

Плюсы Tact

• Низкий порог входа. Если ты знаешь Solidity или TypeScript — Tact учится за день-два.
• Авто-сериализация. Не нужно вручную писать pack/unpack для structs.
• Traits. Готовые модули для jetton-minter, NFT-collection, ownable, jetton-wallet — подключаешь как mixin.
• Хорошая документация на tact-lang.org.
• Production-tested. Много проектов 2024–2025 годов на Tact (USDe-on-TON, несколько gaming-проектов).

Минусы Tact

• Меньше контроля над gas. Компилятор генерирует «безопасный» код, не всегда оптимальный.
• Часть TVM-фич недоступна напрямую. Сложные оптимизации требуют встраивания FunC-фрагментов.
• Меньшее сообщество vs FunC. Меньше готовых паттернов, меньше audit-firms специализирующихся именно на Tact.
• Не каждый аудитор знает Tact глубоко. Может быть проблема при выборе аудит-фирмы.

Когда выбирать Tact

• Прототип, MVP, hackathon-проект.
• Команда с опытом Solidity или TypeScript, без знания TVM-внутренностей.
• Бизнес-логика контракта простая, gas-budget не критичен.
• Нужны готовые traits (jetton, NFT, ownable) без переписывания с нуля.

Tolk — современный, рекомендованный

Tolk — самая новая разработка TON Foundation. К июню 2026 у нас версия 1.4.1 (см. разбор релиза). Синтаксис ближе к TypeScript и Rust, но под капотом — FunC-ядро.

Синтаксис

Hello-world Counter на Tolk 1.4:

contract Counter {
    storage: Storage
    incomingMessages: Increment | Reset
}

struct Storage {
    total: uint32
}

struct Increment(0x1)
struct Reset(0x2)

fun onInternalMessage(in: InMessage) {
    val storage = Storage.load();

    match (in.body) {
        Increment => {
            storage.total += 1;
        }
        Reset => {
            storage.total = 0;
        }
    }

    storage.save();
}

get fun total(): int {
    return Storage.load().total;
}

Что видно:

• Декларативный contract блок (новое в 1.4).
• Структуры с типизацией.
• Pattern matching match на типе сообщения.
• Авто-сериализация storage с явным Storage.load() / .save().
• get fun для get-методов.
• Tag-based union types (Increment | Reset).

Плюсы Tolk

• Современный синтаксис. Если знаешь TypeScript или Rust — освоишься быстро.
• Gas-экономия 30–50% vs FunC по официальным замерам TON Foundation. Достигается через авто-инлайн функций, intelligent stack-management, dead-code elimination.
• ABI экспорт. С 1.4 компилятор автоматически генерирует ABI-описание контракта (типы, методы, события) — машинно-читаемое.
• TypeScript-врапперы. Tolk-сборка выдаёт TS-модуль для dApp с автокомплитом и type-checking.
• Source maps. Можно отлаживать TVM-байткод с привязкой к Tolk-исходнику.
• Pattern matching, generics, null safety. Современные фичи системы типов.
• TON Foundation backing. Новые примеры и tutorials выходят на Tolk.

Минусы Tolk

• Молодой. К июню 2026 ему чуть больше года в production. Меньше edge-cases прошли через mainnet.
• Audit-firms ещё накапливают опыт. Не каждый аудитор имеет deep знание Tolk.
• Документация дописывается. Некоторые продвинутые сценарии — gaps в docs.
• Меньше готовых паттернов. Если хочешь jetton-minter на Tolk — придётся писать с нуля или адаптировать из FunC. На Tact есть готовый trait.

Когда выбирать Tolk

• Новый проект, без legacy-кода на FunC/Tact.
• Команда хочет современный DX и tooling.
• Важна gas-оптимизация, но не настолько критична, чтобы писать ручной FunC.
• Будет dApp, нужны автоматические TS-врапперы для frontend.
• Готов смириться с тем, что часть документации в development и community поддержки меньше, чем у FunC.

Decision matrix — когда что выбирать

Сводная таблица, кладущая критерии в одну плоскость:

Сценарий 1: новичок учит TON

Начни с Tact. Низкий порог, быстрая обратная связь, ты увидишь работающий контракт за вечер. После Tact, когда понимаешь модель сообщений, ячеек, асинхронности — посмотри Tolk и FunC.

Альтернатива: сразу на Tolk, если есть опыт TypeScript. Tolk строго типизирован, ошибки видны на этапе компиляции, синтаксис современный.

Не начинай с FunC — это всё равно что учить веб-разработку с ассемблера. Работает, но не для первого опыта.

Сценарий 2: команда с Solidity-опытом

Tact. Декларативный синтаксис максимально близок к Solidity. Контракт-блок, события, modifiers (через traits), get-методы — всё похожее.

После 1–2 месяцев продакшен-опыта на Tact — посмотри Tolk. Часть концепций переносится, плюс получаешь современный type-system.

Сценарий 3: новый DEX-протокол

FunC. Каждый газ-юнит критичен — на pool-операциях экономия 5% по gas даёт большое преимущество в конкуренции с DeDust и STON.fi. Tolk близок, но Aud-firms ещё накапливают опыт, для крупного DEX — лучше проверенный FunC.

Альтернатива: Tolk для нового DEX-проекта, если команда готова стать early-adopter и есть бюджет на дополнительные аудиты.

Сценарий 4: gaming-проект с миллионами пользователей

Tact или Tolk. Gaming-логика обычно не gas-критична — это много простых вызовов, а не сложная математика. Зато важен скорость разработки и легкость обновлений.

Tact выигрывает по готовым traits (NFT, ownership), Tolk выигрывает по современному DX.

Сценарий 5: jetton-минтер для memecoin

Tact или копирование reference-implementation с FunC. Стандартный jetton — это решённая задача, не надо изобретать велосипед.

• Tact: есть trait Jetton — два часа работы, получаешь рабочий контракт.
• FunC: копируешь reference-minter с TEP-74 examples — час работы, проверенный код.

Tolk пока не имеет canonical jetton-template, придётся писать с нуля.

Сценарий 6: новый core-протокол DeFi (lending, staking, RWA)

Tolk — наиболее перспективный выбор для запуска в 2026–2027. Получаешь gas-экономию, ABI для интеграций, TS-врапперы для frontend, source maps для дебага. Аудит-фирмы постепенно подтягиваются, через пол года-год их экспертиза станет глубокой.

Альтернатива: FunC если команда уже имеет опыт и сильные аудит-связи на FunC.

Инструменты — всё работает через Blueprint

Хорошая новость: фреймворк один — Blueprint от TON Foundation. Поддерживает все три языка. Создание проекта:

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

Blueprint спросит:

• Какой язык контракта (FunC / Tact / Tolk).
• Имя главного контракта.
• Включить ли пример.

После этого получаешь готовую структуру:

my-contract/
  contracts/      # исходники контрактов
  wrappers/       # TS-обёртки для деплоя
  scripts/        # скрипты деплоя
  tests/          # unit-тесты
  build/          # компилированные .boc и ABI

Команды:

• npx blueprint build — компиляция.
• npx blueprint test — запуск тестов в sandbox.
• npx blueprint run --testnet — деплой в testnet.
• npx blueprint run --mainnet — деплой в mainnet.

Подробно про workflow — в гайде по разработке на TON.

Можно ли смешивать языки в одном проекте?

Да, частично:

• Tact + FunC. Tact умеет встраивать FunC-фрагменты для оптимизаций gas-критичных мест. Используется регулярно — основная логика на Tact, hot-path на FunC.
• Tolk + FunC. Tolk компилируется через FunC-промежуточник, можно вызывать FunC-функции из Tolk. Менее распространено.
• Tact + Tolk в одном проекте. Невозможно компилировать вместе, но в одном repo могут быть разные контракты на разных языках с общим Blueprint-ом.

Главное правило: один контракт — один язык. Не пытайся переписать половину контракта на другой язык в попытке оптимизации — это путь к багам.

Что важно понять перед выбором

Несколько финальных мыслей.

1. Язык — это не самое сложное. Сложнее модель TON: ячейки, асинхронные сообщения, bounce, storage fee. На любом из трёх языков ты упрёшься в эти концепции. Tact и Tolk их прячут, но не отменяют — баги от непонимания асинхронности возможны на всех языках.
2. Аудит решает. Независимо от языка, контракт, держащий реальные деньги — должен пройти аудит. Бюджет аудита от $5K (простой контракт) до $50K+ (сложный DeFi-протокол). Заложи это в проект.
3. Tolk будет расти. К концу 2026 — началу 2027 доля Tolk в mainnet вырастет с 10% до 25–30%. Если планируешь карьеру TON-разработчика на годы — ставь на Tolk как primary, FunC как secondary.
4. Tact не умрёт. Solidity-подобный синтаксис притягивает разработчиков из EVM-мира. Это широкий pipeline, и Tact останется в нём востребованным.
5. FunC — это база. Даже если ты пишешь только на Tact или Tolk, понимать FunC полезно — чтобы читать чужие контракты, ревьюить аудит-репорты, оптимизировать критичные места.

Куда дальше

• Если хочешь начать с Blueprint и первого контракта — гайд по разработке на TON.
• Если интересует именно Tolk и его новейшие фичи — Tolk 1.4 разбор и введение в Tolk.
• Если будешь делать jetton — TEP-74 jetton-стандарт.
• Если хочешь понять, что такое jetton простыми словами — гайд по jetton.

Источники

• docs.ton.org/develop/smart-contracts — официальная документация по всем трём языкам.
• tact-lang.org — отдельная документация Tact.
• docs.ton.org/develop/smart-contracts/tolk/overview — Tolk docs.
• GitHub TON-Foundation Blueprint — фреймворк.
• Tolk-bench gas comparisons — официальные замеры gas-экономии.