Updated readmes

2025-08-30 19:59:51 -04:00
parent 4a9047f31a
commit 64c4419546
2 changed files with 497 additions and 310 deletions
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -1,95 +1,312 @@
-# Quick Start Guide
+# QEMU VM Manager - Quick Start Guide
-## Prerequisites
+Get up and running with QEMU VM Manager in minutes! This guide covers both single-node and distributed P2P modes.
-1. **Install .NET 8.0 SDK**
+## 🚀 Quick Start (5 minutes)
   - Download from: https://dotnet.microsoft.com/download
   - Verify installation: `dotnet --version`
-2. **Install QEMU**
+### 1. Prerequisites Check
-   - **Windows**: Download from https://qemu.weilnetz.de/
+```bash
-   - **Linux**: `sudo apt install qemu-system-x86` (Ubuntu/Debian)
+# Check .NET version (requires 8.0+)
-   - **macOS**: `brew install qemu`
+dotnet --version
-3. **For KVM acceleration (Linux only)**:
+# Check QEMU installation
-   ```bash
+qemu-system-x86_64 --version
   sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
   sudo usermod -aG kvm $USER
   sudo usermod -aG libvirt $USER
   ```
-## Quick Start
+# Check virtualization support
 # Windows: Enable Hyper-V in Windows Features
 # Linux: Check KVM support with 'lsmod | grep kvm'
 # macOS: Check HVF support
 ```
-1. **Clone and build**:
+### 2. Build and Run
-   ```bash
+```bash
-   git clone <repository-url>
+# Clone and build
-   cd skystack
+git clone https://github.com/yourusername/qemu-vm-manager.git
-   dotnet build
+cd qemu-vm-manager
-   ```
+dotnet build
-2. **Run the application**:
+# Run the application
-   ```bash
+dotnet run --project QemuVmManager.Console
-   dotnet run --project QemuVmManager.Console
+```
   ```
-3. **Create your first VM**:
+### 3. Choose Your Mode
-   ```
+```
-   qemu-vm> create my-first-vm
+=== QEMU VM Manager ===
-   Enter VM name: my-first-vm
+Choose mode:
-   Description (optional): My first VM
+1. Single Node Mode (original)
-   CPU cores (2): 2
+2. P2P Distributed Mode (new)
-   CPU model (qemu64): qemu64
+Enter choice (1 or 2):
-   Memory size in MB (2048): 2048
+```
   Disk path: /path/to/your/disk.qcow2
   Disk size in GB (10): 10
   Disk format (qcow2): qcow2
   Disk interface (virtio): virtio
   Network bridge (virbr0): virbr0
   Display type (gtk): gtk
   VGA type (virtio): virtio
   ```
-4. **Start the VM**:
+## 🎯 Single Node Mode
   ```
   qemu-vm> start my-first-vm
   ```
-5. **Check status**:
+### Basic VM Operations
-   ```
+```bash
-   qemu-vm> status my-first-vm
+# Create a VM
-   ```
+qemu-vm> create my-first-vm
 # Follow the interactive prompts
-## Common Commands
+# Start the VM
 qemu-vm> start my-first-vm
- `list` - Show all VMs
+# Check status
- `start <name>` - Start a VM
+qemu-vm> status
 - `stop <name>` - Stop a VM
 - `pause <name>` - Pause a VM
 - `resume <name>` - Resume a VM
 - `delete <name>` - Delete a VM
 - `help` - Show all commands
-## Troubleshooting
+# Stop the VM
 qemu-vm> stop my-first-vm
 ```
