Tact Kitchen

🎉 Tact Language Server & VS Code Extension v0.8.0 are live!

Smarter code insight, TL-B support, fresh UI touches and a faster, quieter indexer — all wrapped into v0.8.0 release!

🚀 Headline features

▪️ Flexible toolchain picker – point the extension at any local Tact toolchain and switch them on the fly.
▪️ TL-B first-class citizen – syntax highlighting, completions, document symbols, go-to-references and inline highlighting inside Tact comments.
▪️ Next level navigation – search for functions by type, easily navigate with code lenses with go-to places where messages were sent and received
▪️ Fresh inspections – CanBeInline (with quickfix), DeprecatedSymbolUsage, MissedMembersInContract (with quickfix), NamingConvention, OptimalMathFunctions.

📜 And that's not all 😎, check out our changelog to find all the improvements and fixes in the new release, and also see our X/Twitter thread with the announcement.

📥 Upgrade now via VS Code marketplace or Open VSX
✨ Happy hacking!

🍲 intelli-tact, you're next
♨️ @tact_kitchen from the @ton_studio

🎉 Tact v1.6.12 is released!

This is another joint release: both v1.6.11 and v1.6.12 were published consecutively. The former focused on fixing bugs and implementing performance optimizations, while the latter introduced new quality-of-life features, such as support for toCell() and toSlice() methods on contract types, as well as improvements in trait-based inheritance attributes.

By using the v1.6.12, you get the benefits of both at once. However, before we begin unpacking both, we'd like to give a big shout-out to our new community contributors: hazyone and lordivash. Major kudos to hazyone for opening seven valuable pull requests, listening to the feedback from the Tact team and working on PRs until completion!

Now, let's get back to the release notes.

⛽️ Gas optimizations

Version 1.6.12 marks a new optimization victory of Tact over FunC. Based on the public benchmarks, Tact's _port_ of Jetton contracts consumes 2515 fewer gas units for transfer, 912 fewer for burn, and 437 fewer gas units for discovery compared to the reference FunC code.

These are our best numbers to date, but we don't intent to stop — apart from improving the compiler and the benchmarks, we also tend to our idiomatic Tact implementation of Jettons and other standard contracts.

The latest achievements of v1.6.11 and v1.6.12 were possible in part to those optimizations:

• Compiler now generates more efficient code for Slice serialization and if-throw patterns with throwIf() and throwUnless() function calls
• Deserialization of messages and optional addresses was improved
• Gas consumption of equality comparisons of optionals was reduced

🛠 Bug fixes

Most of bugs were found and squished in v1.6.11. That said, here are most notable ones from both releases:

• Now, if two require() calls generate the same error code, there is a clear and informative error message
• Self-inheritance of traits and contracts was disallowed, and the need in explicit overrides of abstract methods and constants in traits was removed
• Arguments of the == and != operators now are evaluated in the left-to-right order
• Special characters in comment receivers are now better escaped
• No-op instructions are no longer added for dump() and dumpStack() when the debug mode is off
• Map size is now correctly counted for the bounced messages, and equivalent as-annotations of map types are now accepted — for example, Int is identical to Int as int257, Int as varuint16 is identical to Int as coins, etc.
• Issues with trait return types were resolved
• The special type constructor bounced<M> is now allowed as a return type of assembly functions

For the full list, read the release notes of v1.6.11.

🧰 Standard library additions and changes

In Tact, contracts themselves can be represented as struct types by their persistent state variables. You might've seen the following pattern used to obtain the complete contract's state in a single getter:

get fun state(): ContractName {
    return self; // all the contract's variables at once
}

Now, you can also call toCell() and toSlice() methods on the contract types! If a contract doesn’t use parameters, the resulting Cell or Slice will contain a leading one bit representing the lazy initialization bit of the init() function.

🧳 Miscellaneous improvements

• The functions page in the docs got a complete overhaul. Go check it out, your time starts now.

• Described safety-related tact.config.json options on gas and security best practice pages.

• Tact language server and VSCode extensions got a lot of performance updates and feature enhancements.

