📣 TON Developers — we need your feedback!

Help us shape the future of TON development. We’ve prepared a detailed survey to understand your experience with:
🧠 Smart contract languages (Tact, Func, Tolk)
📚 Documentation and education
🛠 SDKs, IDEs, and tools
🤖 Telegram Mini Apps
💬 Developer support and pain points

💎 As a thank you, we’ll issue an SBT (Soulbound Token) to your wallet as proof of contribution to the ecosystem.

👉 Take the survey here:
https://docs.google.com/forms/d/e/1FAIpQLSfDm85Z7YxDw96nMeV9T-b2kmd2qAe8xt0_iag8ZqrgqKuCRw/viewform

🕐 Takes 5 minutes. Every voice matters.
Let’s build a better TON together.

⚠️ If you are still using tonutils-go version below 1.13, you should update ASAP, because after mainnet update GetAccount method becomes incompatible due to changes in blockchain account schema, so your service may stop working.

This method is also used during wallet interraction and sending transactions.

https://github.com/gobicycle/bicycle/releases/tag/v0.10.1

Important update!
Changes will soon be applied to the Mainnet that will disrupt some services (including Bicycle). A new version v0.10.1 has been released to support these changes. To maintain the functionality of bicycle, it is recommended to update as soon as possible.

🫧 Tolk v1.0: lazy loading, partial updating, AST inlining — and extremely low gas fees

This is happening today.

I managed not only to finish up the compiler, but also to migrate standard contracts from FunC to Tolk.

I covered every contract with gas metrics to check whether it's more efficient than FunC or not. I didn't believe my eyes. I double-checked, triple-checked, but nothing changed. The results are correct. And now I am ready to present them to you.

🧪 Benchmarks!

Every contract has several metrics. For example, "basic jetton — mint".
FunC: 19278. Tolk: 11611.
Gas savings: -39.77%

|————————————————–-
| 01 — Jetton (mint, transfer, burn, discover)
| -39.77% | -30.32% | -33.66% | -26.75%
|————————————————–-
| 02 — NFT (deploy, transfer, onchain get)
| -43.79% | -37.47% | -44.28%
|————————————————–-
| 03 — Notcoin
| -35.72% | -27.98% | ...
|————————————————–-
| 04 — tgBTC
| -23.94% | -26.99% | ...
|————————————————–-
| 05 — Wallet v5
| -21.66% | -22.92% | ...
|————————————————–-
| 06 — Vesting
| -45.30% | -29.61% | ...
|————————————————–-
| 07 — Telegram gifts
| -54.81% | -39.39% | ...
|————————————————–-

I have migrated 7 contracts — preserving the original behavior and passing the same tests.

All benchmarks are open. No cheating. Just a smart compiler — and a language designed to be optimized.

— Even wallet?! But it's very low-level and tricky!

Even wallet. You just express your thoughts without any tricks — and it works automatically.

— But how? How is it possible to achieve such numbers?

Of course, I've put a lot of smartness into the compiler. A strong type system. Automatic inlining. Built-in serialization. The magic lazy keyword.

But first of all, Tolk is built for readability. These contracts aren't "just cleaner" than their FunC equivalents — they're elegant. No magic. No low-level intrigues. Just clean, consistent logic — whether it's a Jetton or a Wallet.

And gas savings? They are a consequence. I didn't micro-optimize. Each contract was rewritten in about a day — just focusing on clarity. The core principle is simple: once you make it elegant, it automatically becomes efficient.


✅ Notable changes in Tolk v1.0:

1. Lazy loading — only read what you actually use
2. AST-based inlining — zero-cost getters and methods
3. Peephole optimizations, TVM-11 — smaller code, lower gas

PR on GitHub with detailed info.

Just take a look:

val st = lazy Storage.load();
// the compiler skips everything and loads only what you access
return st.publicKey;

That's it. Lazy loading and partial updates (calculating immutable slices for writing) — one magic lazy keyword to rule them all.

⚙️ The Release. What's inside