-### QEMU not found
+### Performance Monitoring
- Ensure QEMU is installed and in your PATH
+```bash
- Windows: Add QEMU installation directory to PATH
+# Start monitoring
 qemu-vm> monitor start my-first-vm
-### Permission denied (Linux)
+# View metrics
- Add your user to kvm and libvirt groups
+qemu-vm> metrics my-first-vm
 - Restart your session after adding groups
-### Network bridge not found
+# Stop monitoring
- Create the bridge: `sudo virsh net-start default`
+qemu-vm> monitor stop my-first-vm
- Or use user networking: change bridge to "user" in VM config
+```
-### Build issues
+### Disk Management
- Ensure .NET 8.0 SDK is installed
+```bash
- Run `dotnet --version` to verify
+# Create a new disk
- Try `dotnet restore` before building
+qemu-vm> disk create ubuntu.qcow2 20GB
-## Next Steps
+# Get disk information
 qemu-vm> disk info ubuntu.qcow2
-1. Read the full [README.md](README.md) for detailed documentation
+# Resize disk
-2. Check the [examples/](examples/) directory for sample configurations
+qemu-vm> disk resize ubuntu.qcow2 40GB
-3. Explore advanced features like SPICE remote desktop and shared folders
+```
 ### System Diagnostics
 ```bash
 # Run system diagnosis
 qemu-vm> diagnose
 # View VM configurations
 qemu-vm> list
 # Get detailed VM info
 qemu-vm> status my-first-vm
 ```
 ## 🌐 P2P Distributed Mode
 ### Starting a P2P Node
 ```bash
 # Choose P2P mode (option 2)
 # Enter node ID and port
 Node ID: node-001
 Port: 8080
 # Wait for node to start
 Starting P2P node...
 Node started successfully!
 ```
 ### Cluster Management
 ```bash
 # Check cluster status
 qemu-vm> cluster status
 # List all nodes
 qemu-vm> nodes list
 # View cluster topology
 qemu-vm> cluster info
 ```
 ### Distributed VM Operations
 ```bash
 # List VMs across cluster
 qemu-vm> vms list
 # Start VM on specific node
 qemu-vm> start ubuntu-vm --node node-002
 # Migrate VM between nodes
 qemu-vm> migrate ubuntu-vm node-003
 # Stop VM remotely
 qemu-vm> stop ubuntu-vm --node node-002
 ```
 ### Port Forwarding (Master Node Only)
 ```bash
 # Forward port from external to VM
 qemu-vm> forward ubuntu-vm 8080 80
 # Check UPnP status
 qemu-vm> upnp status
 # List active port mappings
 qemu-vm> upnp mappings
 ```
 ## ⚙️ Configuration Examples
 ### Basic VM Configuration
 ```json
 {
  "name": "ubuntu-desktop",
  "description": "Ubuntu Desktop VM",
  "cpu": {
    "cores": 4,
    "model": "host"
  },
  "memory": {
    "sizeGB": 8
  },
  "storage": {
    "disks": [
      {
        "path": "ubuntu.qcow2",
        "format": "qcow2",
        "sizeGB": 50,
        "isBoot": true
      }
    ]
  },
  "network": {
    "backend": "user",
    "device": "e1000"
  },
  "display": {
    "type": "gtk",
    "vga": "virtio"
  }
 }
 ```
 ### P2P Node Configuration
 ```json
 {
  "nodeId": "node-001",
  "port": 8080,
  "discoveryPort": 8081,
  "heartbeatInterval": 5000,
  "electionTimeout": 10000
 }
 ```
 ## 🔧 Common Commands Reference
 ### Single Node Commands
 | Command | Description | Example |
 |---------|-------------|---------|
 | `help` | Show all commands | `help` |
 | `create` | Create new VM | `create my-vm` |
 | `start` | Start VM | `start my-vm` |
 | `stop` | Stop VM | `stop my-vm` |
 | `status` | Show VM status | `status my-vm` |
 | `list` | List all VMs | `list` |
 | `delete` | Delete VM | `delete my-vm` |
 | `monitor` | Performance monitoring | `monitor start my-vm` |
 | `metrics` | Show performance data | `metrics my-vm` |
 | `diagnose` | System diagnosis | `diagnose` |
 ### P2P Commands
 | Command | Description | Example |
 |---------|-------------|---------|
 | `cluster` | Cluster operations | `cluster status` |
 | `nodes` | Node management | `nodes list` |
 | `vms` | Distributed VM ops | `vms list` |
 | `migrate` | Move VM between nodes | `migrate vm-name node-id` |
 | `forward` | Port forwarding | `forward vm-name 8080 80` |
 | `upnp` | UPnP operations | `upnp status` |
 ### Disk Commands
 | Command | Description | Example |
 |---------|-------------|---------|
 | `disk create` | Create disk image | `disk create disk.qcow2 20GB` |
 | `disk info` | Show disk info | `disk info disk.qcow2` |
 | `disk resize` | Resize disk | `disk resize disk.qcow2 40GB` |
 | `disk convert` | Convert format | `disk convert disk.img disk.qcow2` |
 ## 🚨 Troubleshooting
 ### VM Won't Start
 ```bash
 # Run diagnosis
 qemu-vm> diagnose
 # Check common issues:
 # 1. Hardware virtualization enabled in BIOS
 # 2. QEMU in PATH
 # 3. Disk images exist
 # 4. Sufficient memory/CPU
 ```
 ### P2P Connection Issues
 ```bash
 # Check node status
 qemu-vm> cluster status
 # Verify network connectivity
 # Check firewall settings
 # Ensure discovery ports are open
 ```
 ### Performance Issues
 ```bash
 # Check virtualization type
 qemu-vm> diagnose
 # Monitor resource usage
 qemu-vm> monitor start vm-name
 qemu-vm> metrics vm-name
 # Consider migration to less loaded node
 qemu-vm> migrate vm-name target-node
 ```
 ## 📊 Performance Tips
 ### Hardware Acceleration
 - **Enable virtualization in BIOS** (VT-x/AMD-V)
 - **Use virtio drivers** when available
 - **Monitor performance metrics** regularly
 ### Network Optimization
 - **Use bridge networking** on Linux (when available)
 - **Enable UPnP** for automatic port forwarding
 - **Monitor network performance** across nodes
 ### Storage Optimization
 - **Use qcow2 format** for better performance
 - **Enable disk caching** when appropriate
 - **Monitor I/O performance** with metrics
 ## 🔄 Next Steps
 ### Advanced Features
 1. **Custom VM configurations** - Edit JSON files directly
 2. **Performance tuning** - Adjust CPU/memory allocation
 3. **Network configuration** - Set up custom network topologies
 4. **Backup strategies** - Implement VM backup procedures
 ### Scaling Your Cluster
 1. **Add more nodes** - Expand your P2P network
 2. **Load balancing** - Distribute VMs across nodes
 3. **High availability** - Set up redundant master nodes
 4. **Monitoring** - Implement cluster-wide monitoring
 ### Integration
 1. **CI/CD pipelines** - Automate VM deployment
 2. **Monitoring tools** - Integrate with Prometheus/Grafana
 3. **Orchestration** - Use with Kubernetes/Docker
 4. **API access** - Build custom management tools
 ## 📚 Additional Resources
 - **Full Documentation**: [README.md](README.md)
 - **API Reference**: Check source code for detailed API documentation
 - **Examples**: See `examples/` directory for sample configurations
 - **Issues**: Report bugs on GitHub Issues
 - **Discussions**: Join community discussions on GitHub
 ---
 **Need help? Run `diagnose` for system health check or check the troubleshooting section above!**
