Solidity Language Tutorial: A Complete Beginner’s Guide 2025

The solidity language tutorial is where beginners step into the real world of blockchain coding. It’s the foundation behind smart contracts, decentralized apps, and the entire Web3 movement. In this guide, MOR Software will walk you through the best Solidity tutorial​, from your first contract to data structures and inheritance, to help you start building confidently in 2025.

What Is Solidity?

The Solidity language tutorial begins with understanding what Solidity actually is. Solidity is one of high-level fastest programming languages designed specifically for writing smart contract solidity code on the Ethereum blockchain. It is contract-oriented, meaning everything revolves around defining contracts that store logic and data. The language is statically typed, which means every variable type is declared explicitly, helping developers catch errors early and create reliable programs. Solidity source code is compiled into bytecode that runs on the Ethereum Virtual Machine (EVM), ensuring full compatibility across the blockchain network.

That portability is important because Ethereum continues to dominate global blockchain development, attracting the largest community of active developers across regions according to 2024 data.

Anyone with experience in object-oriented programming languages like C, C++, or Java will find Solidity easy to pick up. The syntax feels familiar, using functions, classes, and inheritance in similar ways. It also supports advanced concepts like libraries, modifiers, and user-defined data types, which allow for clean, modular, and reusable code. This makes Solidity a natural choice for blockchain developers who want to write secure, efficient, and maintainable smart contracts.

As the developer landscape expands, roughly one in three blockchain developers now works across multiple networks, most of which align with Ethereum’s standards. This makes Solidity a practical and transferable skill across ecosystems.

Although still relatively young, Solidity has become one of the most in-demand skills in blockchain learning. Its popularity continues to rise as industries explore decentralized technologies and tokenized systems. In 2024, more than 39,000 new developers joined the crypto space, and open-source contributors reached record levels, showing how quickly the EVM ecosystem is expanding.

Whether your goal is to build decentralized applications (DApps), understand crypto coding fundamentals, or work in Web3 development, mastering Solidity gives you a strong foundation in the future of blockchain programming.

Why Learn Solidity For Web3 Development?

The Web3 world is reshaping how the internet works, shifting control from centralized platforms to the users themselves. It’s built on smart contract blockchain technologies that create transparent, secure, and decentralized systems without relying on intermediaries.

 At the core of this ecosystem stands Ethereum, one of the most influential platforms driving the next generation of digital innovation. Solidity acts as the engine behind Ethereum’s smart contract, powering the agreements and logic that make decentralized applications run automatically. These smart contract Solidity codes bring trust and transparency to everything from financial exchanges to gaming ecosystems.

And the backdrop is getting bigger. In July 2025 the entire crypto market briefly topped $4 trillion in value, showing mainstream momentum behind Web3 infrastructure.

• Power Behind Smart Contracts: With Solidity, developers can create self-executing code that powers a wide range of decentralized applications. From blockchain marketplaces to transparent voting systems and even custom digital currencies, the possibilities are vast. In Q2 2025, DappRadar reported that around 24 million unique wallets interacted with decentralized apps each day, showing how consistent and widespread smart contract usage has become. Solidity opens the door to innovation within every sector that values transparency and automation.
• A Career in Web3: The demand for Solidity developers continues to grow rapidly across the world. According to recent data, many professionals in this field earn between $50,000 and $200,000 annually, depending on region and experience. Those who master Solidity today are positioning themselves at the forefront of a booming Web3 job market.
• Ethereum’s Central Role: As Ethereum continues to lead Web3 growth through DeFi, NFTs, and tokenized assets, learning Solidity helps you participate in building real-world blockchain solutions. You’ll not only understand how decentralized systems work but also gain the skills to contribute to major protocols and networks that define the future of blockchain.

In short, mastering this Solidity language tutorial gives you direct access to the most active space in modern crypto coding. It’s the bridge between programming and blockchain security innovation, preparing you to build, create, and grow within the decentralized internet.

Solidity Language Tutorial for Beginners

Now that you understand what Solidity is and why it is important in Web3, it’s time to start coding. This Solidity language tutorial for beginners will guide you step by step through real examples, helping you build your first smart contracts from scratch.

Lesson 1: Getting Started With Solidity