📜 See the full release notes for Tact v1.6.11 and v1.6.12
📥 And upgrade Tact in your projects

You may have noticed the update of Tact's branding — it started with the renewed logo and banner of the X/Twitter account, then continued through our GitHub, Telegram chat, and documentation. How do you find it? Tell us in the comments below.

🍲 tact labubu wen
♨️ @tact_kitchen from the @ton_studio

We’ve launched the ultimate hunt for bugs and hacker mastery — the epic CTF has begun at positive.com/ctf!

On the menu: blazing challenges in EVM and TON security — plus one juicy Bug Bounty worth 100 TON!

🎉 Tact v1.6.10 is released!

Recently, TVM version 10 was rolled out in the mainnet. It introduced a number of new and interesting changes, the most notable being the addition of extra currencies and the removal of anycast addresses in favor of fixed address prefixes, which allows deploying a contract to an arbitrary shard. The Tact team has already begun work on preparing convenient ways to work with both.

However, TVM v10 also effectively removed the variable-length addresses, addr_var, which made the Tact's VarAddress struct and parseVarAddress() function obsolete. We had to adjust to those changes as soon as possible, while bringing other important fixes we've made along the way.

That road was a bit bumpy, as third-party dependencies crippled up and had to be dealt with special care. Two extra patch versions of the Tact compiler were needed along the way to ensure that the resulting version 1.6.10 was stable, well-built and battle-proven.

With that out of the way, let's see the fixes applied:

🧰 Breaking changes in the standard library

With TVM version 10 available in the mainnet, if you try to use the TVM instructions related to the now deprecated addr_var (variable-length addresses), you'll get an exit code 9. That happens because those addresses got deprecated and removed from pretty much any place where they could've been used, and the instructions that work with them did not introduce a special "deprecated" exit code and started re-using the existing one.

Thus, to prevent your new contracts from unwanted failures, the Tact compiler now reports the usage of the VarAddress struct and the parseVarAddress() function as a compilation error.

🛠 Bug fixes

Compiler:
• Now, it correctly handles optional slices, builders, and strings when generating serialization logic
• Usage of type identifiers as values in expressions were disallowed, e.g. let x = Int or let x = MyStruct are now prohibited

Formatter:
• Floating comments are now handled correctly
• Inline comments after the last declaration in the file are now handled correctly
• Floating comments after import are now handled correctly
• Finally, formatter now has a better support of comments inside chained method calls

🧳 Miscellaneous improvements

• The latest v2025.04 WASM build of FunC and Fift compilers is now used in Tact. Aside from other things, that update fixed the SDBEGINS and SDBEGINSQ instructions.
• We've did a number of documentation updates, read more here.

📥 Upgrade Tact in your projects

New specifications are brewing behind the scenes, with new tools being tested and polished enough to share a public link.

However, the link is out there, and you can trace it from the developers' most frequently opened website.

🍲 sharded jockey
♨️ @tact_kitchen from the @ton_studio

For you all, JetBrains IDEs lovers: intelli-tact plugin release 📸

🍲 got IDEA?
♨️ @tact_kitchen from the @ton_studio

🎉 Tact v1.6.7 is released!

We've been listening to your feedback and analyzing the code written throughout the Tact Smart Battle. The battle was heated, with talented developers pushing Tact to its limits and helping us uncover valuable insights to improve the language, introduce new optimizations, and squish some bugs.

❤️ Thank you for participating! The $20,000 prize pool in Toncoin has been distributed to the top 128 competitors based on the final standings. The promised Soulbound Tokens (SBTs) for participants with valid solutions will be delivered in due time, along with TON Studio interview invitations for top performers.

Now, let's explore what Tact v1.6.7 brings to the table:

🧰 Standard library additions and syntax changes

• Added the static extension function Message.opcode() — it returns the opcode of any specified message by its identifier. Note that this function works at compile-time and does not spend any gas, which makes it functionally equivalent to having a special const to store the opcode.

// Instead of this:
const SOME_OPCODE = 0xD_BA1;
message(SOME_OPCODE) TokenNumber9 {}

