Most times, when people start learning how to write smart contracts, the first thing they hear about is Solidity and Ethereum. That was the first thing I heard about too. It's what most tutorials focus on, and for good reason. Solidity made it possible to write programs that live on a blockchain, and Ethereum became the place where many people got started. But Solidity isn’t the only smart contract language out there. And Ethereum isn’t the only blockchain that supports decentralized applications. But Solidity isn’t the only smart contract language out there. And Ethereum isn’t the only blockchain that supports decentralized applications. There’s also TON, short for The Open Network. It was created by Telegram, but it's now a public, community-driven chain. It’s fast, lightweight, and handles things a bit differently from what you might be used to on Ethereum. That includes how smart contracts are written. When I started exploring the TON documentation, I came across four different languages for writing smart contracts: Tact, Tolk, FunC, and Fift. I won’t go deep into all four here. TON The Open Network Tact, Tolk, FunC, and Fift This guide focuses on the Tact language, and we’ll see how to use it to build a basic voting contract that lets users cast votes and check results on-chain. Why I Decided to Learn Tact First The TON ecosystem actually supports multiple languages, each serving different use cases, levels of abstraction, and developer experience. Here’s a quick overview of the of each of them: FunC is the traditional language for writing TON smart contracts. It’s low-level and gives you precise control over how your contract works under the hood. It’s powerful, but it also means you’ll need to understand how the TON Virtual Machine (TVM) works, including concepts like stack manipulation, memory layout, and deterministic execution. The syntax is somewhat similar to C, which can feel unfamiliar if you haven’t worked with that style of language before. Fift is typically used alongside FunC. It’s a stack-based language that’s mostly used for interacting with the TVM directly and used for deploying, debugging, and performing on-chain calculations. It’s not usually the language you start with for writing full smart contracts, but it’s important in the overall development workflow on TON. Tolk is a newer addition that’s still evolving. From what I’ve gathered, it aims to improve tooling and compatibility with higher-level languages. It’s promising, but not yet as widely adopted or documented. Tact is a high-level language that’s designed specifically to make TON smart contract development more accessible and developer friendly. Tact simplifies a lot of the lower-level complexity and lets you focus on writing your logic in a clean, readable way. The syntax is closer to what you’d see in TypeScript or Solidity, which makes it much easier to get started without needing to dive deep into TVM internals. FunC is the traditional language for writing TON smart contracts. It’s low-level and gives you precise control over how your contract works under the hood. It’s powerful, but it also means you’ll need to understand how the TON Virtual Machine (TVM) works, including concepts like stack manipulation, memory layout, and deterministic execution. The syntax is somewhat similar to C, which can feel unfamiliar if you haven’t worked with that style of language before. FunC Fift is typically used alongside FunC. It’s a stack-based language that’s mostly used for interacting with the TVM directly and used for deploying, debugging, and performing on-chain calculations. It’s not usually the language you start with for writing full smart contracts, but it’s important in the overall development workflow on TON. Fift Tolk is a newer addition that’s still evolving. From what I’ve gathered, it aims to improve tooling and compatibility with higher-level languages. It’s promising, but not yet as widely adopted or documented. Tolk Tact is a high-level language that’s designed specifically to make TON smart contract development more accessible and developer friendly. Tact simplifies a lot of the lower-level complexity and lets you focus on writing your logic in a clean, readable way. The syntax is closer to what you’d see in TypeScript or Solidity, which makes it much easier to get started without needing to dive deep into TVM internals. Tact Tact provides and a quicker path for building and deploying contracts on the TON blockchain. Understanding How Tact Works Before we start writing code, it’s important to understand how Tact smart contracts are structured. A typical Tact contract includes a few core components: contract block – This is where you define the name of your contract and declare any state variables. init block – It initializes your contract’s state variables and sets the contract’s starting conditions. This block runs once at the time of deployment. receive blocks – These are like event listeners. They handle incoming messages and define how your contract reacts to them. Getter functions (get fun) – These are optional read-only functions that allow users or other contracts to query the contract’s state without changing it. contract block – This is where you define the name of your contract and declare any state variables. contract block – This is where you define the name of your contract and declare any state variables. contract init block – It initializes your contract’s state variables and sets the contract’s starting conditions. This block runs once at the time of deployment. init block – It initializes your contract’s state variables and sets the contract’s starting conditions. This block runs once at the time of deployment. init receive blocks – These are like event listeners. They handle incoming messages and define how your contract reacts to them. receive blocks – These are like event listeners. They handle incoming messages and define how your contract reacts to them. receive Getter functions (get fun) – These are optional read-only functions that allow users or other contracts to query the contract’s state without changing it. Getter functions (get fun) – These are optional read-only functions that allow users or other contracts to query the contract’s state without changing it. get fun Tact uses message-based communication, which is how all interactions on TON work. Each contract receives a message and processes it in its own receive block. This message-based structure helps organize your contract logic in a modular, maintainable way. receive Let’s now apply this in a real example by building a simple voting contract. Building Your First Voting Contract with Tact (Using the TON Web IDE) In this section, we'll walk through how to implement a basic voting system using Tact. This voting contract will allows users to vote for predefined candidates and tracks the total number of votes each candidate receives. We’ll be doing everything inside the TON Web IDE, which is an in-browser tool where you can write, build, and test your contracts without installing anything locally. Step 1 – Open the TON Web IDE Go to https://ide.ton.org. Click Create a new project. In the popup: Make sure the language is on Tact. Choose Blank Contract as your template. Name your project something like VotingContract. Click + Create. Go to https://ide.ton.org. https://ide.ton.org Click Create a new project. In the popup: Make sure the language is on Tact. Choose Blank Contract as your template. Name your project something like VotingContract. Click + Create. Create a new project Make sure the language is on Tact. Choose Blank Contract as your template. Name your project something like VotingContract. Click + Create. Make sure the language is on Tact. Tact Choose Blank Contract as your template. Blank Contract Name your project something like VotingContract. VotingContract Click + Create. + Create Step 2 – Writing the Voting Contract Code After creating your project, open the main.tact file. You’ll see a boilerplate setup: main.tact // Import the Deployable trait so the contract can be deployed easily import "@stdlib/deploy"; contract BlankContract with Deployable { init() { } } // Import the Deployable trait so the contract can be deployed easily import "@stdlib/deploy"; contract BlankContract with Deployable { init() { } } import "@stdlib/deploy"; is required for deployment to work and should not be removed from the code. BlankContract is the placeholder name. The init() block runs only once when the contract is deployed and is used to initialize state variables. import "@stdlib/deploy"; is required for deployment to work and should not be removed from the code. import "@stdlib/deploy"; BlankContract is the placeholder name. BlankContract The init() block runs only once when the contract is deployed and is used to initialize state variables. init() Now, let’s map out our own code. First, we’ll define the message structure for voting: // Import the Deployable trait so the contract can be deployed easily import "@stdlib/deploy"; // Define a message structure for voting message Vote { candidate: Int as uint32; // 1 = Alice, 2 = Bob } // Import the Deployable trait so the contract can be deployed easily import "@stdlib/deploy"; // Define a message structure for voting message Vote { candidate: Int as uint32; // 1 = Alice, 2 = Bob } This is the Vote message. When someone wants to vote, they’ll send a message to the contract that includes a number: 1 for Alice 2 for Bob 1 for Alice 2 for Bob Tact uses this structure to process the incoming vote and decide which candidate gets the point. Next, we’ll set up our contract and add two state variables to keep track of each candidate’s votes: ... contract VotingContract with Deployable { // State variables to track votes votesAlice: Int as uint32; votesBob: Int as uint32; ... contract VotingContract with Deployable { // State variables to track votes votesAlice: Int as uint32; votesBob: Int as uint32; Inside the contract, we defined two variables: votesAlice: stores the number of votes Alice receives. votesBob: stores the number of votes Bob receives. votesAlice: stores the number of votes Alice receives. votesAlice votesBob: stores the number of votes Bob receives. votesBob We’ll now initialize those vote counts to zero inside the init block to set the starting state of the contract when it's first deployed. init init() { self.votesAlice = 0; self.votesBob = 0; } init() { self.votesAlice = 0; self.votesBob = 0; } The init block runs only once, right when the contract is deployed and it sets both vote counts to zero. init only once Now comes the logic. When a vote is sent, we want the contract to check who the vote is for and increase the correct vote count. // Handle vote messages receive(msg: Vote) { if (msg.candidate == 1) { self.votesAlice += 1; } else if (msg.candidate == 2) { self.votesBob += 1; } } // Handle vote messages receive(msg: Vote) { if (msg.candidate == 1) { self.votesAlice += 1; } else if (msg.candidate == 2) { self.votesBob += 1; } } So when a vote is received: If msg.candidate is 1, we add +1 to votesAlice If msg.candidate is 2, we add +1 to votesBob If msg.candidate is 1, we add +1 to votesAlice msg.candidate votesAlice If msg.candidate is 2, we add +1 to votesBob msg.candidate votesBob Finally, we’ll create getter functions to let anyone query the vote count for each candidate without changing the contract state. // Getter for Alice's votes get fun getVotesForAlice(): Int { return self.votesAlice; } // Getter for Bob's votes get fun getVotesForBob(): Int { return self.votesBob; } } // Getter for Alice's votes get fun getVotesForAlice(): Int { return self.votesAlice; } // Getter for Bob's votes get fun getVotesForBob(): Int { return self.votesBob; } } These two getter functions let us check the number of votes each candidate has received without modifying anything in the contract. It’s a read-only operation. Below is the full voting contract code: import "@stdlib/deploy"; // Define a message structure for voting message Vote { candidate: Int as uint32; // 1 = Alice, 2 = Bob } contract VotingContract with Deployable { // State variables to track votes votesAlice: Int as uint32; votesBob: Int as uint32; init() { self.votesAlice = 0; self.votesBob = 0; } // Handle vote messages receive(msg: Vote) { if (msg.candidate == 1) { self.votesAlice += 1; } else if (msg.candidate == 2) { self.votesBob += 1; } } // Getter for Alice's votes get fun getVotesForAlice(): Int { return self.votesAlice; } // Getter for Bob's votes get fun getVotesForBob(): Int { return self.votesBob; } } import "@stdlib/deploy"; // Define a message structure for voting message Vote { candidate: Int as uint32; // 1 = Alice, 2 = Bob } contract VotingContract with Deployable { // State variables to track votes votesAlice: Int as uint32; votesBob: Int as uint32; init() { self.votesAlice = 0; self.votesBob = 0; } // Handle vote messages receive(msg: Vote) { if (msg.candidate == 1) { self.votesAlice += 1; } else if (msg.candidate == 2) { self.votesBob += 1; } } // Getter for Alice's votes get fun getVotesForAlice(): Int { return self.votesAlice; } // Getter for Bob's votes get fun getVotesForBob(): Int { return self.votesBob; } } Step 4 – Build and Deploy the Contract On the left sidebar, click on Build & Deploy On the left sidebar, click on Build & Deploy Build & Deploy Under Environment, make sure Sandbox is selected. Make sure main.tact is selected and click Build. This will compile your contract and check for any syntax errors or issues in your code. Next, make sure VotingContract is selected in the dropdown as that’s your actual contract, not the default placeholder. If you don’t see it, press Ctrl + S to save your file so the IDE can detect the updated contract. Then click ReDeploy. If everything works correctly, you’ll see a confirmation message in the logs showing that your contract was successfully deployed on Sandbox. Under Environment, make sure Sandbox is selected. Environment Sandbox Make sure main.tact is selected and click Build. This will compile your contract and check for any syntax errors or issues in your code. main.tact Build Next, make sure VotingContract is selected in the dropdown as that’s your actual contract, not the default placeholder. If you don’t see it, press Ctrl + S to save your file so the IDE can detect the updated contract. VotingContract Ctrl + S Then click ReDeploy. If everything works correctly, you’ll see a confirmation message in the logs showing that your contract was successfully deployed on Sandbox. ReDeploy Step 5 – Interact With the Contract Once deployed, scroll down and you’ll see two sections: Getters: getVotesForAlice, getVotesForBob Receivers: Vote Getters: getVotesForAlice, getVotesForBob Getters: getVotesForAlice getVotesForBob Receivers: Vote Receivers: Vote To cast a vote: In the Vote section, enter 1 in the candidate input field and click Send. You’ve just voted for Alice! You can repeat this to cast more votes. To cast a vote: Vote 1 candidate Send. To check the vote count: Click Call under getVotesForAlice and check the logs panel to see the vote count To check the vote count Call getVotesForAlice logs Do the same for Bob by sending 2 in the candidate field, then check getVotesForBob Do the same for Bob by sending 2 in the candidate field, then check getVotesForBob 2 candidate getVotesForBob In my test run, I voted for Alice 9 times and Bob 6 times, and the getter functions showed exactly that. 9 times 6 times 💭 Final Thoughts: Keep Building, Keep Exploring 🙌 Congrats if you read all the way through! 🙌 Congrats if you read all the way through! Now that you’ve seen how a simple voting contract works in Tact, you’ve taken your first step into smart contract development on TON. This contract might be basic, but the structure and concepts apply to more complex logic too. If you want to keep experimenting, try extending this contract or exploring other prebuilt templates from https://tact-by-example.org/all. The TON Web IDE also makes it easy to try out different use cases and it comes with templates as well to help you build and learn faster. https://tact-by-example.org/all So go ahead, tweak, test, build something better. So go ahead, tweak, test, build something better.
