I need a federated learning framework that works on mobile edge devices.

Yes. For mobile edge devices—especially Android/iOS smartphones—I’d recommend Flower as the first framework to evaluate.

Best fit: Flower

Flower is designed to federate existing ML workloads and has explicit support for mobile and embedded clients. Its current documentation includes Android/TensorFlow Lite examples, iOS/Core ML quickstarts, and deployment support for edge devices.

A typical architecture would be:

                 ┌──────────────────────┐
                 │   FL Aggregation     │
                 │       Server         │
                 │  Python + Flower     │
                 └──────────┬───────────┘
                            │
                 Model updates / parameters
             ┌──────────────┼──────────────┐
             │              │              │
       ┌─────▼─────┐  ┌─────▼─────┐  ┌─────▼─────┐
       │ Android   │  │ Android   │  │ iOS /     │
       │ TFLite    │  │ TFLite    │  │ Core ML   │
       │ client    │  │ client    │  │ client    │
       └───────────┘  └───────────┘  └───────────┘
             │              │              │
         Local data     Local data     Local data
         stays local   stays local   stays local

Flower already has an Android example where the server runs in Python while clients run directly on Android, using TensorFlow Lite and FedAvg.

Other options

• FedML — particularly worth considering if your project is research-oriented and you want mobile/edge-specific FL capabilities. FedML has a dedicated mobile project supporting Android and iOS on-device training.
• TensorFlow Federated (TFF) — excellent for developing and experimenting with FL algorithms, but I would not choose it as the primary production mobile deployment framework. Its own FAQ says it currently doesn't provide tools for production deployment on physical mobile phones.

My recommendation

Flower also provides examples for Raspberry Pi and NVIDIA Jetson, so you can build a heterogeneous federation containing phones + edge gateways + traditional servers.

If you tell me whether your devices are Android, iOS, Raspberry Pi/Jetson, or a mixture, and whether you're using PyTorch or TensorFlow, I can recommend a concrete architecture and starter implementation.

When building or deploying federated learning (FL) on mobile edge devices (like Android and iOS smartphones), you need a framework that can handle cross-device orchestration, on-device training constraints (memory, battery, and compute), and lightweight communication protocols.

The top frameworks suited for mobile and edge federated learning include:

• FedML provides FedML-Mobile , a dedicated library explicitly built for cross-device federated learning on Android and iOS. It supports non-IID data distributions on smartphones, offers a flexible backend for production MLOps, and allows local on-device training coupled with server-side aggregation. You can inspect the implementation structure on the FedML GitHub Repository.
• Flower is a highly versatile, framework-agnostic FL platform that supports any machine learning framework (PyTorch, TensorFlow, Scikit-Learn) and extends smoothly to mobile and edge ecosystems. Research and practical deployments demonstrate that Flower can execute on-device training across heterogeneous smartphones and embedded edge hardware efficiently. Check out the documentation and guides on the Flower AI Framework.
• FedKit is an emerging cross-platform framework specifically designed to bridge Python-based backend orchestration with native mobile execution environments on both Android and iOS. It streamlines the pipeline of converting backend models into actionable local training routines on mobile hardware.
• TensorFlow Federated (TFF) is Google's open-source framework for orchestrating computations on decentralized data. While TFF is heavily utilized for simulation and research in Python, its underlying design assumes client-side execution via local TensorFlow runtimes (such as TensorFlow Lite for mobile deployment), making it a powerful conceptual foundation though heavier to set up natively on raw mobile clients compared to Flower or FedML.

To help narrow down the best fit, could you tell me:

• What mobile platforms are you targeting (Android, iOS, or both)?
• What ML framework are you using for your base model (PyTorch, TensorFlow/TLite)?
• Are you looking for a simulation tool or production-ready on-device deployment?

If your target is mobile edge devices (Android/iOS phones, tablets, IoT/embedded devices), I’d shortlist these:

1. Flower — my first choice

• Explicit Android support, including Kotlin/Java + TensorFlow Lite clients.
• Python can run the FL server while training happens directly on Android devices.
• Also has examples for embedded edge devices such as Raspberry Pi.
• Framework-agnostic, so it's a good choice if you expect your model stack to evolve.
• Current docs also indicate Android and iOS SDKs are part of the Flower ecosystem.

2. FedML — best if mobile/IoT is central to the project

• Specifically supports cross-device FL for smartphones and IoT devices.
• Provides an edge SDK approach for Android/iOS and embedded Linux.
• Has broader infrastructure around deployment/MLOps and edge devices.
• FedML's mobile repository includes Android and iOS implementations and on-device training examples.