- JetBrains IDE plugin — with completion, resolving, etc... ✓ done
- VS Code Extension — with suggestions, stdlib integration, etc... ✓ done
- Language server — for any LSP-compatible editor... ✓ done
- FunC-to-Tolk converter — migrate a project in 10 seconds... ✓ done
- Documentation — for smooth transition from FunC... ✓ done

And the TOLK language itself — exactly as I've visioned it... 7 months ago


📅 The essence of Numbers

At this moment, abstract yourself from the text. Take a look at the calendar.

Today is 07/07/25 (I mean 2+5, of course).

After the TON Gateway, throughout all November, I was laying out the roadmap towards Tolk v1.0. On December 1, I started working. It means, that the journey till now took exactly 7 months 7 days. If you scroll this channel to the top, you'll see an announcement... Of Tolk v0.7

🪐 What's next?

I could have written about my plans — for the language, TVM, ABI, TypeScript wrappers... but I won't.

Because today, instead of rushing into the future, maybe we can allow ourselves to look back.
To pause the endless race — just for a moment.
To notice how many beautiful coincidences pass us by — unnoticed in our constant hurry.

Just step outside.
Close your eyes.
Count to seven.
Feel it.

When you're ready —
Let's Tolk

🎉 Unified TON Extension for VS Code is here!

Following the single convenient JetBrains IDE plugin, we are now introducing a unified extension for TON development for VS Code that supports all necessary languages and technologies.

This is the first contribution from Petr, who recently joined the TON Core team to make life sweeter for TON developers.

📜 The extension provides advanced features for the main TON technologies: Tolk, FunC, TL-B, Fift Assembly, TASM, BoC, Blueprint! If you use the old extensions for Tolk or FunC, we recommend trying the new extension, as it offers better language support (we even support try/catch for FunC 😎).

📥 Install now

- VS Code Marketplace
- Open VSX (if you use Cursor, Windsurf, etc.)

We thank the @tontech team for the FunC debugger which is now integrated into the extension, so you don't need to install a separate extension!

Happy hacking! 🛠️✨

🚀 Tolk 1.0 – The New Standard for Smart Contracts on TON Blockchain!

Are you wondering which language to use for building on TON? 🤔 Tolk is TON Foundation’s recommended choice, and it’s here to elevate your smart contract game!

🔹 What’s New?
Tolk 1.0 combines modern syntax and a streamlined experience with the performance and control that TON developers demand. It builds on FunC’s foundations, making smart contract development cleaner, more expressive, and more efficient.

🔹 Why Tolk?
• Primary language for TON smart contracts
• Modern syntax + cleaner structure
• 40% less gas compared to FunC – cheaper deployments!
• 🛠 Full tooling, IDE support, and migration from FunC

Tolk brings you better performance, easier coding, and lower costs while keeping the control you need. Whether you’re new to TON or scaling a complex app, Tolk is the go-to choice for TON development.

Start coding with Tolk today and build the future of TON! 🧑‍💻

Introducing the Jetton 2.0 Smart Contract

Transfers and operations with Jetton 2.0 are up to 3 times faster under heavy network load compared to jettons of the previous version.

This improvement was achieved thanks to new shardchain optimizations—the jetton-wallet holding a user’s token balance is now always deployed in the same shardchain as the owner’s wallet. This became possible after the TON node introduced functionality to deploy smart contracts into a specific shardchain (StateInit.fixed_prefix_length).

The smart contract is a direct successor of Jetton 1.2—used for popular tokens like $NOT—written by the TON Core team and covered by unit tests.

We would like to thank Andrew G Kiba, a community developer who made a contribution to the contract’s design.

A Tolk-language version of the smart contract will be released later.

https://github.com/ton-blockchain/jetton-contract/tree/jetton-2.0

🔬 TON data on Dune Advanced Guide

Shared some advanced sql magic for fellow analysts.

🔹 How to analyze authentic users (excluding contracts and custodial wallets)
🔹 How to calculate TVL using balance tables
🔹 How to calculate USD volumes flowing through addresses
🔹 How to track Telegram Stars volumes on TON Blockchain
🔹 How to analyze both on-chain and estimated off-chain NFT trading volumes

Read the article:
🔗 blog.ton.org/how-to-analyze-ton-users-and-token-flows-on-dune