// You can now do this:
message(0xD_BA1) TokenNumber9 {}
fun showcase() {
    TokenNumber9.opcode(); // 0xD_BA1
}

• Introduced the built-in inMsg() function as an optimized version of Message.toSlice(), which returns the original, raw body of the received message. Using inMsg() saves a lot of gas — try it out in your projects!

• Added support for map literals — expressions that provide a concise and gas-effective way to create maps with multiple entries at compile-time. If you know the key-value pairs in advance, map literals provide a significant gas usage drop compared to the series of .set() assignments.

// Declaring a map as a local variable via a map literal expression
let myMap: map<Int, Int as uint16> = map<Int, Int as uint16> {
    // Key: Value
    1: 100, // key 1, value 100
    2: 200, // key 2, value 200
};

• Finally, init() function now can have parameters with as serialization annotations, which correspond to same annotations one can provide for contract parameters.

🛠 Bug fixes

• Error messages for bounced receivers got fixed
• Getter functions without parameters are now correctly handled
• Trailing comments after the last structure field are now correctly formatted

🧳 Miscellaneous improvements

• Formatter, tact-fmt, now supports formatting several files and directories
• Formatter now automatically applies field punning, i.e., shortens Foo { value: value } to just Foo { value }
• Reduced gas consumption of the following functions: cashback(), self.reply(), self.notify(), self.forward()
• Optimized (de)serialization code of various field types
• Optimized code generation for if...else statements

📜 See the full release notes for Tact v1.6.7
📥 And upgrade Tact in your projects

Good news, everyone! The new official Tact plugin for IntelliJ IDEA and related IDEs will have a proper public release quite soon.

Granted, it is in its very early and very alpha days. But if you're feeling adventurous, you can try installing its initial development version from this GitHub release.

🍲 another ONE bites the LAST
♨️ @tact_kitchen from the @ton_studio

🏆 The Tact Smart Battle is going strong — here are some preliminary standings.

You can still enter the competition and show off your best gas optimizations — the deadline is April 28th, at 12:00 UTC+3.

👉 Hop in: http://codeforces.com/contests/2105

🍲 message sending cell smashing fist
♨️ @tact_kitchen from the @ton_studio

🎉 Tact v1.6.6 is released!

The final patch release of this v1.6 series is upon us, and it brings a significant tooling improvement, amongst other things. Meet the official Tact formatter — a new tool that ensures consistent code style across your Tact projects. It ships with Tact v1.6.6, and you can run it in your projects via npx tact-fmt or by invoking a format command in your editor. You'd need to install the Tact's language server or the VSCode extension for that — see the tact-language-server repo for details.

The v1.6.* series of patches has been a journey of refinement and polish, setting the stage for what's coming next. As we close this chapter, we're already working hard on exciting new features for the future.

For now, let's explore the Tact v1.6.6 release:

🧰 Standard library additions and changes

• Added compute phase exit code constants reserved by the Tact compiler, such as TactExitCodeNullReferenceException (128) and many others.

• Added the SignedBundle struct and the corresponding verifySignature method.

• Added sendRawMessage and sendRawMessageReturnForwardFee functions as replacements for their deprecated counterparts.

• Optimized the sha256() function to about ~270 less gas used per call and added the keccak256() function that works with arbitrarily long slices.

🛠 Bug fixes

There were a lot of those. Remember that last time we started fuzzing the compiler with LLMs to root out bugs? Well, we found many bugs that way and fixed even more — many error messages got way more informative and useful. Some bug fixes allowed for seemingly unrelated UX improvements too.

One nice example of a second-order fix would be that the require() function now supports constants as its second parameter. You no longer need to provide identical string literals everywhere — define a string constant somewhere and reuse it!

See the full release notes for a long list of bugs squished and error messages improved.

✍️ Documentation updates

• Added a "Learn Tact in Y minutes" page, which gives a whirlwind code-first tour of the Tact language.

• Any AI vibe coders out there? The docs now generate llms.txt, llms-full.txt and llms-small.txt files for you to use with your AIs. The small version is particularly interesting as it fits in the 200k context.

