Skip to main content

​
v1.2

  1. Breaking change: address is now “internal only” (details and migration)
  2. Rich bounces: not 256 bits, but the full body on bounce
  3. Cheap builder-to-slice, StateInit, and address composition
  4. Compilation errors significantly improved
  5. Anonymous functions supported
  6. Borrow checker and other stuff related to undefined behavior

​
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. Enhanced overload resolution and partial specialization

​
v1.0

  1. The magic lazy keyword — lazy loading, partial loading, partial updating
  2. Auto-detect and inline functions at the compiler level
  3. Various peephole optimizations for gas efficiency
  4. onInternalMessage and onBouncedMessage, TVM 11 support
  5. Custom pack/unpack serializers for custom types

​
v0.99

  1. Universal createMessage
  2. Universal createExternalLogMessage
  3. Sharding — calculate addresses “close to another contract”

​
v0.13

  1. Auto-packing to/from cells/builders/slices
  2. Type address
  3. Lateinit variables
  4. Defaults for parameters

​
v0.12

  1. Structures struct A { ... }
  2. Generics struct<T> and type<T>
  3. Methods fun Point.getX(self)
  4. Rename stdlib functions to short methods

​
v0.11

  1. Type aliases type NewName = <existing type>
  2. Union types T1 | T2 | ...
  3. Pattern matching for types
  4. Operators is and !is
  5. Pattern matching for expressions
  6. Semicolon for the last statement in a block can be omitted

​
v0.10

  1. Fixed-width integers: int32, uint64, etc. Details
  2. Type coins and function ton("0.05")
  3. bytesN and bitsN types (backed by slices at TVM level)
  4. Replace "..."c postfixes with stringCrc32("...") functions
  5. Support 0b... number literals along with 0x...
  6. Trailing comma support

​
v0.9

  1. Nullable types int?, cell?, etc.; null safety
  2. Standard library (asm definitions) updated to reflect nullability
  3. Smart casts, like in TypeScript in Kotlin
  4. Operator ! (non-null assertion)
  5. Code after throw is treated as unreachable
  6. The never type

​
v0.8

  1. Syntax tensorVar.0 and tupleVar.0 (both for reading and writing)
  2. Allow cell, slice, etc. to be valid identifiers (not keywords)

​
v0.7

  1. Under the hood: refactor compiler internals; AST-level semantic analysis kernel
  2. Under the hood: rewrite the type system to static typing
  3. Clear and readable error messages on type mismatch
  4. Generic functions fun f<T>(...) and instantiations like f<int>(...)
  5. The bool type; type casting via value as T

​
v0.6

The first public release. Here are some notes about its origin:

​
Tolk is a fork of FunC, iteratively improved

For years, FunC was the primary language for TON. It gave complete control over the TVM — and if you mastered it, it gave you power. But its Lisp-like syntax and functional style made onboarding difficult for many. Initially, the plan was to improve FunC itself. The goal was simple: to make it more familiar to developers coming from TypeScript, Rust, or Go — without losing any efficiency. In 2024, a pull request FunC v0.5.0 was submitted — along with a roadmap for further improvements. But instead of merging it, the decision was made: to fork. To leave FunC untouched. As it is. As it always was. And to create a new language under a completely new name. At the TON Gateway in November 2024, Tolk was first announced to the public. The video is available on YouTube. The first released version of Tolk was v0.6 — a metaphor for the FunC v0.5 that could have been but never was.
Comparison can be found here: Tolk vs FunC.