A development and testing framework that supports the creation and use of Ethereum smart contracts; built by a community (Open Source) for the creation and testing of smart contracts written in Solidity or Vyper. Documentation is provided through ReadTheDocs.
As of this release, Brownie is being provided as a Python-based Ethereum smart contract development framework.
There are many Ethereum development tutorials and guides that utilize Brownie.
As of this release, Brownie has achieved production-ready status and includes a comprehensive set of features.
Local Ganache CLI or remote Ethereum nodes
Based on official documentation and development tutorials
| Service | Cost | Details | Source |
|---|---|---|---|
| Core Framework | $0 | Open-source Python framework for Ethereum smart contract development, testing, and deployment | — |
| Feature | Brownie | Hardhat | Truffle | Foundry |
|---|---|---|---|---|
| Core Functionality | Smart contract dev/testing/deployment | Full-stack Ethereum dev | Smart contract testing | Fast Rust-based testing |
| Language | Python | TypeScript/JavaScript | JavaScript | Rust |
| Pricing | Free (open source) | Free (open source) | Free (open source) | Free (open source) |
| Free Tier | Yes (complete product) | Yes | Yes | Yes |
| Testing Framework | Pytest integration | Mocha/Chai | Truffle Asserts | Forge test |
| Debugging Tools | Python tracebacks, console | Hardhat Network | Truffle Debugger | Forge debugger |
| Contract Languages | Solidity, Vyper | Solidity | Solidity | Solidity |
| API Availability | Web3.py integration | Ethers.js | Web3.js | Cast/Forge |
| Support Options | Community/GitHub | Community | Community | Community |
| Deployment Scripts | Python scripts | JavaScript tasks | JavaScript migrations | Forge scripts |
Brownie is targeted toward Python users, while Hardhat is targeted toward users of JavaScript/TypeScript — although Brownie can provide superior debugging capabilities through use of Python traceback, Hardhat can offer a broader plugin ecosystem and larger user base.
Use Brownie if you have a preference for Python and testing; otherwise, choose Hardhat if you need to integrate into your JS ecosystem.
Both are mature frameworks; however, Brownie is the newer of the two and integrates pytest (unit testing) — whereas, Truffle uses an older JavaScript testing mechanism that Brownie’s pytest provides superior functionality to, as far as unit testing goes.
Choose Brownie if you want to develop using a modern Python framework; otherwise, choose Truffle if you have existing legacy JS projects.
Foundry will be able to provide superior performance compared to Brownie — due to Rust; however, Brownie will still be able to provide Python-familiarity to developers — which may be beneficial when attempting to automate complex scripts or fuzzing test cases.
If you are developing with speed-critical testing in mind, choose Foundry — otherwise, choose Brownie if you have Python scripting needs.
Brownie is a Python-based development framework for Ethereum smart contracts. Brownie provides tools for writing tests using pytest, debugging through detailed traceback information, and for performing console interactions and automating deployments to EVM networks.
You may install by using pip: `pip install eth-brownie` You will need Python 3.8+ installed as well as Node.js (Ganache CLI). You may initialize projects using `brownie init`, or create them from templates using `brownie bake token`
Brownie supports both Solidity and Vyper smart contracts. It uses the solc and vyper compilers with available optimization options.
Your tests should be written in the `tests/` directory and follow the pytest format. Run tests using `brownie test` to see what portion of the codebase was covered during testing and `brownie test --coverage` for more detailed reporting.
Deployment scripts should be written in `scripts/` and you may execute them locally using `brownie run script_name` or interactively in the console using `ContractName.deploy(args, {'from': account})`. Supports mainnet, testnets and local Ganache.
Python/pytest (which is more familiar to data scientists), whereas Hardhat's JavaScript. Brownie excels at testing/debugging with Python tracebacks and Hardhat has a much larger set of frontend tooling.
Completely free and open-source. No pricing tiers - MIT licensed on GitHub. Only costs related to blockchain gas fees.
Yes, it supports any EVM compatible chain (Polygon, BSC, Avalanche, etc.), via RPC endpoints. Configure in `brownie-config.json`.
Brownie is a mature Python framework used for developing and testing Ethereum smart contracts. It has features such as testing and debugging capabilities, including a feature called Traceback for developers who like using Python instead of JavaScript for their smart contract tooling. Although it is an open source product, there is no commercial support provided by the company. However, because it is an open source product, there are many users supporting it through the community.
Brownie is the top choice among serious EVM smart contract developers and testers for python based applications.
Brownie is a mature, open-source python framework used for EVM smart contract development, testing and deployment. The focus is on PyTest testing, detailed debugging and integration with Ganache. There is no commercial support available, but there is good documentation and a large and active user base.
Good - comprehensive official documentation and GitHub repository. Limited commercial information as open-source project.
The integration of the pytest framework.
Property-based testing using Hypothesis.
Support for stateful testing.
Ability to fork a network.
Ability to analyze the gas used in transactions.
Ability to evaluate the trace-based coverage of your tests.
Support for snapshots of states.
Support for executing pytest tests in parallel.
Python style tracebacks.
Customizable error messages.
Debugging support for transactions using debug_traceTransaction.
Inspection of ContractContainers.
Deeply detailed debugging of transactions.
Capture and decode events.
The ability to debug using the console of Brownie.
Deployment of contracts through scripts.
Tracking migrations using scripts.
Verification of contracts using Etherscan.
Implementation of proxies by hand.
Networks can be customized.
Estimating pre-deployment times.
CREATE2 support through scripts