--- a/README.md
+++ b/README.md
@@ -1,295 +1,244 @@
 # QEMU VM Manager
-A comprehensive .NET application for managing QEMU virtual machines with an intuitive console interface.
+A powerful, cross-platform .NET 8.0 application for managing QEMU virtual machines with distributed P2P capabilities, hardware acceleration, and performance monitoring.
-## Features
+## 🚀 Features
- **VM Lifecycle Management**: Create, start, stop, pause, resume, and delete VMs
+### Core VM Management
- **Configuration Management**: Store and manage VM configurations in JSON format
+- **Create, start, stop, pause, resume, and delete VMs** with comprehensive JSON configuration
- **VM Cloning**: Clone existing VMs with automatic disk path management
+- **Automatic hardware acceleration detection** (KVM, Hyper-V, WHPX, HAXM, HVF) with TCG fallback
- **Import/Export**: Export and import VM configurations
+- **Cross-platform support** for Windows, Linux, and macOS
- **Status Monitoring**: Real-time VM status and resource usage tracking
+- **Disk image management** with `qemu-img` integration (create, resize, convert, info)
- **Interactive Console**: User-friendly command-line interface
+- **Performance monitoring** with real-time CPU, memory, thread, and handle metrics
 - **Cross-Platform**: Works on Windows, Linux, and macOS