What I'd choose

For a new project, I'd use Flower + TensorFlow Lite if you want a relatively clean architecture:

                  Cloud / Edge Server
                         │
                 Flower FL Server
                         │
          ┌──────────────┼──────────────┐
          │              │              │
      Android 1       Android 2       iOS / Edge
          │              │              │
       TFLite          TFLite          Core ML
       local           local            local
       data            data             data
       training        training         training
          │              │              │
          └────── model updates ────────┘

Flower already provides an Android example where the server runs in Python and clients run on Android, using TensorFlow Lite and FedAvg.

If your main concern is large-scale smartphone deployment, device management, and production MLOps, I'd investigate FedML first instead. Its architecture explicitly targets cross-device smartphone/IoT FL.

If you tell me Android only vs. Android+iOS, your ML framework (PyTorch/TensorFlow), and whether this is research or production, I can recommend a concrete stack and architecture.

When deploying federated learning (FL) directly on mobile edge devices (smartphones, tablets, and embedded edge hardware), you need a framework that can handle on-device training, memory/battery constraints, and cross-platform communication.

The top frameworks suited for mobile edge federated learning include:

• 1. FedML (by TensorOpera) : One of the most production-ready and comprehensive open-source options for cross-device mobile federated learning. It features FedML-Mobile , supporting Android and iOS with an architecture consisting of a native mobile SDK (Java/JNI) and a lightweight C++ mobile training engine (MobileNN ) that interfaces smoothly with backend aggregation servers.
• 1. Flower (flwr) : A framework known for being model- and training-framework-agnostic (works with PyTorch, TensorFlow, MLX, etc.). While Flower is frequently used for simulations, it provides documented guidelines and community projects for bridging the Flower Android SDK with on-device runtimes like TensorFlow Lite.
• 1. TensorFlow Lite (TFLite) with On-Device Training : While not an end-to-end federated orchestration server by itself, TFLite supports on-device model training and fine-tuning (transfer learning) natively on Android (and increasingly across edge architectures). Many developers build custom orchestrators or pair TFLite with frameworks like Flower or custom gRPC servers to handle the federated aggregation loop.
• 1. IBM FLEdge / Research Frameworks : If your use case is more academic or heavily focused on benchmarking heterogeneous edge computing limits (communication bottlenecks, memory constraints, and variable device power), IBM's specialized edge frameworks and evaluation toolkits offer deep insights into hardware-constrained deployments.

To help narrow down the ideal choice, could you tell me:

• What mobile platforms are you targeting (Android, iOS, or embedded IoT)?
• Which ML library are you writing your base model in (PyTorch, TensorFlow/Keras, etc.)?

Yes. If your target is federated learning directly on mobile/edge devices—Android phones, iPhones, Raspberry Pi, Jetson, or similar—I’d recommend Flower as the first framework to evaluate.

Best options

1. Flower — my recommendation

Flower has explicit Android examples, including an Android client using TensorFlow Lite while the FL server runs in Python.

It also has examples for Raspberry Pi and NVIDIA Jetson, making it particularly suitable if your architecture looks like:

                    ┌───────────────┐
                    │  FL Server    │
                    │ Python/Cloud  │
                    └───────┬───────┘
                            │
             ┌──────────────┼──────────────┐
             │              │              │
          Android        Android        Edge Gateway
          + TFLite       + TFLite       Raspberry Pi
             │              │              │
          Local data     Local data     Local data

Flower's current documentation also includes Android and iOS quickstarts and embedded-device examples.

2. FedML

FedML is another strong choice if you're doing research on heterogeneous mobile/IoT fleets or want more extensive edge-to-cloud infrastructure. Its project explicitly supports cross-device FL for smartphones and IoT devices and has mobile-specific components.

What I'd choose

• Android + TensorFlow Lite: Flower
• Android/iOS + heterogeneous IoT/edge fleet: FedML or Flower
• Researching new FL algorithms primarily in simulation: TensorFlow Federated
• Enterprise cross-silo FL: OpenFL

For a real mobile-edge deployment, I'd start with Flower + TensorFlow Lite. There is already a working Android example in which the phone performs the local training and communicates with a Python FL server.

If you tell me whether your devices are Android, iOS, Raspberry Pi/Jetson, or a mixture, I can recommend the specific architecture and give you a starter implementation.