• The "gas best practices" page got updated with new recommendations, such as specialized math functions or the BasechainAddress struct and related functions.

• Lots of examples fixed, with more fixes to arrive as we speak.

🧳 Formatter!

You can run it via npx tact-fmt in your projects — it supports checking the formatting via the --check flag, applying fixes via the --write flag, and can check both individual files and directories of files.

Furthermore, it also ships with our official language server and VSCode extensions. See the tact-language-server's README.md for installation details.

📜 See the full release notes for Tact v1.6.6
📥 And upgrade Tact in your projects

In about 4 days from now, on April 21 at 12:00 (UTC+3), the Tact Smart Battle will begin! It is the ultimate smart contract challenge powered by Tact and organized by TON Studio & Codeforces. The prize pool is $20,000 in Toncoin, and the top 128 participants will receive exclusive Soulbound Tokens (SBTs). Moreover, the best battlers will be invited for job interviews at TON Studio.

And all participants with valid solutions would also receive a Participant SBT.

👉 Register, if not already: Codeforces
• Here's the registration guide, just in case: Notion
• Hop in the community chat to ask questions, receive support and have fun learning and using Tact: @tact_smart_battle

🍲 flint and tact
♨️ @tact_kitchen from the @ton_studio

🧠 Tact Smart Battle 🤜

Join the ultimate smart contract challenge powered by Tact, organized by TON Studio & Codeforces

🏅 Prize Pool — $20,000 in Toncoin!

🎯 Challenge Tasks:
1. Simple Voting — basic voting system.
2. Serial Voting — multiple proposals via a master contract.
3. Scalable Voting — support up to 4 billion voters.
4. Voting with Refunds — refunds to voters.
5. Gas-Managed Voting — fully optimized contracts.

🏆 Rewards:
- Top 128 participants share the prize pool and receive exclusive Soulbound Tokens (SBTs).
- All participants with valid solutions also receive a Participant SBT.
- SBTs include embedded on-chain developer reputation.

⭐️ Additional Perks:
- Top participants will be invited for job interviews at TON Studio.

⏰ Duration: 7 days

🗓️ Start Date: April 21, 12:00 (UTC+3)
🛑 Deadline: April 28, 12:00 (UTC+3)

Registration:
👉 Challenge Link (Codeforces)

Registration guide:
👉 Notion link

Community & Support:
👉 Telegram Challenge Chat

Good luck and may your contracts be efficient and bug-free! 🚀🔥

📣 DivaTech is organizing a Tact competition tomorrow: https://t.me/tactlang/59471

🎉 Misti 0.8 has just landed on NPM!

⚡️ More Detectors: New detectors to find possible optimizations introduced in Tact 1.6: SuboptimalSend, PreferBinaryReceiver, PreferSenderFunction, ImplicitOpcode and SuboptimalCellOperation.

⚙️ Improved Integrability: Standartized JSON output for smoother integration.

👩‍💻 LSP Actions Support: Misti now provides API for LSP code actions, introducing quickfix suggestions for some detectors.

🔧 Fixes & Enhancements: Check out the full changelog.

🎉 Tact v1.6.5 is released!

Back with another round of refinements! While we're working on many exciting things in the background, we're committed to fixing every bug that the community might discover so that Tact can provide a flawless developer experience.

Furthermore, we now actively employ AI and large language model (LLM) fuzzing techniques, such as documentation-driven approaches where LLMs are given only the Tact language documentation and access to the compiler. Then, LLM agents generate potentially problematic code snippets, compile them, and analyze results. They further iterate and provide new, interesting bug reports — resolving those makes both Tact compiler and Tact documentation better at the same time!

Check out this awesome article from one of the team members to learn more: Documentation-Driven Compiler Fuzzing with Large Language Models.

And now, let's see what's new in Tact v1.6.5, starting with the most prominent part of this patch release:

🛠 Bug fixes

