New Simulator Lets Researchers Cut the Cords on Federated Learning Clients Mid-Run

Federated learning has become one of the most consequential ideas in modern machine learning: instead of pooling sensitive data on a central server, a shared model is trained across thousands of distributed devices, each performing local computation and sending only model updates back for aggregation. Yet the canonical picture of this workflow, in which a server broadcasts global weights, clients train locally, and the server merges everything with Federated Averaging, quietly assumes something that real deployments almost never enjoy: that participating devices actually stay online. A newly published open-source tool called FLInterrupt, described in the journal SoftwareX by Tudor-Mihai David and Mihai Udrescu of Politehnica University Timisoara, tackles that assumption head-on by making client interruption an explicit, controllable, and fully visualizable experimental factor.

The motivation is grounded in hard production experience. Large-scale mobile federated learning deployments face unreliable connectivity, interrupted execution, and fluctuating device readiness, and systems research has repeatedly shown that availability is a first-order determinant of both wall-clock progress and final model quality. Despite this, the authors note that the majority of federated learning research still evaluates algorithms under stable or randomly sampled participation. Real deployments experience sudden dropouts, delayed reports, and intermittent failures, but most laboratory experiments simply do not model them. FLInterrupt was built to close that gap, giving research groups a sandbox in which a device can vanish in the middle of a training run and the consequences can be watched, measured, and exported in real time.

Architecturally, FLInterrupt is a two-tier application. The lower tier is a FastAPI service, written in Python, that hosts the federated simulation engine built on PyTorch; it maintains authoritative client and round state and exposes REST endpoints for starting and stopping simulations, querying live state, interrupting or reconnecting clients, and running post-training evaluation. The upper tier is a React and Vite browser dashboard that owns all user interaction, from experiment configuration to live monitoring and figure export. The dashboard polls the backend roughly once per second, rendering configuration controls, live charts, per-client cards, and evaluation views. The engine automatically detects CUDA or Apple Metal Performance Shaders acceleration when available and falls back to CPU otherwise, and the whole stack runs on macOS, Linux, and Windows under the MIT license.

The interruption semantics are deliberately precise. When a client is interrupted, it does not send local weights for that round. If the interruption occurs during local training, the partial work is discarded; if it occurs after training but before aggregation, the finished update is simply dropped. The server then aggregates only the updates that actually arrive, using sample-weighted Federated Averaging, which reweights the global model toward the data of the remaining clients. If no updates arrive at all, the global model is left unchanged and the empty round is logged, an explicit branch that makes total non-participation visible in both metrics and server logs. This bookkeeping distinguishes FLInterrupt from planned client-selection policies, such as the Client Selector pattern in the AP4Fed benchmark, which excludes devices at round-configuration time rather than interrupting them involuntarily during an ongoing run.

Researchers configure a run by choosing the number of clients and rounds, local epochs, samples per client, batch size, learning rate, and random seed. Built-in dataset loaders cover CIFAR-10, CIFAR-100, MNIST, and Fashion-MNIST, with data partitioned either in IID mode, where each client holds a balanced class mix, or non-IID mode, where clients receive class-skewed subsets that better mirror real-world heterogeneity. Model backbones range from a lightweight convolutional network to ResNet-18, ResNet-34, and ResNet-50, MobileNetV3-Small, EfficientNet-B0, DenseNet121, ConvNeXt-Tiny, SqueezeNet, and a Vision Transformer, with optional ImageNet transfer learning. Inputs are resized to 224 by 224 pixels and normalized with ImageNet statistics so that pretrained backbones can be applied directly.

What makes the tool distinctive is the interactive loop. During a live run, a researcher can press a button to interrupt a specific client or reconnect it, with same-round reconnects deferred to the next round. Alternatively, a JSON schedule of inclusive round windows, for example specifying that client 3 goes offline during rounds 8 through 12, can be replayed deterministically without any button presses, ensuring reproducibility. The dashboard reflects participation immediately: client cards show online or offline status, interruption and reconnect counts, participated and missed rounds, local sample budgets, and latest metrics, while a participation strip beneath the round axis of the validation plots ties every dip in accuracy to exactly who was present when it happened. Chart text size is adjustable and legends can be dragged, so figures can be polished for publication without leaving the browser.