Welcome to the first step of your solidity language tutorial. In this lesson, we’ll introduce you to the basics of Solidity and walk through building your first smart contract using a browser-based tool called Remix. Solidity is the primary language used to write smart contract solidity code on the Ethereum blockchain. It’s contract-oriented, meaning that all logic and data are stored inside smart contracts deployed to the blockchain. The syntax feels similar to JavaScript, Python, or C++, and the code runs on the Ethereum Virtual Machine (EVM), the core execution environment maintained by Ethereum nodes. Solidity is statically typed and supports inheritance, libraries, and user-defined types, making it a reliable language for professional blockchain projects.

To start coding, we’ll use Remix, an online IDE for Solidity that lets you write, compile, and deploy contracts directly from your browser. It saves time since you don’t need to install anything locally. Just visit Remix, open the file explorer on the left, and create a new file named MyContract.sol.

At the top of the file, define the compiler version:

pragma solidity ^0.4.24;

Then, declare your first smart contract:

pragma solidity ^0.4.24;

contract MyContract {

    // ...

}

A smart contract automation is like a small API that lives on the blockchain. It’s publicly accessible, and anyone can interact with its functions. Let’s build a simple contract that can store and retrieve a value. First, add a variable called value to hold the data:

pragma solidity ^0.4.24;

contract MyContract {

    string value;

}

This value variable is called a state variable. It stores data permanently on the blockchain. Every time you update it, the new data gets recorded in blockchain storage, making it persistent and visible to anyone who interacts with the contract.

Next, create a function to read this value:

function get() public view returns (string) {

    return value;

}

This get() function is marked as public so anyone can call it, and view tells Solidity that it doesn’t modify data. Now, let’s create another function to set the value:

function set(string _value) public {

    value = _value;

}

Here, _value is a local variable that represents the new input. The underscore is simply a naming convention to distinguish it from the state variable.

We’ll also set a default value using the constructor, which runs once when the contract is deployed:

constructor() public {

    value = "myValue";

}

Now you’ve completed your first working contract! In Remix, go to the compiler tab, select version 0.4.25, and compile your code. Choose the “JavaScript VM” environment, it simulates a blockchain right inside your browser. Then, click the “Deploy” button.

Once deployed, Remix will display your contract’s functions. Try clicking get() and you’ll see "myValue", the default value you set earlier. Now test the set() function by entering a new string like "New Value". Call get() again, and you’ll see the updated text instantly.

The bottom panel in Remix shows your blockchain transaction history. Each set() call represents a transaction recorded on this simulated blockchain. Just like in real Ethereum, every action that changes data generates a transaction inside a block, and those blocks are chained together to form the ledger.

Congratulations, you’ve just completed your first hands-on exercise in this Solidity programming tutorial! You’ve written, compiled, and deployed a contract that reads and writes data on a blockchain. Up next, we’ll expand this foundation to learn about Solidity data types, structures, and how they power real-world blockchain learning projects.

Lesson 2: Data Types And Structures In Solidity

Before we move forward in this Solidity language tutorial, let’s make our smart contract compatible with a newer Solidity version. Update the first line in your file like this:

pragma solidity ^0.5.1;

This ensures that our contract follows current best practices. The new compiler version requires specifying data storage locations such as memory when dealing with strings. Update your functions accordingly:

function get() public view returns (string memory) {

    return value;

}

function set(string memory _value) public {

    value = _value;

}

Now that we’re aligned with version 0.5.1, let’s explore how Solidity programming tutorial lessons handle data types and structures. Solidity lets you declare variables using various data types like strings, booleans, and integers. For example, instead of manually writing a get() function, you can declare a variable as public:

string public value;

This automatically creates a getter function called value(), saving lines of code. You can also assign a default value:

string public value = "myValue";

To make it unchangeable, define it as a constant:

string public constant value = "myValue";

Constants cannot be modified, so you should remove any set() function that tries to update them.

Now, let’s review different data types in Solidity. Boolean variables can hold true or false values:

bool public myBool = true;

Integers can be signed or unsigned. A standard signed integer looks like this:

int public myInt = 1;

Unsigned integers (uint) cannot hold negative values and can specify bit size:

uint public myUint = 1;

uint256 public myUint256 = 9999;

uint8 public myUint8 = 8;

Enums

Solidity’s enum helps manage fixed lists of options, useful for tracking contract states. Here’s an example:

enum State { Waiting, Ready, Active }

State public state;

Set the default state in the constructor:

constructor() public {

    state = State.Waiting;

}

You can change or check the contract’s state using these functions:

function activate() public {

    state = State.Active;

}

function isActive() public view returns (bool) {

    return state == State.Active;

}

Your complete code should now look like this:

pragma solidity 0.5.1;

contract MyContract {

    enum State { Waiting, Ready, Active }

    State public state;

    constructor() public {

        state = State.Waiting;

    }

    function activate() public {

        state = State.Active;

    }

    function isActive() public view returns (bool) {

        return state == State.Active;

    }

}

Enums are handy for managing smart contract stages, like switching between “open” and “closed” in token sales.

Structs

Solidity allows creating custom data models with struct. Let’s define a Person type:

struct Person {

    string _firstName;

    string _lastName;

}

This gives us flexibility to group multiple related fields in one structure.

Arrays

Next, let’s store multiple Person structs using an array:

Person[] public people;

uint256 public peopleCount;

Now, add a function to insert new entries:

function addPerson(string memory _firstName, string memory _lastName) public {

    people.push(Person(_firstName, _lastName));

    peopleCount += 1;

}

When you call people(0), it returns the first element of the array.

Here’s the full contract for arrays:

pragma solidity 0.5.1;

contract MyContract {

    Person[] public people;

    uint256 public peopleCount;

    struct Person {

        string _firstName;

        string _lastName;

    }

    function addPerson(string memory _firstName, string memory _lastName) public {

        people.push(Person(_firstName, _lastName));

        peopleCount += 1;

    }

}

Mappings

Now, let’s improve data management with a mapping. It stores key-value pairs like a hash table:

mapping(uint => Person) public people;

Each person will have an ID. Update your struct and function like this:

struct Person {

    uint _id;

    string _firstName;

    string _lastName;

}

uint256 public peopleCount = 0;

function addPerson(string memory _firstName, string memory _lastName) public {

    peopleCount += 1;

    people[peopleCount] = Person(peopleCount, _firstName, _lastName);

}

Your final smart contract code should now look like this:

pragma solidity 0.5.1;

contract MyContract {

    uint256 public peopleCount = 0;

    mapping(uint => Person) public people;

    struct Person {

        uint _id;

        string _firstName;

        string _lastName;

    }

    function addPerson(string memory _firstName, string memory _lastName) public {

        peopleCount += 1;

        people[peopleCount] = Person(peopleCount, _firstName, _lastName);

    }

}

That wraps up our look at Solidity’s data types and data structures. From strings to mappings, each concept builds the foundation for more complex Solidity tutorials ahead. In the next part, we’ll explore function visibility, modifiers, and blockchain time to deepen your blockchain learning journey.

Lesson 3: Function Visibility, Modifiers, And Blockchain Time

In this part of the Solidity language tutorial, we’ll focus on function visibility, modifiers, and blockchain timestamps. These concepts help developers control access, enforce permissions, and handle time-dependent logic inside a smart contract Solidity project.

In previous lessons, we used the public keyword to make functions callable by anyone on the network. But what if we need a function that only runs internally? Solidity provides internal visibility for that purpose. Let’s move the logic that increases our counter into a private utility function:

function incrementCount() internal {

    peopleCount += 1;

}

This incrementCount() function can now be used only inside the contract itself, invisible to external users. We can call it directly within our addPerson() function:

function addPerson(string memory _firstName, string memory _lastName) public {

    incrementCount();

    people[peopleCount] = Person(peopleCount, _firstName, _lastName);

}

That’s how internal visibility works. Next, let’s talk about function modifiers, which allow us to add conditions or permissions to specific functions. One of the most common examples is restricting actions so that only the contract owner can execute them.

First, declare a state variable to store the owner’s address:

address owner;

Now create a modifier to verify ownership:

modifier onlyOwner() {

    require(msg.sender == owner);

    _;

}

Here’s what’s happening:

• The modifier keyword defines reusable logic that can wrap around a function.
• msg.sender holds the address of the account calling the function.
• The require() statement checks whether the caller matches the owner. If not, it stops execution and throws an error.

We’ll assign ownership to whoever deploys the contract:

constructor() public {

    owner = msg.sender;

}

