Void is a modern, high-performance reverse proxy and maintenance system developed by ByteBrush Studios. It provides intelligent traffic routing with beautiful, techy maintenance pages when services are unavailable. Built with Go for exceptional performance and featuring a stunning glassmorphic UI with animated backgrounds.

• 🔄 Intelligent Reverse Proxy: Automatically routes traffic to healthy backends and shows maintenance pages when services are down
• 🎨 Modern UI: Beautiful glassmorphic design with animated backgrounds and smooth transitions
• ⚡ High Performance: Built with Go's concurrency model for lightning-fast response times
• 📱 Responsive Design: Works flawlessly on desktop, tablet, and mobile devices
• 🛠️ Debug Information: Built-in debugging tools with client and server information
• 🌐 Multi-Service Support: Manage multiple services with individual configurations
• 📊 Smart API Handling: JSON responses for API endpoints during maintenance
• 🔧 Easy Configuration: Simple YAML-based service configuration
• 🐳 Container Ready: Docker and Kubernetes compatible
• 🚀 Multiple Deployment Options: Works with Nginx, Traefik, Dokploy, and more

Experience the modern, techy interface of Void:

Debug Panel Closed Clean, modern maintenance page with glassmorphic design

Debug Panel Open
Comprehensive debug information with syntax highlighting

• Go 1.18 or higher (for building from source)
• OR Docker (for containerized deployment)

1. Download and Build

   git clone https://github.com/ByteBrushStudios/void.git
   cd void
   make build

2. Configure Services

   # Copy example service configuration
   mkdir -p services
   cp examples/services/example.yaml services/myapp.yaml
   # Edit the configuration file

3. Run Void

   ./void

1. Using Docker Compose

   git clone https://github.com/ByteBrushStudios/void.git
   cd void
   cp examples/services.yaml.example services.yaml
   docker-compose -f examples/docker-compose.yml up -d

Void will start on port 1292 by default and begin reverse proxying to your configured services.

Void uses YAML configuration files in the services directory to define your services:

# services/myapp.yaml
services:
 - name: "My Web Application [Production]"
 host: "http://127.0.0.1:3000" # Backend server URL
 domain: "myapp.com" # Domain to match requests
 support: "https://discord.gg/support"
 status: "https://status.myapp.com"

You can create multiple YAML files to organize your services by project or environment.

1. Healthy Service: Void reverse proxies requests to the backend defined in host
2. Unhealthy Service: Void displays the beautiful maintenance page
3. API Endpoints: Services listed in apiUrls receive JSON responses during maintenance

Perfect for traditional server setups. Void acts as a fallback when your main services are down.

# Copy the example configuration
cp examples/nginx.conf /etc/nginx/sites-available/your-site
# Edit and enable the configuration
sudo nginx -t && sudo systemctl reload nginx

See examples/nginx.conf for a complete production-ready configuration.

Ideal for containerized environments with automatic service discovery.

# Copy Traefik configuration
cp examples/traefik.yml /etc/traefik/
# Void integrates seamlessly with Traefik's circuit breaker middleware

Modern deployment platform with built-in container orchestration.

# Import the Dokploy configuration
dokploy import examples/dokploy.json
# Deploy with zero-downtime rolling updates

For production server deployments:

# Copy service file
sudo cp examples/void.service /etc/systemd/system/
# Enable and start
sudo systemctl daemon-reload
sudo systemctl enable void.service
sudo systemctl start void.service

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Load Balancer │────│ Void │────│ Backend Apps │
│ (Nginx/Traefik)│ │ Reverse Proxy │ │ (Your Services) │
└─────────────────┘ └─────────────────┘ └─────────────────┘
 │
 ▼
 ┌─────────────────┐
 │ Maintenance UI │
 │ (When backend │
 │ is unhealthy) │
 └─────────────────┘

1. Incoming Request → Load balancer routes to Void
2. Domain Matching → Void matches request domain to configured service
3. Health Check → Void attempts to proxy to backend service
4. Success → Request proxied to healthy backend
5. Failure → Beautiful maintenance page served (HTML) or JSON response (APIs)