It also has examples for Raspberry Pi and NVIDIA Jetson, making it particularly suitable if your architecture looks like:

                    ┌───────────────┐
                    │  FL Server    │
                    │ Python/Cloud  │
                    └───────┬───────┘
                            │
             ┌──────────────┼──────────────┐
             │              │              │
          Android        Android        Edge Gateway
          + TFLite       + TFLite       Raspberry Pi
             │              │              │
          Local data     Local data     Local data

Flower's current documentation also includes Android and iOS quickstarts and embedded-device examples.

2. FedML

FedML is another strong choice if you're doing research on heterogeneous mobile/IoT fleets or want more extensive edge-to-cloud infrastructure. Its project explicitly supports cross-device FL for smartphones and IoT devices and has mobile-specific components.

When deploying federated learning (FL) on true mobile edge devices (like Android and iOS smartphones), you need a framework that handles on-device training, low memory overhead, intermittent connectivity, and heterogeneous hardware.

The top frameworks suited for mobile edge federated learning include:

• Flower : Widely considered one of the most versatile and production-ready ecosystems for mobile FL. It is framework-agnostic (works with PyTorch, TensorFlow, MLX, etc.) and provides robust client SDK support for mobile environments like Android and iOS, scaling smoothly from simulation to edge deployment.
• FedML : An open-source, community-driven federated learning library that offers FedML-Mobile , specifically engineered for cross-device FL on Android and iOS smartphones. It is optimized for non-IID data distributions and offers comprehensive MLOps support from the cloud backend to edge clients.
• FedKit : A specialized cross-platform framework designed to seamlessly bridge Python-based backend training with local on-device execution and aggregation across both Android and iOS.
• TensorFlow Federated (TFF) / TensorFlow Lite : Google’s native ecosystem for on-device ML. While TFF is heavily used for research and simulation, actual mobile execution leans on TensorFlow Lite for executing and training lightweight models directly on mobile edge hardware (similar to how Google productionizes Gboard next-word prediction).

To help narrow down the best fit, tell me:

• Are your mobile clients Android, iOS, or both?
• Which ML framework (PyTorch, TensorFlow, etc.) is your base model built in?
• Is this for production deployment or academic research/simulation?

When deploying federated learning (FL) on mobile edge devices (like smartphones or embedded IoT hardware), you need a framework that can handle unstable network conditions, heterogeneous compute capabilities, and mobile-friendly model runtimes (such as TensorFlow Lite or Alibaba MNN).

The top frameworks suited for mobile and edge federated learning include:

1. Flower (flwr)
   • Overview: A highly framework-agnostic, highly extensible open-source FL framework. It lets you write your training code in PyTorch, TensorFlow, or Keras and deploy clients to mobile platforms.
   • Mobile Support: Flower provides an Android client SDK and integration examples using TensorFlow Lite and background execution libraries like Android WorkManager.
   • Best For: Production-leaning research, flexibility across different ML frameworks, and deploying to real-world Android devices. Check out the Flower Documentation.
2. FedScale
   • Overview: Developed to scale and evaluate federated learning systems rigorously, FedScale offers a runtime engine specifically designed for edge and mobile environments.
   • Mobile Support: It features a comprehensive runtime and mobile SDK that natively supports deploying training and evaluation workloads to Android smartphones using backends like TensorFlow Lite and Alibaba MNN.
   • Best For: Large-scale deployments, realistic edge-simulation, and out-of-the-box mobile app integration templates. Explore the repository via FedScale on GitHub.
3. TensorFlow Federated (TFF) & TensorFlow Lite (TFL)
   • Overview: Google’s open-source framework for machine learning and other computations on decentralized data. While core TFF is focused on research and simulation, it bridges to TensorFlow Lite for actual on-device execution.
   • Mobile Support: TFLite enables on-device training and fine-tuning natively on Android and iOS.
   • Best For: Deep integration with the TensorFlow/TFLite ecosystem, especially if your target is strictly Android/iOS native apps. Read more at TensorFlow Federated.

To help narrow down the best choice, tell me:

• Are you targeting Android, iOS, or both?
• What ML framework (PyTorch, TensorFlow, etc.) is your model built in?
• Are you looking for a simulation tool or deploying to physical hardware?

Yes. For federated learning on mobile/edge devices, I’d shortlist these:

My recommendation: Flower

Flower is probably the strongest starting point if your architecture looks like:

Android/iOS devices → wireless/mobile edge network → edge/server aggregator → cloud (optional)

Flower has an actual Android + TensorFlow Lite example, where Android devices perform local training while a Python server performs federated aggregation.

It also has examples for embedded edge devices such as Raspberry Pi, and supports frameworks including PyTorch, TensorFlow, TFLite, JAX, and others.

When I'd choose FedML instead