• Ternary operator ?: now correctly works with structs and null values
• New parser now properly handles the code that wasn't completed at the end of the file
• The error for assembly functions and the get attribute is now correctly shown
• Now, when you call the dump() function with an argument of the unsupported StringBuilder type, the error will always be shown even if the debug mode is disabled
• Improper whitespace between the operator and the equals sign is no longer allowed
• The &&= and ||= augmented assignment operators are now properly short-circuited
• Get methods now can return an optional contract state
• The Struct.fromSlice(), Message.fromSlice(), and similar functions now work properly if the slice has been parsed entirely and the last field of the struct had the serialization annotation as remaining
• The wildcard symbol _ is prohibited for struct and message struct fields, function names, contract, and trait names
• The contract's state is now properly saved on early return statements in the receiver functions

🧳 Miscellaneous improvements

• Whenever you access context().sender, it now calls the sender() function instead to optimize the gas usage
• The internalExternalReceiversOutsideMethodsMap option and its respective receiver order optimization were reworked to ensure compatibility with explorers and user wallets
• The SendPayGasSeparately constant was deprecated in favor of SendPayFwdFeesSeparately — they're functionally identical, but the latter better expresses the intent and action that this optional flag makes when sending messages
• The Stoppable trait now throws the exit code 133 instead of the exit code generated by the require() function from the "Contract stopped" message

📜 See the full release notes for Tact v1.6.5
📥 And upgrade Tact in your projects

LLMs are great, but we value our community no less. It's great being around a bunch of talented, passionate, and bright engineers who make a future of safe and scalable ⚡️ Tact smart contracts on TON possible for everyone. Thank you for everything you do and for the feedback you give!

A special shoutout goes to the RSquad team @rsquadlife for their early adoption of Tact features, thoughtful suggestions, and bug reports. If punk were code, they'd be its maintainers 🤘

🍲 ghibli deez bugs
♨️ @tact_kitchen from the @ton_studio

🤫 Psst, there's one more thing. Rumor has it that Tact v1.6 allowed PixelSwap to reduce transaction fees by a factor of three.

It’s a nice one, PixelSwap, let’s BUIDL more stuff 🫡

https://t.me/PixelSwap_io/119

🍲 where would you spend the saved gas?
♨️ @tact_kitchen by the @ton_studio

🎉 Tact v1.6.3 and v1.6.4 are released!

We're back with some quality-of-life improvements! I cannot promise there won't be another patch release before the next big one — that's because we're working on something really enticing in the background and would like you to continue receiving updates in the meantime.

Now, this isn't a dual release per se. It's just that the post for v1.6.3 got lost in the river of time... Kidding! The two patches are simply very connected since we wanted to ensure that v1.6.4 acknowledges the possible gaps in v1.6.3.

Let's unfold the v1.6.3 and v1.6.4 at once:

🛠 Bug fixes

• In the compilation report, TL-B for Address? is not Maybe Address, but plain Address. This is a temporary measure until the Address type is reworked to allow not just the addr_std scheme, but also the addr_none, addr_var and addr_extern.

• Parameter reordering optimization is now only applied to single-parameter asm extension functions, to avoid confusion when performing multiple mutation operations on arguments.

• The postinstall script has been removed from Tact's package.json so that Node.js package managers won't unexpectedly trip on it when you try to upgrade or reinstall the compiler in your projects.

✍️ Documentation updates

• Deprecated Deployable and FactoryDeployable traits in favor of null message body receive(), with or without a call to the new cashback() function at your discretion.

• ⛽️ Added gas best practices page, go check it out to reduce gas usage of your contracts: Gas best practices.

• 🎁 Enhanced the TypeScript wrappers produced by Tact compiler, and documented how to use the new exit code and opcode records: Interacting with TypeScript wrappers.

• Added missing reference docs and fixed many descriptions and links throughout the standard library.

• Made a significant change to the Reference section: removed the core-common and core-advanced pages, and distributed their contents across other libraries, such as: core-crypto, core-contextstate, core-send, core-gas, and core-addresses.

🧳 Miscellaneous improvements

• Added forceBasechain() and forceWorkchain() functions.

• Added the internalExternalReceiversOutsideMethodsMap config option as part of optimization options to prevent the contracts from being incorrectly recognized by some explorers and user wallets.

