canopy-network/canopy

★ 11,600GoAudience · developerComplexity · 4/5Setup · hard

Mindmap

mindmap
  root((canopy))
    What it does
      Blockchain protocol
      Recursive chain launch
      BFT consensus
    Core Modules
      Controller
      State machine
      P2P networking
      Persistence
    Use Cases
      Run a node
      Local devnet
      Protocol dev
    Status
      Betanet live
      Mainnet pending

mindmap root((canopy)) What it does Blockchain protocol Recursive chain launch BFT consensus Core Modules Controller State machine P2P networking Persistence Use Cases Run a node Local devnet Protocol dev Status Betanet live Mainnet pending

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Run a Canopy Network node to participate in the live Betanet and test the recursive chain architecture.

USE CASE 2

Spin up a local multi-node test network using Docker Compose to develop or test blockchain applications.

USE CASE 3

Contribute to consensus, state machine, or peer-to-peer networking modules in Go as the project approaches mainnet.

Tech stack

GoDocker

Getting it running

Difficulty · hard Time to first run · 1day+

Requires building a Go binary or running Docker Compose, project is in Betanet with mainnet milestones still in progress.

In plain English

Canopy is the official Go implementation of the Canopy Network Protocol, a blockchain system designed around a recursive model where new chains can bootstrap themselves into existence using other chains as a foundation. The idea is that each chain in the network can help secure and launch additional chains, creating a growing web of interconnected blockchains that do not depend on any central authority. The codebase is organized into five core modules. The Controller acts as a central coordinator that connects all the other parts together. The Finite State Machine handles the rules for how transactions change the blockchain's stored data from one block to the next, deciding what counts as valid. The Byzantine Fault Tolerant consensus module lets nodes in the network agree on new blocks even when some participants are unreliable or acting dishonestly. The peer-to-peer networking layer handles encrypted communication between nodes directly, without a central server. Finally, the persistence module manages storage: saving the current state, indexing past transactions, and making sure data can be verified quickly. The project is currently in Betanet, meaning it is live and testable but not yet at full mainnet release. A road-to-mainnet document on the project's website tracks the remaining milestones. Running the software requires either building the Go binary directly with a make command, or spinning up a local test network using Docker Compose. The repository includes unit tests runnable with Go's standard testing tools. Contributions are welcome. The project asks that large or architectural changes be discussed on their Discord server first, and that all code follow standard Go formatting conventions. Pull requests should be submitted against the development branch rather than main.

Copy-paste prompts

Prompt 1

Show me how to build the Canopy Network binary from source using make, then connect it to the Betanet as a full node.

Prompt 2

I want to spin up a 4-node local Canopy devnet using Docker Compose. What configuration does the compose file need and what commands start and stop it?

Prompt 3

Explain how Canopy's Byzantine Fault Tolerant consensus module reaches agreement on a new block when some nodes are offline or behaving incorrectly.

Prompt 4

How does the Canopy persistence module store blockchain state and index past transactions? What does the data layout look like on disk?

Open on GitHub → Explain another repo

← canopy-network on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.