A mumble-based modular radio simulation framework that provides realistic radio communication for flight simulators and games with geographic separation, propagation modeling, and authentic radio effects.

| Deutsche Version

FGCom-mumble is a sophisticated radio communication simulator that brings realistic radio procedures to flight simulation and games. It's designed for enthusiasts who want authentic radio communication experiences with proper propagation modeling, geographic separation, and realistic audio effects.

• Realistic Radio Simulation: Geographic separation, propagation modeling, and authentic audio effects
• Multi-Platform Support: FlightGear (native), Microsoft Flight Simulator 2020 (experimental), and web browsers
• Advanced Features: ATIS recording, radio station broadcasts, landline/intercom support, and RDF detection
• WebRTC Support: Browser-based access without installation requirements
• GPU Acceleration with Dynamic Scaling: Intelligent GPU resource management for up to 200 concurrent users for high-performance propagation
• Advanced GPU acceleration with shared computing capabilities: Distribute calculations across multiple clients
• Real-Time Data Integration: Solar data, lightning data, and weather data for accurate propagation modeling
• Antenna Pattern Library: EZNEC-based 3D radiation patterns for all vehicle types
• Physics-Based Propagation: Atmospheric effects, tropospheric ducting, and terrain obstruction modeling
• Feature Toggle System: 50+ configurable features for custom deployments
• API Integration: RESTful APIs and WebSocket support for game developer integration
• Voice Encryption Systems: Military-grade voice encryption simulated
• Satellite Communication: Real-time satellite tracking and communication simulation
• Advanced Fuzzing: Comprehensive testing framework with AFL++ and MULL integration
• ATIS Weather Integration: Automatic weather data integration for realistic ATIS generation
• Modular Design: Extensible architecture for custom integrations

FGCom-mumble is actively seeking beta testers to help improve the system!

We need experienced users to test new features, provide feedback, and help identify issues before public release. Beta testing is particularly valuable for:

• GPU Acceleration Features: Test CUDA, OpenCL, and Metal GPU acceleration
• Advanced Configuration Options: Validate multiple configuration settings across 17 categories
• Multi-Platform Integration: Test FlightGear, MSFS 2020, and WebRTC compatibility
• Performance Optimization: Help optimize GPU resource management and thermal control
• New API Endpoints: Test RESTful API and WebSocket interfaces
• Security Features: Validate authentication and authorization systems

1. Join the Beta Program: Contact the development team through GitHub Issues
2. Report Issues: Use the issue tracker to report bugs and suggest improvements
3. Provide Feedback: Share your experience with different configurations and use cases
4. Test New Features: Help validate new functionality before public release

• Technical Expertise: Server administration and configuration experience
• Testing Environment: Dedicated test system for beta features
• Feedback Commitment: Regular feedback and issue reporting
• Documentation: Help improve documentation and user guides
• Preferred optional skills: C++/C experience and log reading ability

Interested? Open an issue on GitHub with "Beta Tester Application" in the title and describe your technical background and testing environment.

IMPORTANT: Never store passwords, API keys, or usernames in configuration files!

FGCom-mumble requires secure credential management. All sensitive data must be stored as environment variables.

# 1. Run the interactive configuration setup (RECOMMENDED)
./scripts/setup.sh

# 2. Or run the environment setup only
./scripts/setup_environment.sh

# 3. Or manually copy the template
cp configs/env.template .env
chmod 600 .env

# 4. Edit with your credentials
nano .env

# 4. Load environment variables
source .env

The interactive setup script (./scripts/setup.sh) will guide you through:

• Core application settings (API keys, database)
• External data sources (NOAA, NASA, weather APIs)
• GPU acceleration configuration
• Feature toggles and network settings
• Monitoring and logging options

• Security Setup Guide - Complete guide for setting up environment variables
• Security Best Practices - Production security guidelines
• Environment Template - Template for all required environment variables

• FGCOM_API_KEY - Main application API key
• NOAA_SWPC_API_KEY - NOAA Space Weather API
• NASA_API_KEY - NASA API access
• OPENWEATHERMAP_API_KEY - Weather data API
• Database credentials (if using external database)

• Voice Encryption Systems: Complete implementation of military-grade voice encryption including FreeDV, MELPe, and NATO standards
• Satellite Communication: Real-time satellite tracking with TLE support for military and amateur radio satellites
• Advanced Fuzzing Framework: Comprehensive testing with AFL++ and MULL integration for improved code quality
• ATIS Weather Integration: Automatic weather data integration with Piper TTS for realistic ATIS generation
• Enhanced Security: Multi-core optimization and comprehensive security fixes
• Interactive Configuration: New setup scripts for easier installation and configuration

• Plugin: 1.1.1
• Server: 1.3.0
• RadioGUI: 1.2.0
• FlightGear Addon: 1.3.1