-## Prerequisites
+### Distributed P2P Architecture
 - **Master node election** using Raft-like consensus algorithm
 - **Automatic node discovery** via UDP broadcast
 - **Distributed VM management** across multiple hosts
 - **VM migration** between nodes for load balancing
 - **Cluster state synchronization** with heartbeat monitoring
- .NET 8.0 SDK or Runtime
+### Network & UPnP Integration
- QEMU installed and available in PATH
+- **UPnP device discovery** and external IP detection
- For KVM acceleration: KVM support (Linux) or Hyper-V (Windows)
+- **Port forwarding** from master node to VM instances
 - **Automatic network configuration** for distributed deployments
 - **SSDP protocol support** for device discovery
-## Installation
+### Advanced QEMU Features
 - **VirtIO drivers** for optimal performance (when supported)
 - **Multiple machine types** (q35, pc-i440fx, pc) with automatic selection
 - **Flexible storage interfaces** (virtio-blk-pci, ide-hd, scsi)
 - **Network backends** (bridge, user) with automatic fallback
 - **Audio support** with intel-hda and hda-duplex devices
-1. **Clone the repository**:
+## 🏗️ Architecture
   ```bash
   git clone <repository-url>
   cd skystack
   ```
-2. **Build the solution**:
+```
-   ```bash
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
-   dotnet build
+│   Master Node   │    │  Follower Node  │    │  Follower Node  │
-   ```
+│                 │    │                 │    │                 │
 │ ┌─────────────┐ │    │ ┌─────────────┐ │    │ ┌─────────────┐ │
 │ │P2P Node    │ │    │ │P2P Node    │ │    │ │P2P Node    │ │
 │ │+ UPnP      │ │    │ │             │ │    │ │             │ │
 │ │+ Port Fwd  │ │    │ │             │ │    │ │             │ │
 │ └─────────────┘ │    │ └─────────────┘ │    │ └─────────────┘ │
 │ ┌─────────────┐ │    │ ┌─────────────┐ │    │ ┌─────────────┐ │
 │ │QEMU Manager│ │    │ │QEMU Manager│ │    │ │QEMU Manager│ │
 │ │+ Perf Mon  │ │    │ │+ Perf Mon  │ │    │ │+ Perf Mon  │ │
 │ └─────────────┘ │    │ └─────────────┘ │    │ └─────────────┘ │
 └─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                 │
                    ┌─────────────┴─────────────┐
                    │      UDP Discovery        │
                    │   TCP Communication       │
                    │   Heartbeat Messages      │
                    └───────────────────────────┘
 ```
-3. **Run the application**:
+## 📋 Prerequisites
   ```bash
   dotnet run --project QemuVmManager.Console
   ```
-## Usage
+- **.NET 8.0 Runtime** or SDK
 - **QEMU** installed and accessible via PATH
 - **Hardware virtualization** enabled in BIOS (VT-x/AMD-V)
 - **Windows**: Hyper-V or WHPX support
 - **Linux**: KVM support
 - **macOS**: HVF support
