DEV.co
Open-Source DevOps · xxh

xxh

xxh is a Python tool that lets you bring your customized shell environment (zsh, fish, bash, xonsh) to remote hosts via SSH without requiring root access or system-wide installations. It packages your shell and plugins locally, uploads them to ~/.xxh on the target host, and runs them hermetically so they can be completely removed by deleting one directory.

Source: GitHub — github.com/xxh/xxh
6k
GitHub stars
123
Forks
Python
Primary language
BSD-2-Clause
License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

FieldValue
Repositoryxxh/xxh
Ownerxxh
Primary languagePython
LicenseBSD-2-Clause — OSI-approved
Stars6k
Forks123
Open issues30
Latest release0.8.16 (2026-04-06)
Last updated2026-06-02
Sourcehttps://github.com/xxh/xxh

What xxh is

xxh builds portable, self-contained shell environments (xonsh, zsh, fish, bash, osquery) with plugins and configuration, uploads them via SSH as a tarball, and executes them from a sandboxed ~/.xxh directory. It uses prerun plugins to inject tools, dotfiles, and environment setup before shell initialization, supporting multiple deployment methods (PyPI, Homebrew, AppImage, portable binary) and both local and remote execution modes.

Quickstart

Get the xxh source

Clone the repository and explore it locally.

terminalbash
git clone https://github.com/xxh/xxh.gitcd xxh# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

DevOps/SRE Tool Portability

Carry your full shell configuration, aliases, and tools (tmux, vim, custom scripts) to temporary or restricted remote hosts without waiting for system package managers or requiring sudo access.

Multi-Host Consistency

Maintain identical shell environments across heterogeneous Linux infrastructure (different distros, minimal containers, embedded systems) by uploading the same pre-built portable shell package to each host.

Temporary/Ephemeral Environments

Work in CI/CD runners, containers, or jump hosts where you need a familiar shell experience without polluting the host filesystem; simply delete ~/.xxh when done and leave no trace.

Implementation considerations

  • Plan upload disk space: portable shells (xonsh, fish, zsh with plugins) may consume 50–200 MB per host in ~/.xxh; confirm remote filesystem quotas.
  • Test on target OS/distro before production: while Linux x86_64 is the official support surface, GLIBC version mismatches or missing libc6 dependencies on musl-based systems may require AppImage or alternative portable binaries.
  • Define hermetic level per use case: choose between isolated HOME in ~/.xxh or mounting system HOME; document this in your xxh launch wrapper or config.
  • Version-pin shells and plugins: fork or customize xxh-shell and xxh-plugin repos to ensure reproducible, auditable configurations rather than pulling latest upstream.
  • Monitor ~/.xxh cleanup: establish a policy for removing xxh directories from long-lived hosts to prevent disk bloat; consider cron jobs or post-session hooks.

When to avoid it — and what to weigh

  • Non-Linux or Non-x86_64 Targets — Currently supported only on Linux x86_64 targets. ARM support is listed as a community request. Windows, macOS, or other architectures are not supported.
  • Require Native System Integration — If your workflow depends on system-wide shell registration, PAM integration, or persistent home directory use cases where you cannot isolate to ~/.xxh, xxh's hermetic design may be a constraint.
  • Low Bandwidth or Constrained Upload Scenarios — xxh uploads entire portable shells (typically multiple MB) on every connection. Hosts with severe bandwidth restrictions or high-latency links may find the overhead impractical.
  • Minimal Security/Trust Model — xxh relies on SSH connectivity and local binary trust; if your threat model requires deep sandboxing of remote shell execution or does not allow uploading binaries, consider alternative approaches.

License & commercial use

xxh is licensed under BSD-2-Clause (Simplified BSD License), a permissive OSI-approved open-source license. This allows unrestricted use, modification, and distribution in both proprietary and open-source projects, provided the original license and copyright notice are retained.

BSD-2-Clause is a permissive license that explicitly permits commercial use without requiring release of modifications or reciprocal licensing. You may use xxh in proprietary products without obligation to contribute changes back. However, verify compliance with any bundled dependencies (shells, plugins, prerun tools) which may carry different licenses (e.g., ohmyzsh, powerlevel10k).

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

SignalAssessment
MaintenanceActive
DocumentationAdequate
License clarityClear
Deployment complexityLow
DEV.co fitGood
Assessment confidenceHigh
Security considerations

xxh uploads pre-built portable binaries to remote hosts; ensure binaries are built from trusted sources or compiled locally before upload. SSH transport is standard and inherited from OpenSSH. No additional authentication or encryption beyond SSH is added. Hermetic isolation in ~/.xxh limits side effects on host filesystem but does not prevent xxh process compromise. Plugins and prerun tools run with user privileges; review plugin source before installation. Temporary files and environment variables are stored in ~/.xxh; ensure sensitive data (API keys, tokens) are not leaked in dotfiles or shell history.

Alternatives to consider

ansible + local shell provisioning

Ansible can deploy shell configs and dotfiles to multiple hosts with privilege escalation and idempotence; better for large infrastructure but requires Ansible installation and more configuration overhead than xxh's lightweight SSH wrapper.

nix flakes or guix

Pure functional package managers can provision reproducible environments including shells; more powerful for dependency management and rollback but steeper learning curve and not designed primarily for remote SSH use.

container images (Docker/Podman) with entrypoint shells

Containerization provides stronger isolation and portability across any OS; suitable for controlled environments (Kubernetes, container registries) but overkill for ad-hoc remote SSH sessions and not applicable to bare-metal or restricted hosts.

Software development agency

Build on xxh with DEV.co software developers

Evaluate xxh for your multi-host infrastructure, ephemeral environments, or restricted remote systems. Start with a test deployment to a staging host, review the plugin ecosystem for your tools, and establish a disk-cleanup policy. For large-scale or mission-critical deployments, consider integrating xxh into a CI/CD pipeline and pair it with configuration management.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

Related on DEV.co

Explore the category and the services that help you build with it.

xxh FAQ

Do I need root access on the remote host to use xxh?
No. xxh is designed to work entirely within user permissions, uploading to ~/.xxh and not requiring sudo. This makes it ideal for shared hosting, restricted accounts, or hosts where you do not have privilege escalation.
What happens to my remote host when I disconnect from xxh?
By default, the ~/.xxh directory persists on the remote host and can be reused on subsequent connections. You can configure xxh to delete ~/.xxh on disconnect using the +hhr flag, making the session completely ephemeral and leaving no trace.
Can I use xxh with my existing SSH config and keys?
Yes. xxh accepts standard SSH arguments (e.g., -i for identity file, -p for port, -u for user, jump host specifications). Your ~/.ssh/config and SSH agent are respected without modification.
Is xxh limited to Linux?
The xxh client can run on macOS, Linux, and other Unix-like systems (via Homebrew, pip, etc.), but the remote target host must be Linux x86_64. ARM support is a community request not yet merged into stable releases.

Software development & web development with DEV.co

From first prototype to production, DEV.co delivers software development services around tools like xxh. Our software development agency staffs experienced software developers and web developers for custom software development, web development, integrations, and ongoing support across open-source devops and beyond.

Ready to Unify Your Remote Shell Experience?

Evaluate xxh for your multi-host infrastructure, ephemeral environments, or restricted remote systems. Start with a test deployment to a staging host, review the plugin ecosystem for your tools, and establish a disk-cleanup policy. For large-scale or mission-critical deployments, consider integrating xxh into a CI/CD pipeline and pair it with configuration management.