Nearcore is the full node client for NEAR Protocol, open source software that runs a complete, locally checked copy of the NEAR blockchain on your own computer. It is aimed at developers, validator operators and technically confident users who want to verify the network themselves instead of relying on a third-party service. The program is free, and its source code is public on GitHub.
Nearcore for Windows is listed as a build target, so the client can run on a Windows PC, though availability of a Windows file can vary from release to release. The latest tagged release is statelessnet-89.0, and the code was last updated in late October 2026, which shows the project is active. This page explains what the client does, how to get a verified copy, what the wider NEAR developer toolkit offers, and how it compares with the Ethereum clients many readers already know.
What Is a NEAR Full Node?
A full node is a program that keeps a complete, locally verified copy of a blockchain. Instead of trusting a remote server to report the current state, it checks the blocks it receives against the protocol rules and stores the results on disk. Nearcore is the main implementation of that role for NEAR Protocol.
In practice, a full node does three jobs at once. It connects to peers to exchange blocks and transactions, it validates everything it receives, and it exposes an interface that applications or scripts can query. Peer connections keep the node in step with the network, validation means you do not have to accept someone else's answer, and the query interface lets your own tools read the chain.
The trade-off is resources. A node needs disk space that grows over time, a steady internet connection and attention whenever updates arrive. For many people a hosted API is a simpler starting point. Running your own node makes sense when independent verification or low-level access is worth that extra work.
Staking, Validators and Delegation Explained
NEAR Protocol relies on validators, participants who lock up tokens, called stake, to help produce and confirm blocks. The stake is a commitment to the network, and the protocol rules govern how validators are selected and what happens when they underperform. Running validator software such as Nearcore is one way to take on that role.
Delegation offers a different path. Token holders who do not want to run infrastructure can delegate their tokens to a validator and share in the network's rewards without operating a node themselves. The project's documentation on staking and delegation walks through the mechanics, including how to think about choosing a validator and what the trade-offs look like.
Both roles carry real risk. Rewards depend on network conditions and on how a validator performs, and the value of staked tokens can fall as well as rise. Anyone considering staking should read the official documentation, understand the lock-up and unbonding rules, and treat the decision as a personal one rather than a path to guaranteed income.
Who Nearcore Is For
Nearcore suits a few clearly defined groups. Application developers use a local node to test against a real chain rather than a shared test server, which can make debugging faster and more predictable. Infrastructure teams use it to reduce their dependence on a single outside provider.
Validator operators and people preparing to become validators use the client as the base of their setup. They need to monitor uptime closely and keep their software current, so the release history and the official documentation become part of their daily routine.
Researchers and curious engineers can also learn a lot from reading the source code and the specification. Someone studying how a proof-of-stake network handles blocks and state will find concrete material here. People who only want to hold tokens, send transfers or use a decentralized app will usually find a wallet or hosted service far more practical than a full node.
Key features
JavaScript client library
Rust and JavaScript SDKs for smart contracts
Core repositories for the open web platform
Browser-based examples
Documentation, tutorials and API reference
Formal protocol specification
Supported coins
NEAR Protocol is the network this client runs, so NEAR is the asset most directly relevant to the node itself. The project's documentation also mentions Ethereum (ETH) alongside NEAR. The node is built for NEAR, so Ethereum matters mainly for comparison and for developers who work across both networks.
How to install Nearcore on Windows
- 1
Get the file from an official source
Go to the project's GitHub Releases page at github.com/near/nearcore, or follow the official documentation links. Download only from the official website or GitHub, and avoid mirror sites that offer repackaged installers or bundled extras.
- 2
Find a Windows build in the release
Check the release notes for the latest tag, which is statelessnet-89.0 at the time of writing, and look for a Windows file among the assets. Windows builds are listed for the project, but not every release necessarily includes a prebuilt file, so confirm one exists before you plan around it.
- 3
Verify the checksum
Calculate the SHA-256 hash of the downloaded file with a tool such as PowerShell's Get-FileHash command, then compare the result with the value published on the release page. If the two values differ, delete the file and download it again before running anything.
-
Install and run a test
Place the program in a dedicated folder rather than your downloads directory, then start it from a terminal to confirm it launches. Building from source is a separate path that requires developer tooling such as Rust, which is not needed when you use the ready-made build.
How to use Nearcore
Running Nearcore is less about clicking buttons and more about deciding what role your node will play. Before you start, settle on whether you want a local development node, a node that follows the network, or a validator setup, because each needs a different configuration.
- Confirm which release you need on the Releases page and note the tag, such as statelessnet-89.0 if it is still the newest.
- Extract or place the Windows build in a folder you control, separate from your downloads.
- Open a terminal in that folder and check that the binary starts and reports its version.
- Create the configuration files by following the official documentation, and review the network settings before you connect.
- Start the node and let it sync, watching the logs for errors about storage, network ports or peers.
- Once the node is synced, query its local RPC endpoint from the terminal or a small script to confirm it responds.
- Only after the node runs stably should you consider validator keys or staking, and handle those keys offline with extra care.
Keep a short notes file with the version, the configuration choices and the date of each change. It makes troubleshooting far easier when an update changes behavior.
Pros & cons
- Free and open source, with the source code publicly available on GitHub.
- A full node for NEAR Protocol, so you can check chain state without trusting a third party.
- Written in Rust, with an active codebase that was updated in October 2026.
- The SDKs, examples and tutorials sit in one ecosystem, which shortens the path from node to application.
- The formal specification gives developers a precise reference for intended protocol behavior.
- Aimed at technical users, so setup, monitoring and troubleshooting take real time.
- Windows support is listed as likely rather than guaranteed, so a prebuilt file may not appear in every release.
- Much of the surrounding material is written for developers, which leaves casual users with less guidance.
- Ethereum appears in the documentation, which may confuse readers who expect an Ethereum client.
Is Nearcore safe?
Nearcore runs on your own machine, and if you operate a validator it can sit close to keys tied to staked tokens, so treat it like any software that handles money. Download only from the official website or the project's GitHub Releases page, and avoid third-party sites that repackage the binary. Compare the SHA-256 checksum with the value published alongside the release before you run the file. Never enter a seed phrase or private key into a third-party website or a tool you have not verified, and keep validator keys offline wherever possible. Before installing, check the latest version on the official website, since a newer release may fix issues present in older builds.
- Official source only. Download from github.com/near/nearcore. Ignore ads and lookalike domains.
- Check the SHA-256. Compare the installer hash with the value the developer publishes before running it.
- Never share your seed phrase. No developer, support agent or website — including CryptApps — will ever ask for it.
Alternatives
Most people comparing node software meet Ethereum clients first. Geth is the official Go implementation of the Ethereum protocol, Erigon focuses on performance, and Nethermind is an execution client built on .NET. Nimbus is a lightweight consensus client for Ethereum. These programs serve Ethereum, while Nearcore serves NEAR Protocol, so the choice depends less on features and more on which network you want to join or build on.
Evmos runs a node for another network entirely, which makes it a different kind of tool. Older or unsupported options such as OpenEthereum, which has closed, GoQuorum, which is no longer supported, and Ethereum Grid, which is archived, are worth avoiding for new projects.
Specifications
- Price
- Free
- Type
- Open source
- License
- —
- Latest version
- statelessnet-89.0
- Last update
- 30 Oct 2026
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/near/nearcore
Frequently asked questions
Nearcore is the full node client for NEAR Protocol. It lets you run your own copy of the network, which is useful for developers testing applications, validator operators and anyone who wants to check chain data without relying on a third party. Most everyday users interact with NEAR through wallets and apps instead of running a node.
It can be, provided you get the file from the official source and verify it. Download from the project's GitHub Releases page, compare the SHA-256 checksum with the published value, and avoid repackaged copies from unknown sites. Software that may handle validator keys deserves the same care as a wallet, so never share a seed phrase with anyone or anything.
Windows builds are listed for the project, so Windows is a supported target, but support is described as likely rather than guaranteed. Check the Releases page for a Windows file in the release you want. If a particular release lacks one, look at the official documentation for the build path.
Yes, Nearcore is free and open source, and its source code is public on GitHub. Running a node still costs time and hardware resources, though. Joining as a validator involves staking tokens, which is a separate decision with its own risks and should be weighed on its own terms.
No, not for the ready-made program. Rust is the language the project is written in and the usual toolchain for building from source. If you download an official build, you only need to run the file. Building it yourself is an option for developers who want to modify the code.
Nearcore is a node for the NEAR Protocol network. The project's documentation mentions Ethereum (ETH) alongside NEAR, but the client does not turn your machine into an Ethereum node. If you need Ethereum, clients such as Geth or Nethermind are designed for that network.
Staking means locking up tokens to back a validator, which helps secure the network. The project's staking and delegation documentation explains how validators and delegators work together. Returns depend on network conditions and are not guaranteed, so read the documentation carefully before committing any funds.
Verdict
Nearcore is the right choice if you need a full node for NEAR Protocol and you are comfortable with command-line tools, configuration files and reading logs. Developers building on NEAR will also value the surrounding SDKs and documentation. Casual users who mainly want to send tokens or use an app are better served by a wallet. If you are unsure whether a node fits your goals, start with the documentation and a local development setup before committing hardware or stake.