If you are new to TON data or Dune, read the first part: blog.ton.org/ton-on-chain-data-analysis-dune

Intellij TON v3.0.0 is the biggest update of the plugin ever.

We have improved every part of the plugin, every supported language.
The list of supported languages has expanded, and now the plugin also supports TASM, the future assembler standard in
the Tolk language, and Fift assembly has received its improved support as part of Fift support.
BoC files are no longer just opaque binary files, you can open them and see the disassembled code!
In this version, we also supported the latest release of Tolk 1.1.

Available on JetBrains Marketplace

Read full change-log:
https://github.com/ton-blockchain/intellij-ton/releases/tag/v3.0.0

🫧 Tolk v1.1: built-in map<K,V>, enums, private and readonly fields, method overloads

Two months have passed — maybe you even started to worry about the silence. The reason is simple: I worked on features that are "nice to have" but complex and time-consuming to implement — and they've only just been finished.

✅ Notable changes in Tolk v1.1:

1. map<K, V> — a convenient zero-overhead wrapper over TVM dictionaries
2. enum — group numeric constants into a distinct type
3. private and readonly fields in structures
4. Overload resolution and partial specialization

PR on GitHub with detailed info.

✔ Built-in maps

Forget about uDictSetBuilder, sDictGetFirstAsRef, and the endless boilerplate of low-level dict helpers. A universal map<K, V> now fully replaces them.

var m: map<int8, int32> = createEmptyMap();
m.set(1, 10);
m.addIfNotExists(9, -90);
m.delete(9);   // now: [ 1 => 10 ]
m.exists(1);   // true
m.isEmpty();   // false

Just m.get() — no need to care about cells and slices under the hood:

val r = m.get(1);
if (r.isFound) {   // true
    val v = r.loadValue();  // 10
}

// or if the key 100% exists
val v = m.mustGet(1);  // 10

Easily iterate forward and backward:

var r = m.findFirst();
while (r.isFound) {
    // use r.getKey() and r.loadValue()
    r = m.iterateNext(r);
}

Any serializable keys and values — it just works:

map<address, Point>
map<Point, Cell<Extra>>
map<int32, map<int64, bool>>
...

All in all:
- self-explanatory methods, nicely suggested by IDEs
- DICTISETREF, DICTREPLACE, DICTUREPLACEGET, ... — 100+ asm instructions covered by the type system
- all deserialization to/from cells perfectly hidden by high-level API
- absolutely zero overhead compared to low-level TVM dictionaries

✔ Enums

A long-awaited syntax feature for grouping constants.

// will be 0 1 2
enum Color {
    Red
    Green
    Blue
}

Being integers at runtime, enums have their own place in the type system. They resemble TypeScript/C++ enums. (Unlike Rust, where each variant may have its own shape. In Tolk we have union types — a more powerful solution)

struct Gradient {
    from: Color
    to: Color? = null
}

var g: Gradient = { from: Color.Blue };
g.from == Color.Red;    // false

Compatible with all language features: auto-serialization, exhaustive pattern matching, generics, etc.

✔ Private and readonly fields

Fields can now have modifiers:
* private — accessible only within methods
* readonly — immutable after object creation

struct PosInTuple {
    private readonly t: tuple
    curIndex: int
}

fun PosInTuple.last(mutate self) {
    // `t` is visible only in methods
    // and cannot be modified
    self.curIndex = self.t.size() - 1;
}

✔ Partial specialization

Now it's possible to overload methods for "more specific" implementations:

// general implementation
fun Iterator<T>.next(self) { ... }

// a more specific one
fun Iterator<Cell<T>>.next(self) { ... }

In complex scenarios, this feature lets you adjust the behavior of specific types while keeping a common interface. It "just works", but internally the compiler was enhanced with shape of types, structural depth, type dominators, and several heuristics.

🌳 After Tolk v1.0 release, many people and companies started migrating from FunC to Tolk. I have received a lot of feedback and requests (and almost zero bug reports, huh). Meanwhile, a bigger roadmap is already in motion. In the near future I'll also try to close long-standing questions around TypeScript wrappers, and deliver proper from-scratch documentation.