UavNetSim-v1: Lightweight UAV Network Simulator

• UavNetSim-v1 is an open-source Python-based simulation platform that focuses on UAV communication networks with simplified, yet effective protocol, MAC, and mobility modeling.
• It leverages a discrete-event SimPy environment to model key layers such as routing, MAC, mobility, topology control, and energy, promoting rapid prototyping and debugging.
• The simulator’s modular architecture and interactive visualization interface facilitate comparative performance studies and extendability for advanced UAV networking research.

UavNetSim-v1 is an open-source, Python-based simulation platform for UAV communication networks, designed for the rapid development, testing, and evaluation of protocols and algorithms in multi-UAV systems. Its scope is explicitly centered on networking problems—routing, medium access control, topology control, mobility, and energy—rather than high-fidelity vehicle dynamics or sensor realism. Built on SimPy and equipped with performance evaluation and an interactive visualization interface, it is positioned as a lightweight yet powerful alternative to mature network simulators for UAV communication research, rapid prototyping, and educational use (Zhou et al., 14 Jul 2025).

1. Purpose, scope, and intended use

UavNetSim-v1 was introduced to address a gap between two established tool families. On one side are robot and UAV simulators such as Gazebo, Webots, V-REP, and AirSim, which emphasize high-fidelity single-UAV physics and sensing but are not designed for scalable, real-time simulation of large multi-UAV communication networks. On the other side are full-featured network simulators such as GloMoSim, NS-2/NS-3, and OMNeT++, which model protocol stacks in much greater detail but impose substantial conceptual and implementation complexity. The stated design goal is therefore “as simple as possible, but still realistic enough for meaningful research” (Zhou et al., 14 Jul 2025).

The platform targets researchers working on UAV communication networks, students and educators needing an accessible environment for FANET concepts, and protocol and algorithm designers who require a lightweight and extensible testbed. The intended workload includes rapid prototyping and debugging of routing, MAC, and topology-control algorithms; comparative performance studies; and the analysis of AI-based schemes such as reinforcement-learning-aided routing. In that framing, UavNetSim-v1 does not aim to reproduce every layer of a general-purpose Internet simulator. It instead isolates the core problems of UAV networking and exposes them through a codebase meant to be understandable and modifiable (Zhou et al., 14 Jul 2025).

This focus has direct implications for what the simulator does and does not model. It supports multi-UAV communication behavior in a 3D space, abstracts much of the PHY layer, and maintains minimal application and transport-layer logic. A plausible implication is that the platform is best suited to studies where topology dynamics, interference, forwarding behavior, contention, and mobility-energy trade-offs dominate over waveform-level or protocol-stack-level fidelity.

2. Core architecture and execution model

The execution model is based on SimPy, a process-based discrete-event simulation framework in Python. SimPy provides an Environment for global simulation time and event scheduling, Event objects for delays and state changes, and process functions implemented as Python generators. This process-oriented model is used to represent asynchronous networking and multi-agent communication, which are central to UAV networks (Zhou et al., 14 Jul 2025).

The central simulation entity is the Drone class in entities/drone.py. Each UAV is represented as an instance of Drone, and each instance installs a protocol stack consisting of a routing protocol module, a MAC protocol module, a mobility model, and an energy model. UAVs are placed in a 3D Cartesian space with position

$[x(t), y(t), z(t)] \in \mathbb{R}^{3 \times 1}.$

At the application level, the simulator deliberately adopts a minimal model: the UAV runs a process function generate_data_packet() that simulates packet arrivals and creates DataPacket objects derived from a base Packet class in entities/packet.py (Zhou et al., 14 Jul 2025).

The packet-processing path is organized as a sequence of modular operations. A generated DataPacket first undergoes head-of-line processing, where the routing protocol invokes next_hop_selection() and the MAC protocol invokes mac_send(). The packet then traverses a wireless channel model in which attenuation and possible collisions are represented while many low-level PHY details are abstracted away. On reception, the routing protocol calls packet_reception() to update state and either forward, drop, or deliver the packet. When a packet reaches its destination, the metrics subsystem records outcomes, and the visualization subsystem can display UAV trajectories, links, and forwarding paths (Zhou et al., 14 Jul 2025).

Component	Role
Drone	UAV entity with routing, MAC, mobility, and energy modules
Packet / DataPacket	Base packet abstraction and data payload objects
SimPy Environment	Global simulation time and event scheduler

The architecture described in the paper’s Figure 1 places the SimPy environment at the base, with entities, routing, mac, mobility, topology, energy, and simulator/metrics above it. The code structure is therefore intentionally aligned with the conceptual decomposition of UAV networking problems. This suggests a design philosophy in which algorithmic clarity and modular replacement are treated as first-order requirements.

3. Protocol, mobility, topology, and energy models

