Reti is an open-source monorepo from the Algorand Foundation that bundles smart contracts, a node daemon and a sample user interface for running an open pooling protocol on the Algorand network. It is aimed at developers, node operators and researchers who want to understand or experiment with how stake can be pooled to share consensus incentives.
The project's goal is to let more participants take part in Algorand consensus rewards by combining small stakes into shared pools. In practice, the repository is a working reference implementation rather than a turnkey desktop wallet, so it rewards readers who are comfortable with a terminal and a local development environment.
What Reti Is and Why Pooling Matters
Consensus on Algorand rewards accounts that participate in securing the network. For a single person with a modest balance, meeting the thresholds for those rewards can be difficult. Pooling addresses this by letting many holders combine stake under one set of rules, so the group can participate as a unit.
Reti is the codebase that explores this idea. It is best understood as a reference for how such a pool can be built: the contracts define the shared rules, the node daemon handles the operational side, and the UI shows the result. Because the project is open source, anyone can read the logic instead of trusting a black box.
Who Reti Is For
The project fits three kinds of readers. Developers building staking or pooling tools on Algorand can use Reti as a starting point and borrow patterns from its contracts. Node operators who already run infrastructure can study how a pool interacts with a validator. Researchers and students interested in proof-of-stake incentive design get a concrete, inspectable implementation.
It is less suited to someone who simply wants to click a button and earn. Expect to read code, install developer tools and tolerate an experimental setup.
How the Local Development Workflow Looks
A typical session follows a short sequence. You move into the reti directory, start the local test network, bootstrap the validator, and then launch the UI. Each step builds on the previous one, so skipping ahead usually produces confusing errors.
Running everything locally means you can stop, reset and repeat without consequences. For many users this is the main value: a sandbox where mistakes cost nothing and the protocol's behavior can be observed step by step before any real stake is involved.
Understanding Consensus Incentives and Staking Pools
In proof-of-stake systems, participants lock value to help validate blocks and receive rewards in return. Solo participation often requires a minimum amount, and rewards are distributed in proportion to the stake contributed. A pool lets several holders share that threshold and split the outcome according to agreed rules.
When reading any pooling design, look for three things: how contributions are recorded, how rewards are calculated and split, and how withdrawals work. Reti's documentation addresses these questions, and working through them in the local environment makes the abstract rules concrete.
Key features
Local test network support
Validator bootstrapping
Example web interface
Single monorepo layout
Documentation-driven design
Supported coins
The documentation references Algorand as the network Reti is built for. The project is focused on that single chain, so readers looking for multi-network support should look at other tools in the catalog.
How to install Reti on Windows
- 1
Install Docker
Docker is required because AlgoKit relies on it to run the local network components. Install Docker Desktop from the official Docker website, start it, and confirm it is running before continuing.
- 2
Install AlgoKit version 2.0 or later
AlgoKit must be version 2.0 or newer. Follow the installation guide in the Algorand developer documentation. After installing, open a terminal and run algokit --version to confirm the installed version.
- 3
Get the Reti source
Download the repository from the official Algorand Foundation GitHub page at https://github.com/algorandfoundation/reti, either by cloning it with Git or by downloading a release archive from the GitHub Releases page. Verify that you are on the official repository before continuing.
- 4
Navigate to the project directory
Open a terminal, change into the reti directory, and confirm the files from the repository are present before running any commands.
- 5
Start the local test network
Run the command that starts the local fnet-compatible test network from the project directory, following the current instructions in the README. Wait until the network reports that it is running.
-
Bootstrap the validator and launch the UI
Run the bootstrap step to set up the validator inside the local environment, then start the example UI using the command given in the README and open the local address it reports in your browser.
System requirements
- Docker installed and running, required for AlgoKit
- AlgoKit version 2.0 or later, verified with algokit --version
- A terminal for running setup and start commands
How to use Reti
Reti is used as a local development environment rather than a single application you open from a Start menu. The workflow below assumes you have completed the installation steps and that Docker and AlgoKit are working.
- Open a terminal and move into the reti directory.
- Start the local fnet-compatible test network and wait for it to finish initializing.
- Bootstrap the validator so the pooled setup has its starting state.
- Launch the example UI and open the address shown in the terminal.
- Explore the interface and read the matching sections of the Gitbook documentation to connect what you see with the protocol rules.
- When finished, stop the UI and the test network so they do not keep consuming resources.
Repeat the sequence whenever you want a clean run. Because everything is local, resetting the environment is safe and is often the quickest way to recover from a misconfigured step.
Pros & cons
- Open source, so the contracts and daemon can be read and audited
- Local test network allows experimentation without real funds
- Single repository keeps contracts, daemon and UI together
- Documentation explains the objectives behind the design
- Free to use and study
- Aimed at developers, not everyday stakers
- Requires Docker and AlgoKit, which adds setup overhead
- Covers a single network, Algorand
- Example UI is for demonstration rather than polished production use
Is Reti safe?
Because Reti deals with staking logic, treat it with care. Download the code only from the official Algorand Foundation repository at GitHub or from its release page, and avoid mirrors or copies from unknown sites. Where releases publish checksums or signatures, verify the SHA-256 hash or signature before running anything. Never enter a seed phrase or private key on a third-party website, and never share it with anyone claiming to support the project. Antivirus tools are not usually a concern for source code you build yourself, but keep your operating system and Docker updated. Keep in mind that development repositories change, so review the latest commit history before relying on any behavior described here.
- Official source only. Download from github.com/algorandfoundation/reti. 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
Reti sits in a different niche from most entries in this category. Algorand Node UI is a terminal tool for managing a remote node, while GO Algorand is the core node software that most operators run. Reti is narrower: it focuses on the pooling protocol and its reference contracts and UI rather than on running a node for its own sake.
Compared with general clients such as Geth or Bitcoin Core, Reti does not aim to validate an entire blockchain on its own. Its value is in the specific pooling design for one network. If your goal is to run a full node, start with GO Algorand or Algorand Windows Node; if your goal is to study or build pooled staking, Reti is the more relevant starting point.
Specifications
- Price
- Free
- Type
- Open source
- License
- —
- Latest version
- v1.5.1
- Last update
- 21 Sept 2026
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/algorandfoundation/reti
Frequently asked questions
Yes. Reti is open source and distributed for free through the official GitHub repository. There is no purchase required to download or study the code. Keep in mind that running it on a live network involves your own stake and any associated risks, which are separate from the software cost.
Reti is built with JavaScript and TypeScript and uses Docker and AlgoKit for its local environment. Windows support is likely, since the project builds for Windows, but you should check the current releases and documentation. Running it with Docker Desktop on Windows is the usual approach.
Yes. The setup instructions rely on AlgoKit, which must be version 2.0 or later. You can verify the installation by running algokit --version in a terminal. Without it, the local test network and bootstrap steps will not run as documented.
The documented workflow focuses on a local test network, which is the safe way to learn the protocol. Using it with real funds means understanding the contracts and their risks in depth. Review the Gitbook documentation and the latest code before committing any value.
A staking pool lets several holders combine their stake so they can meet participation thresholds together. Rewards are then split according to the pool's rules. Reti provides a reference implementation of how those rules can be coded and run.
Download it only from the official Algorand Foundation GitHub repository. Verify checksums or signatures where they are published, and never enter a seed phrase on a third-party site. Review the code and recent changes before running it on any network.
The project points to its Gitbook documentation for detailed protocol information and objectives. Reading that alongside the README and the source code gives the most complete picture of how the pooling rules are meant to work.
Verdict
Reti is a serious, open-source reference for pooled staking on Algorand. It suits developers, node operators and researchers who are comfortable with a terminal and Docker. It is not a one-click tool for casual holders. Start in the local test network, read the documentation, and review the latest code before using it with any real value.