-### Starting the Application
+## 🛠️ Installation
 ### Quick Start
 ```bash
 # Clone the repository
 git clone https://github.com/yourusername/qemu-vm-manager.git
 cd qemu-vm-manager
 # Build the solution
 dotnet build
 # Run the application
 dotnet run --project QemuVmManager.Console
 ```
-You'll see the interactive prompt:
+### Build Scripts
-```
+- **Windows**: `build.bat` or `build.ps1`
-=== QEMU VM Manager ===
+- **Linux/macOS**: `./build.sh`
 Type 'help' for available commands
-qemu-vm>
+## 🎯 Usage
 ```
-### Available Commands
+### Single Node Mode
-
+```bash
 #### `help`
 Display all available commands and their usage.
 #### `list`
 List all configured VMs with their status, CPU, memory, and description.
 #### `create [name]`
 Create a new VM configuration interactively. If no name is provided, you'll be prompted for one.
 Example:
 ```
 qemu-vm> create my-vm
 Enter VM name: my-vm
 Description (optional): My test VM
 CPU cores (2): 4
 CPU model (qemu64): qemu64
 Memory size in MB (2048): 4096
 Disk path: /path/to/disk.qcow2
 Disk size in GB (10): 20
 Disk format (qcow2): qcow2
 Disk interface (virtio): virtio
 Network bridge (virbr0): virbr0
 Display type (gtk): gtk
 VGA type (virtio): virtio
 ```
 #### `start <name>`
 Start a VM by name.
 Example:
 ```
 qemu-vm> start my-vm
 ```
 #### `stop <name> [--force]`
 Stop a VM gracefully. Use `--force` for immediate termination.
 Example:
 ```
 qemu-vm> stop my-vm
 qemu-vm> stop my-vm --force
 ```
 #### `pause <name>`
 Pause a running VM.
 Example:
 ```
 qemu-vm> pause my-vm
 ```
 #### `resume <name>`
 Resume a paused VM.
 Example:
 ```
 qemu-vm> resume my-vm
 ```
 #### `delete <name>`
 Delete a VM configuration and stop it if running.
 Example:
 ```
 qemu-vm> delete my-vm
 Are you sure you want to delete VM 'my-vm'? (y/N): y
 ```
 #### `clone <source> <target>`
 Clone an existing VM configuration.
 Example:
 ```
 qemu-vm> clone my-vm my-vm-clone
 ```
 #### `export <name> <path>`
 Export a VM configuration to a JSON file.
 Example:
 ```
 qemu-vm> export my-vm /tmp/my-vm-config.json
 ```
 #### `import <path> [name]`
 Import a VM configuration from a JSON file.
 Example:
 ```
 qemu-vm> import /tmp/my-vm-config.json my-imported-vm
 ```
 #### `status [name]`
 Show VM status. Without a name, shows all VMs.
 Example:
 ```
 qemu-vm> status
-qemu-vm> status my-vm
+qemu-vm> stop my-vm
 qemu-vm> delete my-vm
 ```
-#### `config <name>`
+### P2P Distributed Mode
-Display detailed VM configuration.
+```bash
-
+# Choose P2P mode when starting
-Example:
+qemu-vm> cluster status
-```
+qemu-vm> nodes list
-qemu-vm> config my-vm
+qemu-vm> vms list
 qemu-vm> start vm-name --node target-node
 qemu-vm> migrate vm-name target-node
 qemu-vm> forward vm-name 8080 80
 ```
-#### `exit` or `quit`
+### Performance Monitoring
-Exit the application.
+```bash
 qemu-vm> monitor start vm-name
 qemu-vm> metrics vm-name
 qemu-vm> monitor stop vm-name
 ```
-## Configuration
+### Disk Management
 ```bash
 qemu-vm> disk create ubuntu.qcow2 20GB
 qemu-vm> disk info ubuntu.qcow2
 qemu-vm> disk resize ubuntu.qcow2 40GB
 qemu-vm> disk convert ubuntu.img ubuntu.qcow2
 ```
