Flow CLI (Dapper Labs)

What Is Flow CLI?

Flow CLI is the official command-line interface for developing applications and interacting with the Flow blockchain.

CLI stands for command-line interface, which means developers control the tool by entering text commands in a terminal instead of clicking buttons in a graphical application.

Flow CLI can initialize blockchain projects, run a local Flow network, test Cadence code, deploy smart contracts, send transactions, execute scripts, manage accounts, generate keys, install contract dependencies, and retrieve blockchain data.

It provides a common development workflow across the local Flow Emulator, Flow Testnet, and Flow Mainnet.

The tool is primarily intended for smart contract developers, decentralized application teams, infrastructure engineers, testers, and other technical users building on Flow.

Flow CLI is not a cryptocurrency, crypto wallet, blockchain node, consumer application, or trading product.

It is developer software that communicates with Flow Access Nodes and local development services.

The official Flow CLI documentation describes it as a tool for managing projects, accounts, contracts, transactions, dependencies, and blockchain queries from one interface.

What Is the Connection Between Flow CLI and Dapper Labs?

Flow was originally designed and developed by Dapper Labs, which is why Flow CLI is sometimes searched for as “Flow CLI Dapper Labs.”

Dapper Labs created Flow to support blockchain applications that could serve large consumer audiences without requiring every application to compete for the same limited processing resources.

The official history of Flow and Cadence identifies Dapper Labs as the original designer and developer of the blockchain.

Flow CLI is now distributed as open-source software through the Onflow organization and forms part of the wider Flow developer ecosystem.

The tool’s official source-code repository is publicly available under the Apache 2.0 license.

Flow CLI should therefore be understood as official Flow network tooling rather than as a private consumer application operated only inside Dapper Labs.

What Is the Latest Flow CLI Version?

As of July 14, 2026, the latest published Flow CLI release is version 2.17.4.

Version 2.17.4 was released on June 4, 2026 and updated the tool to Cadence version 1.10.3.

The release also updated bundled Flow core contract components to versions compatible with Cadence 1.10.3.

Developers can confirm the current release through the official Flow CLI releases page.

Version information can change frequently because the CLI must remain compatible with new Cadence releases, emulator updates, core contracts, network features, and security fixes.

A developer can check the locally installed version by running

in a terminal.

Production teams should use a tested and pinned CLI version in automated build systems rather than automatically changing versions during every deployment.

Why Is Flow CLI Important?

Blockchain development involves more than writing a smart contract file.

A developer must also create accounts, manage keys, resolve contract addresses, submit signed transactions, inspect results, test failure conditions, and deploy code to the correct network.

Flow CLI brings these tasks into one consistent tool.

It reduces the need to manually construct raw requests to Flow Access Nodes for routine development operations.

The CLI also makes commands repeatable, which is valuable for testing, deployment scripts, continuous integration, and team collaboration.

A command saved in a deployment script can be reviewed and executed consistently across several development environments.

This is safer than depending entirely on undocumented manual steps performed through a graphical interface.

How to Install Flow CLI

Flow CLI can be installed on macOS, Windows, and most Linux systems.

Developers should follow the official Flow CLI installation instructions because available binaries and supported operating-system versions can change.

On macOS, a common installation command is

.

A Homebrew installation can normally be updated with

.

Official installation scripts are also provided for supported Linux, macOS, and Windows environments.

A developer should review an installation script before running it with elevated system permissions.

Installing software directly from an unverified website or copied social-media message can expose a computer, private keys, and project files to malicious code.

After installation, the developer should run

and to confirm that the executable works and is available through the system path.

How to Start a Flow Project

The main command for creating a Flow project is

.

This command creates the project structure and generates a central configuration file named

.

Current versions of Flow CLI can offer project scaffolds for different types of applications, including basic Cadence projects and more specialized blockchain workflows.

A scaffold may include directories for smart contracts, transactions, scripts, tests, and project configuration.

The official project initialization guide explains how

creates the files required for a new development environment.

Developers should inspect the generated project instead of assuming that every default setting is appropriate for production.

Network addresses, account aliases, dependencies, signer settings, and deployment targets should all be checked before live transactions are submitted.

What Is flow.json?

is the central configuration file used by Flow CLI.

It describes the networks, accounts, contracts, dependencies, deployment targets, and project paths that the CLI should use.

The official flow.json configuration reference explains the available sections and formats.

The

section defines connections to environments such as the emulator, testnet, and mainnet.

The

section maps readable account names to Flow addresses and signing-key configurations.

The

section maps Cadence contract names to source files and network-specific addresses.

The

section identifies which contracts should be deployed to which accounts on each network.

A well-maintained configuration file allows the same Cadence import to resolve to different addresses on the emulator, testnet, and mainnet.

This prevents developers from hard-coding one network’s contract address into every source file.

Teams should review changes to

through version control because a modified deployment target or account alias can send a transaction to the wrong environment.

Does flow.json Store Private Keys?

Flow CLI supports configurations that contain private-key information, but placing an unencrypted production key directly inside a shared

file is dangerous.

A private key gives its holder the ability to authorize blockchain transactions for the associated Flow account according to the key’s weight and account configuration.

If the configuration file is uploaded to a public repository, an attacker may gain control over contracts, tokens, and administrative capabilities.

Current Flow CLI configuration options include direct hexadecimal keys, external key files, mnemonic-based derivation, and Google Cloud KMS integration.

Using an external key-management system can reduce the need to expose raw signing material to local project files.

Key files, environment-specific configurations, and other secrets should be excluded from public version control.

Developers should also separate emulator keys from testnet and mainnet keys.

The default emulator service key is publicly known and is safe only because the emulator is a local development network containing no real assets.

What Networks Can Flow CLI Use?

Flow CLI can interact with the local Flow Emulator, Flow Testnet, Flow Mainnet, and custom Flow Access Node endpoints.

The emulator is intended for private local development.

Testnet is a public environment used to test applications without using production Flow assets.

Mainnet is the production blockchain where transactions can affect real accounts, deployed contracts, and crypto assets.

Many commands accept a

option that identifies the target environment.

For example, a developer may use

, , or .

Failing to specify or verify the network can cause a deployment or transaction to be sent somewhere other than the developer intended.

Production scripts should make the selected network explicit and should require additional checks before using mainnet signers.

What Is the Flow Emulator?

The Flow Emulator is a lightweight local network that reproduces important Flow blockchain behavior for development and testing.

It is included with Flow CLI and can be started with

.

The official Flow Emulator documentation describes it as a local environment for executing transactions, deploying contracts, and testing applications before using a public network.

Because the emulator runs locally, developers can reset its state, inspect detailed logs, and test failures without spending real cryptocurrency.

The emulator includes a service account that can create accounts, sign transactions, and deploy contracts within the local environment.

Its private key is not suitable for mainnet because it is intentionally public and predictable.

The emulator provides near feature parity with the Flow Access API, but developers should not assume that every production condition can be reproduced perfectly on one computer.

Public-network latency, validator behavior, network congestion, external services, and production account configurations may produce different results.

How Does the Local Development Workflow Work?

A common Flow CLI workflow begins by creating a project with

.

The developer then starts a local blockchain with

.

Cadence contracts are added to the project and mapped in

.

The developer deploys the contracts to emulator accounts and executes test transactions or scripts.

Automated tests can be run with

.

After local tests pass, the project can be deployed to testnet for testing against a shared public network.

Mainnet deployment should happen only after the code, account configuration, signer permissions, dependencies, and deployment plan have been reviewed.

How Does Flow CLI Deploy Smart Contracts?

Flow CLI can deploy Cadence smart contracts to accounts defined in the project configuration.

The project-level deployment command is

.

The official deployment documentation explains that this command reads the contracts and deployment targets from

.

A developer can specify the intended network when deploying.

For example,

deploys the configured project contracts to the local environment.

Changing the network to testnet or mainnet causes the CLI to use the corresponding accounts, aliases, and Access Node configuration.

Smart contract deployment is a blockchain transaction and therefore requires authorization from an account with the appropriate key permissions.

A failed deployment may result from invalid Cadence code, unresolved imports, insufficient account permissions, an incorrect signing key, or a network connection problem.

Mainnet deployment can have permanent consequences, so developers should verify the contract source and account address before signing.

Can Flow CLI Update an Existing Contract?

Flow CLI can submit contract-update transactions for contracts that are already stored in a Flow account.

The update must be authorized by a key with sufficient weight on the account that owns the contract.

Cadence contract updates are subject to language and network rules that protect stored resources and existing application state.

An update can still introduce bugs, break dependent applications, or change expected behavior even when the transaction is technically valid.

Developers should run migration tests and confirm compatibility with existing account data before updating a production contract.

The official Flow contract deployment guidance explains account setup, deployment, and contract-update considerations.

What Is Cadence?

Cadence is a smart contract programming language designed for the Flow blockchain.

It uses resource-oriented programming concepts to represent crypto assets and other values that should not be accidentally copied or lost.

Flow CLI includes the tools required to execute, test, lint, deploy, and interact with Cadence code.

The CLI and Cadence versions must remain compatible because language changes can affect parsing, type checking, execution, and contract behavior.

As of Flow CLI version 2.17.4, the bundled Cadence version is 1.10.3.

Developers can learn about current language behavior through the official Cadence documentation.

What Is the Difference Between a Cadence Script and Transaction?

A Cadence script reads blockchain state without permanently changing it.

A script can retrieve an account balance, read a public contract field, calculate a result, or inspect stored public capabilities.

Scripts do not require transaction authorization because they cannot modify blockchain state.

A Cadence transaction can change blockchain state.

Transactions can transfer crypto assets, create resources, call contract functions, modify account storage, or perform other authorized actions.

A transaction must be signed by the accounts performing its payer, proposer, or authorizer roles.

Flow CLI provides separate command groups for executing scripts and sending transactions.

This distinction is important because submitting a transaction carries authorization, fee, and state-change risks that do not apply in the same way to a read-only script.

How Does Flow CLI Send Transactions?

Flow CLI can build, sign, submit, and retrieve Flow transactions.

A transaction command identifies the Cadence transaction file, arguments, signer configuration, and target network.

The CLI uses account information from

or command-line options to create the required signatures.

After submission, a Flow transaction progresses through several statuses before reaching a final sealed result.

A transaction can fail after submission when its Cadence execution produces an error.

The developer should inspect the transaction result, emitted events, and error messages rather than treating submission as proof of success.

The exact command syntax and available flags are listed in the official Flow CLI command overview.

How Does Flow CLI Manage Accounts?

Flow accounts can contain crypto assets, smart contracts, stored resources, public capabilities, and one or more public keys.

Flow CLI can create accounts, retrieve account details, inspect keys, add or revoke keys, and deploy contracts to authorized accounts.

The account model separates a Flow address from any single public key.

An account can contain several keys with different weights, signature algorithms, hash algorithms, and sequence numbers.

This design supports key rotation, multiple devices, shared control, and other authorization models.

The official Flow account documentation explains how Flow accounts differ from address models in which one key permanently determines one address.

Revoking a compromised key can protect an account only when other valid keys still provide enough authorization weight.

Developers should test key-management procedures before relying on them for high-value production accounts.

How Does Flow CLI Handle Cryptographic Keys?

Flow CLI includes commands for generating and decoding Flow-compatible keys.

It also provides commands for creating and verifying digital signatures.

Key generation must use secure randomness because a predictable private key can be reconstructed by an attacker.

A private key should never be pasted into a public issue, shared terminal recording, chat message, or source-code repository.

Command-line history can also expose secrets when private keys are supplied directly as command arguments.

Production systems should prefer dedicated key files with restricted permissions, hardware-backed storage, or a supported key-management service.

Key backups must be protected because losing every valid key can permanently remove the ability to control the account.

What Is the Flow CLI Dependency Manager?

The Flow CLI Dependency Manager installs and tracks external Cadence contracts used by a project.

Smart contracts frequently depend on standards, interfaces, and implementations deployed elsewhere on the Flow network.

The dependency manager can retrieve contract sources and update project configuration so imports resolve correctly.

The command

displays the dependencies currently recorded in a project.

The command

can install a dependency from a supported network location.

The official dependency-management documentation explains how to install, inspect, and manage contract dependencies.

Developers should review dependency code and addresses rather than assuming that every on-chain contract is safe.

A malicious or incorrectly identified dependency can introduce unauthorized behavior into a decentralized application.

Teams should also consider whether an imported contract can be updated by another account after their application is deployed.

How Does Flow CLI Test Cadence Smart Contracts?

Flow CLI includes the Cadence Testing Framework and runs test files with the

command.

Tests can verify smart contracts, scripts, transactions, emitted events, account changes, and expected failures.

The testing system uses the Flow Emulator underneath the Cadence test environment.

This allows tests to create accounts, deploy contracts, submit transactions, and inspect state without affecting a public blockchain.

The official Cadence testing guide explains both unit and integration testing workflows.

Integration tests are especially valuable because they can reveal problems involving account setup, transaction authorization, imports, capabilities, and resource movement.

A high code-coverage percentage does not prove that a contract is secure because tests may fail to examine the most dangerous assumptions.

Security-critical contracts should also receive manual review, adversarial testing, and an independent audit when appropriate.

