XPipe is a desktop application designed for system administrators, DevOps engineers, and developers who need to manage hundreds of remote servers, containers, and virtual machines from a single interface. It solves the fragmentation problem of juggling multiple tools like SSH, Docker CLI, kubectl, RDP, and VNC by integrating them into a unified, local desktop hub. All connections are managed without installing agents on remote systems, preserving security and reducing setup overhead.
Built in Java with JavaFX, XPipe leverages existing command-line tools (SSH, docker, kubectl, tmux, etc.) and integrates with local environments like WSL, PowerShell, and password managers. It supports deployment on Windows, macOS, and Linux via installers, portable archives, or package managers (apt, brew, winget, choco). Data is stored locally in a cryptographically secure vault, with optional Git-based sync for team collaboration.
What You Get
- Unified Connection Hub - Centralize and organize SSH, Docker, Kubernetes, Proxmox, Hyper-V, VMware, LXD, incus, and cloud servers (AWS, Hetzner) in a hierarchical tree with one-click access.
- Remote File Browser - Browse, edit, and transfer files on remote systems using your local editors (VS Code, Sublime, etc.) with dynamic sudo elevation and tabbed multitasking across multiple hosts.
- Terminal Launcher - Instantly open shell sessions in your preferred terminal (iTerm2, Windows Terminal, Alacritty, etc.) with auto-filled credentials, tmux/zellij integration, and pre-configured shell environments (oh-my-zsh, starship).
- SSH Full Integration - Automatically load and apply existing SSH config files, agents, jump hosts, key files, smartcards, and X11 forwarding without reconfiguration.
- Container & K8s Management - Connect to Docker, Podman, LXD, incus, and Kubernetes clusters to list, start, stop, and inspect containers and pods directly from the UI.
- Scripting System - Create reusable shell scripts and init templates that auto-deploy to remote systems, customize shell environments, and trigger actions like tunneling or service restarts.
- Remote Desktop & X11 Forwarding - Launch RDP, VNC, and X11 applications remotely with automatic SSH tunneling and seamless desktop app integration.
- Automatic Service Tunneling - Detect and tunnel remote services (e.g., web apps in containers) to your local machine with one click, no manual port mapping required.
- Git-Based Sync & Vault - Synchronize connection configurations and secrets across devices using your own Git repository; secrets are never stored by XPipe but pulled from local password managers.
- No Remote Setup Required - XPipe works entirely through local CLI tools — no agents, daemons, or configuration changes needed on remote servers.
Common Use Cases
- Managing hundreds of cloud and on-prem servers - A DevOps engineer uses XPipe to quickly access 200+ AWS, Hetzner, and on-prem Linux servers via SSH, with grouped categories and one-click terminal launches.
- Developing in containerized environments - A developer uses XPipe to browse files in Docker/Podman containers, exec into running pods in Kubernetes, and tunnel services like PostgreSQL or Redis to their local IDE.
- Team collaboration on infrastructure - A sysadmin team shares SSH configs, scripts, and connection hierarchies via a private Git repo, ensuring consistent access and reducing onboarding time.
- Remote desktop and GUI app access - A Linux admin connects to a remote Proxmox VM via RDP or X11 forwarding to run GUI tools like GIMP or Docker Desktop without installing a full desktop environment.
- Automating repetitive server tasks - A SRE creates a script to restart Nginx on all web servers in a group, then assigns it to a desktop shortcut for one-click execution across multiple hosts.
Under The Hood
Architecture
- Modular Java 17+ module system enforces clean boundaries through explicit exports and requires declarations, enabling controlled extensibility of core components like ActionProvider and EventHandler
- Service-oriented design with interface-based contracts (ValidatableStore, ProcessControlProvider) and ServiceLoader enables dynamic plugin extension without core modification
- UI and business logic are cleanly separated using MVC patterns with JavaFX Bindings for reactive state updates, while platform abstraction layers handle OS-specific behaviors like graphics initialization
- Extensible configuration system leverages Jacksonized builders and declarative validation to support type-safe, complex strategy definitions
Tech Stack
- Java 8+ backend with Spring Boot 2.x for RESTful microservices and distributed system coordination
- Redis for distributed caching and pub/sub messaging with custom clustering logic
- MySQL 5.7 with MyBatis for persistent storage and manually optimized queries
- Maven for multi-module build orchestration and dependency management
- JUnit 5 and Mockito for comprehensive unit and integration testing with extensive service mocking
- Docker Compose and Kubernetes for containerized deployment and service orchestration
Code Quality
- Strong modularity enforced via Java Platform Module System with clear package hierarchies and descriptive naming conventions
- Lombok reduces boilerplate while structured logging and custom error classes improve maintainability and error propagation
- Type safety is prioritized through Java’s strong typing, Jackson annotations, and contract-based interfaces
- Test coverage is extensive in core modules but inconsistent in application-layer code, with some tests lacking assertions or relying on println statements
What Makes It Unique
- Native integration of Model Context Protocol directly into the UI, enabling seamless LLM tooling across popular editors without external plugins
- Decoupled beacon server architecture exposes local filesystem, SSH, and action APIs over HTTP, turning local systems into remote-extensible platforms
- Unified terminal and shell framework with dialect-aware scripting, automatic transcript logging, and cross-platform process control
- First-class support for RDP, VNC, and SPICE protocols embedded within the desktop interface, treating remote sessions as native interactive components
- LocalStore abstraction unifies shell execution, state persistence, and network tunneling into a single context-aware remote access model