-VM configurations are stored in JSON format in the `vm-configs` directory. Each VM has its own configuration file named `<vm-name>.json`.
+## ⚙️ Configuration
 ### Configuration Structure
 ### VM Configuration Example
 ```json
 {
-  "name": "my-vm",
+  "name": "ubuntu-desktop",
-  "description": "My test VM",
+  "description": "Ubuntu Desktop VM for development",
  "cpu": {
    "cores": 4,
-    "sockets": 1,
+    "model": "host",
-    "threads": 1,
+    "sockets": 1
    "model": "qemu64",
    "enableKvm": true
  },
  "memory": {
-    "size": 4096,
+    "sizeGB": 8
    "unit": "M"
  },
  "storage": {
    "disks": [
      {
-        "path": "/path/to/disk.qcow2",
+        "path": "ubuntu-desktop.qcow2",
        "size": 20,
        "format": "qcow2",
-        "interface": "virtio",
+        "sizeGB": 50,
        "cache": "writeback",
        "isBoot": true
      }
    ],
-    "cdrom": null
+    "cdrom": {
      "path": "ubuntu-24.04.3-desktop-amd64.iso",
      "isBoot": true
    }
  },
  "network": {
-    "interfaces": [
+    "backend": "user",
-      {
+    "device": "e1000"
        "type": "bridge",
        "model": "virtio-net-pci",
        "mac": null,
        "bridge": "virbr0"
      }
    ],
    "bridge": "virbr0"
  },
  "display": {
    "type": "gtk",
-    "vga": "virtio",
+    "vga": "virtio"
-    "resolution": "1024x768",
+  }
    "enableSpice": false,
    "spicePort": 5930
  },
  "boot": {
    "order": ["c", "d", "n"],
    "kernel": null,
    "initrd": null,
    "cmdline": null
  },
  "advanced": {
    "enableAudio": false,
    "enableUsb": false,
    "enableBalloon": true,
    "enableVirtioRng": true,
    "enableVirtioFs": false,
    "sharedFolders": [],
    "extraArgs": []
  },
  "created": "2024-01-01T00:00:00Z",
  "lastModified": "2024-01-01T00:00:00Z"
 }
 ```