• Further decreased gas usage of contracts with some special cases of binary and fallback Slice receivers. This is relevant mainly for Jettons, but other contracts could benefit from this, too.

• The old parser is finally removed. As a user of the compiler, you shouldn't notice a thing, but if something misparses or behaves weirdly in terms of syntax — please notify us in the chat or by opening an issue and providing a minimal reproducible example.

📜 See the full release notes for Tact v1.6.3 and Tact v1.6.4
📥 And upgrade Tact in your projects

🍲 spinning cat be like: u-ii-tact-i, ou-iii-tact-i
♨️ @tact_kitchen from the @ton_studio

🎉 Tact v1.6.2 is released!

Release a day keeps the sanitarians away.

Seriously though, before we commit to the next big release, refining rough edges and adding useful things to the standard library is always nice without making you wait for them for long. To discover such points of improvement, we actively collect feedback that we see in Tact chats and that we receive from the teams that actively use Tact in production.

We're not yet done with all the suggestions, so apart from this release, there are plans to make at least one more patch release with possible bug fixes and additions to the standard library.

❤️ All constructive feedback is welcome — let's enjoy writing ⚡️ Tact together!

On that note, let's quickly unpack the v1.6.2:

🛠 Bug fixes

• An empty init() function is no longer implicitly added when empty contract parameters are declared. This is done to save gas and storage, and it is backward compatible with the lazy initialization that Tact offered as the sole data initialization mechanism before v1.6.0.

• Compiler no longer screams at you if the message struct becomes small enough to fit into the 224 bits and does not require an explicit bounced<M> constructor. That was a noisy warning, and it's much better without it.

• Contract constructors are now public in TypeScript wrappers.

• Now, if getters do not have explicit method ID overrides in Tact code, they are called by their name and not their numeric IDs in the generated TypeScript wrappers. This change restores the pre-1.6.0 behavior that was important for compatibility with some third-party tools that do not support calling getters by their method IDs.

• Compiler upgrades via npm i now work as they should. Note that upgrades through the npm update --save command continue working, too.

🧰 Standard library additions and changes

• Doc comments, doc comments everywhere! They're especially fun to use with the language server, see more info on that below.

• Added Slice.skipRef, Slice.skipMaybeRef, Slice.skipBool, Slice.skipCoins, Slice.skipVarUint16, Slice.skipVarInt16, Slice.skipVarUint32, Slice.skipVarInt32, Slice.skipAddress functions.

📜 See the full release notes for Tact v1.6.2
📥 And upgrade Tact in your projects

The alpha testing for the new TON Studio's official Tact language server continues. Have you tried it? It also has a neat VSCode extension and an extension for VSCode-based editors!

Here's a quick rundown of their features:
• Semantic syntax highlighting
• Code completion with auto import, postfix completion, snippets, and import completion
• Go to definition, implementation, type definition
• Find all references, workspace symbol search, symbol renaming
• Types and documentation on hover
• Inlay hints for types, parameter names, and more
• On-the-fly inspections with quick fixes
• Signature help inside calls, and actions for initOf and struct initialization
• Lenses with implementation/reference counts
• Gas estimates for assembly functions
• Commands for building and testing projects based on Blueprint and tact-template
• Integration with Tact compiler and Misti static analyzer

Sounds exciting? Install it and tell us what needs improvement — the language server is quite new, but it matures very fast!

🍲 please try to enjoy each release equally
♨️ @tact_kitchen from the @ton_studio

🎉 Misti 0.7 has just landed on NPM!

🔍 More Tact Detectors: StateMutationInGetter, UnprotectedCall and SuspiciousLoop.

⚡ Tact 1.6.1 support: Including new language syntax and features.

⚙️ Improved Tools: Added more Callgraph functionality to enhance contracts audits.

🔧 Fixes & Enhancements: Check out the full changelog.

🎉 Tact v1.6.1 is released!

👀 "Long" time no see — many tools have been updated to support the latest Tact versions, and we've prepared some quality-of-life additions and minor fixes.

A big release cannot exist without a follow-up patch. This patch is mainly focused on polishing things in the internal infrastructure, standard library, and public APIs.