What Is Fork Testing in Flow CLI?

Fork testing creates a local development environment that can read state from Flow Mainnet or Testnet while executing changes locally.

It allows developers to test code against real deployed contracts, addresses, and blockchain state without modifying the original public network.

A developer can start a mainnet-based fork with a command such as

.

The official Flow fork-testing guide explains how the local emulator mirrors state from another Flow network.

Fork testing is useful when an application depends on contracts or account data that would be difficult to reproduce manually.

It can also help identify compatibility problems before a production contract update.

A forked environment is not the same as creating a permanent fork of the Flow blockchain.

It is a private testing copy whose local transactions do not change mainnet or testnet.

Developers should still verify the selected block height and network because results may differ when production state changes later.

What Is Flow CLI Linting?

Linting examines source code for possible errors, unsafe patterns, formatting problems, and other issues without deploying the contract.

Flow CLI provides the

command for Cadence projects.

Linting can identify some problems early in the development process and can be added to automated checks.

Current versions support a base-directory option for projects that store Cadence files outside the default location.

A successful lint result does not prove that business logic, access control, economic incentives, or resource-management behavior is correct.

Linting should be used together with testing, code review, and production monitoring.

How Can Flow CLI Query Blockchain Data?

Flow CLI can retrieve accounts, blocks, collections, events, transactions, execution results, and other information exposed through the Flow Access API.

The command

can retrieve a block by identifier, height, or the latest available block.

The command

retrieves information about a Flow account.

Event commands can retrieve events emitted across a selected block range.

Transaction commands can inspect the status and result of a submitted transaction.

These capabilities are useful for development, debugging, monitoring, and simple blockchain investigations.

The CLI is not a complete historical indexer because Access Nodes and specialized indexing services may expose different query capabilities.

A large analytics application will normally require a database, event-processing service, or other dedicated infrastructure in addition to CLI commands.

What Are Flow Interaction Templates?

Flow Interaction Templates provide standardized descriptions of Cadence transactions and scripts.

They are sometimes called FLIX templates.

A template can describe the interaction code, arguments, dependencies, and metadata required for wallets or applications to understand an operation.

Flow CLI includes FLIX commands for executing, generating, and packaging supported interactions.

Templates can improve consistency between application developers, wallets, and smart contracts.

Users must still verify the transaction code and arguments before signing because a template does not eliminate smart contract or wallet risk.

What Are Scheduled Transaction Commands?

Current Flow CLI versions include commands for interacting with Flow scheduled transactions.

Scheduled transactions allow smart contracts to arrange future autonomous execution under the network’s scheduling rules.

Possible crypto use cases include recurring transfers, delayed contract actions, automated financial logic, and time-based application behavior.

The

command can create the manager resource required to manage scheduled transactions for an account.

Additional commands can list, inspect, and cancel supported scheduled transactions.

The official scheduled-transactions documentation explains setup requirements, priorities, and command behavior.

Scheduling a transaction does not guarantee that its economic result will be favorable because asset prices, account balances, contract state, and network conditions may change before execution.

What Is Flowser?

Flowser is a visual explorer that can be used with a local Flow Emulator environment.

Flow CLI includes a command for starting Flowser where the required components are available.

The interface helps developers inspect local accounts, contracts, blocks, transactions, and events without querying every item manually.

Flowser complements the command line but does not replace automated tests or source-code review.

A result displayed in a local explorer applies to the current emulator state and should not be confused with mainnet activity.

What Is the Flow Dev Wallet?

The Flow Dev Wallet is a development tool used to test wallet authorization and application interactions.

Flow CLI can start a development-wallet environment for supported local workflows.

A developer can use it to simulate login, account authorization, transaction approval, and other wallet behavior while building a decentralized application.

The Dev Wallet is not intended to protect valuable production assets.

Production applications must integrate with appropriate user wallets and follow secure authentication and transaction-review practices.

Does Flow CLI Support Flow EVM?

Flow supports both Cadence smart contracts and an Ethereum Virtual Machine environment, but Flow CLI is primarily the official command-line workflow for Flow’s Cadence and Access API development model.

Solidity applications on Flow EVM commonly use EVM-compatible JSON-RPC tools and an EVM Gateway.

The official Flow EVM Gateway documentation explains that EVM clients connect through a gateway implementing the Ethereum JSON-RPC specification.

Cadence applications can also interact with Flow EVM through Cadence Owned Accounts and network contracts.

A developer should choose tools according to whether the application is written in Cadence, Solidity, or combines both execution environments.

Using the Flow CLI name does not mean that every EVM-specific operation is performed through the same command set.

Flow CLI vs. a Flow SDK

Flow CLI is an interactive and scriptable terminal tool.

A Flow software development kit is a programming library imported into application code.

The CLI is useful for local development, project configuration, manual network interaction, testing, and deployment automation.

An SDK is better suited to backend services, application servers, bots, wallets, indexers, and other software that must communicate with Flow while running.

A development team may use Flow CLI to deploy a contract and then use a JavaScript, Go, or mobile SDK to interact with that contract from an application.

The two tool categories complement each other rather than serving as direct replacements.

Flow CLI vs. a Graphical Development Environment

A graphical development environment offers menus, editors, visual account tools, and other point-and-click features.

Flow CLI offers commands that are easier to automate, save in scripts, and reproduce in continuous integration.

A graphical tool may be more approachable for a beginner, while a CLI can provide greater control and transparency for repeatable workflows.

Many developers use both approaches by editing Cadence in an integrated development environment while running Flow CLI commands in an embedded terminal.

The official Cadence extension can provide syntax support and development assistance while Flow CLI handles execution and deployment.

Can Flow CLI Be Used in Continuous Integration?

Flow CLI commands can be included in continuous integration and continuous deployment workflows.

A pipeline may install a pinned CLI version, lint Cadence files, run tests, initialize an emulator, deploy test contracts, and verify expected transactions.

Automated mainnet deployment requires much stronger controls than automated testing.

Private keys should be stored in a secure secret-management system rather than directly in the pipeline file.

Production deployment may require manual approval, signed release artifacts, protected branches, and multiple reviewers.

A pipeline should fail when tests, lint checks, deployment verification, or transaction-result checks do not produce the expected outcome.

Teams should also record which Flow CLI and Cadence versions were used for each release.

Does Flow CLI Collect Usage Data?

Flow CLI currently collects aggregate command-usage counts through Mixpanel by default.

The official documentation states that command argument values and flag values are not collected as part of this usage-count system.

Users can disable the metrics collection with

.

Metrics can be enabled again with

.

The official Flow CLI data-collection page explains what is collected and how to change the setting.

Organizations with privacy, compliance, or isolated-build requirements should review telemetry behavior before installing the CLI in controlled environments.

Flow CLI Security Best Practices

Developers should install Flow CLI only through official documentation or verified release assets.

They should verify the selected network before signing or deploying any transaction.

Mainnet private keys should not be stored as plain text in public project files.

Separate accounts and keys should be used for local development, testing, contract administration, treasury control, and routine application activity.

Production accounts should use appropriate key weights and avoid depending on one unprotected developer laptop.

Contract imports and dependency addresses should be verified for each network.

Transactions should be reviewed for signer roles, arguments, gas limits, and target contracts before submission.

Developers should inspect the sealed transaction result rather than assuming that a submitted transaction succeeded.

CLI versions should be tested before upgrades are introduced into production workflows.

Old or unused account keys should be revoked when a secure replacement authorization path exists.

Seed phrases and private keys should never be entered into websites claiming that they are required to activate Flow CLI.

Common Flow CLI Errors

A connection error may mean that the emulator is not running, the Access Node address is incorrect, the selected port is unavailable, or a network service cannot be reached.

An authorization error may result from an incorrect private key, key index, sequence number, signature algorithm, hash algorithm, or account address.

An import error can occur when a Cadence contract alias is missing or points to the wrong network address.

A deployment error may result from invalid Cadence code, an incompatible language version, missing dependencies, or insufficient account authorization.

A transaction can fail when an argument has the wrong Cadence type or when the account lacks the required resource or capability.

A sequence-number error can occur when several transactions attempt to use the same proposer key at nearly the same time.

Developers should read the complete error output, confirm the active network, and use the command’s

option before changing unrelated project settings.

Common Uses of Flow CLI

Flow CLI can be used to create and configure a new Cadence project.

It can run a local blockchain for smart contract development.

It can create accounts and manage account keys.

It can deploy and update Cadence contracts.

It can execute read-only scripts and signed transactions.

It can install contract dependencies and manage network aliases.

It can run unit tests, integration tests, lint checks, and mainnet-state fork tests.

It can retrieve blocks, transactions, accounts, collections, and events.

It can support automated build and deployment pipelines.

It can also help developers reproduce blockchain operations when investigating application errors.

Limitations of Flow CLI

Flow CLI does not automatically make a smart contract secure.

It cannot prevent a developer from signing a harmful transaction or deploying code to the wrong account.

It does not replace professional auditing, threat modeling, access-control design, or operational monitoring.

The local emulator cannot perfectly reproduce every public-network condition.

The CLI is also not a full wallet interface designed for ordinary consumers.

It does not provide a complete historical analytics database for every Flow transaction.

Developers must still understand Cadence, Flow accounts, transaction roles, capabilities, resource storage, dependencies, and network security.

Frequently Asked Questions

What does Flow CLI mean?

Flow CLI means Flow Command-Line Interface, which is the official terminal-based development tool for the Flow blockchain.

Is Flow CLI made by Dapper Labs?

Flow was originally designed and developed by Dapper Labs, while Flow CLI is now maintained as official open-source Flow ecosystem software through the Onflow organization.

Is Flow CLI a cryptocurrency wallet?

No, Flow CLI is a developer tool, although it can use configured private keys to sign transactions and manage Flow accounts.

What is the latest Flow CLI version?

As of July 14, 2026, the latest official release is Flow CLI version 2.17.4.

Which Cadence version is included with Flow CLI 2.17.4?

Flow CLI version 2.17.4 includes Cadence version 1.10.3.

How do I install Flow CLI on macOS?

A common method is to run

through Homebrew.

How do I check my Flow CLI version?

Run

in a terminal.

How do I create a new Flow project?

Run

and select an appropriate project scaffold.

What is flow.json?

is the main project configuration file defining networks, accounts, contracts, dependencies, and deployment targets.

How do I start the Flow Emulator?

Run

from the terminal.

Does the Flow Emulator use real FLOW?

No, the local emulator uses development state and assets that have no mainnet value.

Can Flow CLI deploy contracts to mainnet?

Yes, Flow CLI can deploy contracts to Flow Mainnet when the correct network, account, key, and deployment configuration are provided.

What command deploys a Flow project?

The standard project deployment command is

, normally combined with an explicit network option.

Can Flow CLI update smart contracts?

Yes, it can submit authorized contract-update transactions subject to Cadence and Flow network rules.

How do I run Cadence tests?

Run

from a configured Flow project.

What is Flow fork testing?

Fork testing runs a local environment against copied mainnet or testnet state without changing the public blockchain.

Does Flow CLI support account creation?

Yes, Flow CLI can create and retrieve Flow accounts and manage their keys.

Can Flow CLI read blockchain data?

Yes, it can retrieve blocks, accounts, transactions, events, collections, and other data available through Flow Access Nodes.

What is the difference between a Flow script and transaction?

A script reads state without changing the blockchain, while a transaction is signed and can modify blockchain state.

Can Flow CLI manage contract dependencies?

Yes, its Dependency Manager can install, list, and track external Cadence contracts used by a project.

Does Flow CLI collect telemetry?

Flow CLI currently collects aggregate command counts by default, and users can disable the feature with

.

Should private keys be stored in flow.json?

Production private keys should not be stored as unencrypted text in a shared or public

file.

Can Flow CLI be used in automated deployments?

Yes, but production deployments should use pinned versions, protected secrets, review controls, and explicit network verification.

Does Flow CLI work with Flow Testnet?

Yes, testnet is one of the standard environments supported through Flow CLI network configuration.

Is Flow CLI used for Solidity development?

Flow CLI mainly supports Cadence and Flow Access API workflows, while Solidity applications on Flow EVM commonly use EVM-compatible JSON-RPC tools.

Is Flow CLI open source?

Yes, Flow CLI source code is publicly available under the Apache 2.0 license.

Can using Flow CLI cause a loss of cryptocurrency?

Yes, incorrect keys, networks, addresses, contract code, or transaction arguments can create irreversible mainnet losses.

Conclusion

Flow CLI is the official command-line development tool for building and interacting with applications on the Flow blockchain.

Its connection to Dapper Labs comes from Dapper Labs’ original design and development of Flow, while the CLI now operates as open-source Flow ecosystem software.

The tool combines project initialization, emulator access, Cadence testing, account management, key operations, contract deployment, dependency management, transaction submission, and blockchain queries.

Its

configuration system allows developers to manage consistent environments across the emulator, testnet, mainnet, and local network forks.

Flow CLI can make blockchain development more repeatable, but it does not remove the risks of insecure keys, faulty contracts, incorrect deployment targets, malicious dependencies, or irreversible transactions.

Developers should use official releases, protect signing credentials, test against several environments, inspect transaction results, and apply strict review controls before deploying to Flow Mainnet.