After training completes, the same interface supports a rigorous evaluation stage. The frozen global model is scored on repeated held-out folds of a configurable test subsample, with no retraining, yielding split-level validation curves and a statistical summary with means, standard deviations, and 95 percent confidence intervals. A mean confusion matrix and a row-normalized view, together with per-class precision, recall, and F1 scores, support fine-grained class-level diagnostics. All charts can be exported as PNG, PDF, or EPS, and the full experiment configuration, seed, partition, and interruption history can be exported as JSON, giving researchers a complete, replayable record suitable for papers and technical reports.

To demonstrate the tool, the authors ran a controlled 18-run grid on CIFAR-10 using ten clients, twenty rounds, three local epochs, a 1000-sample budget per client, and MobileNetV3-Small with ImageNet transfer learning, across seeds 42, 7, and 123. Three schedules were compared: an all-connected control, a moderate schedule in which clients 3 through 5 were offline during rounds 8 through 12, and a severe schedule in which clients 0 through 6 were offline during rounds 8 through 15. The results are instructive rather than dramatic. Mean final-round accuracy reached about 0.91 for the IID control and about 0.69 for the non-IID control, confirming that data heterogeneity dwarfs availability effects in this setting. Under interruption, mean final IID accuracy was about 0.88 in the moderate case and about 0.90 in the severe case, showing that Federated Averaging can recover even when a large fraction of clients vanishes for many rounds, though individual runs varied considerably, with one moderate non-IID run ending at 0.59.

The authors are careful about causal interpretation, and this caution is itself a lesson for the field. Because IID controls at a learning rate of 0.01 already exhibit volatility, a dip during rounds 8 through 15 cannot be attributed to interruption by default; only shocks that appear in interrupted runs but not in the control can be blamed on unavailability. The paper also candidly lists limitations: participation is modeled as a binary availability flag, so delayed arrivals, stale-update reuse, bandwidth constraints, and packet loss are out of scope, and the optional submission wait is an in-process sleep rather than a network deadline. A scalability benchmark on Apple silicon showed two-round runs completing in 154 seconds at ten clients and 826 seconds at one hundred clients, with memory growing from roughly 4 to 15 gigabytes, underscoring that this is a research simulator rather than a production cross-device platform.

Positioned against the crowded federated learning ecosystem, FLInterrupt does not compete with Flower, FedML, FedScale, FATE, OpenFL, or TensorFlow Federated on deployment scale, privacy infrastructure, or benchmarking breadth, nor with InFL-UX on collaborative in-browser labeling. Its contribution is narrower and arguably more immediately useful: a standalone, Flower-independent simulator in which involuntary unavailability becomes a first-class experimental variable, coupled with transparent aggregation accounting, synchronized live visualization, and publication-ready statistical diagnostics. By letting researchers isolate interruption while holding model, dataset, partition, and optimizer fixed, and by making every empty round and discarded update visible on the same timeline as the accuracy curves, the tool turns one of federated learning’s messiest real-world phenomena into a clean, reproducible science. For a field whose algorithms will ultimately live on phones, sensors, and hospitals where devices drop out without warning, that kind of controlled adversity may prove exactly what the literature has been missing.

Subject of Research: An interactive federated learning simulator for studying the effects of client interruption on model training

Article Title: FLInterrupt: An interactive federated learning simulator for client interruption experiments

Article References: David, T.-M., & Udrescu, M. (2026). FLInterrupt: An interactive federated learning simulator for client interruption experiments. SoftwareX, 36, Article 103099. https://doi.org/10.1016/j.softx.2026.103099

Image Credits: AI Generated

DOI: 10.1016/j.softx.2026.103099

Keywords: federated learning, FLInterrupt, client interruption, FedAvg, machine learning, open-source software, PyTorch, CIFAR-10, non-IID data, simulation, distributed training, SoftwareX