Chia Blockchain: a Python full node, farmer and wallet you install from source

What the Chia blockchain repository actually ships

This is not a library you import into an application. The pyproject.toml declares a set of console entry points, and each one starts a separate long-running process: chia, chia_daemon, chia_wallet, chia_full_node, chia_harvester, chia_farmer, chia_introducer, chia_crawler, chia_seeder, chia_timelord, chia_timelord_launcher, chia_full_node_simulator, chia_data_layer, chia_data_layer_http, chia_data_layer_s3_plugin and chia_solver. A working farm is a set of these processes talking to each other, not a single binary.

The README is explicit about who should run what. Most users should only install harvesters, farmers, plotter, full nodes, and wallets. Running a seeder is described as best left to more advanced users, and building Timelords and VDFs is described as work for sophisticated users in most environments, with the note that Chia Network and additional volunteers already run sufficient Timelords for consensus. That last sentence matters: the consensus role most people assume they must run is the one the project says you can skip.

The project describes itself as a modern cryptocurrency built from scratch, with proof of space and time consensus that lets anyone farm with commodity hardware, a Lisp-style Turing-complete functional language called Chialisp for money-related use cases, BLS keys with aggregate signatures so a block carries one signature, and a pooling protocol that leaves block production under the farmer's control. Python 3.10 or newer is required, and the README tells you to confirm it with python3 before you start.

How the node, farmer, harvester and wallet fit together

The architecture is visible in the entry points and the repository layout. chia_daemon is the process manager: the other services are started and supervised through it, which is why the GUI and the chia CLI can both control a running farm. chia_full_node syncs and validates the chain. chia_farmer talks to the full node and to one or more chia_harvester processes, which hold the plots and answer challenges. chia_wallet manages keys and coins. chia_timelord and the VDF components sit at the consensus layer, and chia_seeder plus chia_crawler maintain the node list the network uses to find peers.

The consensus design is proof of space and time, and the README frames the practical consequence directly: anyone can farm with commodity hardware. That is the whole point of the design. Instead of bidding hardware and electricity against other miners, a farmer commits disk space to plots and the chain uses VDFs to order blocks in time. The transaction model is a simplified UTXO model with small on-chain state, and Chialisp is the language for the conditions attached to coins.

The repository is a Python monorepo with a separate chia-blockchain-gui submodule, which is why install-gui.sh and start-gui.sh sit next to install.sh at the top level. The pyproject.toml also points at a supplemental package index at https://pypi.chia.net/simple/, so some dependencies resolve from Chia's own index rather than only from PyPI. If you are auditing what you install, that is the line to look at first.

Installing Chia blockchain and starting a first node

The README does not contain install commands. It says install instructions are available in the Installation Details section of the Chia Docs, and links there. What the repository does provide is the scripts themselves, so the honest answer to how to install Chia blockchain is: follow the docs, or read the scripts in the repo root.

The repository carries install.sh, install-gui.sh, install-plotter.sh and install-timelord.sh for Unix-like systems, and Install.ps1, Install-gui.ps1, Install-plotter.ps1 and Setup-poetry.ps1 for Windows. The naming is deliberate: the plotter and timelord installers are separate from the main one, matching the README's advice that most people do not need a timelord. Before running any of them, confirm the interpreter version, because the project requires Python 3.10 or newer and the metadata pins it to >=3.10, <4. The README's own check is to make sure your default python version is >=3.10 by typing python3.

On a Unix-like system, the main installer is a shell script in the repository root:

./install.sh

The README does not describe what this script prints on success, so the thing to verify afterwards is the CLI entry point that pyproject.toml declares as chia = "chia.cmds.chia:main". From there the README points at the Intro to Chia guide in the Chia Docs for running the node, which is where the actual start, sync and wallet steps live. The README's one concrete networking instruction is worth applying before you sync: if you are behind a NAT, peers outside your subnet may not reach you at startup, so enable UPnP on your router or add a NAT rule and firewall rule for TCP port 8444 (IPv4 only, not IPv6). Those rules are router make and model specific.

Where the install path and the docs stop short

