SkyWeave is an advanced UAV swarm simulation platform built as an Atlas School capstone project.
It combines a multithreaded C++ physics simulator, a Rust telemetry and command server, and a fully interactive Next.js 3D mission-control interface.

The system demonstrates real-time networking, distributed autonomy, and visually rich telemetry visualization through a unified, modern tech stack.

• SkyWeave — Autonomous UAV Swarm Simulator
  • Table of Contents
  • Environment
  • Running SkyWeave Locally
    • Installation
    • Install UI Dependencies
    • Run the Rust Backend
    • Build and Run the C++ Simulator
  • Running through Fly.io and the Vercel App
    • Installation
    • Connect Bridge
    • Run the C++ Simulator:
    • Open Vercel App
    • FLY
  • Project Structure
  • How It Works
    • 1. C++ Simulator (UAV Processes)
    • 2. Rust Telemetry Server
    • 3. Next.js 3D Mission Control UI
  • Mission Control Interface
  • Core Features
  • Technical Concepts
    • UDP Telemetry
    • WebSocket Command Stream
    • Autonomous Swarm Cohesion
    • R3F + Three.js Rendering
  • Stretch Goals
  • About the Developers
    • Stephen Newby
    • Nash Thames
  • License

This project was developed and tested on:

• Operating System: macOS, Linux, & Ubuntu 22.04
• Simulation Engine: C++17 (multithreaded, real-time loop)
• Backend: Rust (Tokio async, actix-web, WebSocket, UDP)
• Frontend: Next.js 14 (React + TypeScript)
• 3D Engine: @react-three/fiber (R3F) + Three.js
• Pathfinding A*
• Deployment:
  • Fly.io (Rust server)
  • Vercel (UI)

Clone the project:

git clone https://github.com/TheSnewby/Capstone.git
cd Capstone

cd ui
npm install
npm run dev

UI will be accessible at:

http://localhost:3000

cd server
cargo run

cd sim
mkdir build && cd build
cmake ..
make -j8
./sim

Clone the project:

git clone https://github.com/TheSnewby/SkyWeave.git
cd SkyWeave

In a separate terminal, run UDP->WebSocket node:

cd SkyWeave/udp_ws_bridge
node udp_ws_bridge.mjs

Start simulation pointed at fly.io server:

cd sim/build
./sim

In browser, navigate to Skyweave

• https://skyweave.vercel.app

Live telemetry will instantly appear in the user interface.

Capstone/
 ├── sim/                         # C++ UAV simulation engine
 │   ├── uav.cpp / uav.h          # Individual UAV dynamics & cohesion logic
 │   ├── simulator.cpp            # Multi-UAV real-time control loop
 │   └── ...
 ├── server/                      # Rust telemetry + WebSocket command server
 │   ├── src/telemetry.rs
 │   ├── src/websocket_server.rs
 │   └── ...
 ├── ui/                          # Next.js mission control interface
 │   ├── app/
 │   ├── components/
 │   ├── public/
 │   └── ...
 ├── README.md
 └── ...

Each UAV runs as an autonomous agent with:

• Local awareness
• Cohesion / separation / alignment forces
• Basic pathfinding behavior
• Adjustable swarm preferences
• Live state broadcasting over UDP

Each UAV transmits packets at ~30Hz:

{ position, velocity, orientation, health, ... }

The Rust server:

• Receives UDP telemetry from all UAVs
• Maintains synchronized global swarm state
• Handles WebSocket connections to the UI
• Streams telemetry to all connected clients
• Accepts user movement & formation commands
• Sends live command packets back to the simulator
• Stores swarm settings for consistent control

The UI provides:

• A real-time 3D R3F scene
• UAV icons, trails, orientation cones
• Leader highlighting (gold triangle + gold trail)
• Follower indicators (cyan triangles + cyan trails)
• Formation controls
• Command console with keyboard + button input
• HUD overlays (heading, altitude, speed, WS status)
• Telemetry table updated every frame
• NASA‑style CRT aesthetic

• 3D swarm visualization
• Grid plane + camera tracking
• Toggleable flight trails
• Slider controls for spacing, altitude, velocity
• Command panel for movement, formation, and altitude control
• HUD with glowing green text
• Return-to-splash navigation
• Responsive layout for both desktop and laptop screens

• Multithreaded UAV physics simulation (C++)
• Real-time UDP telemetry ingestion
• Rust-powered WebSocket command dispatcher
• Fault-tolerant telemetry stream
• 3D visualization using React Three Fiber
• Mission-control inspired UI
• WASD + QE keyboard control system
• Adjustable swarm parameters
• Obstacle avoidance

Lightweight, fast transport for continuous swarm updates.

Maintains a persistent control channel for movement, formations, and preferences.

Implements behaviors similar to Craig Reynolds’ Boids model:

• Separation
• Cohesion
• Alignment
• Formation locking

Handles:

• Real-time UAV rendering
• Grid + camera logic
• Trail geometry buffers
• HUD overlays

• Collision detection
• Click‑to‑place waypoints
• Rogue UAV behavior testing
• Real drone integration (future)

Project Manager / C++ / Simulation Model

• UAV Physics
• Telemetry Sender (UDP)
• Swarm Cohesion, Spacing, and Autonomy Logic
• Simulator Threading
• Pathfinding Algorithms

GitHub: https://github.com/TheSnewby
LinkedIn: https://www.linkedin.com/in/stephenjnewby/

UI / Rust / System Architecture

• 3D Mission Control Interface
• WebSocket + UDP Rust Backend
• Telemetry Pipeline
• UI Design
• App Construction + Deployment

GitHub: https://github.com/internashionalist
LinkedIn: https://linkedin.com/in/nashthames

This project is open-source under the Public Domain.
Use, modify, extend — no restrictions.