Wololo - Wake On LAN Management Tool

A simple and efficient web-based Wake On LAN (WoL) management tool built with Rust, designed for homelab environments. Wololo provides an intuitive interface to manage and wake up devices on your local network. With a minimal memory footprint (<5MB) and a fully config-driven architecture that requires no persistence layer, Wololo is perfect for GitOps workflows and resource-constrained environments.

Note: The project name "Wololo" is an homage to the iconic conversion sound from Age of Empires, where monks would chant "Wololo" to convert enemy units. Just like the monks converted units, this tool "converts" (wakes up) your devices! The sound effect played when waking devices is also a tribute to this classic game.

Features

• 🌐 Web-based Interface: Clean, responsive UI built with HTMX and Tailwind CSS
• 💾 Minimal Memory Footprint: Runs with less than 5MB of memory usage, making it ideal for resource-constrained environments
• 📝 Config-Driven Architecture: Fully configuration-based system with no persistence layer required. Perfect for GitOps workflows - commit your config to version control and deploy anywhere
• 🔧 YAML Configuration: Simple device management through configuration files
• 🔍 Network Discovery: Automatic device discovery with config generation
• 📊 Real-time Status: Live device status monitoring with ping functionality
• ⏱️ Configurable Sync: Automatic periodic status updates
• 🚀 Fast & Lightweight: Built with Rust for optimal performance
• 🏠 Homelab Ready: Perfect for self-hosted environments
• 📱 Mobile Friendly: Responsive design works on all devices

Quick Start

Prerequisites

• Docker (recommended) or Rust 1.70.0+ for building from source
• Network devices with Wake On LAN support enabled

Docker Installation (Recommended)

1. Pull the container image:

docker pull ghcr.io/sharmashobhit/wololo:latest

Create a config.yaml file (see Configuration section below) 1.

Run the container:

docker run -d \
--name wololo \
-p 3000:3000 \
--network host \
-v $(pwd)/config.yaml:/app/config.yaml:ro \
ghcr.io/sharmashobhit/wololo:latest

1. Open your browser and navigate to http://localhost:3000

For more deployment options, see Deployment Guide and Container Guide.

Building from Source

If you prefer to build from source:

1. Clone and build:

git clone https://github.com/sharmashobhit/wololo.git
cd wololo
cargo build --release

Configure your devices in config.yaml (see Configuration section) 1.

Run:

cargo run --release

For development setup and technical details, see Developer Guide.

Configuration

Wololo is fully config-driven and requires no database or persistence layer. All settings and device configurations are stored in a single YAML file (config.yaml), making it perfect for GitOps workflows. Simply commit your configuration to version control and deploy it anywhere - the system will run entirely from the config file without any need for persistent storage.

server:
ip: "0.0.0.0"
port: 3000
external_url: "http://localhost:3000"

sync:
enabled: true
interval_seconds: 30 # Auto-refresh device status every 30 seconds

sound:
enabled: true # Play sound when waking devices (default: true)

devices:
- name: "Device Name"
mac_address: "XX:XX:XX:XX:XX:XX"
ip_address: "192.168.1.XXX"

Configuration Options

Server Configuration

• server.ip: IP address to bind the server (default: 127.0.0.1)
• server.port: Port to run the server (default: 3000)
• server.external_url: External URL for the application (default: http://127.0.0.1:3000)

Sync Configuration

• sync.enabled: Enable/disable automatic device status refresh (default: true)
• sync.interval_seconds: Interval for automatic refresh in seconds (default: 60)

Sound Configuration

• sound.enabled: Enable/disable sound playback when waking devices (default: true). When enabled, plays the classic "Wololo" sound effect from Age of Empires when a wake packet is sent.

Device Configuration

• devices: List of devices to manage

• name: Friendly name for the device

• mac_address: MAC address of the device (required for WoL, format: XX:XX:XX:XX:XX:XX)

• ip_address: IP address of the device

See config-examples.yaml for additional configuration examples.

Device Discovery

Wololo includes a powerful network discovery feature to automatically find devices on your network:

1. Navigate to Discovery: Click the "Discovery" tab in the web interface
2. Start Network Scan: Click "Start Network Scan" to discover devices
3. Review Results: Found devices will be displayed with their status, IP, MAC, and hostname
4. Generate Config: Select desired devices and click "Generate Config"
5. Download: Download the updated config.yaml file with discovered devices

Discovery Features

• Automatic Network Detection: Scans your local network subnets
• Device Information: Retrieves IP addresses, MAC addresses, and hostnames
• Status Checking: Shows which devices are currently online/offline
• Selective Addition: Choose which discovered devices to include
• Config Integration: Merges with existing configuration seamlessly

Usage

Dashboard

The main dashboard displays all configured devices with their current status. You can:

• View device online/offline status
• Wake devices with a single click
• Manually refresh device status
• See auto-refresh status if enabled

Waking Devices

Click the "Wake" button next to any device to send a Wake On LAN packet. The device should power on if WoL is properly configured in its BIOS/UEFI settings. If sound is enabled in your configuration, you’ll hear the classic "Wololo" sound effect when the wake packet is sent!

Device Status

Device status is checked via ping. Green indicates online, red indicates offline. Status refreshes automatically if sync is enabled, or manually via the "Refresh All" button.

Deployment

Wololo can be deployed in various ways:

• Docker: Containerized deployment (recommended)
• Systemd: Linux service deployment
• Reverse Proxy: Behind Nginx, Traefik, or similar
• GitOps: Perfect for Kubernetes ConfigMaps, Docker volumes, or any infrastructure-as-code setup

With its minimal memory footprint (<5MB) and stateless, config-driven design, Wololo is ideal for containerized environments and can be easily managed through GitOps workflows. Simply mount your config.yaml file and the application runs entirely from configuration - no databases, no persistent volumes required.

For detailed deployment instructions, see Deployment Guide and Container Guide.

Documentation

• Developer Guide - Technical documentation, API reference, and development setup
• Deployment Guide - Deployment options and configurations
• Container Guide - Container-specific documentation
• Testing Guide - Testing documentation
• Contributing Guide - How to contribute to the project

License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Acknowledgments

• wol-rs for Wake On LAN functionality
• Axum for the web framework
• HTMX for dynamic web interactions
• Tailwind CSS for styling

Support

If you encounter any issues or have questions, please open an issue on GitHub.