🛠 Bug fixes

▪️ The multiple wildcard function parameters are now supported.

That is, the following works in v1.6.1:

trait WildThing {
    // Using wildcards for parameter names
    virtual fun assure(_: Int, _: Int): Bool {
        return true;
    }
}

contract YouMakeMyHeartSing with WildThing {
    // And then overriding them with concrete names
    override fun assure(a: Int, b: Int): Bool {
        return a + b == b + a;
    }
}

▪️ Made calls to the .toCell() function on struct as a contract field handled correctly.

struct MyStruct { x: Int; y: Int; z: Int }

contract MyContract(myField: MyStruct) {
    receive() {
        // This works fine now:
        self.reply(self.myField.toCell());
    }
}

🧰 Standard library additions and changes

• Added the StateInit.hasSameBasechainAddress() function, which is a gas-efficient way to check whether the given initial state corresponds to a specified address.

• Added the cashback() function to efficiently forward excess funds from an incoming message to the target address.

• All entities in Core libraries received documentation comments. Next time, we'll add missing doc comments for the standard libraries, i.e., everything imported using the import "@stdlib/..." syntax.

🧳 Some other changes:

• We've inlined the contract load functions, so the gas consumption of the benchmarked Jetton implementation in Tact is even smaller than that of its reference implementation in FunC.

• The TypeScript wrappers now produce bi-directional mappings of exit codes from their numbers to string descriptions and vice versa. Plus, the message opcodes are exported too.

• The .code infix is no longer added to the file names of the generated FunC, Fift, and disassembled Fift outputs. It was annoying to see it everywhere, so now it's only present on the compiled .boc files.

📜 See the full release notes for Tact v1.6.1
📥 And upgrade Tact in your projects

Besides, the tact.vim plugin for Vim 8+ and tact-sublime package for Sublime Text 3+ have been updated to support Tact v1.6.0 (and v1.6.1 too).

The Misti static analyzer has been updated to v0.7.0 and now supports Tact v1.6.0 and v1.6.1. See its full release notes.

Speaking of plugins and tools, we have another announcement to make — we're starting an alpha test of the tact-language-server: an official language server for Tact that can be used standalone or within a dedicated extension for VSCode and VSCode-based editors, such as VSCodium, Cursor, Windsurf, and others.

Join the alpha squad and gain early access to great tooling: tact-language-server. If things are good, please give it a star and write a positive review. If they're not — open an issue, and we'll take a look!

🍲 cue the Tact type beat (sped up)
♨️ @tact_kitchen from the @ton_studio

🎉 Tact v1.6.0 is released!

🏆 This is the biggest update of Tact since its creation, bigger than all previous milestones combined. There were so many improvements that we've even won over FunC in terms of gas usage on many standard contracts, such as Jettons.
🤔 Don't believe me?
🥳 Let's unpack Tact v1.6.0 together and see these improvements for ourselves!

We'll start with the number one achievement of this release:

⛽️ Gas optimization victory over FunC

Gas has long been a major pain point for Tact. Prior to v1.6.0, Tact's gas usage on many common contracts, such as Jettons, was far from ideal, requiring about 2.5 times gas of the FunC reference implementation.

But with Tact 1.6.0, those old gas-expensive days are long gone.

🤯 For example, a Tact rewrite of the reference FunC Jetton code consumes less gas for transfer, burn and discovery messages!
😎 So, expect to receive easy-to-use idiomatic Tact implementations of common contracts in the near future

Some of the things we did to achieve this:
▪️ Removed "system" cell — for most cases, parent contract code is no longer stored in the system cell with all the child contract codes
▪️ Removed redundant address checks
▪️ Deprecated Deployable trait in favor of receive(){}
▪️ Introduced contract parameters as an alternative to init() function

And optimized compiler internals, many old and new functions in the stdlib:

🧰 Some of the standard library additions and changes