UavNetSim-v1 includes a set of built-in models covering the main layers relevant to UAV communication research (Zhou et al., 14 Jul 2025).

Category	Built-in support
Routing	DSDV, Greedy forwarding, GRAd, OPAR, Q-routing, QGeo
MAC	CSMA/CA, Pure ALOHA
Mobility	3D Gauss-Markov, 3D random walk, 3D random waypoint
Topology control	Virtual force-based topology control
Energy	Rotary-wing propulsion model and transmit-energy model

At the routing layer, DSDV provides a proactive distance-vector baseline; Greedy forwarding and QGeo use geometric information; GRAd is gradient-based; OPAR is predictive and adaptive; and Q-routing is reinforcement-learning-based. All routing modules conform to the same minimal interface, centered on next_hop_selection(packet) and packet_reception(packet). At the MAC layer, the simulator includes CSMA/CA with carrier sensing, backoff, ACK-based reliability, and retransmission handling, as well as Pure ALOHA as a simpler contention baseline. The MAC interface is similarly constrained to a small set of methods, notably mac_send(packet) and wait_ack(packet) (Zhou et al., 14 Jul 2025).

Mobility is represented in 3D Cartesian coordinates. The 3D Gauss-Markov model provides temporally correlated motion, the 3D random walk model provides memoryless randomized movement, and the 3D random waypoint model provides waypoint-driven trajectories. Each mobility class implements mobility_update(), which periodically updates position, speed, direction, and pitch. In addition, the topology package implements virtual force-based topology control, modeling UAVs as particles subject to attractive and repulsive virtual forces to improve connectivity and avoid excessive clustering (Zhou et al., 14 Jul 2025).

The energy model separates propulsion energy from communication energy. The simulator uses a rotary-wing propulsion power model based on Zeng et al. (2019), and movement over duration $t_{\rm move}$ yields propulsion energy

$E_{\rm prop} = P_{\rm prop}(v) \, t_{\rm move}.$

For communication-related energy, the current version considers only transmit energy:

$E_{\rm comm} = P_t \, t_{\rm packet}.$

The paper states explicitly that future work will extend this treatment to circuitry, reception, and acceleration/deceleration effects (Zhou et al., 14 Jul 2025).

The wireless channel model is intentionally simplified. The platform abstracts many PHY details such as modulation and coding, but still models transmit power, noise power, interference, and a SINR threshold for successful reception. Conceptually, successful delivery depends on the signal-to-interference-plus-noise ratio satisfying a threshold criterion. This abstraction is consistent with the platform’s stated objective: focused UAV-networking research with modest implementation overhead rather than full waveform fidelity.

4. Metrics, visualization, and example evaluation

The simulator includes an interactive visualization interface that displays UAV trajectories, communication links, and packet forwarding paths. The paper’s Figure 2 shows a graphical window in which UAV positions evolve over time and packet routes can be visually inspected. This is explicitly described as useful for understanding and debugging complex algorithms, including RL-based routing, and for teaching connectivity, topology control, and forwarding behavior (Zhou et al., 14 Jul 2025).

Performance evaluation is handled by simulator/metrics.py. The reported metrics are Packet Delivery Ratio (PDR), average end-to-end delay, average throughput, routing load, and hop count. PDR is defined as

