Clarinet is a free, open-source command-line tool for developers who write smart contracts in the Clarity language. It packages a Clarity runtime, a read-eval-print loop (REPL) and a testing harness into one program, so you can write, check and debug contracts on your own machine. It suits smart contract developers, reviewers who want to read Clarity code closely, and teams that need repeatable tests before anything is deployed.
The main idea is speed. Instead of pushing every draft to a public network to see what happens, you run the contract against a local devnet or a testnet, iterate quickly, and only then move on. The current release is 3.23.2, and the Windows build is available through winget, so setup takes a single command in a terminal. Because project setup, testing and editor support live in one toolchain, the whole development loop stays in one place.
What Is Clarity and Why It Needs Dedicated Tooling
Clarity is a smart contract language designed to be read and reasoned about before it runs. Its code is intentionally direct, which makes contracts easier to review, but it also means developers need tools that match the language's rules rather than general-purpose compilers alone.
Clarinet fills that gap. It runs Clarity code in a runtime that behaves the way the language expects, so a test result reflects how the contract will actually execute. For anyone used to other smart contract ecosystems, this is the main shift: you check behavior against Clarity's own semantics from the start.
Real-World Scenarios for Clarinet
Consider a developer writing a simple token contract with transfer and balance functions. Using the REPL, they call transfer with a few amounts and confirm the balances change as expected. Then they turn those checks into unit tests so the same behavior is verified every time they edit the code.
Another common case is revising a contract that is already in use. Before changing a function, a developer can write tests that capture the current behavior, make the edit, and see exactly which expectations break. This keeps unintended changes out of the next deployment and gives reviewers a clear record of what the contract is supposed to do.
How the Local Development Loop Works
Clarinet is built around a loop: write code, check it interactively, test it, then deploy to a local devnet or testnet. The REPL is best for quick experiments, such as trying a function with unusual inputs. The testing harness is better for checks you want to repeat automatically.
A local devnet lets you deploy and interact with a contract without waiting on a public network. Moving to a testnet is the next step, when you want to confirm that the contract behaves the same in a more realistic environment. Keeping these stages separate makes it easier to find the source of a problem.
Key features
Command-line project management
Unit tests in JavaScript or TypeScript
Editor support for VS Code
How to install Clarinet on Windows
PS> winget install HiroSystems.Clarinet- 1
Check that winget is available
Open Windows Terminal or PowerShell and run winget --version. If a version number appears, you can install Clarinet with a single command.
- 2
Install Clarinet with winget
Run winget install HiroSystems.Clarinet and let the installer finish. This installs the ready-made program, so you do not need a compiler or build tools on your machine.
- 3
Install manually if you prefer
If you would rather not use winget, download only from the official website at hiro.so or from the Releases page of the official GitHub repository. Verify the file's SHA-256 checksum or signature before running the installer.
-
Confirm the installation
Close and reopen your terminal, then run clarinet --version. The output should show a version number, such as 3.23.2 or a newer release.
How to use Clarinet
Once Clarinet is installed, a typical session moves from a new project to a passing test run. The steps below assume you work in a terminal and use VS Code for editing.
- Create a project folder with the Clarinet CLI, then open it in your editor.
- Write or edit a Clarity contract in the project's contracts folder.
- Open the REPL and call your functions with a few inputs to check the return values.
- Write unit tests in JavaScript or TypeScript using the Clarinet SDK, then run them from the terminal.
- Use the VS Code extension to read lint messages and step through any test that fails.
- When the contract passes locally, deploy it to a local devnet or testnet. Repeat the cycle whenever you change the code.
Pros & cons
- Free and open source under GPL-3.0
- Installs with one winget command
- REPL and testing harness in a single tool
- Unit tests can be written in JavaScript or TypeScript
- VS Code extension adds linting and step-by-step debugging
- Scriptable command-line interface for repeatable workflows
- Command-line first, with no graphical interface
- Only useful if you write Clarity contracts
- Step-by-step debugging depends on the VS Code extension
- SDK tests require comfort with JavaScript or TypeScript
Is Clarinet safe?
Clarinet is a developer tool, so the main risk comes from where you get the file. Download it only from the official website or the official GitHub Releases page, and verify the SHA-256 checksum or signature before running the installer. Because the project is open source under GPL-3.0, you can also review the source code on GitHub.
Keep private keys for real accounts out of project folders, especially if you commit your code to a shared repository. Test configurations should use placeholder values rather than credentials you use elsewhere. Also check the latest version on the official website before installing, so you have the current release.
- Official source only. Download from www.hiro.so. 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
Clarinet is designed specifically for Clarity, so it is narrower in scope than the tools below. Remix Desktop is an IDE for Solidity, which suits developers working on Ethereum-style contracts. Foundry is a Solidity toolkit built around forge, cast and anvil, with a command-line focus similar to Clarinet's.
Visual Studio Code with Solidity is an editor setup rather than a testing environment. Tenderly CLI focuses on debugging and monitoring contracts after they are deployed. Clarinet's distinct strength is the combination of a Clarity REPL, a testing harness and a VS Code extension in one program. If your project uses Solidity or Solana, a different tool from this list will likely fit better.
Specifications
- Price
- Free
- Type
- Open source
- License
- GPL-3.0
- Latest version
- 3.23.2
- Last update
- 30 Oct 2026
- Windows support
- Yes (available via winget)
- Official site
- www.hiro.so
- Source code
- github.com/hirosystems/clarinet
- Install command
- winget install HiroSystems.Clarinet
Frequently asked questions
Yes, Clarinet is free and open source under the GPL-3.0 license. You can install the Windows version with winget using the command winget install HiroSystems.Clarinet. The license lets you read, modify and share the source code, provided you follow its terms.
Open a terminal and run winget install HiroSystems.Clarinet. The installer sets up the ready-made program, so you do not need to build anything yourself. Once it finishes, open a new terminal window and run clarinet --version to confirm that the command is available.
Clarinet is a developer tool, and its safety depends mainly on where you download it. Use the official website or the official GitHub Releases page, then verify the checksum or signature before you run the installer. Because the code is open source, the community can review it, which adds another layer of transparency.
No. Rust is used to build the program, but the ready-made Windows install does not need Rust on your computer. You only need the Clarinet installation itself to run the CLI, the REPL and the test harness. Developers who want to modify the source code would need a Rust toolchain for that separate task.
The REPL is an interactive prompt where you call contract functions one at a time and see the results immediately. It is useful for exploration and quick checks. Tests are scripts, written with the Clarinet SDK, that verify behavior automatically and can be rerun after every change.
Yes, the VS Code extension adds step-by-step debugging for Clarity code. You can move through a contract's execution and inspect how values change at each step. This helps you find the exact point where a result differs from what you expected, which is faster than guessing from output alone.
No. Clarity is the smart contract language, and Clarinet is the tooling that helps you write, test and deploy code written in it. You need to know some Clarity to use Clarinet effectively, but Clarinet itself is a separate program with its own CLI, REPL and testing harness.
Verdict
Clarinet is a strong choice for developers who write Clarity smart contracts on Windows and want a free, open-source toolchain. It covers the core loop of writing, testing and deploying locally, and the VS Code extension makes debugging much easier. It is less suitable if you prefer graphical tools or work mainly with Solidity or Solana, where the alternatives listed above are a better match. For Clarity work, it is the natural starting point.