The Move Journey: Part 1

Introduction

Move goes beyond being just a smart contract language — it’s the product of years of R&D at the intersection of programming language theory, cryptography, and blockchain infrastructure. Originally built by Facebook for the now-defunct Diem (née Libra) blockchain, Move was designed with one goal: to make smart contracts safer.

At the center of this story is Sam Blackshear, the language’s creator and co-founder of Mysten Labs — and the very first engineer to join the Libra project.

Move and its surrounding ecosystem are undergoing a great expansion; while Sui currently occupies the global mindshare, more and more prominent projects are opting to join the Move revolution. This is a prime time to edify ourselves on the technology powering these emerging players.

This two-part series explores Move’s evolution: from its early days at Facebook to powering next-gen networks like Sui, Aptos, Movement, Supra, and now IOTA — and the role Mysten Labs played in shaping this journey.

Move's Origins

When Facebook started Libra, they wanted to build a blockchain-powered Global Payments Network. According to Blackshear, when he appeared on the podcast Let's Get MOVING. Sam Blackshear discloses that Move Programming Language was super ambitious and initially a top-secret project. Facebook examined the technical areas needed for the project and pulled in experts from across the company. So they tapped cryptographers, distributed systems, databases, and payments people.

As for Blackshear, Facebook's instructions were, "We want programmable money, and there's this smart contracts thing that seems important, so figure it out." It was a broad mandate. They didn't specifically say "build a language" or "use the EVM;" they basically said, "figure it out."

Blackshear began working in April 2018 and had the first Move program running that September. Back then, the code name for the language was "Tulip," which was rejected by the Diem leadership, so they went with "Move" instead. The source language came out in late 2019.

One might ask, " Why do we even need another programming language?" The Move team initially examined this question as well. Why create a new language if it is possible to use Rust, WASM, or the JVM? So, they considered extending and tweaking them. However, going in that direction didn't make sense for several reasons, as shown below.

The Challenges of Blockchain Programming

Blackshear and the team learned that choosing another programming language and tweaking it wouldn't work. In everyday programming, productivity is king, so a few bugs aren't that bad. For smart contracts, however, the code must be perfect in every way, or else hackers could abscond with potentially hundreds of millions of dollars. It's an entirely different shift to an adversarial mindset.

One property that smart contract languages need that normal programming languages don't have is determinism. It doesn't sound like a massive requirement, but many conventional languages aren't deterministic.

What is Determinism? A deterministic program always produces the same result when given the same input — no matter who runs it or when. This is crucial for blockchain nodes to stay in sync and reach consensus.

Then there's the issue of gas metering. It's uber important for smart contracts because we don't have infinite resources to consume on the blockchain. The challenge is that conventional languages don't offer gas metering. The team at Move thought about this a lot, and they have built-in gas metering in their Virtual Machine (VM).

On a more conceptual note, smart contracts are a super-specialized domain. Thus, smart contract programmers are not likely to write a compiler, a distributed system, or a web application. Smart contract code is limited to defining the assets, the rules for reading and writing them, and the rules for transferring them.

So, if the team were to start with a general-purpose language, it would be missing the necessary features.

The other option was to take an existing language and cut parts out of it, but they would end up cutting out the libraries, tooling, and things that rely on those features. They could restrict the existing language by removing features they didn't want, like non-determinism. However, then they would have to add gas metering, which would have resulted in something extra complicated, minus the advantages the language originally had.

That is why they opted out of using an existing general-purpose language. However, the team dug deep into the EVM. Blackshear explains, "When we designed Move, we looked at the EVM and other smart contract languages. The thing that makes it difficult to write safe smart contracts is how low-level the EVM is and how hard it is to have typed values that can flow across trust boundaries and dynamic dispatch and these sorts of things."

Blackshear studied programs with bugs and tried to understand where they originated and what led developers to create them. By doing so, he could redesign a language to prevent these bugs from happening or at least make them harder to write in the first place. So, Blackshear sprinkled many techniques from other programming languages into Move.

Move's Emphasis on Security

For those who believe that Web3 is the future of finance, safety and security are paramount for this to happen. UX notwithstanding, smart contract security is the greatest existential threat to broader Web 3 adoption.

Today, Web3 developers are highly qualified and understand the underlying blockchains. Furthermore, despite their security-mindedness, their efforts still result in hundreds of millions of dollars being stolen by hackers each year. But can we expect this situation to improve as the pool of developers grows?

Move is betting that future blockchain developers will be more product-focused and won't want to learn the blockchains in depth or about security. If this scenario holds up, security problems will only get worse. This likelihood will lead to a place where Web3 can't grow much because there's no sustainable or safe way to expand the developer pool.

The other option is to build underlying blockchain languages and tooling with safety in mind. That is why Move doesn't have code injection or re-entrancy, which causes security issues on other chains.

Simplifying Blockchain Development

The power of Move is that developers don't need to audit and debug their code for hours because the code does what it's supposed to do. Other blockchain programming languages can be so complex that they demand high expertise, making them inaccessible for many developers.

It's great that we're all excited about Web3, but it still has not delivered in terms of broad adoption. This is particularly true in emerging markets where developers may not have much expertise in programming languages. They may have plenty of ideas for Web3 innovations but find it impossible to bring them to life with a programming language that's too easy to break.

Next is the notion of linear types representing money or memory resources. Move has this baked in deeply so that there are abstractions for programming with money. Developers can define an object type and determine they don't want it to be copyable because that wouldn't be appropriate for money. Or they can restrict creation for another object, offering isolation from other programs.

So Move takes abstractions for programming with money and security principles and flexibly applies them. Moreover, it does not deploy a native asset; rather, Move provides building blocks to let programmers create whatever kind of native assets they want.

Move is the programming language that targets the specific demands of smart contracts. It tries to provide the right abstractions for developers to write the code they need. That's what Move is about.

Conclusion

One of the key design principles in Move is a small core language that's completely blockchain agnostic. Move doesn't have accounts or even coins. For those who only want to build another EVM-based blockchain, just know that you'll inherit the past decisions that make the blockchain harder to scale and be safe.

A simple explanation of Move is that it's just a programming language with features baked in for programming for scarcity and preventing things from being copied. However, developers can specify their account or data model, use their own transaction format, and decide what cryptography or addresses to use. Developers can also use existing libraries and verification tools like Move Prover and apply their expertise to any blockchain.

In our next article, we will examine some of the Move-based projects on Web3.

About Luganodes

Luganodes is a world-class, Swiss-operated, non-custodial blockchain infrastructure provider that has rapidly gained recognition in the industry for offering institutional-grade services. It was born out of the Lugano Plan B Program, an initiative driven by Tether and the City of Lugano. Luganodes maintains an exceptional 99.9% uptime with round-the-clock monitoring by SRE experts. With support for 45+ PoS networks, it ranks among the top validators on Polygon, Polkadot, Sui, and Tron. Luganodes prioritizes security and compliance, holding the distinction of being one of the first staking providers to adhere to all SOC 2 Type II, GDPR, and ISO 27001 standards as well as offering Chainproof insurance to institutional clients.

The information herein is for general informational purposes only and does not constitute legal, business, tax, professional, financial, or investment advice. No warranties are made regarding its accuracy, correctness, completeness, or reliability. Luganodes and its affiliates disclaim all liability for any losses or damages arising from reliance on this information. Luganodes is not obligated to update or amend any content. Use of this at your own risk. For any advice, please consult a qualified professional.