• Automatic Failover: Seamlessly switches between backend and maintenance mode
• Domain-Based Routing: Route different domains to different backend services
• Health Detection: Automatically detects when services are available again
• Header Preservation: Maintains original request headers for proper backend handling

apiUrls:
 - "api.example.com"
 - "webhooks.example.com"

API endpoints receive structured JSON responses instead of HTML:

{
 "message": "This service is down for maintenance...",
 "service": {
 "name": "API Server [Production]",
 "domain": "api.example.com",
 "support": "https://support.example.com",
 "status": "https://status.example.com"
 },
 "info": {
 "version": "2.0.0-alpha.1",
 "commit": "abc123"
 }
}

The debug panel provides comprehensive diagnostics:

• Server Info: Void version, commit hash, routing details
• Client Info: IP address, geolocation, browser details with privacy controls
• Request Details: Path, hostname, and routing information

• Animated Background: Subtle particle animations and grid patterns
• Glassmorphic Design: Modern blur effects and transparency
• Smooth Transitions: Buttery smooth animations and micro-interactions
• Responsive Layout: Perfect on all screen sizes and devices
• Dark Theme: Modern color palette optimized for readability

void/
├── main.go # Main application entry point
├── services.yaml # Service configuration
├── app.html # Modern maintenance page template
├── assets/ # Static assets (images, icons)
│ └── previews/ # UI preview images
├── state/ # Application state management
├── types/ # Type definitions and structs
├── examples/ # Configuration examples
│ ├── nginx.conf # Nginx integration example
│ ├── traefik.yml # Traefik configuration
│ ├── dokploy.json # Dokploy deployment config
│ ├── void.service # Systemd service template
│ ├── docker-compose.yml # Docker Compose setup
│ └── services.yaml.example # Service configuration example
├── temp/ # Temporary files and drafts
└── README.md # This documentation

# Install dependencies and build
make build
# Run in development mode with hot reload
make dev
# Run tests
make test
# Build for production with optimizations
make release

Void works excellently behind load balancers:

HAProxy Example:

backend void_maintenance
 server void1 127.0.0.1:1292 check
backend app_servers
 option httpchk GET /health
 server app1 127.0.0.1:3000 check fall 3 rise 2
 server app2 127.0.0.1:3001 check fall 3 rise 2
frontend web_frontend
 default_backend app_servers
 # Fallback to maintenance on 5xx errors
 errorfile 503 /dev/null
 errorloc 503 http://void-maintenance:1292

Kubernetes Example:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: void-maintenance
spec:
 replicas: 2
 selector:
 matchLabels:
 app: void
 template:
 metadata:
 labels:
 app: void
 spec:
 containers:
 - name: void
 image: void:latest
 ports:
 - containerPort: 1292
 env:
 - name: VOID_PORT
 value: "1292"
 - name: VOID_LOG_LEVEL
 value: "info"

We welcome contributions! Here's how to get started:

1. Fork & Clone

   git clone https://github.com/your-username/void.git
   cd void

2. Create Feature Branch

   git checkout -b feature/amazing-feature

3. Make Changes & Test

   make test
   make dev # Test your changes

4. Commit & Push

   git commit -m "feat: add amazing feature"
   git push origin feature/amazing-feature

5. Open Pull Request

• Follow Go best practices and gofmt formatting
• Add tests for new features
• Update documentation for any API changes
• Ensure backwards compatibility
• Test with multiple deployment scenarios

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

• Go - The Go Programming Language
• Chi Router - Lightweight HTTP router
• Tailwind CSS - Utility-first CSS framework
• Iconify - Unified icon framework
• ipapi.co - IP geolocation API

• 📚 Documentation: This README and inline code comments
• 🐛 Issues: GitHub Issues
• 💬 Discussions: GitHub Discussions
• 💬 Discord: Join our community
• 📧 Email: hey@bytebrush.dev

Void is developed and maintained by ByteBrush Studios, creators of high-quality open-source software for developers and businesses.

Other Projects:

• Infinity Bot List - The next generation Discord bot list
• Eureka - Powerful logging and utilities library