rvm/rvm

Features

• Per-Project Library Isolations - Maintains separate directory hierarchies for libraries per Ruby version to prevent dependency conflicts between projects.
• Multi-Interpreter Support - Downloads and configures multiple language implementations and versions on a single system to support varying project requirements.
• Ruby Version Managers - Installs and switches between multiple Ruby interpreter versions on a single system to support different project requirements.
• Environment Wrappers - Creates wrapper scripts that preload specific language versions and dependency sets for execution in non-interactive shells.
• Isolated Environment Managers - Creates self-contained environments including specific interpreter versions and dedicated dependencies to prevent conflicts.
• Language Environment Provisioning - Automates the installation of the environment manager and language runtimes during system setup.
• Dependency Isolation - Implements named library sets to prevent dependency conflicts between different Ruby projects.
• Runtime Version Switching - Changes the active interpreter for the current shell session or based on a project configuration file.
• Shell Initialization Scripts - Uses shell profile scripts to initialize the environment manager and load configurations automatically during login.
• Shell Initialization Managers - Automates the injection of management logic into shell startup files to control Ruby environment variables.
• Dependency Isolation - Assigns distinct library sets to different projects on an application server to prevent dependency conflicts.
• Language Runtime Provisioning - Provisions Ruby runtimes and environments across remote servers and build agents using configuration management tools.
• Isolated Runtime Environments - Creates isolated environments with specific language versions and dedicated dependencies to prevent conflicts between projects.
• Environment Wrappers - Generates standalone scripts that load specific interpreters and environments for service managers and init scripts.
• Interpreter Source Compilations - Provides automated source compilation of Ruby interpreters with custom compiler flags for specific system library links.
• Isolated Library Sets - Creates, deletes, copies, and switches between independent sets of libraries for a specific interpreter to prevent conflicts.
• Language Build Automation - Provides automated source compilation of the Ruby interpreter with custom compiler flags and system library links.
• Language Interpreters - Downloads and installs specific versions of various language implementations on a single system.
• Runtime Environment Managers - Manages the creation and switching of named library sets to ensure dependency isolation.
• Shell Environment Injections - Injects shell functions into sessions to dynamically modify the PATH and environment variables for runtime selection.
• Named Dependency Groups - Creates and switches between named groups of libraries for specific interpreters to avoid version conflicts.
• Environment Path Injections - Dynamically updates the system PATH variable to prioritize selected Ruby interpreters over system defaults.
• Remote Environment Management - Manages dependencies and ensures automatic installation of the correct interpreter for remote deployment tasks.
• Build Environment Configurators - Configures specific interpreters and library sets on build agents to ensure consistent automated build environments.
• Compiler Flag Customization - Builds interpreter versions using custom compiler flags to link against external system or manager-provided libraries.
• Deployment Automation - Automates the process of updating servers with fresh releases and managing transitions from staging to production.
• Project Ecosystem Detection - Automatically detects and loads specific Ruby interpreters and project environments based on the directory.
• Remote Environment Configurations - Provides mechanisms to synchronize the language version and configuration between local development and remote production platforms.
• Runtime Environment Integrations - Connects Ruby interpreters and library sets with text editors, terminal emulators, and shell profiles for a seamless workflow.
• Environment Wrapper Generators - Creates standalone executables that automatically load a specific Ruby interpreter and library set from any shell location.
• Shell Integrations - Configures the environment manager for Zsh to ensure compatibility with prompt behavior and regex operators.
• Configuration Management Integrations - Deploys and configures the environment manager across systems using Chef cookbooks for automated infrastructure management.
• Environment Parity - Matches local language versions to remote platform stacks to ensure consistency between development and production.
• Infrastructure as Code Deployments - Uses programmable infrastructure definitions to install and configure language interpreters across multiple machines.
• Language Runtime Deployment - Automates the provisioning of Ruby runtimes across remote servers and build agents to align development and production.
• Remote Toolkit Deployments - Automates the deployment of the environment manager and specific language runtimes to remote servers.
• Runtime Dependency Enforcement - Ensures deployment tasks utilize the correct language version and library sets during project updates.
• User-Mode Installations - Compiles and installs Ruby runtimes into user-owned directories to avoid requiring root privileges.
• Application Server Integrations - Links specific language versions to web application servers to ensure apps execute in the correct environment.
• Shell Script Wrappers - Generates shell scripts that preload specific Ruby interpreters and library sets for execution outside interactive shells.
• Build Dependency Installers - Detects and utilizes system package managers to install native libraries required for building language interpreters from source.
• Interpreter Source Compilation - Downloads and compiles specific language implementations with configurable language modes and build options.
• Named Dependency Set Organization - Organizes groups of libraries into named sets that can be shared across different environments or mapped to branches.
• Runtime Executable Wrappers - Creates standalone executable scripts that automatically load a specific Ruby version and environment for cron jobs or service managers.
• Service Environment Wrappers - Generates standalone scripts that load a specific interpreter and library set to start applications via system init scripts.

Star history