FGCom-mumble is NOT a simple "plug and play" system. It requires technical expertise:

• Server Administration: Linux/Windows server management experience
• Technical Configuration: Multiple configuration options across 17 categories
• Network Setup: UDP port configuration, firewall rules, channel management
• Radio Knowledge: Understanding of radio frequencies and propagation
• Installation Time: 2-4 hours for basic setup, 1-2 days for advanced configuration

• FlightGear: Native integration (requires technical knowledge)
• Microsoft Flight Simulator 2020: Via RadioGUI with SimConnect (requires technical setup)
• Web Browsers: WebRTC gateway (no installation required)

# Copy the example configuration
cp configs/fgcom-mumble.ini ~/.fgcom-mumble.ini
nano ~/.fgcom-mumble.ini

For Pilots:

radioAudioEffects=1
allowHearingNonPluginUsers=0
udpServerHost=127.0.0.1

For ATC Controllers:

radioAudioEffects=1
allowHearingNonPluginUsers=1
autoJoinChannel=1

For WebRTC Gateway:

radioAudioEffects=1
allowHearingNonPluginUsers=1
udpServerHost=*

• How This Works for Dummies - Simple explanation of radio propagation with practical examples
• Radio Propagation Mathematics - Mathematical models and calculations
• Technical User Guide - Technical overview and capabilities

• Advanced Features - Comprehensive overview of all advanced features
• WebRTC Browser Client Support - WebRTC implementation documentation
• Antenna Pattern Creation - Antenna pattern creation guides
• Dynamic GPU Scaling - Intelligent GPU resource management
• Utilities and Tools - Available utilities and tools

• Game Developer Integration Guide - Integration requirements and protocols
• Terrain and Environmental Data API - Critical terrain and environmental data requirements
• Game Terrain Integration Guide - Terrain integration instructions

• Aviation VHF Civil - Civil aviation VHF frequency bands
• Military VHF/UHF - Military VHF/UHF frequency bands
• Civil HF Frequencies - Civil HF frequency allocations
• Known Military Bands - Military frequency bands and protocols
• Band Segments Reference - Frequency allocations and regulatory compliance

• Good Coding Practices - Strict coding standards and quality requirements

• Mumble Plugin - Technical details on plugin design and data formats
• RadioGUI - Radio GUI client documentation
• FlightGear Addon - FlightGear integration addon

• Server Documentation - Server-side components and operation
• Status Page - Status page implementation details

• Work Unit Distribution API - Distributed computing and work unit management
• Security API Documentation - Comprehensive security implementation

• Satellite Communication Documentation - Complete satellite communication system
• TLE Support - Two-Line Element orbital calculations
• Military Satellites - Military satellite systems (Strela-3, FLTSATCOM, Tsiklon)
• Amateur Radio Satellites - Amateur radio satellite systems (AO-7, FO-29, ISS, etc.)
• IoT Satellites - IoT and data satellite systems (Orbcomm, Gonets)

• Piper TTS Integration - Automatic ATIS generation with Piper TTS
• ATIS Weather Integration - Real-time weather data integration for ATIS

• Yachta T-219 (Soviet/East Bloc)
• VINSON KY-57 (NATO)
• Granit (Soviet/East Bloc)
• STANAG 4197 (NATO)
• MELPe with NATO Type 1 Encryption (NATO)
• FreeDV with ChaCha20-Poly1305 + X25519 Key Exchange (Modern)

IMPORTANT DISCLAIMER: All voice encryption systems in this project are implemented for educational and simulation purposes only. These systems are designed to provide authentic Cold War-era and modern military communication simulation for flight simulators and games. If used for any illegal activities, the responsibility lies solely with the user. The developers and maintainers of this project are not responsible for any misuse of these systems.

• Voice Encryption Analysis - Comprehensive analysis of voice encryption systems
• FreeDV Implementation - FreeDV digital voice system with X25519 key exchange
• MELPe Implementation - MELPe NATO standard vocoder with NATO Type 1 encryption
• Military Encryption Systems - Various military-grade encryption systems

• 128-bit (Standard): Squadron communications, routine operations
• 192-bit (Tactical): Command channels, tactical operations
• 256-bit (Top Secret): Special operations, classified missions

• Satellite Communication Documentation - Complete satellite communication system
• TLE Support - Two-Line Element orbital calculations
• Military Satellites - Military satellite systems (Strela-3, FLTSATCOM, Tsiklon)
• Amateur Radio Satellites - Amateur radio satellite systems (AO-7, FO-29, ISS, etc.)
• IoT Satellites - IoT and data satellite systems (Orbcomm, Gonets)

# Clone the repository
git clone https://github.com/Supermagnum/fgcom-mumble.git
cd fgcom-mumble

# Run the interactive configuration setup (RECOMMENDED)
./scripts/setup.sh

# Or run the automated installation script
sudo ./scripts/install_fgcom_mumble.sh

