What Is NEAR Protocol? Layer 1 Blockchain
Learn what NEAR Protocol is, how it works with Nightshade sharding, stateless validation, and what the network upgrade means for you.
Last Updated: July 2025
NEAR Protocol is a Layer 1 Proof-of-Stake blockchain designed for high-throughput, low-cost transactions and developer accessibility. Launched on mainnet in 2020 and co-founded by AI researcher Illia Polosukhin and engineer Alexander Skidanov, NEAR processes transactions using a proprietary sharding architecture called Nightshade. Its native NEAR token is used for gas fees, staking, and protocol governance.
NEAR Protocol at a Glance
Launch Year 2020 (mainnet) Consensus Thresholded Proof of Stake + Doomslug Sharding Nightshade (Phase 2 active) Gas Fees Typically fractions of a cent per transaction Native Token NEAR Smart Contract Languages Rust, JavaScript/TypeScript Active Validators Approximately 100 (verify current data at NEAR Explorer)
In this article:
- What Is NEAR Protocol? A Plain-Language Overview
- How NEAR Protocol Works: Architecture, Consensus, and Speed
- What Is the NEAR Protocol Network Upgrade?
- What the NEAR Network Upgrade Means for You
- How NEAR Protocol Compares to Ethereum, Solana, and Other Layer 1s
- The NEAR Token: Utility, Staking, and What the Upgrade Changes
- The NEAR Ecosystem: dApps, DeFi, and Ethereum Interoperability
- Frequently Asked Questions About NEAR Protocol
- The Bottom Line: What NEAR Protocol Is and Where It's Headed
What Is NEAR Protocol? A Plain-Language Overview
NEAR Protocol is the base blockchain network itself, while the NEAR token is the native cryptocurrency that runs on top of it. This distinction matters: when people search for "NEAR crypto," they sometimes conflate the two. NEAR Protocol is the infrastructure; the NEAR token is the asset that powers it.
A Layer 1 blockchain is the base protocol of a network, handling transaction processing, consensus, and data availability directly on its own chain, rather than relying on another blockchain for security. NEAR Protocol is a Layer 1, placing it in the same category as Ethereum, Solana, and Avalanche. Each of these networks makes different architectural tradeoffs in how they balance throughput, security, and decentralization.
NEAR functions specifically as a smart contract platform, a blockchain that supports self-executing programs (smart contracts) that run automatically when predefined conditions are met. Smart contracts power decentralized applications (dApps), software that runs on a blockchain rather than a centralized server. NEAR is designed as a platform for building dApps, with developer accessibility as a core design principle. Unlike Ethereum, which requires Solidity for native smart contract development, NEAR supports contracts written in Rust and JavaScript/TypeScript, lowering the barrier for the millions of developers already familiar with JavaScript.
Who Created NEAR Protocol and When?
NEAR Protocol was co-founded by Illia Polosukhin, co-author of the landmark 2017 AI research paper "Attention Is All You Need" that introduced the Transformer architecture foundational to modern large language models, and Alexander Skidanov, a former engineer at MemSQL. The protocol launched its mainnet in 2020 after a period of development and testnet activity beginning in 2018. The NEAR Foundation, a Swiss nonprofit, governs the ecosystem through grants, developer support, and protocol coordination via NEAR Enhancement Proposals (NEPs).
How NEAR Protocol Works: Architecture, Consensus, and Speed
NEAR Protocol's architecture is built around solving a core challenge every blockchain faces: the scalability trilemma. Attributed to Ethereum co-founder Vitalik Buterin, the trilemma states that a blockchain can only fully achieve two of three properties simultaneously: scalability (high throughput), security (resistance to attack), and decentralization (no central point of control). NEAR's design, combining Nightshade sharding with Thresholded Proof of Stake and Doomslug consensus, represents a serious technical attempt to address all three at once rather than sacrificing one for the others.
A consensus mechanism is the set of rules by which all participants in a blockchain network agree on which transactions are valid and in what order they occurred. It is the foundation of a blockchain's security. NEAR uses Proof of Stake as its consensus category and a specific protocol called Doomslug as its block production implementation.
Is NEAR Protocol Proof of Stake?
Yes, NEAR Protocol uses Proof of Stake as its consensus mechanism, specifically a variant called Thresholded Proof of Stake. In Proof of Stake, validators lock up (stake) cryptocurrency as collateral to earn the right to validate transactions and produce blocks, rather than expending computational energy as in Proof of Work. NEAR's Thresholded variant allocates validator seats based on the amount of NEAR staked, with a minimum seat price that adjusts dynamically based on demand. Token holders who do not run validator nodes can delegate their NEAR to existing validators via staking pools and earn a proportional share of rewards. Full specification details are available in the NEAR Protocol technical documentation.
The Proof of Stake layer handles validator selection and incentives. On top of that sits NEAR's block production protocol, called Doomslug, which manages the actual mechanics of producing and finalizing blocks.
What Is Sharding in NEAR Protocol?
Sharding in NEAR Protocol means dividing the network into parallel segments, called shards, each processing a subset of transactions simultaneously. Think of sharding like adding lanes to a highway: each shard is an additional lane, allowing more transactions to move simultaneously without queuing behind each other in a single line. As shard count grows, total throughput scales proportionally.
What Is Sharding? Sharding is a database and blockchain scaling technique that splits a network into parallel processing segments. Each segment handles a portion of the total transaction load, so the network's capacity grows with each shard added rather than being limited to what one machine can process.
NEAR's specific sharding design, called Nightshade sharding, treats the entire blockchain as a single chain whose blocks are produced collaboratively by multiple shards. Each shard produces a "chunk," a portion of the full block, which are then combined into the complete block. This differs from approaches where shards operate as entirely separate chains. The Nightshade design, documented in the Nightshade sharding whitepaper, preserves unified state across shards while enabling parallel transaction processing.
How Fast Is NEAR Protocol?
For everyday dApp users, transactions on NEAR confirm in roughly the time it takes to refresh a web page. NEAR Protocol achieves practical transaction finality in approximately one to two seconds under normal network conditions, via its block production protocol, Doomslug. Doomslug uses a two-round message-passing system: after one round, a block is considered practically irreversible (Doomslug-final); after a second round with sufficient validator signatures, it reaches full Byzantine Fault Tolerant (BFT) finality, a cryptographic guarantee that the block cannot be reversed.
NEAR's current throughput varies by the number of active shards. With Nightshade sharding designed to scale proportionally with each shard added, theoretical throughput increases with each phase of the rollout. Exact current TPS figures vary by load; verify current network performance at NEAR Explorer.
What Programming Languages Does NEAR Protocol Support?
NEAR Protocol natively supports smart contracts written in Rust and JavaScript/TypeScript, compiled to WebAssembly (WASM) for execution on the network. Rust provides performance and memory safety for production contracts; JavaScript/TypeScript support opens NEAR to the broad population of web developers without blockchain experience. For developers who want to deploy existing Ethereum Solidity contracts on NEAR infrastructure, Aurora EVM (covered in the next section) provides an EVM-compatible environment without requiring NEAR's native languages.
Gas fees on NEAR, the small amounts of cryptocurrency paid to validators for processing and recording transactions, typically cost fractions of a cent per transaction. NEAR uses a deterministic gas price model rather than the auction-based model Ethereum uses, making fees predictable rather than dependent on network congestion. A notable protocol feature: NEAR allocates 30% of transaction fees back to the smart contract developer, creating a direct economic incentive for builders. For technical details on fee calculation, see NEAR gas fee documentation.
What Is the NEAR Protocol Network Upgrade? Nightshade Phases and Stateless Validation Explained
The NEAR Protocol network upgrade refers to the ongoing phased rollout of Nightshade sharding, NEAR's proprietary architecture for processing transactions across parallel shards. The current upgrade cycle introduces stateless validation, a mechanism that changes how validators process transactions and substantially reduces the hardware requirements for running a validator node.
What Is a Network Upgrade? A network upgrade is a coordinated change to a blockchain's software rules, requiring validators and node operators to update their software to implement new protocol features. Changes can be backward-compatible (soft fork) or require all participants to upgrade (hard fork). NEAR's upgrade process is governed through NEAR Enhancement Proposals (NEPs), analogous to Ethereum Improvement Proposals (EIPs), tracked in the NEAR Enhancement Proposals repository.
What Is the NEAR Protocol Network Upgrade?
The NEAR Protocol network upgrade is the coordinated deployment of Nightshade sharding phases, with the most recent phase introducing stateless validation, a mechanism that allows validators to confirm transactions without storing the full blockchain state locally. This reduces hardware requirements for validator nodes, lowers the barrier to validator participation, and advances NEAR's decentralization goals.
The Nightshade Upgrade Timeline: Phase 0 to Phase 3
Nightshade sharding is being deployed in four phases, each adding new capabilities to the network. The table below shows the progression from NEAR's 2020 mainnet launch through the current live phase and the planned roadmap.
| Phase | Key Feature | Status | Description |
|---|---|---|---|
| Phase 0 | Single shard | Live (2020) | NEAR launched with a single shard. All validators processed all transactions. Full state stored by all nodes. |
| Phase 1 | Four shards, validator rotation | Live | Network split into four shards. Validators assigned to shards per epoch. Block production distributed across shard sets. |
| Phase 2 | Chunk-only producers + stateless validation | Live | Introduces chunk-only producers (validators assigned to specific shards only) and stateless validation, eliminating the need for validators to store full state. |
| Phase 3 | Dynamic resharding | Roadmap | Planned capability for the network to autonomously adjust shard count based on demand, enabling theoretically unlimited horizontal scalability. |
Verify current phase status at near.org before publishing or making decisions based on this information.
What Is Stateless Validation and Why Does It Matter?
Stateless validation is a method that allows validators to confirm transactions without storing the full blockchain state on their local machines. Think of it as checking a receipt without needing to memorize the entire store's inventory. Validators receive a cryptographic proof called a witness, a compact package containing everything needed to verify a transaction's validity, alongside the transaction data itself. They no longer need to maintain a full local copy of the blockchain's state to do their job.
What Is Stateless Validation? Stateless validation allows validators to verify transactions using cryptographic witnesses rather than a locally stored full-state database. The witness contains the relevant state information needed for verification, delivered with the transaction. Validators process the witness and transaction together, then discard the data, rather than maintaining a growing permanent state database.
Before stateless validation, running a NEAR validator required significant and growing storage capacity to maintain the full blockchain state. Post-upgrade, storage requirements drop sharply because validators receive state witnesses per chunk rather than maintaining a persistent state database. This reduces the hardware cost of validator participation, which in turn lowers the threshold for new validators to join the network.
The stateless validation design in NEAR is specific to chunk-level witnesses within the Nightshade architecture. Ethereum researchers have discussed similar concepts under the label "stateless clients," but the two implementations differ architecturally and should not be conflated.
How the Upgrade Affects Validators
Before the stateless validation upgrade, validators on NEAR needed to maintain a complete local copy of the entire blockchain state to process transactions. This requirement grew over time as the state expanded, creating an increasing hardware cost that limited who could practically run a validator node.
Post-upgrade, validators receive state witnesses per chunk alongside transaction data. The validators (network participants who stake NEAR tokens as collateral to produce blocks and earn rewards) process the witness and transaction together without needing persistent state storage. NEAR currently operates with approximately 100 active validators in a rotating set, with the rotation occurring per epoch, a validator assignment period of approximately 12 hours. New validators enter through a staking auction where the minimum seat price fluctuates with demand.
Phase 2's introduction of chunk-only producers adds a second validator tier: validators assigned to specific shards only, rather than all shards simultaneously. This role requires less computational overhead than full block producers and creates a pathway for broader validator participation without the resource requirements of full network coverage. Token holders who prefer not to operate infrastructure directly can delegate NEAR to any validator and earn proportional staking rewards.
What the NEAR Network Upgrade Means for You
The implications of NEAR's upgrade differ depending on how you interact with the network. The sections below translate the technical changes into practical terms for each audience.
For Token Holders and Investors
For NEAR token holders, the stateless validation upgrade carries an indirect protocol health signal: lowering the hardware bar for validators makes it easier for more participants to join the network. More validators participating in block production increases decentralization, which is generally considered a security improvement for the protocol. The upgrade does not change NEAR's fee structure in a way that directly alters token economics, and staking mechanics remain consistent with pre-upgrade operation. Any assessment of how these network health signals translate to token value falls outside the scope of this educational content. See the token section below for NEAR token utility and staking details.
For Developers and dApp Builders
For developers with deployed smart contracts on NEAR, the stateless validation upgrade introduces no breaking changes. The native WASM execution environment and Rust/JavaScript support remain as before, and existing contracts continue running without modification. Aurora EVM, the EVM-compatible Layer 2 environment built on NEAR by Aurora Labs (see aurora.dev), continues to operate as before, with no disruption to Solidity contract deployments. The upgrade improves the validator infrastructure underlying the network without altering the developer-facing application layer.
For Validators and Node Operators
Validators running nodes on NEAR Protocol see the most direct operational benefit from the stateless validation upgrade. Storage requirements for running a validator node drop substantially, since validators no longer need to maintain a full-state database and instead process chunk-level witnesses delivered with each transaction. The chunk-only producer role introduced in Phase 2 creates a participation pathway that requires less total resources than full block production, opening validator participation to operators who previously could not meet full-node hardware requirements. A lower hardware barrier translates to a lower effective staking seat price over time as validator supply increases.
How NEAR Protocol Compares to Ethereum, Solana, and Other Layer 1s
NEAR Protocol, Ethereum, and Solana are all Layer 1 smart contract platforms that make different architectural tradeoffs. The right platform depends on the specific requirements of the application being built, not on any single metric of performance.
NEAR Protocol vs. Ethereum vs. Solana: Key Differences
The table below compares NEAR Protocol's current architecture, including post-upgrade Phase 2 specifications, against Ethereum and Solana across the metrics that matter most for developers and investors.
| Attribute | NEAR Protocol (as of Phase 2) | Ethereum | Solana |
|---|---|---|---|
| Consensus Mechanism | Thresholded Proof of Stake + Doomslug | Proof of Stake (Gasper) | Proof of History + Proof of Stake |
| Throughput | Scales with shard count; design target thousands of TPS per shard | ~15-30 TPS base layer (higher via L2s) | ~65,000 TPS theoretical; actual varies |
| Gas Fee Range | Typically fractions of a cent (deterministic pricing) | Variable; historically $1-$50+ during congestion | Typically fractions of a cent |
| Smart Contract Languages | Rust, JavaScript/TypeScript (WASM execution) | Solidity, Vyper (EVM execution) | Rust, C (SBF execution) |
| Scaling Approach | Nightshade sharding (horizontal, on L1) | Layer 2 rollups + future danksharding | Parallel processing via Sealevel runtime |
| Finality Time | ~1-2 seconds (practical via Doomslug) | ~12 seconds block time + confirmation | ~400ms block time; finality varies |
| EVM Compatibility | Via Aurora (Layer 2, separate project) | Native | No (separate EVM chains exist) |
NEAR offers lower and more predictable transaction fees and higher base-layer throughput via sharding; Ethereum offers greater ecosystem maturity, a larger developer community, and a longer security track record. Solana achieves high throughput through a different architectural approach (Proof of History and parallel transaction processing rather than sharding) and has historically experienced network availability issues during high-demand periods. Avalanche takes a third path, using subnet architecture for scalability rather than sharding, offering yet another set of tradeoffs for developers to weigh. Each architecture reflects different engineering priorities, and none has definitively resolved the scalability trilemma.
Post-upgrade, NEAR's stateless validation reduces validator centralization risk relative to its own prior state, a meaningful improvement in network decentralization.
Who Owns NEAR Protocol? Understanding the NEAR Foundation
No single entity owns NEAR Protocol. The NEAR Foundation, a Swiss nonprofit organization, governs the ecosystem through grants, developer support, and coordination of protocol development via the NEP process. Protocol changes are proposed as NEAR Enhancement Proposals, reviewed by the community and technical teams, and require validator adoption to go live. NEAR has meaningful decentralization at the validator level, with approximately 100 active validators in a rotating set. The Foundation retains significant influence over protocol direction and ecosystem funding, which is worth acknowledging honestly: NEAR is decentralized at the infrastructure layer but not without organizational influence over its development trajectory.
The NEAR Token: Utility, Staking, and What the Upgrade Changes
The NEAR token is the native cryptocurrency of the NEAR Protocol network, and it serves three functions: paying transaction fees, staking to secure the network, and participating in governance. The token and the protocol share a name, which creates confusion worth resolving before going further.
Is NEAR Protocol the Same as NEAR Coin?
No. NEAR Protocol is the blockchain network itself, the infrastructure. NEAR (also called the NEAR token) is the native cryptocurrency that runs on that network, used to pay gas fees, stake for network security, and participate in governance decisions. The two share the same name but refer to distinct things. The accurate term for the asset is "NEAR token," not "NEAR coin." The coin label implies a payment-only function, which understates the token's governance and staking roles.
The NEAR token has a total supply with an inflation model tied to staking rewards: new NEAR tokens are issued as staking rewards, funded by protocol inflation rather than a fixed emission schedule. A protocol treasury allocation also exists. The upgrade does not change the fundamental token supply mechanics, though a lower validator hardware barrier may increase staking participation over time as more validators enter the network.
How to Stake NEAR Protocol
NEAR holders can participate in staking through two routes: running a validator node directly, or delegating tokens to an existing validator via a staking pool.
Running a validator node requires meeting the current minimum seat price (the staking threshold required to be included in the active validator set), maintaining compatible hardware, and keeping node software updated. The minimum seat price fluctuates with total staked supply and demand for validator slots.
Delegating to a staking pool is accessible to any NEAR holder, with no minimum beyond the pool's own requirement. Delegation means assigning your NEAR tokens to an existing validator, who stakes them on your behalf in exchange for a commission on rewards. Staking rewards on NEAR are funded by protocol inflation and distributed proportionally to stake. Rates vary based on total staked supply and validator performance. Check current validator data at NEAR staking documentation for up-to-date figures before making any staking decisions.
The stateless validation upgrade reduces hardware requirements for validators, which may lower the minimum seat price over time as validator supply increases. This does not change the delegation model for token holders.
Is NEAR Protocol a Good Investment?
Evaluating NEAR Protocol as an investment requires looking at several technical and market factors rather than at price history alone.
Disclaimer: This content is for informational and educational purposes only. It does not constitute financial advice, investment advice, or a recommendation to buy, sell, or hold any cryptocurrency. Cryptocurrency investments carry significant risk, including the potential loss of capital. Always conduct your own research and consult a qualified financial advisor before making investment decisions.
Factors that technically-minded investors typically consider when evaluating NEAR include: the pace and quality of protocol development (the Nightshade upgrade progression from Phase 0 through Phase 2 represents multi-year consistent delivery); competitive positioning relative to Ethereum and Solana (NEAR's deterministic fees and horizontal sharding offer architectural differentiation); ecosystem growth (the number of active dApps, DeFi protocols, and developers building on NEAR); and token utility depth (NEAR serves gas, staking, and governance functions rather than being a speculation-only asset).
NEAR remains an active development project with a documented roadmap (Phase 3 dynamic resharding is planned but not yet deployed). For those researching NEAR token price data or price forecasts, this article does not provide price predictions. Current price data is available at CoinGecko and CoinMarketCap; independent financial analysis is outside the scope of this educational content.
The NEAR Ecosystem: dApps, DeFi, and Ethereum Interoperability
NEAR Protocol supports a range of decentralized applications across DeFi, NFTs, gaming, and social platforms, with Ref Finance as its primary decentralized exchange and Aurora EVM bridging Ethereum developers into the ecosystem. Developers building Web3 applications, internet applications built on decentralized protocols rather than centralized servers, have access to NEAR's low-fee infrastructure and its JavaScript-friendly development environment.
Decentralized Finance (DeFi) describes financial services such as lending and trading, plus yield generation, delivered via smart contracts without banks or brokers as intermediaries. NEAR's DeFi ecosystem is growing but smaller in total value and protocol count than Ethereum's; Ref Finance operates as the primary automated market maker (DEX) on NEAR. NFT platforms, gaming applications, and social dApps also operate on NEAR, using the network's low transaction fees to serve consumer-facing use cases where Ethereum's variable fees would create a poor user experience.
Rainbow Bridge: How NEAR Connects to Ethereum
Rainbow Bridge is a trustless cross-chain bridge (a protocol that enables asset transfers between two separate blockchain networks) connecting NEAR Protocol to Ethereum, allowing users to transfer tokens and data between the two networks without a centralized intermediary. Rainbow Bridge uses light client proofs to verify transactions on both chains: each chain's light client runs on the other chain, so transfers can be verified cryptographically without relying on a trusted third party to attest to their validity. This trustless design is a security feature. Bridge security is an active concern across the crypto industry; Rainbow Bridge's design removes the single point of failure that has made centralized bridge operators targets for exploits. Current bridge information is available at Rainbow Bridge.
The practical ecosystem benefit is that Ethereum-based ERC-20 tokens can be used within NEAR's DeFi ecosystem via the bridge, and NEAR-native assets can flow to Ethereum. This interoperability expands the usable asset base for NEAR's DeFi protocols and connects NEAR to Ethereum's liquidity without requiring users to choose between ecosystems permanently.
To explore active dApps and protocols in the NEAR ecosystem, visit near.org.
Frequently Asked Questions About NEAR Protocol
The questions below address the most common points of confusion about NEAR Protocol, its network upgrade, and its token.
What is NEAR Protocol used for?
NEAR Protocol is used as a platform for building decentralized applications (dApps), including DeFi protocols, NFT marketplaces, gaming applications, and Web3 social platforms. Its low gas fees (typically fractions of a cent) and Nightshade sharding-based throughput make it suitable for consumer-facing dApps requiring fast, cheap transactions. With Aurora EVM, Ethereum smart contracts can also run on NEAR infrastructure without rewriting code.
Is NEAR Protocol the same as NEAR coin?
No. NEAR Protocol is the blockchain network, the infrastructure layer. NEAR (also called the NEAR token) is the native cryptocurrency that runs on that network, used to pay gas fees, stake for network security, and participate in protocol governance through NEPs. The two share the same name but refer to distinct things. The accurate term for the asset is "NEAR token," not "NEAR coin."
How is NEAR Protocol different from Ethereum?
NEAR Protocol differs from Ethereum in three primary architectural respects: lower and more predictable gas fees (fractions of a cent versus Ethereum's variable fees that have reached several dollars during peak congestion); higher base-layer throughput via Nightshade sharding rather than relying on Layer 2 rollups for scaling; and native JavaScript/TypeScript smart contract support alongside Rust. Ethereum has significantly greater ecosystem maturity, a larger developer community, and a longer security track record. Neither is categorically superior; the right choice depends on application requirements.
What is sharding in NEAR Protocol?
Sharding in NEAR Protocol means dividing the network into parallel segments called shards, each processing a subset of transactions simultaneously, like adding lanes to a highway. NEAR's sharding design, called Nightshade, treats the blockchain as one unified chain whose blocks are produced collaboratively by multiple shards, with each shard producing a "chunk" that combines into the full block. This differs from architectures where shards operate as separate chains.
Who owns NEAR Protocol?
No single entity owns NEAR Protocol. The NEAR Foundation, a Swiss nonprofit, governs the ecosystem through grants and development coordination. Protocol upgrades are proposed via NEAR Enhancement Proposals (NEPs) and require community and validator coordination to implement. Approximately 100 active validators currently participate in block production, providing meaningful infrastructure-level decentralization.
Is NEAR Protocol proof of stake?
Yes. NEAR Protocol uses a Proof of Stake consensus mechanism, specifically a variant called Thresholded Proof of Stake. Validators stake NEAR tokens as collateral to produce blocks and earn rewards, with the block production protocol called Doomslug sitting on top of this validator selection layer. Token holders who do not run validator nodes can delegate NEAR to validators via staking pools and earn proportional rewards. Practical transaction finality takes approximately one to two seconds under normal conditions.
What is the NEAR Protocol network upgrade?
The NEAR Protocol network upgrade refers to the phased implementation of Nightshade sharding. The most recent live upgrade phase introduces stateless validation, a mechanism that allows validators to confirm transactions by processing cryptographic state witnesses rather than maintaining a full local blockchain state database. This reduces validator hardware requirements and lowers the barrier to validator participation, improving network decentralization.
How fast is NEAR Protocol?
Practical transaction finality on NEAR takes approximately one to two seconds under normal network conditions, achieved via the Doomslug consensus protocol. Doomslug reaches practical irreversibility after one round of block confirmation and full BFT-guaranteed finality after a second round with sufficient validator signatures. Throughput scales with shard count as Nightshade sharding progresses through its phases.
What programming languages does NEAR Protocol support?
Smart contracts on NEAR are written in Rust and JavaScript/TypeScript, using the NEAR SDK, and compiled to WebAssembly (WASM) for execution on the network. Ethereum Solidity developers can deploy existing contracts to NEAR via Aurora EVM, a separate EVM-compatible environment built on NEAR's Layer 1 by Aurora Labs, without rewriting code in NEAR's native languages.
What is the NEAR Foundation?
The NEAR Foundation is a Swiss nonprofit organization responsible for stewarding the NEAR Protocol ecosystem. It funds development grants, supports community projects, and coordinates protocol governance through the NEAR Enhancement Proposal (NEP) process. The Foundation does not own or control the NEAR Protocol network directly; protocol changes require validator adoption to go live. The Foundation retains significant influence over the direction of ecosystem funding and development priorities.
The Bottom Line: What NEAR Protocol Is and Where It's Headed
NEAR Protocol is a Layer 1 blockchain with a technically specific approach to scalability: Nightshade sharding, deployed in phases, now including stateless validation as its most recent architectural advancement. The combination of Thresholded Proof of Stake, Doomslug consensus, and phased Nightshade rollout represents one of the more technically serious attempts to address the scalability trilemma without sacrificing one property entirely for another.
The network upgrade story is ongoing. Phases 0 through 2 are live, with stateless validation reducing validator hardware requirements and chunk-only producers broadening participation. Phase 3, dynamic resharding, remains on the roadmap as the design target for theoretically unlimited horizontal scalability. Whether and when Phase 3 deploys depends on continued development and validator coordination.
NEAR sits in a competitive Layer 1 landscape alongside Ethereum, Solana, Avalanche, and others. Its differentiators include deterministic fee pricing, native JavaScript support for developers, and a sharding-based scaling approach that operates at the base layer rather than requiring application developers to navigate Layer 2 complexity. These are architectural facts that investors and developers can weigh; their significance relative to an individual use case or investment thesis is a judgment each person must make for themselves.
For next steps based on your interest: to stake NEAR or review current validator data, see NEAR staking documentation. To build on NEAR, start with the NEAR developer documentation. To track upgrade progress and NEP governance, visit the NEAR Enhancement Proposals repository. For the official NEAR ecosystem overview, visit near.org.