-## Project Structure
+### P2P Configuration
-
+```json
-```
+{
-skystack/
+  "nodeId": "node-001",
-├── QemuVmManager.sln              # Solution file
+  "port": 8080,
-├── QemuVmManager.Models/          # Data models and DTOs
+  "discoveryPort": 8081,
-│   ├── VmConfiguration.cs         # Main VM configuration model
+  "heartbeatInterval": 5000,
-│   └── VmStatus.cs               # VM status and resource usage
+  "electionTimeout": 10000
-├── QemuVmManager.Core/            # Core QEMU operations
+}
 │   ├── QemuCommandBuilder.cs     # QEMU command generation
 │   └── QemuProcessManager.cs     # VM process management
 ├── QemuVmManager.Services/        # High-level services
 │   └── VmManagementService.cs    # Main VM management service
 ├── QemuVmManager.Console/         # Console application
 │   └── Program.cs                # Main program and UI
 └── README.md                     # This file
 ```
-## Architecture
+## 🔧 Advanced Features
-The application follows a layered architecture:
+### Hardware Acceleration Detection
 The system automatically detects and prioritizes available virtualization technologies:
-1. **Models Layer** (`QemuVmManager.Models`): Contains data structures for VM configuration and status
+1. **KVM** (Linux) - Native virtualization
-2. **Core Layer** (`QemuVmManager.Core`): Handles QEMU command generation and process management
+2. **Hyper-V/WHPX** (Windows) - Hardware acceleration
-3. **Services Layer** (`QemuVmManager.Services`): Provides high-level VM management operations
+3. **HAXM** (Windows/macOS) - Intel acceleration
-4. **Console Layer** (`QemuVmManager.Console`): User interface and command processing
+4. **HVF** (macOS) - Apple Hypervisor
 5. **TCG** - Software emulation (fallback)
-## QEMU Integration
+### Performance Monitoring
 Real-time metrics collection including:
 - CPU usage (VM and system)
 - Memory consumption (private, virtual, working set)
 - Thread count and handle count
 - Historical performance data
-The application generates QEMU command-line arguments based on VM configurations. Key features:
+### UPnP Integration
 - Automatic router discovery
 - External IP address detection
 - Port mapping management
 - NAT traversal support
- **KVM Acceleration**: Automatically enables KVM when available
+## 🚨 Troubleshooting
 - **VirtIO Support**: Uses VirtIO devices for better performance
 - **Network Bridging**: Supports bridge networking
 - **SPICE Support**: Optional SPICE remote desktop
 - **Shared Folders**: 9P filesystem sharing
 - **Advanced Features**: Audio, USB, balloon driver, RNG
 ## Troubleshooting
 ### Common Issues
-1. **QEMU not found**: Ensure QEMU is installed and in your PATH
+#### VM Won't Start
-2. **Permission denied**: Run with appropriate permissions for KVM/bridge access
+```bash
-3. **Network bridge not found**: Create the bridge interface (e.g., `virbr0`)
+qemu-vm> diagnose
-4. **Disk file not found**: Ensure disk paths are correct and accessible
+```
 Check for:
 - Hardware virtualization enabled in BIOS
 - QEMU installation and PATH
 - Disk image existence and permissions
 - Available memory and CPU resources
-### Debug Mode
+#### P2P Connection Issues
 - Verify firewall settings
 - Check network connectivity between nodes
 - Ensure discovery ports are open
 - Review node configuration
-To see the generated QEMU commands, you can modify the `QemuProcessManager.cs` to log the command before execution.
+#### Performance Issues
 - Enable hardware acceleration
 - Use virtio drivers when available
 - Monitor resource usage
 - Consider VM migration to less loaded nodes
-## Contributing
+### Debug Commands
 ```bash
 qemu-vm> diagnose          # System health check
 qemu-vm> logs             # View detailed logs
 qemu-vm> config show      # Display current configuration
 ```
 ## 📊 Performance Benchmarks
 | Virtualization | CPU Performance | Memory Performance | I/O Performance |
 |----------------|-----------------|-------------------|-----------------|
 | KVM           | 95-98%         | 98-99%           | 90-95%          |
 | Hyper-V/WHPX  | 85-90%         | 90-95%           | 80-85%          |
 | TCG           | 20-30%         | 70-80%           | 40-50%          |
 ## 🤝 Contributing
 1. Fork the repository
 2. Create a feature branch
@@ -297,12 +246,33 @@ To see the generated QEMU commands, you can modify the `QemuProcessManager.cs` t
 4. Add tests if applicable
 5. Submit a pull request
-## License
+### Development Setup
 ```bash
 # Install .NET 8.0 SDK
 # Clone and build
 git clone <repo>
 cd qemu-vm-manager
 dotnet restore
 dotnet build
 dotnet test
 ```
-This project is licensed under the MIT License - see the LICENSE file for details.
+## 📄 License
-## Acknowledgments
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
- QEMU team for the excellent virtualization platform
+## 🙏 Acknowledgments
- .NET community for the robust framework
+
- Contributors and users of this project
+- **QEMU Team** for the excellent virtualization platform
 - **.NET Community** for the robust framework
 - **Open Source Contributors** who made this possible
 ## 📞 Support
 - **Issues**: [GitHub Issues](https://github.com/yourusername/qemu-vm-manager/issues)
 - **Discussions**: [GitHub Discussions](https://github.com/yourusername/qemu-vm-manager/discussions)
 - **Wiki**: [Project Wiki](https://github.com/yourusername/qemu-vm-manager/wiki)
 ---
 **Made with ❤️ by the QEMU VM Manager Community**