Narwhal is an open source project for developers and researchers who want to study or run a high-throughput mempool and consensus layer for blockchain networks. It is aimed at engineers building distributed systems, not at everyday crypto users looking for a simple wallet or trading tool.
The project is written mainly in Rust and is released under the Apache 2.0 license. It is tied to the Sui blockchain ecosystem, and its documentation focuses on deploying and benchmarking a small testbed on a single machine. The latest tagged version is v0.1.1, and the last code update dates from October 2022, so treat it as a reference codebase rather than an actively maintained production product.
What Narwhal Does in a Blockchain Stack
In many blockchain designs, the component that collects and shares pending transactions is a bottleneck. Narwhal addresses this by separating transaction dissemination from the ordering decision. Transactions are gathered into a structured graph of batches that many nodes can reference, which lets data move in parallel.
This separation is the main idea readers should take away. Consensus then needs to agree only on a compact set of references rather than on every raw transaction, which is why the design is often discussed in throughput terms.
Who Narwhal Is For
The project suits people who work close to the infrastructure layer:
- Protocol researchers comparing mempool and consensus designs
- Engineers at blockchain teams evaluating throughput under controlled load
- University students learning Byzantine fault tolerant systems through working code
- Developers who want a reproducible benchmark setup before modifying a protocol
If you only want to hold tokens or swap assets, this is not the right tool. A wallet or exchange client will serve you far better.
Key Concepts for Newcomers
Several terms appear repeatedly in the project and related literature. A mempool is the holding area for transactions waiting to be included in a block. Consensus is the process by which nodes agree on a single order of events despite some nodes failing or acting maliciously. A DAG, or directed acyclic graph, is a structure where each batch points to earlier batches without loops.
Understanding these terms makes the benchmark output much easier to read, because throughput and latency numbers only mean something when you know which stage they measure.
Why a Local Benchmark Matters
Running the testbed on one machine does not reproduce the conditions of a geographically distributed network. Latency between real servers, bandwidth limits and hardware differences all change results. The value of a local run is that it confirms the software works and gives you a baseline you can compare against later changes.
Treat any numbers you obtain as relative indicators for your own setup rather than as a claim about production performance.
Key features
Rust Core Protocols
Python Benchmark Scripts
Local Four-Node Testbed
Permissive Apache 2.0 License
Open Source Source Access
Supported coins
The documentation mentions the Sui network as the blockchain context for this project. Narwhal is a component designed for that ecosystem rather than a general wallet supporting many coins.
How to install Narwhal on Windows
- 1
Install Prerequisites
Make sure Python and its package manager are available. You also need Clang, which RocksDB requires during the build, and tmux, which the benchmark uses to run nodes and clients in the background. On Windows, many developers use WSL (Windows Subsystem for Linux) because the scripts assume a Unix-style shell.
- 2
Download the Source Code
Download the official source from the project repository on GitHub, or use the Releases page to pick a tagged version such as v0.1.1. Clone the repository with git so you can later pull updates or check out a specific commit.
- 3
Install Python Dependencies
Navigate into the benchmark folder and install the Python packages listed in the project requirements, including Fabric. Use a virtual environment to keep these packages isolated from other projects on your machine.
-
Run the Local Benchmark
Launch the four-node testbed using the Fabric commands from the documentation. The scripts build the Rust binaries, start the nodes and clients in tmux sessions, and report results when the run finishes. Allow time for the first build, since compiling Rust code takes a while.
System requirements
- Clang, required by the RocksDB dependency
- tmux, used to run nodes and clients in the background
- Python with the packages listed in the benchmark requirements
- Git for cloning the repository
How to use Narwhal
Narwhal is a developer tool, so using it means running its benchmark and reading the output. The workflow below assumes you have completed the installation steps and are working in a Unix-style shell, such as WSL on Windows.
- Open your WSL terminal and move into the cloned repository folder.
- Activate the Python virtual environment where Fabric is installed.
- Start the local benchmark with the Fabric command described in the documentation.
- Wait while the Rust binaries compile and the four nodes start inside tmux.
- Watch the client output to confirm transactions are being submitted.
- Read the summary the script prints at the end of the run, noting throughput and latency figures.
- Attach to tmux sessions if you want to inspect individual node logs for errors.
- Stop the testbed cleanly when finished so background processes do not keep consuming memory.
- Repeat the run with changed parameters, such as the number of transactions, to see how results shift.
Pros & cons
- Open source under the permissive Apache 2.0 license
- Full source code available for inspection and modification
- Clear local benchmark workflow for a four-node testbed
- Useful for learning modern consensus and mempool design
- Core implementation written in Rust
- Last code update was in October 2022, so it may not track recent changes
- Primarily aimed at developers, with no graphical interface
- Requires command-line comfort and a build toolchain
- Local results do not represent real network performance
- Documentation is focused on benchmarking rather than production deployment
Is Narwhal safe?
Because this is source code you build yourself, the main risk is downloading a tampered copy. Always obtain the code from the official GitHub repository or its Releases page, and verify the commit or tag matches what the maintainers published. If checksums or signatures are offered for a release, compare them before building.
Do not run the benchmark with real funds or keys on the same environment, and avoid pasting private keys into any third-party site. Since the project has not seen code updates since 2022, review dependencies and consider running it in an isolated WSL instance or virtual machine.
- Official source only. Download from github.com/MystenLabs/narwhal. 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
Narwhal differs from most programs in this catalog because it is a protocol component rather than an end-user application. Tools such as Geth, Bitcoin Core, Nethermind and Agave are full node clients that connect to live networks and serve ongoing operations. Narwhal instead focuses on the mempool and consensus research layer and is built to be benchmarked in isolation.
If your goal is to run a validator on a live chain, a full node client is the better choice. If your goal is to study or benchmark how transactions are disseminated before ordering, Narwhal is the more specialized option.
Specifications
- Price
- Free
- Type
- Open source
- License
- Apache 2.0
- Latest version
- v0.1.1
- Last update
- 3 Oct 2022
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/MystenLabs/narwhal
Frequently asked questions
No. Narwhal is not a wallet and does not store or manage cryptocurrency for you. It is a research and infrastructure project that implements transaction dissemination and consensus components for developers to study and benchmark. If you need to hold or send tokens, use a dedicated wallet application instead.
The project is built with Rust and Unix-oriented tooling, so the most practical route on Windows is WSL. The documentation indicates builds are possible on Windows, but the benchmark scripts expect a shell environment with tmux. Running inside WSL avoids most compatibility problems.
The code is public and open source, which allows review, but safety depends on where you get it. Download only from the official GitHub repository or its Releases page. Check the tag or commit hash against what the maintainers published before building anything on your machine.
Basic familiarity with the command line and Python is necessary to run the benchmark. You do not need to write Rust to run the testbed. However, understanding the code would require knowledge of Rust and distributed systems concepts.
The most recent code update in the repository is from October 2022, and the latest tagged version is v0.1.1. Treat it as a reference implementation rather than an actively developed product, and check the repository for any newer activity before relying on it.
The duration depends mostly on how long the Rust code takes to compile on your hardware, which can be several minutes the first time. Once built, a benchmark run itself completes in a time determined by the parameters you choose. Subsequent runs are typically faster because the binaries are already compiled.
The Apache 2.0 license permits commercial use, modification and redistribution, provided you retain the license notice and document your changes. Review the license text in the repository and consult a legal professional if you plan to build a product around the code.
Verdict
Narwhal is a focused, open source project for developers, researchers and students who want to examine how a high-throughput transaction dissemination layer works. It is not a consumer app and it is not a substitute for a maintained full node client. If you are comfortable with a command-line workflow under WSL and you value readable Rust code and reproducible benchmarks, it is a worthwhile reference. Anyone planning to depend on it in production should first evaluate its current state carefully.