Now we can attach the modifier to the addPerson() function, restricting access to the owner only:

function addPerson(

    string memory _firstName,

    string memory _lastName

) public

    onlyOwner

{

    incrementCount();

    people[peopleCount] = Person(peopleCount, _firstName, _lastName);

}

Try running this in Remix, only the deployer’s address should successfully execute the function. The complete smart contract so far looks like this:

pragma solidity 0.5.1;

contract MyContract {

    uint256 public peopleCount = 0;

    mapping(uint => Person) public people;

    address owner;

    modifier onlyOwner() {

        require(msg.sender == owner);

        _;

    }

    struct Person {

        uint _id;

        string _firstName;

        string _lastName;

    }

    constructor() public {

        owner = msg.sender;

    }

    function addPerson(

        string memory _firstName,

        string memory _lastName

    )

        public

        onlyOwner

    {

        incrementCount();

        people[peopleCount] = Person(peopleCount, _firstName, _lastName);

    }

    function incrementCount() internal {

        peopleCount += 1;

    }

}

Now, let’s explore time-based conditions in Solidity. Many blockchain applications, especially token sales, depend on specific timing. Solidity tracks time using block.timestamp, which returns the current block’s Unix time (seconds since January 1, 1970).

We’ll define a variable to record when certain actions can begin:

uint256 startTime;

Then, we’ll assign the timestamp inside the constructor:

constructor() public {

    startTime = 1544668513; // Update this to a future time

}

To control access based on time, we’ll use another modifier:

modifier onlyWhileOpen() {

    require(block.timestamp >= startTime);

    _;

}

This modifier allows execution only if the current blockchain time is greater than or equal to startTime. Now attach it to addPerson() so it can’t be called until that time has passed:

function addPerson(

    string memory _firstName,

    string memory _lastName

)

    public

    onlyWhileOpen

{

    people[peopleCount] = Person(peopleCount, _firstName, _lastName);

}

Your full contract with time-based restrictions now looks like this:

pragma solidity 0.5.1;

contract MyContract {

    uint256 public peopleCount = 0;

    mapping(uint => Person) public people;

    uint256 startTime;

    modifier onlyWhileOpen() {

        require(block.timestamp >= startTime);

        _;

    }

    struct Person {

        uint _id;

        string _firstName;

        string _lastName;

    }

    constructor() public {

        startTime = 1544668513;

    }

    function addPerson(

        string memory _firstName,

        string memory _lastName

    )

        public

        onlyWhileOpen

    {

        people[peopleCount] = Person(peopleCount, _firstName, _lastName);

    }

    function incrementCount() internal {

        peopleCount += 1;

    }

}

This example shows how time and access control enhance contract security and functionality. You now understand visibility, modifiers, and blockchain time, key parts of professional Solidity tutorials. In the next section, we’ll extend this contract to send Ether and trigger blockchain events, helping you deepen your blockchain learning with practical coding.

Lesson 4: Sending Ether And Using Events

In this part of the Solidity language tutorial, we’ll build a simple ICO-style contract that accepts Ether and tracks token balances. You’ll learn how to handle payments, define a fallback function, and use events to track blockchain activity. These features are fundamental to smart contract Solidity development for real-world use cases like crowdfunding or token sales.

Let’s start by creating a mapping to record token ownership:

mapping(address => uint256) public balances;

This mapping links each wallet address to its token balance. Now we’ll create a buyToken() function that allows users to purchase tokens by sending Ether to the contract:

function buyToken() public {

    balances[msg.sender] += 1;

}

Next, declare a wallet address that will receive the Ether whenever someone buys tokens:

address wallet;

Now let’s modify buyToken() so it accepts Ether and transfers it directly to the wallet:

function buyToken() public payable {

    balances[msg.sender] += 1;

    wallet.transfer(msg.value);

}

Here’s what’s happening:

• The keyword payable allows the function to receive Ether.
• msg.value represents the amount of Ether sent by the caller.
• The wallet.transfer() function moves that Ether to our designated wallet.

To comply with Solidity 0.5.1 syntax, mark the wallet as payable too:

address payable wallet;

We’ll now set the wallet address in the constructor when deploying the contract:

constructor(address payable _wallet) public {

    wallet = _wallet;

}

At this point, your contract should look like this:

contract MyContract {

    mapping(address => uint256) public balances;

    address payable wallet;

    constructor(address payable _wallet) public {

        wallet = _wallet;

    }

    function buyToken() public payable {

        balances[msg.sender] += 1;

        wallet.transfer(msg.value);

    }

}

Next, we’ll add a fallback function. This function automatically runs when someone sends Ether directly to the contract’s address without calling any specific function. It’s a common pattern in ICOs, where sending Ether triggers token purchases:

function() external payable {

    buyToken();

}

Now any Ether sent to the contract will automatically execute buyToken().

Working With Events

Events let smart contracts communicate with external applications by logging key blockchain activities. We can declare an event called Purchase to record token purchases:

event Purchase(

    address _buyer,

    uint256 _amount

);

Inside the buyToken() function, we’ll trigger this event whenever someone buys tokens:

function buyToken() public payable {

    balances[msg.sender] += 1;

    wallet.transfer(msg.value);

    emit Purchase(msg.sender, 1);

}

The keyword emit signals the blockchain to record the event. External tools like Web3.js can listen for this event to update interfaces or confirm transactions.

If you want to track events for specific users, Solidity allows indexed parameters to make event filters more efficient:

event Purchase(

    address indexed _buyer,

    uint256 _amount

);

Now you can query for all purchases made by a specific buyer address using Web3 or similar libraries.

Your completed contract should look like this:

pragma solidity 0.5.1;

contract MyContract {

    mapping(address => uint256) public balances;

    address payable wallet;

    event Purchase(

        address indexed _buyer,

        uint256 _amount

    );

    constructor(address payable _wallet) public {

        wallet = _wallet;

    }

    function() external payable {

        buyToken();

    }

    function buyToken() public payable {

        balances[msg.sender] += 1;

        wallet.transfer(msg.value);

        emit Purchase(msg.sender, 1);

    }

}

This contract demonstrates how Ether transfers and events work together in Solidity tutorials. Events are essential for tracking actions, verifying transactions, and syncing front-end apps with blockchain activity. You can listen for them directly after each function call or retrieve the entire log history to audit token purchases. These event-driven principles are also the foundation for Solidity fallback function tutorial topics and dApp integration workflows. In the next section, we’ll expand your knowledge by connecting multiple contracts and exploring inheritance in Solidity for advanced blockchain learning.

Lesson 5: Working With Multiple Contracts And Inheritance

This final part of our Solidity language tutorial explores how to make contracts interact with one another and how inheritance allows you to reuse and extend existing logic. You’ll learn how to call one smart contract from another, then how to create a child contract that inherits behavior from its parent.

We’ll begin by refactoring the previous code to separate token-related logic into a new contract. This will act as a simplified version of an ERC-20 token. Here’s the structure:

contract ERC20Token {

    string name;

    mapping(address => uint256) public balances;

    function mint() public {

        balances[msg.sender] += 1;

    }

}

This code moves the balances mapping, name, and mint() function into their own smart contract Solidity file. The mint() function lets users create tokens and updates their balance. Now, we’ll integrate this token contract with another one that manages Ether payments and calls mint() when users buy tokens.

First, declare a state variable in the second contract to store the token’s address:

contract MyContract {

    address public token;

    // ...

}

Next, pass the token address to the constructor so it’s available when deploying the contract:

constructor(address payable _wallet, address _token) public {

    wallet = _wallet;

    token = _token;

}

Now modify the buyToken() function to interact with the token contract:

function buyToken() public payable {

    ERC20Token _token = ERC20Token(address(token));

    _token.mint();

    wallet.transfer(msg.value);

}

When called, this function mints a token for the buyer and sends their Ether to the wallet address. But there’s an issue, msg.sender in mint() refers to MyContract, not the buyer. To fix this, we’ll use tx.origin, which points to the account that started the transaction:

function mint() public {

    balances[tx.origin] += 1;

}

Now the correct address will receive the tokens. After deploying, remember to first deploy ERC20Token, copy its address, and pass it into MyContract as a constructor argument.

Your combined contracts should now look like this:

pragma solidity 0.5.1;

contract ERC20Token {

    string name;

    mapping(address => uint256) public balances;

    function mint() public {

        balances[tx.origin] += 1;

    }

}

contract MyContract {

    address public token;

    address payable wallet;

    constructor(address payable _wallet, address _token) public {

        wallet = _wallet;

        token = _token;

    }

    function buyToken() public payable {

        ERC20Token _token = ERC20Token(address(token));

        _token.mint();

        wallet.transfer(msg.value);

    }

}

You can simplify the token call using one line:

ERC20Token(address(token)).mint();

Or define the token type directly in a state variable:

ERC20Token public token;

Then call it easily inside the function:

token.mint();

wallet.transfer(msg.value);

Inheritance In Solidity

Solidity supports inheritance, allowing contracts to extend and modify others. Let’s create a new child contract called MyToken that inherits from ERC20Token.

contract MyToken is ERC20Token {

    // custom code here

}

Now, let’s enhance the parent token to include a name and constructor:

pragma solidity 0.5.1;

contract ERC20Token {

    string public name;

    mapping(address => uint256) public balances;

    constructor(string memory _name) public {

        name = _name;

    }

    function mint() public {

        balances[tx.origin] += 1;

    }

}

Inside the child contract, we’ll add a symbol and override the constructor:

contract MyToken is ERC20Token {

    string public symbol;

    constructor(

        string memory _name,

        string memory _symbol

    )

        ERC20Token(_name)

        public

    {

        symbol = _symbol;

    }

}

We’ll also extend the token behavior to keep track of owners.

contract MyToken is ERC20Token {

    string public symbol;

    address[] public owners;

    uint256 public ownerCount;

    constructor(

        string memory _name,

        string memory _symbol

    )

        ERC20Token(_name)

        public

    {

        symbol = _symbol;

    }

    function mint() public {

        super.mint();

        ownerCount++;

        owners.push(msg.sender);

    }

}

Here’s what’s happening:

• super.mint() calls the parent’s version of the mint() function, preserving its logic.
• We extend it by adding each minter’s address to an owners array and incrementing the ownerCount.

The full contract now looks like this:

pragma solidity 0.5.1;

contract ERC20Token {

    string public name;

    mapping(address => uint256) public balances;

    constructor(string memory _name) public {

        name = _name;

    }

    function mint() public {

        balances[tx.origin] += 1;

    }

}

contract MyToken is ERC20Token {

    string public symbol;

    address[] public owners;

    uint256 public ownerCount;

    constructor(

        string memory _name,

        string memory _symbol

    )

        ERC20Token(_name)

        public

    {

        symbol = _symbol;

    }

    function mint() public {

        super.mint();

        ownerCount++;

        owners.push(msg.sender);

    }

}

That completes this section of our Solidity tutorials. You’ve now seen how contracts communicate, how inheritance allows code reuse, and how modifiers like super extend logic efficiently. This concept forms the backbone of building scalable systems in Ethereum and beyond. Keep experimenting with these patterns as you continue your blockchain learning journey.

MOR Software: Your Trusted Solidity Development Partner

At MOR Software, we help businesses and startups turn blockchain concepts into real, functional applications using Solidity and smart contract technology.

Our engineering teams have years of experience in Ethereum-based development, from tokenization and NFT marketplaces to enterprise blockchain systems.

We build secure, scalable, and transparent decentralized solutions that align with clients’ goals, whether that’s automating business workflows, creating digital assets, or building entire Web3 ecosystems.

With over 850+ projects across 10 countries and a proven track record as one of Vietnam’s Top 10 ICT Companies, we provide end-to-end support:

• Smart contract design and auditing to ensure reliability and security.
• Integration with blockchain frameworks such as Ethereum, Polygon, and Binance Smart Chain.
• Full-cycle development from research and prototyping to deployment and ongoing maintenance.

Our global teams in Vietnam and Japan collaborate closely with clients to deliver blockchain products that meet international standards.

If you’re looking to build decentralized apps or explore the potential of Web3, our Solidity experts are ready to help.

Contact us to start your Solidity project today.

Conclusion

Mastering Solidity opens the door to real innovation in blockchain and Web3. This Solidity language tutorial gives you the foundation to code smart contracts, understand blockchain logic, and create secure decentralized applications. Whether you’re building tokens, NFTs, or enterprise blockchain systems, the right partner makes all the difference. MOR Software brings proven expertise and global experience to your project. Contact us today to start your Solidity development journey.