• Added specialized deploy and message functions for efficient on-chain deployments and non-deployment messages respectively
• Many math functions, such as divc, mulShiftRightCeil, and others
• More advanced functions, such as setGasLimit, setSeed, myCode, and others
• Handy throwIf and throwUnless functions, which deprecated their "native" prefixed counterparts
• Optimized emptyCell and emptySlice functions
• Int.toString function now consumes up to 64% less gas
• Int.toFloatString function now consumes up to 62% less gas

Added many functions for Cell, Slice and Builder types:
• Variable integer serialization types and the corresponding .load and .store functions of Slice and Builder types
• Functions Slice.hashData and String.hashData for efficient hashes of data only
• Functions for working with addresses: Slice.asAddress, Slice.asAddressUnsafe, contractHash, and a new BasechainAddress type with its helper functions
• ...and more!

🧳 More auxiliary things

• Basic let-destructuring of structs and Messages
• Compile-time method ID expressions for getters and Message opcodes
• The codeOf expression to get the code of child contracts
• More map improvements and new methods, like replace and replaceGet
• New augmented assignment operators &&=, ||=, >>= and <<=
• Better error reporting for many cases
• Generation of constants in TypeScript wrappers
• The -w, --watch CLI flags for watching for changes and automatic recompilations
• CLI for the Tact's TVM disassembler — unboc
• Fixes of the compilation report
• Fixes of the compiler's third-party API
• Fixes of the internal infrastructure and code generation
• Lots of other smaller bug fixes and enhancements
• ...and documentation for all of that and beyond!

Besides, check out the updated Awesome Tact list and add your awesome projects, especially those using Tact in production!

⚠️ Breaking changes

There are only two, and they're both pretty minor:

• Tact 1.6.0 replaces Context.bounced field with Context.bounceable — whether the received message can bounce back or not. Previously, bounced field was useless since any bounced messages would be handled in a separate bounced() receiver.

• The enabledMasterchain option was removed from tact.config.json. Going forward, support of masterchain addresses is always enabled in Tact contracts.

♥️ Special thanks goes to all the contributors and community members — without you there would be nothing. Let's keep building the future of smart contracts with ⚡️ Tact!
📜 See full release notes for Tact v1.6.0
📥 And upgrade Tact in your projects

🍲 we're beating the gas allegations with this one 🗣🗣🗣
♨️ @tact_kitchen

🚀 Tact v1.5 Audited by Trail of Bits

The security audit for Tact v1.5 has been completed by Trail of Bits, a leading Web3 security firm.

✅ No high-severity vulnerabilities were found.

🔧 Some bugs and points of improvement were discovered and addressed in a new Tact v1.5.4 bugfix release.

Thanks to Trail of Bits for their thorough review!

The report can be accessed at the Trail of Bits GitHub repo: https://github.com/trailofbits/publications/blob/master/reviews/2025-01-ton-studio-tact-compiler-securityreview.pdf

⚡️ In the meantime we continue to improve Tact with new language features, gas optimizations (a lot of those lately!), and enhancements to the compiler’s reliability. This ensures a secure and efficient development experience on TON Blockchain.

👉 Upgrade to Tact 1.5.4, if not already: https://docs.tact-lang.org/book/compile/#upgrades

🍲 cooking with great care for performance and users
♨️ @tact_kitchen

⚡️ Added a Compilation page to the docs

❓ Did you know how to use Tact compiler on the CLI and its configuration settings?
❓ Have you ever wanted to easily upgrade the compiler or pin a specific version?
❓ Or have you ever wondered about the build/ or output/ folders and build artifacts produced within them?
✅ Well, look no further — the Compilation page describes it all and more!

See what's in store:
▪️ Compiler upgrades
▪️ Compilation report
▪️ BoC-encoded contracts code
▪️ Contract's package .pkg and ABI .abi
▪️ Bindings and wrappers for simpler deployments, debugging and interactions with deployed contracts

The wrappers are currently only generated for TypeScript, but this may change in the future — stay tuned 😉

🧑‍🍳 Contributor: Novus Nota
🐙 Implementation: #1309 and #1676
✈️ Delivered: docs.tact-lang.org/book/compile

The image for this post is taken from:
https://xkcd.com/1755/

🍲 don't console my bugs
♨️ @tact_kitchen