PROVIDER Β· the Ethereum smart contract language

Solidity

Solidity is the Ethereum Virtual Machine contract language compiled to immutable on-chain bytecode as the common implementation for DeFi, NFTs, and DAOs, where audits and gas optimisation are unavoidable engineering concerns.

Programming Languages & Frameworks International 2026.11.16
Programming Languages & Frameworks International the Ethereum smart contract language
4pts

Pros

4 items
The de facto EVM standard across DeFi and NFT contracts
Mature tooling from Hardhat and Foundry to Remix with full test frameworks
Contracts port across EVM-compatible chains such as Polygon, BSC, and Arbitrum
Strong typing and inheritance give more expressiveness than early contract languages

Cons

4 items
Bugs cause irreversible fund loss with costly audits
Gas costs constrain design with optimisation fighting readability
Frequent language versions keep best practices evolving
Post-deployment immutability demands proxy and governance design upfront

Product Information

solidity
Category Programming Languages & Frameworks
Company Solidity
Service Region International
Official Website https://soliditylang.org/
Recommendation Score 4 pts
Published 2026-11-16

Detailed Notes

Overview

Solidity was proposed by Gavin Wood and others in 2014 and is maintained by the Ethereum Foundation with JavaScript-like syntax compiling to Ethereum Virtual Machine bytecode, deployed immutably on chain for DeFi, NFT, DAO, and dApp contract logic.

For Programming Languages & Frameworks work the value is being the single common language of on-chain logic, since most DeFi protocols, stablecoins, and NFT contracts use it, tooling from Hardhat and Foundry to Remix is mature, and contracts port directly to EVM-compatible chains such as BSC, Polygon, and Arbitrum.

Recognise the risks, because contract bugs cause irreversible fund loss making audits and formal verification mandatory, gas costs constrain design since storage is expensive with optimisation often conflicting with readability, and the language and ecosystem keep evolving with frequent versions requiring proxy patterns for upgrades.

Core Strengths

  • The de facto EVM standard across DeFi and NFT contracts
  • Mature tooling from Hardhat and Foundry to Remix with full test frameworks
  • Contracts port across EVM-compatible chains such as Polygon, BSC, and Arbitrum
  • Strong typing and inheritance give more expressiveness than early contract languages

Product Ecosystem

Language and runtime

EVM bytecode, ABI interfaces, events, revert handling, modifiers, and libraries.

Tooling

Hardhat or Foundry builds and tests, the Remix IDE, and OpenZeppelin contracts.

Security and upgrades

Slither and Mythril analysis with UUPS or transparent proxies and multisig governance.

Drawbacks

  • Bugs cause irreversible fund loss with costly audits
  • Gas costs constrain design with optimisation fighting readability
  • Frequent language versions keep best practices evolving
  • Post-deployment immutability demands proxy and governance design upfront

Use Cases

  • DeFi and stablecoin contracts (β˜…β˜…β˜…β˜…β˜…) - Ecosystem standard
  • NFTs and DAOs (β˜…β˜…β˜…β˜…β˜…) - Mature tooling
  • Learning on-chain logic (β˜…β˜…β˜…β˜…) - Clear entry path
  • Traditional business systems (β˜…) - Not applicable

Pricing

Plan Price Scope
Solidity and tooling $0 GPL or MIT, free
On-chain gas Network billing Tens to hundreds of dollars per deployment on mainnet
Security audits Thousands to hundreds of thousands Depending on complexity and firm

The language and tooling are free with real cost in gas and audits, where mainnet deployment runs tens to hundreds of dollars and professional audits from thousands to hundreds of thousands, never to be skipped for contracts holding funds.

FAQ

  • Is Solidity beginner friendly? Blockchain and EVM models come first, since the language is easy but security thinking and gas economics are not.

  • Can contracts be upgraded? Not by default, requiring proxy patterns like UUPS or transparent proxies designed before deployment.

  • Are audits mandatory? Contracts holding real funds must be audited, ideally with formal verification and bug bounties.

Code Examples

Contract with structs and events

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract PlanStore {
    struct Plan { string name; uint256 price; }
    Plan[] public plans;

    event PlanAdded(uint256 indexed id, string name, uint256 price);

    function add(string calldata name, uint256 price) external {
        plans.push(Plan(name, price));
        emit PlanAdded(plans.length - 1, name, price);
    }
}

Since 0.8 arithmetic checks overflow by default and external costs less gas than public.

Reading state and watching gas

function cheapCount(uint256 max) external view returns (uint256 count) {
    for (uint256 i = 0; i < plans.length; i++) {
        if (plans[i].price <= max) count++;
    }
}

view functions cost no gas on chain, and estimate write costs in Remix first.

Community & Resources

Communities and official channels

Learning resources and tools

Visit Solidity Website β†’ https://soliditylang.org/
Visit Website β†—