twpayne/chezmoi
Chezmoi
chezmoi is a command-line utility designed to manage and synchronize system configuration files across multiple machines. It uses a local Git repository as the single source of truth, allowing users to track, version, and distribute dotfiles while maintaining a consistent state across diverse operating systems and hardware architectures.
The project distinguishes itself through a declarative reconciliation model that computes the difference between the current filesystem and the desired state defined in the repository. It features a robust templating engine that processes configuration files as dynamic templates, enabling the injection of machine-specific data, environment variables, and system metadata. To maintain security, it includes a transparent encryption layer and integrates directly with third-party password managers and key vaults, allowing sensitive credentials to be retrieved at runtime rather than stored in plain text.
Beyond core synchronization, the tool provides extensive automation capabilities for environment provisioning and lifecycle management. It supports custom hook-based scripts that execute before or after configuration operations, facilitating automated dependency installation and system-level setup. The platform also handles complex file management tasks, including symbolic link creation, external dependency fetching, and the ability to manage configurations within ephemeral container environments.
The project is distributed as a standalone binary, providing a comprehensive command-line interface for auditing configuration drift, previewing changes, and bootstrapping new environments.
Features
- Dotfile Managers - Provides a command-line utility for secure, version-controlled dotfile management using Git, templates, and encryption.
- Dotfile Managers - Provides a declarative system for tracking, versioning, and synchronizing dotfiles across multiple machines using Git.
- Configuration File Tracking - Tracks configuration file changes in a version-controlled working tree for synchronization across machines.
- Configuration File Generators - Generates and maintains configuration files in target locations using templates, encryption, and custom permissions.
- Environment Initialization - Initializes local configuration directories by cloning repositories or creating new tracking environments for system settings.
- State Synchronization - Synchronizes local system files to match the target state defined in the source repository.
- Configuration Management - Synchronizes personal configuration files across multiple machines using a central repository.
- System Configuration Templates - Generates machine-specific configuration files from shared templates using dynamic variables and conditional logic.
- Source State - Uses a local Git repository as the single source of truth for tracking and synchronizing configuration files.
- Cross-Machine Configuration Synchronization - Maintains a unified set of configuration files across multiple machines and operating systems.
- Configuration Templating - Injects machine-specific data into configuration files using templates to adapt settings to the deployment environment.
- Environment Bootstrapping - Bootstraps new environments by cloning configuration repositories and applying the defined state in a single operation.
- Deterministic State Reconciliation - Computes differences between the current filesystem and the desired state to maintain consistent configuration.
- Configuration-Driven Templating Engines - Processes configuration files as dynamic templates to inject machine-specific data and environment variables.
- File Synchronization - Maintains desired state for local configuration files by computing differences and applying updates.
- Git Integration Management - Executes version control commands directly within the source directory to track and synchronize configuration changes.
- Secret Management Integrations - Retrieves sensitive credentials from external password managers and vaults to inject them securely into configuration files at runtime.
- Configuration Generators - Injects system-specific data and conditional logic into configuration files using a templating engine.
- Data Injection - Provides mechanisms for dynamically populating configuration templates with external variables and environment-specific data.
- Update Preview Utilities - Compares current local file states against repository definitions to preview pending updates before application.
- Repository Synchronization - Clones and pulls configuration repositories to maintain consistent settings across multiple computers.
- Version Control Automation - Automates staging, committing, and pushing of configuration changes to ensure state consistency across machines.
- File Template Generators - Processes configuration files as templates to inject machine-specific data and automate file management.
- Configuration Encryption - Decrypts sensitive information from structured files during template processing to inject secrets securely.
- Secret Vault Integrations - Retrieves sensitive credentials from third-party password managers and key vaults at runtime.
- Configuration Lifecycle Management - Orchestrates configuration application by processing files in a specific order to manage state and dependencies.
- Configuration State Managers - Audits current file states against the intended target to identify configuration drift and pending changes.
- Dynamic Template Rendering - Processes configuration files as dynamic templates to inject machine-specific data and environment variables.
- Dotfile Managers - Secure dotfile management across multiple machines.
- Configuration State Validation - Verifies that local configuration files match their intended state and detects configuration drift.
- Automation Hooks - Triggers custom scripts before or after core operations to automate auxiliary tasks during configuration management.
- File-Based Configuration - Modifies managed configuration files and optionally applies changes to the local system.
- Lifecycle Hooks - Runs custom scripts or commands before and after specific operations to automate environment setup or cleanup.
- System Environment Setup - Executes automated scripts to install dependencies and configure system settings on new machines.
- Secret Management - Retrieves sensitive data from external password managers during file generation to keep secrets out of version control.
- Secret Injection Tools - Retrieves sensitive configuration data from remote secret managers to inject into templates securely.
- Configuration Templates - Executes template files with dynamic data to generate configuration content for multiple machines.
- Lifecycle Hook Scripts - Executes custom scripts before or after configuration operations to automate system-level setup.
- Configuration Automation Scripts - Executes custom scripts before or after configuration application to enable automated maintenance and setup.
- Configuration Inspection - Displays the intended state of configuration files to allow verification of templates before applying changes.
- Configuration Updates - Automatically triggers synchronization commands when changes occur in the source directory to maintain consistency.
- File Ignore Patterns - Defines patterns to selectively ignore files or directories during synchronization and version control tracking.
- Initialization Hooks - Executes setup scripts automatically upon startup to initialize dependencies and environment settings.
- Script Execution Engines - Runs arbitrary shell scripts during configuration application with support for conditional execution.
- Automated Merge Conflict Resolvers - Performs three-way merges to reconcile configuration differences between local and source states.
- Workspace Initialization Templates - Generates machine-specific configuration files by executing templates and prompting for environment-specific data during initialization.
- Automated System Provisioning - Automates dependency installation and system configuration during environment setup.
- Managed Configuration Updates - Refreshes the local source state with changes while maintaining encryption and template logic.
- Container Configuration - Automates configuration setup and application within ephemeral containerized environments.
- Container Runtime Managers - Manages containerized environments by aliasing commands to runtimes for consistent configuration application.
- Remote Server Provisioning - Provisions remote environments by installing the configuration manager and applying the desired state via SSH.
- Password Manager Integrations - Retrieves secrets directly from external password management services during the configuration application process.
- Environment Setup Scripts - Runs custom scripts automatically during the configuration process to handle complex setup tasks.
- Environment Detection Tools - Identifies host operating system and kernel details to conditionally apply configuration logic.
- Remote Data Fetching - Downloads files and repositories from remote sources to integrate them into the local configuration state.
- Command Execution - Runs system commands during template processing and returns status for conditional logic.
- Configuration Dictionaries - Updates configuration dictionaries by setting values at specific paths to support dynamic data manipulation.
- Configuration Injection Utilities - Injects environment-specific data and secrets into configuration files using template logic before deployment.
- Ephemeral - Provides automated configuration setup and cleanup for ephemeral containerized environments.
- External Configuration Integration - Downloads and integrates remote files or archives into the local configuration state automatically.
- Configuration Change Alerts - Displays differences between current and target file states to allow users to preview modifications before application.
- Reusable Configuration Blocks - Stores shared code snippets in a dedicated directory for injection into multiple configuration files.
- Dynamic Configuration Modifiers - Removes keys or values from data structures during template processing to dynamically filter configuration settings.
- File Attribute Modifiers - Updates metadata and processing behavior of managed files by toggling flags like encryption or permissions.
- External Dependency Managers - Downloads and tracks external dependencies as part of the configuration setup process.
- Automated Package Synchronization - Automates software package installation and updates based on configuration changes.
- Release Asset Managers - Retrieves specific file URLs from remote releases by matching version tags and file patterns.
- Template Variables - Creates reusable template variables based on system properties to simplify conditional configuration logic.
- Template Snippet Sharing - Reuses shared template snippets across multiple configuration files to maintain consistency.
- System Identifiers - Retrieves stable machine identifiers to ensure configuration logic remains consistent across different environments.
- Secrets Management - Injects secrets from external password managers and encrypted sources into configuration files at runtime.
- Secrets Management - Integrates with external password managers and encryption tools to keep sensitive data out of version-controlled repositories.
- Password Managers - Retrieves sensitive data from external password managers during template rendering to inject credentials securely.
- Environment Variable Injection - Exposes system metadata and environment variables to configuration templates for dynamic file generation.
- Symbolic Link Utilities - Creates and manages symbolic links for configuration files with appropriate administrative privileges.
