Skip to main content

Why Move?

While EVM/Solidity is the most famous smart contracts platform, it has some downsides that IOTA Move aims to address:

  • Performance, scaling, and cost: EVM builds on top of a global shared state, which is practical but doesn't scale well. This results in limitations in throughput, which is directly reflected in the fees you must pay to interact with these networks. The more congested the network, the more expensive it gets. This is worked around with additional extra execution layers (L2s on top of L1s) or rollup solutions, which also have downsides and limitations.
  • Security: As the first well-used smart contract language, Solidity did not have much to go by in terms of learnings around secure practices (there was no existing ecosystem yet), and it had to develop over the years with that legacy and backward compatibility in mind. Many of the issues from the past have been mitigated with workarounds. Still, given the nature of things, there are some limitations and annoyances we currently can't get around, like the security issues it has with both the code and infamous design patterns like the approve() method in the ERC standards.
  • Tokens: Assets like ERC20 tokens and ERC721/1155 NFTs are not part of the EVM and are purely standards for smart contracts deployed on an EVM chain interpreted as tokens by clients. While this works and allows much flexibility, it also has its downsides. Due to the nature of tokens being contracts and the state of your balance being stored with those contracts, it's not trivial to find all tokens in your account without knowing all token contract addresses and manually adding them, unlike the Ethereum balance itself, which is a different kind of token which can be found directly but works differently over an ERC20 token. This makes discovering your assets difficult and adds additional complexity to applications to close the gap between the native asset (ETH) and ERC20 tokens with workarounds like wrapped tokens, which is not ideal.
  • Developer experience: Solidity offers a wealth of developer tools and resources, including various libraries and frameworks to choose from, as well as extensive documentation and tutorials. The language, influenced by popular languages like C++ and JavaScript, is easy to learn and get started with. However, Solidity's lack of strictness allows for mistakes that the compiler may not catch, leading to bugs and security issues that are difficult to identify and resolve. Consequently, the developer experience suffers, and the language itself is not as safe to work with as it could be.

IOTA Move is here to learn from these downsides and come up with a better alternative addressing these issues:

  • Performance, scaling, and cost: Given that IOTA Move is based on the object model (similar to UTXO's) and not a globally shared state, transactions can be executed in parallel, resulting in a much higher (potential) throughput over a traditional blockchain with shared state. This results in a lot less congestion and, thus, lower fees on an actively used network.
  • Security: Move was designed with security in mind. The language itself is based on Rust and is very strict regarding its typing system. You really have to try to make a mistake that the compiler won't catch before deploying. There's no such thing as re-entry, and given the object-based approach of Move, Assets residing in your account can't be touched at all by the smart contract itself without access to your account keys.
  • Tokens: In IOTA Move, there is no difference between the IOTA token (Coin<IOTA>) and a custom token (Coin<YOUR_NAME_HERE>), not in terms of use or implementation. These objects reside in your own account and can thus easily be found without needing to know a Smart Contract address (this goes for any other type of owned object as well). There's no strange approve() functionality, and you keep control over your own owned assets.
  • Developer Experience: While Move is more challenging to get started with compared to Solidity due to its novelty and less mature developer tooling, the safety of the language and the ease of finding and resolving issues in your code make up for that. With Move, it's not so scary anymore to write complex logic from scratch, given most mistakes (apart from obvious implementation logic, doing things 'as intended') are caught directly by the compiler. This allows for more innovation, fewer value-destroying bugs, and a more excellent developer experience, fueling the next generation of smart contracts.

To sum this up: IOTA offers both EVM and Move, so you can choose the best tool for the job. If you want to build something that needs to be secure, scalable, and cost-effective, IOTA Move is definitely the way to go. However, if you want a fast shortcut to get started with IOTA smart contracts, or you want to migrate an existing EVM project to IOTA, EVM/Solidity is a good choice.

EVM/SolidityMove
State as part of contractsState as objects
Global shared stateOwned and Shared objects
Transactions executed one by oneParallel execution
No enforced security for standardsStrict type system for standards, assurances
Easy to get started with, hard to do rightHarder to get started with, but less room for mistakes