Kaspad is a full node implementation for the Kaspa (KAS) network, written in Go. It is aimed at developers and node operators who want to run their own copy of the blockchain and check transactions without relying on a third party. The program is free and released as open source under the ISC license.
Kaspad is deprecated. The reference full node was rewritten in Rust, which means the Go version is no longer the recommended choice. Most people starting today should look at Rusty Kaspa instead. Kaspad still has value for studying the older codebase, reviewing how the network evolved, or comparing implementations, but it should not be your default pick for a new node.
What Is a Kaspa Full Node?
A full node is a program that downloads and checks the entire history of a blockchain. Instead of accepting whatever a wallet or website says about a balance, a node applies the network's rules to every block and transaction itself. Kaspa is a proof-of-work network, so nodes also track the blocks that miners produce and decide which data is valid.
Running a node is mostly about independence. You get your own view of the network, which matters for developers building applications, for researchers studying network behavior, and for users who want to avoid depending on a single public service. The trade-off is resources: a node needs disk space, a stable connection, and time to synchronize before it is fully up to date.
Kaspad was one of the early ways to run such a node for Kaspa. Understanding what it does makes it easier to judge any Kaspa node software, whether you are choosing a current client or reading older code.
Why the Go Implementation Was Deprecated
Kaspa's full node reference implementation was rewritten in Rust. Once a maintained Rust version became the reference, continuing to develop the Go version as a parallel project made less sense for the ecosystem. Keeping two full implementations aligned is costly, and a single reference client is easier to test, document, and secure.
For you as a user, deprecation means that the Go code is no longer the main path forward. Bug reports and new protocol work are expected to target the Rust implementation. An older release may still run, but you should not assume it will keep pace with network changes.
The practical lesson is to check which implementation a project treats as current before you invest time in setup. Looking at the project's own announcements and its release notes is the quickest way to confirm that status.
Who Should Use Kaspad Today
Kaspad still fits a few specific situations. A developer studying how Kaspa nodes handle block validation can read the Go source and compare it with other implementations. A teacher or researcher may want an older client to illustrate how a blockchain node is structured.
Teams that already maintain Go tooling around Kaspa may also find it useful as a reference during migration work. They can compare behavior, test assumptions, and document differences before moving to the Rust client.
For a typical person who simply wants a working Kaspa node on a home computer, the better starting point is Rusty Kaspa. It is the implementation the project now points to, and it avoids building your setup around software that is no longer the main line of development.
Key features
Full Kaspa node
Written in Go
Open source under ISC
Supported coins
Kaspad is documented for the Kaspa network, which uses the KAS token. It is a node for that network only, so it does not connect to other blockchains.
How to install Kaspad on Windows
- 1
Get the file from an official source
Download only from the official website or the project's GitHub Releases page at github.com/kaspanet/kaspad. Avoid mirrors, file-sharing sites, and links posted in chat groups, because a modified build can look identical to the original.
- 2
Verify the download
Compare the SHA-256 checksum of the file with the value published on the release page. If the project provides a signature, check that as well. Do not run a file whose checksum does not match.
-
Install and start the program
Extract or install the package into a folder you control, then start it from a terminal so you can read its output. Allow it time to connect to peers and begin synchronizing with the network before you judge its behavior.
How to use Kaspad
Kaspad is run from a command line, so it suits people who are comfortable with terminals. The steps below describe a general workflow for a node. Check the project's documentation for the exact options that match the release you installed.
- Open a terminal in the folder where you placed the program.
- Start the node and leave the window open so you can read the log output.
- Wait while the node connects to peers and downloads the chain. Initial synchronization can take a long time and depends on your connection and disk speed.
- Confirm that the node reports peer connections and progress in its log before relying on it.
- Use the documentation to query the node through its interface when you need data from your own copy of the chain.
- Stop the node cleanly when you are done, so its database is closed properly.
Pros & cons
- Free to download and use
- Open source under the permissive ISC license
- Runs a full node that validates the chain independently
- Go codebase is readable for developers familiar with the language
- Useful as a reference when comparing Kaspa node implementations
- Deprecated, so it is not the recommended choice for new setups
- The Rust reference implementation is where current development is focused
- Synchronization takes time and disk space
- Command-line use is required, which may not suit beginners
- Windows builds should be confirmed on the releases page before installing
Is Kaspad safe?
Kaspad is deprecated, so treat it with extra caution. Download it only from the official project site or the GitHub Releases page, and verify the SHA-256 checksum or signature before running the file. Be aware that a node does not need your seed phrase, so never enter one on a third-party website or into a program that asks for it. Because the project is no longer actively developed, older builds may miss later network changes and security fixes. For the most current build, check the latest version on the official website. If you are choosing software for production use, Rusty Kaspa is the safer direction.
- Official source only. Download from github.com/kaspanet/kaspad. 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
The most important difference is maintenance status. Rusty Kaspa is the full node implementation the project now treats as the reference, while Kaspad is the older Go version that has been deprecated. If you need a node that will keep pace with Kaspa, the Rust client is the better fit.
Both programs aim to run a full node, so the day-to-day workflow is similar: start the program, wait for synchronization, and keep it connected. The difference lies in which codebase receives ongoing work. Other node entries in the catalog, such as Bitcoin Core, Geth, Aptos, and TON, serve different networks and should be compared on that basis rather than against Kaspad directly.
Specifications
- Price
- Free
- Type
- Open source
- License
- ISC
- Latest version
- v1.9.15-temp-stability-tests
- Last update
- 5 Jun 2026
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/kaspanet/kaspad
Frequently asked questions
Kaspad is deprecated. The Kaspa full node reference implementation was rewritten in Rust, so the Go version is no longer the main line of development. You can still study or run it, but you should expect limited future updates and plan to move to Rusty Kaspa for new setups.
The project builds for Windows, but availability depends on the current release. Check the GitHub Releases page for a Windows file in the version you want. Download only from that official source and verify the SHA-256 checksum before installing.
Rusty Kaspa is the current full node and command-line wallet for the Kaspa network, and it is the implementation the project now points to. It is the better choice for anyone setting up a node today, since it receives the active development and reference updates.
A node does not ask for a seed phrase, so there is no reason to enter one anywhere. The main risk is running a modified file. Download only from the official website or GitHub Releases, verify the checksum, and remember that an older deprecated build may lack later security fixes.
No. Kaspad is free to download and use. It is released under the ISC license, which allows you to read, change, and share the code. Costs for running a node come from your own hardware, storage space, and internet connection rather than from the software itself.
Synchronization time depends on your connection speed, disk performance, and how many peers you reach. Initial sync can take a long time because the node must download and validate the chain history. Leave it running and check the log to confirm that progress continues.
No. Kaspad is a node for the Kaspa (KAS) network. It is not a general-purpose client for other chains. If you need a node for a different network, look for software built specifically for that blockchain.
Verdict
Kaspad is a free, open source full node for the Kaspa network, written in Go. It is worth a look if you want to study the older codebase, compare implementations, or review how a Kaspa node validates the chain. It is not the right choice for someone who wants a current, actively developed node. For that, the Rust-based Rusty Kaspa is the direction the project recommends.