Build federated computing applications that collaborate across organizational and geographic boundaries while each site keeps control of its data and local execution.

Website | NVIDIA FLARE Developer Site | Documentation | Quick Start | Examples | Discussions

Paper | Blogs | Talks & Papers | Webinars | Research

NVIDIA FLARE™ (NVIDIA Federated Learning Application Runtime Environment) is a domain-agnostic, open-source, extensible Python SDK for federated learning and other federated-computing applications. It coordinates approved local computation and exchanges application-defined results across independently controlled sites, while each site retains its source datasets and controls what results may leave.

Start with a small federated-learning example on your computer. Then adapt your training code or explore statistics, custom workflows, and deployment options.

In this federated-learning workflow, the server sends a model to participating clients. Each client trains the model on its local data and returns model updates, keeping its source dataset local. The server aggregates the updates into a global model and repeats the process across training rounds.

The example below runs this workflow on your computer, with two simulated clients and a server.

Create and activate a fresh Python virtual environment as described in the installation guide, then choose one installation:

Released package, once NVFLARE 2.10.0 or later is available on PyPI:

python -m pip install "nvflare>=2.10.0"

Development version from main, including before the 2.10.0 release:

python -m pip install "git+https://github.com/NVIDIA/NVFlare.git@main"

The development option requires Git; pip manages a temporary checkout. main is the unstable development branch. Use a separate virtual environment for each installation. If you use an earlier stable release, follow its version of the Quick Start; the nvflare examples command was introduced in 2.10.0.

After either installation, retrieve the matching Hello PyTorch example, install its dependencies, and run it:

nvflare examples get hello-pt
cd hello-pt
python -m pip install -r requirements.txt
python job.py --log_config progress

This runs a two-client simulation on CPU using synthetic data; no dataset download is required. For other examples, retrieve a revision-matched copy with nvflare examples get. Add the extras the example's README names, such as HE, to the same NVFLARE installation, install its requirements.txt, then follow its README. If an older requirements.txt still has a line that installs nvflare or nvflare-nightly, skip it so the installed NVFLARE version is preserved.

The installed NVFLARE version selects the example version: nvflare examples get downloads the example from the source revision recorded in your installation. To reproduce a released version, pin that version when installing it. For download failures and GitHub rate limits, see the examples CLI guide.

Continue with the Quick Start for main to understand the run and inspect its results. If you use a released package, select its version in the documentation and follow the matching example README for dependencies, commands, and troubleshooting. The nvflare examples command requires NVFLARE 2.10.0 or later, or a development installation from main.

Start with the guide for the concept and supported workflow, then use a maintained example as the runnable reference.

Use the NVIDIA FLARE website to discover tutorials, examples, research, webinars, and events. The documentation provides the authoritative guides. After installing NVFLARE 2.10.0 or later, or the development version from main, nvflare examples list shows the curated catalog and nvflare examples get <name> retrieves an example matched to that installation's source revision. Each example README then owns its exact setup and run steps.

Federated learning lets sites collaboratively train or evaluate models on their local data. Training and evaluation happen where the data resides; the underlying training examples are not exchanged between sites or sent to a central server. This can enable collaboration where privacy, regulation, data sovereignty, intellectual property, data ownership, or the cost of moving data makes central collection impractical. Federated learning is one application of the broader federated computing paradigm.

Federated computing brings approved computation to data distributed across multiple parties or locations. In addition to model training and evaluation, it supports analytics, statistics, site-local data processing, and custom multi-site computation. Participating sites run tasks locally and share only outputs permitted by the collaboration.

NVIDIA FLARE builds its federated-learning capabilities on top of a general federated-computing core. That core provides workflow orchestration, task execution, communication, security, and lifecycle services shared by training, evaluation, analytics, statistics, and custom distributed applications.

A job packages the application logic and configuration. A workflow coordinates tasks across participating sites. Each site executes its task against local resources, and policies determine what can run and what may leave the site. Depending on the application, the shared result can be an aggregate model, evaluation, statistic, intersection, or another collaboration artifact.

NVIDIA FLARE also supports decentralized and client-controlled workflows, as well as federated computing applications whose shared result is a statistic, evaluation, intersection, or another permitted application result rather than a model.

Keep data at its source. NVIDIA FLARE moves approved computation to participating sites. In a properly designed and governed federation, raw datasets remain at their source and only outputs permitted by the collaboration and each site's policies leave the site. Application owners and site operators define and enforce those policies for their data and threat model.

FLARE's component and event architecture lets applications replace or extend controllers, aggregators, executors, filters, persistence, communication, and deployment behavior without rewriting the entire system.

The application stays consistent while its execution environment changes:

See the run modes and deployment guide for the differences and operational requirements.

Federated computing is useful when organizations need a shared result but cannot freely pool the source data. NVIDIA FLARE has been applied to:

These references describe particular deployments and studies. The privacy, security, governance, and model-quality properties of a new application still depend on its design, policies, data, and validation.

Independent software vendors (ISVs) and global systems integrators (GSIs) use NVIDIA FLARE to build federated platforms, governed data-collaboration solutions, and customer implementations. Public technical sessions include Rhino Health's federated computing platform, an Apheris and BioNeMo data-collaboration implementation, and Deloitte's FedRAG implementation. Explore these and other ecosystem work in the NVIDIA FLARE webinar series and FLARE Day.

• Read What's New and the talks and publications.
• Ask questions and share ideas in GitHub Discussions.
• Review the contributing guide and open good first issues.
• Cite the NVIDIA FLARE paper when the project supports your work.

NVIDIA FLARE is released under the Apache 2.0 license.