$$\text{PDR} = \frac{\text{\# data packets successfully received at destinations}}{\text{\# data packets generated at sources}}.$$

Average end-to-end delay includes queuing delay, MAC contention delay, retransmission delay, transmission time, and propagation delay, while multi-hop delay is the sum of per-hop delays. Throughput is total successfully received data per unit time; routing load is the number of control packets transmitted per data packet successfully delivered; and hop count records the number of intermediate UAVs traversed by each packet (Zhou et al., 14 Jul 2025).

The paper validates the simulator through a case study comparing Greedy forwarding, DSDV, and OPAR under varying UAV speeds. The scenario configuration includes a map size of $$600\,\text{m} \times 600\,\text{m} \times 100\,\text{m}$$, 15 UAVs, transmit power of 0.1 W, omnidirectional antennas, noise power of $4 \times 10^{-11}$ W, and a SINR threshold of 6 dB. The MAC layer uses CSMA/CA with carrier frequency 2.4 GHz, bandwidth 22 MHz, bit rate 2 Mbps, time slot 20 µs, SIFS 10 µs, DIFS 50 µs, initial contention window 31, retransmission limit 5, and ACK packets of 30 bytes. Data payloads are 1024 bytes, and sources generate packets according to a Poisson process with parameter $\lambda = 5$ packets/s while UAVs move according to the 3D Gauss-Markov model (Zhou et al., 14 Jul 2025).

Under this setup, OPAR achieves the highest PDR across all evaluated velocities, while all protocols show decreasing PDR as speed increases from 5 m/s to 25 m/s. For delay, Greedy forwarding has the highest delay at 5 m/s, approximately 298.613 ms, DSDV has the highest delay at 25 m/s, approximately 322.333 ms, and OPAR consistently attains the lowest end-to-end delay at all evaluated velocities. The reported interpretation is that predictive and adaptive routing better tolerates rapid topology changes, whereas local greedy decisions and proactive tables degrade as mobility increases (Zhou et al., 14 Jul 2025).

5. Position within the simulator landscape

UavNetSim-v1 occupies a distinct position among UAV simulation frameworks. Unlike co-simulation systems that combine realistic autopilot logic with detailed network simulators, it is entirely Python-based and built on SimPy. FlyNetSim, for example, couples ArduPilot SITL and ns-3 through a ZeroMQ publish/subscribe middleware, preserves real autopilot behavior, uses a real-time scheduler, and supports multi-technology networks such as Wi-Fi, LTE, and D2D/ad-hoc links (Baidya et al., 2018). By contrast, UavNetSim-v1 does not attempt to preserve a full autopilot or a full communication stack; it focuses instead on a compact, modular environment for algorithm design (Zhou et al., 14 Jul 2025).

A second contrast appears with recent 5G-oriented UAV networking simulators. One ns-3-based FANET simulator integrates the 5G-LENA NR V2X module, Zenoh, TUN/TAP, VXLAN, and VM/container-based application stacks in order to evaluate 5G sidelink multi-hop communication and a data-centric NDN-style paradigm (Rúa-Estévez et al., 28 Sep 2025). A MATLAB-based simulator for connected UAVs in 5G networks, in turn, emphasizes 5G Toolbox PHY/MAC/RLC modeling, customizable UAV mobility, handover management, and external TCP, UDP, QUIC, and MP-QUIC traffic via sockets (Su et al., 31 Aug 2025). These platforms are directed toward protocol-stack fidelity in 5G scenarios, whereas UavNetSim-v1 is centered on rapid experimentation with routing, MAC, topology control, mobility, and energy abstractions (Zhou et al., 14 Jul 2025).

The platform also differs from high-fidelity traffic and digital-twin environments. RflyUT-Sim models low-altitude UAV traffic management with RflySim/AirSim, Unreal Engine 5, Cesium, Redis-based communication, anomaly injection, and scenarios with up to 100 UAVs, but its network model is system-level rather than packet-protocol-level (Li et al., 30 Dec 2025). A measurement-calibrated Matlab-based simulation framework aligned with the NSF AERPAW digital twin focuses on RSRP, SNR, and throughput abstractions for fast iteration against a full-stack UAV wireless digital twin (Hossen et al., 11 Mar 2025). These examples suggest a broader design spectrum: UavNetSim-v1 represents the lightweight, algorithm-centric end of that spectrum, prioritizing ease of use and modularity over high-fidelity flight, environment, or 5G-stack realism.

6. Limitations, extensibility, and practical relevance

The paper explicitly identifies several limitations. Only UAV entities are currently implemented; there is no support yet for satellites, ground vehicles, or static sensors. Traffic generation is limited to simple random processes such as uniform or Poisson arrivals, with no realistic application layer or transport protocols. Security is absent: there is no modeling of spoofing, jamming, blackhole, wormhole, Sybil, or other attacks, and there are no secure routing protocols. The energy model assumes constant-speed propulsion and counts only radiated transmit energy, ignoring acceleration, deceleration, circuitry, processing, and reception. Physical-layer behavior is simplified as well, since there is no detailed encoding or modulation model and reception is abstracted through interference and SINR-threshold logic (Zhou et al., 14 Jul 2025).

These simplifications are matched by a deliberately extensible architecture. New routing protocols can be added by implementing next_hop_selection(packet) and packet_reception(packet); new MAC protocols by implementing mac_send(packet) and wait_ack(packet); new mobility models by implementing mobility_update(); and new topology-control algorithms by defining periodic processes that gather local neighbor information and alter UAV motion. Because the code is entirely in Python and modularized by function, the paper states that users can easily modify or subclass existing implementations (Zhou et al., 14 Jul 2025).

The practical relevance of UavNetSim-v1 lies in this combination of constrained scope and low overhead. It is well matched to studies of 3D mobility, interference-aware forwarding, contention behavior, topology-control effects, RL-based routing, and energy-aware network design when full-stack network fidelity or high-fidelity vehicle dynamics are not required. The simulator is open-source and available at https://github.com/Zihao-Felix-Zhou/UavNetSim-v1, reinforcing its stated roles in rapid prototyping and education (Zhou et al., 14 Jul 2025). A plausible implication is that UavNetSim-v1 can function both as a standalone research tool for UAV-network algorithms and as a pedagogical platform from which more specialized or higher-fidelity co-simulation environments can later be approached.