# Check system status
sudo ./scripts/status_fgcom_mumble.sh

# Uninstall (if needed)
sudo ./scripts/uninstall_fgcom_mumble.sh

# Set up environment variables securely
./scripts/setup_environment.sh

# Or manually copy and edit the template
cp configs/env.template .env
nano .env
source .env

# Build all components
make all

# Build without MSFS 2020 support (recommended)
make build-radioGUI-without-jsimconnect

# Build with MSFS 2020 support (experimental)
make build-radioGUI-with-jsimconnect

# Build headless server (no GUI components)
make build-headless

# Create release packages
make release

Advanced GPU acceleration with shared computing capabilities:

• Multi-GPU Support: Distribute calculations across multiple graphics cards
• Network GPU Sharing: Use GPUs from multiple computers in your network
• Cloud GPU Integration: Combine local and cloud GPU resources
• Automatic Load Balancing: Distribute work optimally across available GPUs
• Cross-Platform: CUDA (NVIDIA), OpenCL (AMD/Intel), Metal (Apple)

Performance Benefits:

• 10-100x faster than CPU-only calculations
• Handles 200+ pilots with intelligent dynamic scaling simultaneously
• Real-time weather effects with no lag
• Scalable performance as you add more GPUs

For detailed configuration and implementation guide, see Dynamic GPU Scaling Documentation

Intelligent GPU resource management for high user loads (up to 200 concurrent users):

• Automatic Scaling: Adjusts GPU allocation based on user count (1-200+ users)
• Network GPU Support: Distribute calculations across multiple computers
• Health Monitoring: Automatic failover and load balancing
• Performance Optimization: Intelligent resource allocation with minimal waste

# Enable dynamic GPU scaling
enable_dynamic_gpu_scaling = true
max_local_gpus = 4
max_network_gpus = 8
scaling_thresholds = [20, 50, 100, 150, 200]

For complete configuration options, troubleshooting, and advanced setup, see the Dynamic GPU Scaling Documentation.

For detailed antenna pattern guide, see Antenna Pattern Creation Documentation

The system includes comprehensive antenna pattern visualization showing realistic radiation patterns for various vehicle types. The purple lines represent a basic, crude representation of a JEEP vehicle (sides and wheels not shown for clarity). The "8" figure demonstrates how a typical antenna tied down at a 45° angle radiates, providing realistic propagation modeling for ground-based vehicles.

Note: Not all patterns are included to conserve repository space. Some patterns must be generated by users. Some of these needs improvements

• Yagi Antennas: 116 patterns covering HF (7-28MHz), VHF (50-144MHz), and UHF (432MHz) bands
• Vertical Antennas: 22 patterns for VHF/UHF fixed installations
• Loop Antennas: 10 patterns for HF (80m) operations
• Coastal Stations: 7 patterns for HF maritime communications

• Soviet UAZ: 588 patterns with attitude variations
• Leopard 1 MBT: 3 patterns
• T-55 Soviet MBT: 3 patterns
• NATO Jeep: 2 patterns

• Ford Transit: 2 patterns
• VW Passat: 2 patterns

• Aircraft Patterns: Not included due to storage constraints - must be generated using the pattern generation script
• Marine Patterns: Not available - cannot be generated due to safety limits (exceeds 50,000+ combination limit)
• Ground Type Variations: Ideally, patterns should be generated for each ground type (conductivity, permittivity), but this would create an extremely large database

Generation: Use scripts/pattern_generation/antenna-radiation-pattern-generator.sh to generate missing aircraft patterns. See Antenna Pattern Creation Documentation for complete details.

Note on Ground Types: While ideal antenna patterns would account for different ground types (soil conductivity, moisture, urban vs rural environments), the database would become prohibitively large. Current patterns use standard ground assumptions for practical implementation.

The project lives on GitHub: https://github.com/Supermagnum/fgcom-mumble

• Issues: Report bugs or request features on the issue tracker
• Pull Requests: Contributions are welcome! Clone the repository and submit pull requests

• Testing Guide - Simple explanation of what all tests do (non-programmer friendly)
• Test Results - Test suite execution results and coverage analysis
• Fuzzing Framework - Advanced testing with AFL++ and MULL integration
• Fuzzing Results Report - Comprehensive 12-hour fuzzing session results with zero crashes found
• Fuzzing Harnesses - libFuzzer-based fuzzing targets for comprehensive testing
• Test Modules - Comprehensive test suite with 20+ specialized testing modules
• RapidCheck Integration - Property-based testing framework
• Test Coverage Documentation - Comprehensive test coverage analysis

This code was built with AI assistance. I cannot program at all, but I can understand some compiler warnings and understand some log files. The code has proper formulas and calculations throughout. "Is these claims bullshit?" has one definitive answer: Run the tests. Examine what they do. Examine the mathematics. Read the documentation.