Choose FedML if your project is more research/production-oriented around cross-device FL, particularly if you need explicit support for smartphones, IoT devices, edge servers, and heterogeneous devices. FedML's Beehive component is specifically designed for cross-device FL involving smartphones and IoT, with Android/iOS and embedded-Linux support.

FedML also maintains a mobile repository with Android and iOS implementations.

One I'd avoid for this particular requirement

TensorFlow Federated (TFF) is excellent for developing and evaluating FL algorithms, but its own FAQ says it does not currently provide tools for production deployment on physical mobile phones.

Bottom line:

• Android/iOS prototype → Flower
• Large heterogeneous mobile/IoT research platform → FedML
• FL algorithm experimentation/simulation → TFF

If you tell me whether your devices are Android, iOS, Raspberry Pi/Jetson, or a mix, I can also recommend a concrete mobile-edge FL architecture and framework stack (including communication protocol, aggregation server, model runtime, and privacy/security components).

When deploying federated learning (FL) on mobile edge devices (smartphones, tablets, IoT), you need a framework that handles on-device resource constraints, cross-platform support (Android/iOS), intermittent network connectivity, and hardware-accelerated local training.

The top-tier frameworks tailored for mobile edge federated learning include:

• Flower (flower.ai) : A highly extensible, framework-agnostic FL platform. It supports PyTorch, TensorFlow, and other libraries, and provides a lightweight client SDK (supporting Java/Kotlin for Android and C++/Python) capable of scaling from cross-device mobile setups to massive edge deployments.
• FedML : An open-source, community-driven federated learning library that explicitly provides FedML-Mobile for Android and iOS smartphones. It handles non-IID data distributions well and supports both cross-device (smartphones) and cross-silo (edge servers) paradigms.
• FedKit : An academic/open-source system built explicitly for cross-platform federated learning on Android and iOS. It streamlines model conversion, hardware-accelerated on-device training, and MLOps pipeline integration.
• TensorFlow Lite / TensorFlow Federated (TFF) : Google’s ecosystem approach. While TFF is heavily used for simulation and research, deployment to actual mobile devices relies on TensorFlow Lite on-device training capabilities, making it robust if you are deeply tied to the TensorFlow stack.

Key Considerations for Mobile Edge FL:

• On-Device Constraints: Mobile processors have tight thermal and memory limits; look into model compression or quantization (like TFLite) to fit models into RAM.
• Communication Overhead: Cellular/Wi-Fi bandwidth is precious and unstable; choose frameworks that support secure, asynchronous weight updates or compression algorithms.

If you can share a bit more about your project, I can help narrow it down:

• Are you targeting Android, iOS, or both?
• Which machine learning library are you using (PyTorch vs. TensorFlow)?
• Is this for production deployment or academic research/simulation?

If your target is mobile edge devices—especially Android phones, tablets, or embedded edge hardware—I’d recommend Flower.

Why Flower

• Real-device support: Flower has an official Android + TensorFlow Lite example where the FL server runs in Python while clients train on Android devices.
• Framework-agnostic: You can work with TensorFlow/TFLite, PyTorch, JAX, and other ML stacks rather than being locked into one framework.
• Edge-device support: There are examples for Raspberry Pi and NVIDIA Jetson in addition to mobile devices.
• Mobile roadmap: Current Flower documentation lists Android and iOS SDKs for on-device federated learning.
• Customizable aggregation: FedAvg and other strategies can be customized, which is useful when you need device-aware client selection, partial participation, or heterogeneous-device handling.

What I would use

A practical architecture would look like:

              Cloud / Edge FL Server
                       │
             ┌─────────┴─────────┐
             │   Flower Server   │
             │ FedAvg/FedProx... │
             └─────────┬─────────┘
                       │
              Wi-Fi / 5G / Internet
          ┌────────────┼────────────┐
          ▼            ▼            ▼
      Android       Android       Edge Gateway
      + TFLite      + TFLite      Raspberry Pi/Jetson
          │            │            │
       Local ML     Local ML     Local ML
       training     training     training
          │            │            │
          └────── model updates ───┘

For Android, I'd pair Flower with TensorFlow Lite for a relatively lightweight client. Flower's current Android example specifically demonstrates this combination.

Other options

Bottom line: For a new mobile-edge FL project, I'd start with Flower + TensorFlow Lite on Android, with a Python Flower server. If you tell me whether your devices are Android, iOS, Raspberry Pi/Jetson, or a mixture, and whether you're using PyTorch or TensorFlow, I can recommend a concrete architecture and starter repository.