The README is a signpost, not a manual. It contains no install commands, no configuration file format, no description of the config directory, and no rollback procedure. It tells you that instructions live in the Chia Docs and that an Intro to Chia guide exists there. If your adoption decision depends on knowing exactly which files an upgrade touches or how to revert, this repository's README will not answer that, and the CHANGELOG.md is the only release-level record it links.

The networking section is similarly thin. The README says NAT traversal is difficult, suggests UPnP or a manual rule for TCP port 8444, and notes that these methods tend to be router make and model specific. There is no troubleshooting path for a node that stays at zero peers. For a project whose value depends on peer connectivity, that is a real gap, and it is the first thing to plan for if you run a node on a network you do not control.

The Python version floor is a second hard boundary. requires-python is ">=3.10, <4", so a system Python from an older long-term-support distribution will not satisfy it. The repository ships Setup-poetry.ps1, setup-poetry.sh and requirements-poetry.txt, which tells you the dependency resolution path goes through Poetry, but the README does not walk through it. Expect to read the install scripts if the documented flow fails on your platform.

Chia compared with Bitcoin Core for an operator

The README states the difference plainly: Chia uses proof of space and time consensus instead of proof of work, which allows anyone to farm with commodity hardware. Bitcoin Core, by contrast, is a full node implementation for a proof-of-work chain where block production is a separate industrial activity. If you want to participate in consensus rather than just verify it, that distinction decides the choice: on Chia the README says commodity hardware is enough, on a proof-of-work chain it is not.

The second difference is the scripting layer. Chia's README describes a Lisp-style Turing-complete functional programming language for money related use cases, and the repository exposes chia_solver = "chia.solver.start_solver:main" as a separate entry point for it. Bitcoin's script is deliberately not Turing-complete, which is a design position, not an oversight. If your application needs general computation attached to coins, Chia's model is the one that allows it; if you prefer a deliberately constrained script, the opposite holds.

A third difference is operational scope. This repository bundles the full node, farmer, harvester, timelord, wallet, seeder, crawler and a data layer server in one tree, with a GUI submodule alongside. Bitcoin Core ships a node and wallet, and leaves the rest of the stack to other projects. That breadth is convenient for a farmer and more surface area to keep patched for anyone running several roles.

Maintenance, release cadence and the Apache-2.0 licence

The last push to the default branch was on 2026-09-21, and the most recent release is 2.7.4, published on 2026-09-10, preceded by 2.7.4-rc4 on 2026-09-09 and 2.7.4-rc3 on 2026-09-08. The release candidates landing days before the final tag indicate a short stabilisation window rather than a long soak, which is normal for this project but worth knowing if you schedule upgrades around releases.

The repository also carries LEGACY-SUPPORT-POLICY.md, which is the file to read before assuming an old client keeps working. The README does not summarise that policy, so treat it as required reading rather than optional. Upgrading means re-running the install path for your platform and restarting the daemon-managed services; because the README documents no rollback, keep the previous release artifacts and your configuration and database directories before you upgrade a node you care about.

The licence is Apache-2.0, declared in both LICENSE and pyproject.toml. That is a permissive licence with an explicit patent grant, which matters for a network client that may touch BLS signatures and VDF code. It is not a legal opinion, and the repository contains no separate licensing FAQ, so if you redistribute a modified node, read LICENSE rather than this article.

The install scripts are Windows PowerShell and POSIX shell, and the GUI is a separate submodule, so a headless server and a desktop farmer take different paths through the same tree.

Editorial conclusion

Adopt it if you want the reference implementation of the Chia protocol in Python: a full node, farmer, harvester and wallet that you can read, patch and run yourself. Do not adopt it if you want a hosted service or a one-line Docker image; the install path is the Chia Docs installation section plus the install scripts in the repository, and the README does not document rollback for a bad upgrade. Verify first that your Python is 3.10 or newer, that TCP port 8444 is reachable or UPnP is enabled on your router, and that you know which component you actually need, because the README says most users should install only harvesters, farmers, plotters, full nodes and wallets.

Frequently asked questions

Official sources

1. Chia-Network/chia-blockchain on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases