Servin - Open-Source Cross-Platform Container Runtime

Overview

Servin is a free and open-source lightweight container runtime built from scratch in Go that provides comprehensive containerization capabilities with cross-platform support for development and production environments. As an open-source project, Servin includes advanced security features such as user namespaces, rootless containers, and local registry support, with full transparency and community-driven development.

🔓 Open Source License: Servin is released under an open-source license, allowing free use, modification, and distribution for both personal and commercial projects- ✅ Distribution: Share modified versions with the community

👥 Contributors

Servin Container Runtime is built by an amazing community of developers committed to revolutionizing cross-platform containerization.

🏆 Core Team

Brijesh Kumar - Project Founder & Lead Architect
Abhishek Kumar - Lead Developer & Feature Implementation

🤝 Join Our Community

We welcome contributors of all skill levels! Check out our CONTRIBUTORS.md for:

🚀 Getting Started - How to set up your development environment
💡 Contribution Types - Ways to contribute (code, docs, testing, design)
🏅 Recognition - How we celebrate contributor achievements
📋 Guidelines - Best practices for contributions

📊 Project Stats

📚 Learn More## � Quick Installation

Download from GitHub Releases

Get the latest release from: GitHub Releases

🍎 macOS

# Download complete PKG installer (Recommended)
# 1. Download servin_*_macos_*_installer.pkg from releases
# 2. Double-click to run installer wizard
# 3. Follows macOS installation standards with proper code signing

# Or download traditional archive
curl -O https://github.com/immyemperor/servin/releases/latest/download/servin-macos-universal.tar.gz
tar -xzf servin-macos-universal.tar.gz
cd servin-macos-universal
sudo ./ServinInstaller.command

🐧 Linux

# Download complete AppImage (Recommended - Self-contained)
wget https://github.com/immyemperor/servin/releases/latest/download/servin_*_linux_*_appimage
chmod +x servin_*_linux_*_appimage
./servin_*_linux_*_appimage --install  # Install system-wide

# Or download traditional archive
wget https://github.com/immyemperor/servin/releases/latest/download/servin-linux-amd64.tar.gz
tar -xzf servin-linux-amd64.tar.gz
cd servin-linux-amd64
sudo ./ServinInstaller.sh

🪟 Windows

# Download complete NSIS installer (Recommended)
# 1. Download servin_*_windows_*_installer.exe from releases
# 2. Run installer with administrative privileges
# 3. Automatically handles VM dependencies and system integration

# Or download traditional archive
# Download servin-windows-amd64.zip from releases
# Extract and run installer
.\ServinSetup.exe

🎯 Installer Features

Our professional installer packages provide:

Complete VM Integration

✅ Embedded VM Dependencies: QEMU, KVM, and platform-specific virtualization components
✅ Automatic Prerequisites: Detects and installs required system components
✅ Hardware Acceleration: Configures optimal VM performance for each platform

Enterprise-Quality Installation

✅ Code-Signed Packages: Verified and trusted installation experience
✅ System Integration: Proper PATH configuration and desktop shortcuts
✅ Uninstall Support: Clean removal with system restoration

Cross-Platform Consistency

✅ Unified Experience: Identical installer behavior across Windows, Linux, macOS
✅ Smart Detection: Automatically detects platform capabilities and optimizes accordingly
✅ VM Mode Ready: Pre-configured for immediate VM-based containerization

Quality Assurance

✅ 3-Tier Verification: Package validation, integrity testing, VM dependencies verification
✅ Cryptographic Validation: SHA256 checksums and binary integrity verification
✅ Automated CI/CD: Comprehensive GitHub Actions pipeline ensures quality

�📚 Documentation

Complete documentation is available at: https://immyemperor.github.io/servin

The documentation includes:

🛠️ Installation guides for Windows, Linux, and macOS
🖥️ User interface documentation (CLI, TUI, Desktop GUI)
📖 API reference and developer guides
🏗️ Architecture overview and technical details
🔧 Configuration and troubleshooting guides

Platform Support

🐧 Linux (Production Ready)

Full containerization support with namespaces (PID, UTS, IPC, NET, Mount, User)
Enhanced security isolation with user namespaces and UID/GID mapping
Complete cgroups v1 integration for resource management
Advanced networking with bridge networks, veth pairs, and IPAM
Root filesystem isolation using chroot
System-wide installation in /var/lib/servin

🪟 Windows (Development Environment)

Cross-platform container simulation for development workflows
Image management system with full import/export capabilities
Container state persistence in user home directory (cd )
Development-friendly with automatic dev mode enabling
CLI compatibility with all commands available

🍎 macOS (Development Environment)

Unix-compatible development environment with proper privilege handling
Complete image management matching Linux functionality
Homebrew-style user directory storage (~/.servin)
Sudo requirement handling with --dev flag bypass option
Native macOS path conventions

🎯 Core Features

🛡️ Security First

User Namespaces: Complete user and group ID mapping
Rootless Containers: Run containers without root privileges
PID Isolation: Process ID namespace isolation
Network Isolation: Dedicated network namespaces per container
cgroup v2 Integration: Advanced resource management and limits

🏗️ Container Management

Lifecycle Control: Create, start, stop, pause, resume containers
Multi-format Support: OCI, Docker images, and custom rootfs
Volume Management: Bind mounts and named volumes
Network Management: Custom networking with IPAM
Compose Support: Multi-container application orchestration

🖥️ Multiple User Interfaces

CLI: Command-line interface for automation and scripting
TUI: Text-based user interface for interactive management
Desktop GUI: Native desktop application (Flask + pywebview, distributed as binary)
CRI Support: Kubernetes Container Runtime Interface compatible

🚀 Recent Improvements

Enterprise-Grade Installer Packages: Complete NSIS (Windows), AppImage (Linux), and PKG (macOS) installers with embedded VM dependencies
Comprehensive CI/CD Pipeline: GitHub Actions workflow with 3-tier installer verification system (package validation, integrity testing, VM dependencies)
Automated Build & Distribution: Cross-platform package building with build-packages.sh and automated release creation
Professional Installation Experience: Smart wizard installers that detect prerequisites and handle VM setup automatically
Binary Distribution: Desktop GUI ships as compiled binary for optimal performance
Enhanced Security: VM-level isolation with proper privilege escalation and user consent flows
Quality Assurance: Cryptographic verification, file integrity checking, and component validation for all installer packages

Desktop Interface

Terminal User Interface (TUI): Full-featured text-based interface for all Servin operations
Interactive menus: Easy navigation through container, image, CRI, volume, and registry management
Real-time feedback: Command output and status updates displayed directly in terminal
Cross-platform: Works on Windows, Linux, and macOS with no additional dependencies
Docker Desktop-like experience: Familiar interface for container management workflows

Kubernetes Integration

Container Runtime Interface (CRI): HTTP-based CRI server for Kubernetes compatibility
Pod sandbox management: Create, list, and remove pod sandboxes
Container lifecycle: Full Kubernetes-compatible container operations
Image service: List, pull, remove, and status operations for container images
Health monitoring: Built-in health checks and status endpoints
RESTful API: HTTP endpoints matching CRI specification

Logging and Error Handling

Structured logging: Multi-level logging with file and console output
Rich error context: Categorized errors with contextual information
Debug support: Verbose mode with caller information and stack traces
Cross-platform logs: Platform-specific log file locations
Operational monitoring: Comprehensive audit trail and troubleshooting

VM Mode Commands

When using Servin's VM mode (automatically enabled on Windows/macOS), all standard container commands work identically but run within a secure Linux VM:

# Enable VM mode (automatic on Windows/macOS)
servin init --vm             # Initialize VM-based containerization

# Standard commands work identically in VM mode
servin run ubuntu:latest bash    # Run containers in VM
servin run --vm ubuntu bash      # Explicitly force VM mode
servin ls                        # List containers (VM or native)
servin stop CONTAINER_ID         # Stop containers in VM
servin exec CONTAINER_ID bash    # Execute commands in VM containers

# VM management
servin vm status             # Check VM status
servin vm start              # Start containerization VM
servin vm stop               # Stop containerization VM
servin vm reset              # Reset VM to clean state

Command Line Interface

# Container operations (work in both native and VM modes)
servin run [--name NAME] IMAGE COMMAND [ARGS...]
servin ls                    # List containers
servin stop CONTAINER_ID     # Stop running container
servin rm CONTAINER_ID       # Remove container
servin exec CONTAINER_ID CMD # Execute command in container
servin logs CONTAINER_ID     # Fetch logs from container

# Image operations (work in both native and VM modes)
servin image ls              # List images
servin image import FILE     # Import tarball as image
servin image rm IMAGE        # Remove image
servin image inspect IMAGE   # Inspect image details
servin image tag SOURCE TARGET # Tag an image with a new name
servin build PATH            # Build image from Buildfile

# CRI operations - Kubernetes Container Runtime Interface
servin cri start             # Start CRI HTTP server on port 8080
servin cri start --port 9090 # Start CRI server on custom port
servin cri status            # Check CRI server status
servin cri test              # Test CRI server connectivity

# GUI operations - Desktop interface
servin gui                   # Launch Servin Desktop GUI
servin gui --tui             # Launch Terminal User Interface
servin gui --dev             # Launch in development mode
servin gui --port 8081       # Launch GUI on custom port

# Network operations (native Linux + VM mode on all platforms)
servin network ls            # List networks
servin network create NAME   # Create network
servin network rm NAME       # Remove network

# Volume operations (work in both native and VM modes)
servin volume ls             # List volumes
servin volume create NAME    # Create volume
servin volume rm VOLUME      # Remove volume
servin volume rm-all         # Remove all volumes
servin volume inspect VOLUME # Inspect volume details
servin volume prune          # Remove unused volumes

# Logs operations (work in both native and VM modes)
servin logs CONTAINER        # Show container logs
servin logs -f CONTAINER     # Follow logs in real-time

Why VM Mode is Revolutionary

🚀 Universal Containerization

One Solution, All Platforms: Identical container behavior on Windows, macOS, and Linux
No Platform Limitations: Full Linux container capabilities everywhere, not just basic process isolation
True Hardware Isolation: VM-level security boundaries that exceed native container security

🔧 Technical Advantages

Complete Linux Environment: Full access to Linux namespaces, cgroups, and security features on any OS
Hardware-Level Security: VM isolation provides stronger security than process-level containers
Consistent Development: Developers get identical container behavior across all platforms
Production Parity: Development containers match Linux production environments exactly

💡 Use Cases Enabled by VM Mode

Cross-Platform Development Teams: Windows/Mac developers can run identical Linux containers
Security-Critical Applications: VM isolation for enhanced security requirements
Legacy System Modernization: Run modern containerized applications on older Windows/Mac systems
Hybrid Cloud Deployments: Consistent container behavior from developer laptops to cloud instances
Educational Environments: Teaching containerization concepts on any platform

🎯 When to Use Each Mode

VM Mode: Windows/macOS (automatic), enhanced security needs, cross-platform consistency
Native Mode: Linux servers, maximum performance, traditional container workflows servin logs -t CONTAINER # Show logs with timestamps servin logs --tail 10 CONTAINER # Show last 10 lines servin logs --since 1h CONTAINER # Show logs from last hour

Build operations

servin build . # Build image from Buildfile in current directory servin build -t myapp:v1.0 . # Build and tag image servin build -f MyBuildfile . # Build with custom Buildfile name servin build --build-arg VERSION=1.0 . # Build with arguments servin build -q . # Quiet build (only show image ID)

Compose operations

servin compose up # Create and start services from servin-compose.yml servin compose up -d # Start services in detached mode servin compose down # Stop and remove services servin compose down --volumes # Stop services and remove volumes servin compose ps # List running services servin compose ps -a # List all services (including stopped) servin compose logs # Show logs from all services servin compose logs web # Show logs from specific service servin compose logs -f web # Follow logs from specific service servin compose exec web sh # Execute command in running service servin compose -f custom-compose.yml up # Use custom compose file servin compose -p myproject up # Specify project name

Registry operations

servin registry start # Start local registry server on port 5000 servin registry start --port 5001 # Start on custom port servin registry start --detach # Start in background (planned) servin registry stop # Stop local registry server servin registry push myapp:latest # Push image to default registry servin registry push myapp:v1.0 localhost:5001 # Push to specific registry servin registry pull nginx:alpine # Pull image from default registry servin registry pull myapp:latest localhost:5001 # Pull from specific registry servin registry login docker.io # Authenticate with registry servin registry logout docker.io # Remove authentication servin registry list # List configured registries and status

Security operations

servin security check # Check security feature availability servin security info # Display current security configuration servin security config --user-ns --uid-map "0:1000:1" # Configure user namespace mapping servin security config --rootless # Enable rootless container mode servin security config --no-new-privs # Enable no-new-privileges policy servin security test # Test security isolation and namespace functionality servin security test --user-ns # Test specific security feature

Global logging and debugging flags

servin --verbose COMMAND # Enable verbose output servin --log-level debug COMMAND # Set log level (debug, info, warn, error) servin --log-file PATH COMMAND # Specify custom log file


## Platform-Specific Behavior

## Installation and Setup

### VM Mode Prerequisites
For optimal VM-based containerization experience:

**Windows:**
- Windows 10/11 Pro or Enterprise (for Hyper-V)
- Enable Hyper-V or WSL2
- 4GB+ RAM recommended for VM operations

**macOS:**
- macOS 10.15+ with Virtualization.framework
- 4GB+ RAM recommended for VM operations
- Rosetta 2 for Apple Silicon compatibility

**Linux:**
- KVM/QEMU support for VM mode (optional, native mode preferred)
- libvirt for VM management

### Quick Start with VM Mode

```bash
# Install Servin (platform-specific installer)
# Windows: Run servin-installer.exe
# macOS: Run servin-installer.pkg  
# Linux: ./install.sh

# Initialize VM mode (automatic on Windows/macOS)
servin init --vm

# Pull and run your first container in VM
servin run ubuntu:latest echo "Hello from VM containers!"

# Check VM status
servin vm status

# Start GUI for easy VM management
servin gui

Platform-Specific Behavior

Storage Locations

Native Mode (Linux)

Component	Location
Container State	`/var/lib/servin/containers`
Images	`/var/lib/servin/images`
Volumes	`/var/lib/servin/volumes`
Networks	`/var/lib/servin/networks`
Logs	`/var/lib/servin/logs`
Registry	`/var/lib/servin/registry`

VM Mode (All Platforms)

Platform	Base Directory	VM Storage	Container Data
Linux	`/var/lib/servin/vm/`	`/var/lib/servin/vm/disk.qcow2`	Inside VM filesystem
Windows	`%USERPROFILE%\.servin\vm\`	`%USERPROFILE%\.servin\vm\disk.vhdx`	Inside VM filesystem
macOS	`~/.servin/vm/`	`~/.servin/vm/disk.img`	Inside VM filesystem

Feature Matrix

🔄 Dual-Mode Architecture: Native + VM-Based Containerization

Servin provides two containerization modes for maximum flexibility:

Native Mode: Direct OS integration (Linux-only for full features)
VM Mode: Universal Linux VM for cross-platform true containerization

# Enable VM mode for universal containerization
servin vm enable

# Run containers with true isolation on ANY platform
servin run --vm alpine echo "Hello from Linux VM!"

Containerization Features by Mode

Feature	Linux	Windows	macOS
Container Isolation (Native Mode)
Namespaces (PID, NET, etc.)	✅	❌	❌
Cgroups Resource Control	✅	❌	❌
User Namespaces	✅	❌	❌
Rootless Containers	✅	❌	❌
Security Isolation	✅	❌	❌
Container Isolation (VM Mode)
Namespaces (PID, NET, etc.)	✅	✅	✅
Cgroups Resource Control	✅	✅	✅
User Namespaces	✅	✅	✅
Rootless Containers	✅	✅	✅
Security Isolation	✅	✅	✅
Container Management (All Modes)
Container Lifecycle	✅	✅	✅
Process Management	✅	✅	✅
Container Simulation	✅	✅	✅

🚀 VM-Based Universal Containerization (Revolutionary Feature)

Feature	Linux	Windows	macOS
True Container Isolation
Hardware-Level Isolation	✅	✅	✅
Full Linux Namespaces	✅	✅	✅
Complete Cgroups Support	✅	✅	✅
User Namespaces	✅	✅	✅
Rootless Containers	✅	✅	✅
Network Isolation	✅	✅	✅
VM Infrastructure
Virtualization Framework	KVM/QEMU	Hyper-V	Virtualization.framework
Hardware Acceleration	✅	✅	✅
VM Lifecycle Management	✅	✅	✅
Resource Optimization	✅	✅	✅

Universal Platform Features

Feature	Linux	Windows	macOS
Images & Registry
Image Management	✅	✅	✅
Image Building	✅	✅	✅
Multi-Architecture	✅	✅	✅
Local Registry	✅	✅	✅
Registry Push/Pull	✅	✅	✅
Image Security Scan	✅	✅	✅
Storage & Networking
Volume Management	✅	✅	✅
Bridge Networking (Native)	✅	❌	❌
Bridge Networking (VM)	✅	✅	✅
Port Management	✅	✅	✅
Network Isolation (Native)	✅	❌	❌
Network Isolation (VM)	✅	✅	✅
Orchestration
Compose Orchestration	✅	✅	✅
Multi-Container Apps	✅	✅	✅
Service Discovery	✅	✅	✅
Kubernetes Integration
CRI v1alpha2	✅	✅	✅
Pod Sandbox Management	✅	✅	✅
gRPC API Server	✅	✅	✅
Kubelet Integration	✅	✅	✅
VM Engine
VM Management	✅	✅	✅
VM Status Monitoring	✅	✅	✅
Cross-Platform VMs	✅	✅	✅
VM Configuration	✅	✅	✅
User Interfaces
CLI Interface	✅	✅	✅
Terminal UI (TUI)	✅	✅	✅
Desktop GUI	✅	✅	✅
WebView Interface	✅	✅	✅
Security Features
Capability Management (Native)	✅	❌	❌
Capability Management (VM)	✅	✅	✅
Security Policies (Native)	✅	❌	❌
Security Policies (VM)	✅	✅	✅
Security Testing	✅	✅	✅
Privilege Dropping (Native)	✅	❌	❌
Privilege Dropping (VM)	✅	✅	✅
Monitoring & Logging
Container Logs	✅	✅	✅
Log Streaming (Native)	✅	❌	❌
Log Streaming (VM)	✅	✅	✅
Health Checks	✅	✅	✅
Metrics Export	✅	✅	✅
Performance Monitoring	✅	✅	✅
Prometheus Integration	✅	✅	✅
Development & DevOps
State Persistence	✅	✅	✅
Development Mode	✅	✅	✅
Cross-Platform Testing	✅	✅	✅
Professional Installers	✅	✅	✅

🚀 Revolutionary Insight: With VM mode enabled, Servin provides identical containerization capabilities across all platforms, solving the fundamental cross-platform container compatibility problem.

Development Workflow

Cross-Platform Development

Develop on any platform using full image and state management
Test container logic with simulated environments
Deploy to Linux for production containerization

Build Instructions

# Build for current platform
go build -o servin .

# Cross-compile for different platforms
GOOS=linux go build -o servin-linux .
GOOS=windows go build -o servin-windows.exe .
GOOS=darwin go build -o servin-macos .

Testing

# Run comprehensive cross-platform test
go run test-platform.go

# Test basic functionality
./servin run alpine echo "Hello World"
./servin image ls
./servin ls

Architecture

Core Packages

cmd/: CLI command implementations using Cobra framework
pkg/container/: Container lifecycle and process management
pkg/image/: Image storage, import/export, and metadata management
pkg/state/: Container state persistence and retrieval
pkg/rootfs/: Root filesystem creation and management
pkg/network/: Networking stack with bridge and veth support
pkg/namespaces/: Linux namespace creation and management
pkg/cgroups/: Resource limitation and monitoring
pkg/cri/: Container Runtime Interface (CRI) server and Kubernetes integration

Build Constraints

//go:build linux
// Full implementation for Linux

//go:build !linux  
// Cross-platform stubs for Windows/macOS

Installation & Usage

📖 For detailed installation instructions with professional installers, see the Installation Guide

Recommended: Download from Releases

Get the latest release from: GitHub Releases

Pre-built binaries are available for:

macOS: Universal binary + professional .dmg installer
Linux: AMD64 binary + installer wizard
Windows: AMD64 binary + setup wizard

Building from Source (Development)

For development or custom builds:

Prerequisites

Go 1.21+ for building from source
Python 3.8+ for desktop GUI development
Linux kernel 3.8+ for full containerization features
Root privileges for production Linux deployment

Quick Start

# Clone and build
git clone <repository>
cd servin
go build -o servin .

# Import an image
servin image import alpine.tar

# Run a container
servin run alpine echo "Hello from Servin!"

# List containers
servin ls

# Clean up
servin rm <container_id>

Limitations & Future Enhancements

Current Limitations

Windows/macOS: No true containerization (development simulation only)
Networking: Linux-only bridge networking
Remote registries: Docker Hub and other remote registries (implementation in progress)

Planned Enhancements

Complete remote registry support for Docker Hub and other registries
Windows Containers integration
macOS containers via hypervisor framework

🚀 Getting Started Guide

For Docker Users

Migrating from Docker to Servin is straightforward with familiar commands:

# Docker vs Servin command comparison
docker run ubuntu:latest       →  servin run ubuntu:latest
docker ps                      →  servin ls  
docker stop CONTAINER          →  servin stop CONTAINER
docker rm CONTAINER            →  servin rm CONTAINER
docker images                  →  servin image ls
docker build .                 →  servin build .
docker exec CONTAINER CMD      →  servin exec CONTAINER CMD

VM Mode Advantages for Ex-Docker Users

Cross-Platform Consistency: Same container behavior on Windows/Mac as Linux
Enhanced Security: VM-level isolation exceeds Docker's process isolation
No Docker Desktop: Native tool without licensing restrictions
Better Resource Control: VM boundaries provide cleaner resource management
Educational Value: Understand containerization without abstraction layers

🚀 Deployment Modes

Servin supports two primary deployment modes to fit different infrastructure needs:

🎯 Pure VM Mode (Recommended)

Best for: Development, production workloads, Docker replacement scenarios

# Install natively (Windows/Linux/macOS)
# Download installer from GitHub releases
./servin vm start
./servin run nginx:alpine

Advantages:

✅ Best Performance: Direct VM management without container overhead
✅ True Cross-Platform: Identical behavior on Windows/Mac/Linux
✅ Security: VM-level isolation superior to containers
✅ Resource Efficiency: No Docker daemon overhead

🔄 Hybrid Mode (Advanced)

Best for: Kubernetes deployments, service orchestration, hybrid infrastructure

# Run Servin daemon in Docker/Kubernetes
docker run -d --privileged \
  --name servin-daemon \
  -v /var/run:/var/run \
  -p 10250:10250 \
  servin:latest

# Servin manages VM-based workloads
servin run nginx:alpine  # Runs in VM, not Docker!

Architecture:

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Docker Host   │    │  Servin Container│    │   VM Workloads  │
│                 │───▶│    (daemon)      │───▶│   (containers)  │
│   Kubernetes    │    │                  │    │                 │
└─────────────────┘    └──────────────────┘    └─────────────────┘

When to Use Hybrid Mode:

✅ Kubernetes Integration: Servin as a containerized service
✅ Orchestration Platforms: Service mesh deployments
✅ Hybrid Infrastructure: Docker for services, VMs for workloads
✅ Development Testing: Quick daemon setup

When to Use Pure VM Mode:

✅ Single-host Development: Direct binary usage
✅ Production Workloads: Maximum performance
✅ Docker Replacement: Pure VM-based containerization
✅ Learning: Understanding containerization fundamentals

📊 Mode Comparison

Feature	Pure VM Mode	Hybrid Mode
Performance	⭐⭐⭐⭐⭐ Best	⭐⭐⭐⭐ Good
Kubernetes	⭐⭐ Manual	⭐⭐⭐⭐⭐ Native
Simplicity	⭐⭐⭐⭐⭐ Simple	⭐⭐⭐ Complex
Security	⭐⭐⭐⭐⭐ VM isolation	⭐⭐⭐⭐ Container + VM
Resource Usage	⭐⭐⭐⭐⭐ Efficient	⭐⭐⭐ Overhead

Migration Checklist

Phase 1: Installation & Setup

Install Servin for your platform
Initialize VM mode: servin init --vm
Verify installation: servin version
Test basic functionality: servin run hello-world

Phase 2: Image Migration

Export Docker images: docker save myapp:latest | servin image import -
Pull common images: servin pull ubuntu nginx postgres
Convert Dockerfiles to Buildfiles (minimal changes needed)
Test image compatibility

Phase 3: Workflow Integration

Update CI/CD scripts to use Servin commands
Configure development environment variables
Test container networking and volumes
Verify application compatibility

Phase 4: Team Adoption

Document Servin-specific workflows
Train team on VM mode benefits
Establish cross-platform development standards
Monitor performance and resource usage

Example: WordPress Development Environment

# Traditional Docker approach (Linux only)
docker run -d --name mysql -e MYSQL_ROOT_PASSWORD=secret mysql:5.7
docker run -d --name wordpress -p 8080:80 --link mysql:mysql wordpress

# Servin approach (works identically on Windows/Mac/Linux)
servin run -d --name mysql -e MYSQL_ROOT_PASSWORD=secret mysql:5.7
servin run -d --name wordpress -p 8080:80 --link mysql:mysql wordpress

# VM mode provides identical behavior across all platforms!

Conclusion

Servin provides a complete foundation for understanding and working with container technologies while offering practical cross-platform development capabilities. It bridges the gap between learning containerization concepts and building production-ready solutions.

🎯 Key Takeaways:

Universal Containerization: VM mode enables true Linux containers on any platform
Enhanced Security: VM-level isolation provides superior security boundaries
Educational Value: Learn containerization without vendor abstractions
Production Ready: Comprehensive feature set for real-world applications
Open Source Freedom: No licensing restrictions or vendor lock-in

� Open Source & Community

Why Open Source?

Servin is committed to open-source principles, providing:

🔍 Full Transparency: Complete source code visibility and audit capability
🤝 Community-Driven: Development guided by community needs and contributions
📚 Educational Value: Learn containerization by studying real implementation
🔒 No Vendor Lock-in: Freedom to modify, extend, and distribute
🆓 Always Free: No licensing fees, premium tiers, or usage restrictions

Contributing to Servin

We welcome contributions from developers of all skill levels:

🐛 Bug Reports: Help improve stability and reliability
💡 Feature Requests: Suggest new capabilities and enhancements
📝 Documentation: Improve guides, examples, and explanations
💻 Code Contributions: Implement features, fix bugs, optimize performance
🧪 Testing: Cross-platform testing and validation
🌐 Translations: Help make Servin accessible globally

Repository & Development

📦 Source Code: https://github.com/immyemperor/servin
🐛 Issue Tracker: Report bugs and request features on GitHub
📋 Project Board: Track development progress and roadmap
🔄 Pull Requests: Contribute code improvements and new features
📞 Discussions: Join community discussions and ask questions

License & Usage

Servin is released under an open-source license that permits:

✅ Personal Use: Free for individual developers and personal projects
✅ Commercial Use: No restrictions for business and enterprise usage
✅ Modification: Adapt and customize for specific needs
✅ Distribution: Share modified versions with the community

�📚 Learn More

📖 Full Documentation: https://immyemperor.github.io/servin
🛠️ Installation Guide: Installation Instructions
🖥️ User Interfaces: CLI, TUI, GUI
🏗️ Architecture: Technical Overview
🔧 Configuration: Setup and Configuration
❓ Troubleshooting: Common Issues

Name		Name	Last commit message	Last commit date
Latest commit History 111 Commits
.github/workflows		.github/workflows
cmd		cmd
docs		docs
examples		examples
icons		icons
installers		installers
packages		packages
pkg		pkg
scripts		scripts
test-results		test-results
webview_gui		webview_gui
.gitignore		.gitignore
0001-Enhance-Linux-artifact-debugging-and-error-handling-.patch		0001-Enhance-Linux-artifact-debugging-and-error-handling-.patch
BUILD_GUIDE.md		BUILD_GUIDE.md
CLOSE_BUTTON_FIX.md		CLOSE_BUTTON_FIX.md
COMPLETE_INSTALLER_SUMMARY.md		COMPLETE_INSTALLER_SUMMARY.md
COMPOSE.md		COMPOSE.md
CONTAINERIZATION.md		CONTAINERIZATION.md
CONTAINER_EXIT_GUIDE.md		CONTAINER_EXIT_GUIDE.md
CONTAINER_LOGS.md		CONTAINER_LOGS.md
CONTRIBUTORS.md		CONTRIBUTORS.md
CRI.md		CRI.md
DESKTOP_GUI.md		DESKTOP_GUI.md
DOCKERFILE_README.md		DOCKERFILE_README.md
DOCUMENTATION_UPDATES_COMPLETE.md		DOCUMENTATION_UPDATES_COMPLETE.md
Dockerfile		Dockerfile
GITHUB_ACTIONS_INTEGRATION_COMPLETE.md		GITHUB_ACTIONS_INTEGRATION_COMPLETE.md
HEADER_FIXES_COMPLETE.md		HEADER_FIXES_COMPLETE.md
IMAGE_BUILD.md		IMAGE_BUILD.md
IMAGE_TAGGING.md		IMAGE_TAGGING.md
IMPLEMENTATION_SUMMARY.md		IMPLEMENTATION_SUMMARY.md
INSTALL.md		INSTALL.md
INSTALLER_VERIFICATION_ENHANCED.md		INSTALLER_VERIFICATION_ENHANCED.md
LICENSE		LICENSE
LOGGING_AND_ERRORS.md		LOGGING_AND_ERRORS.md
Makefile		Makefile
README-NEW.md		README-NEW.md
README-OLD.md		README-OLD.md
README.md		README.md
REGISTRY.md		REGISTRY.md
SSH_AUTOMATION_GUIDE.md		SSH_AUTOMATION_GUIDE.md
VM_IMPLEMENTATION_SUMMARY.md		VM_IMPLEMENTATION_SUMMARY.md
VM_PREREQUISITES.md		VM_PREREQUISITES.md
VM_SSH_AUTOMATION.md		VM_SSH_AUTOMATION.md
VOLUME_MANAGEMENT.md		VOLUME_MANAGEMENT.md
WIKI.md		WIKI.md
WIKI_COMPLETE.md		WIKI_COMPLETE.md
automate-vm-ssh.exp		automate-vm-ssh.exp
build-all.sh		build-all.sh
build-cross.sh		build-cross.sh
build-gui.bat		build-gui.bat
build-installer.ps1		build-installer.ps1
build-local.sh		build-local.sh
build-packages.sh		build-packages.sh
build-vm-distribution.sh		build-vm-distribution.sh
build-vm-only.sh		build-vm-only.sh
build-with-vm.sh		build-with-vm.sh
build.ps1		build.ps1
build.sh		build.sh
cross_platform_analysis.py		cross_platform_analysis.py
go.mod		go.mod
go.sum		go.sum
main.go		main.go
quick-build.sh		quick-build.sh
rebuild.sh		rebuild.sh
run-gui-fixed.bat		run-gui-fixed.bat
run-gui-latest.bat		run-gui-latest.bat
run-gui-latest.ps1		run-gui-latest.ps1
run-gui.bat		run-gui.bat
run-gui.ps1		run-gui.ps1
setup-ssh-automated.sh		setup-ssh-automated.sh
setup-vm-complete.sh		setup-vm-complete.sh
setup-vm-ssh.sh		setup-vm-ssh.sh
test-integration.sh		test-integration.sh
test-vm-containers.sh		test-vm-containers.sh
test_enhanced_vm_status.py		test_enhanced_vm_status.py
test_vm_api.py		test_vm_api.py
test_vm_gui.py		test_vm_gui.py
validate-github-actions.sh		validate-github-actions.sh

License

immyemperor/servin

Folders and files

Latest commit

History

Repository files navigation