Convert Figma logo to code with AI

thoughtbot logorcm

rc file (dotfile) management

3,121
134
3,121
27

Top Related Projects

12,818

Manage your dotfiles across multiple diverse machines, securely.

7,001

A tool that bootstraps your dotfiles ⚡️

A set of vim, zsh, git, and tmux configuration files.

📦 Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask and the Mac App Store.

Quick Overview

rcm is a management suite for dotfiles, which are configuration files typically stored in a user's home directory. It provides tools to manage, synchronize, and install dotfiles across multiple machines, making it easier to maintain consistent configurations and settings.

Pros

  • Simplifies the process of managing and syncing dotfiles across multiple systems
  • Offers flexibility in organizing dotfiles with support for tags and host-specific configurations
  • Provides a set of command-line tools for easy installation, updating, and removal of dotfiles
  • Allows for version control integration, making it easy to track changes and collaborate on configurations

Cons

  • Requires initial setup and learning curve to understand the rcm workflow
  • May be overkill for users with simple dotfile needs or those who prefer manual management
  • Limited GUI support, which might be less appealing for non-command-line users
  • Potential for conflicts if not carefully managed across different systems or environments

Getting Started

To get started with rcm, follow these steps:

  1. Install rcm using your package manager (e.g., Homebrew for macOS):

    brew install rcm
    
  2. Create a dotfiles directory:

    mkdir ~/.dotfiles
    
  3. Move your existing dotfiles into the new directory:

    mv ~/.bashrc ~/.dotfiles/bashrc
    mv ~/.vimrc ~/.dotfiles/vimrc
    
  4. Use rcm to symlink the dotfiles:

    rcup
    
  5. To add new dotfiles in the future, use the mkrc command:

    mkrc ~/.zshrc
    

This will move the file to your dotfiles directory and create a symlink in your home directory.

Competitor Comparisons

12,818

Manage your dotfiles across multiple diverse machines, securely.

Pros of chezmoi

  • Cross-platform support (Windows, macOS, Linux)
  • Built-in encryption and templating features
  • Supports multiple machines with different configurations

Cons of chezmoi

  • Steeper learning curve due to more complex features
  • Requires Go installation for some advanced functionalities

Code comparison

rcm:

rcup -v
lsrc
mkrc ~/.vimrc

chezmoi:

chezmoi init
chezmoi add ~/.vimrc
chezmoi apply

Summary

rcm is a simpler, more straightforward dotfile management tool primarily designed for Unix-like systems. It uses a traditional symlink-based approach and is easy to set up and use.

chezmoi offers more advanced features like encryption, templating, and multi-machine support. It uses a source-based approach, copying files instead of symlinking, which can be beneficial in certain scenarios. However, this comes with a slightly higher complexity.

Both tools are effective for managing dotfiles, but chezmoi is more suitable for users with complex setups or those requiring advanced features, while rcm is ideal for users seeking a simpler, more traditional approach to dotfile management.

7,001

A tool that bootstraps your dotfiles ⚡️

Pros of dotbot

  • More flexible configuration using YAML files
  • Supports multiple installation methods (symlinks, copy, shell commands)
  • Cross-platform compatibility (Windows, macOS, Linux)

Cons of dotbot

  • Requires Python to run
  • Steeper learning curve for complex configurations
  • Less integrated with system package managers

Code Comparison

dotbot configuration (YAML):

- link:
    ~/.vimrc: vimrc
    ~/.zshrc: zshrc
- shell:
    - [git submodule update --init --recursive, Installing submodules]

rcm usage (shell):

rcup -v
lsrc
mkrc ~/.vimrc

Key Differences

  • dotbot uses a centralized configuration file, while rcm relies on a specific directory structure
  • rcm integrates better with system package managers and follows Unix philosophy
  • dotbot offers more granular control over installation methods
  • rcm has a simpler learning curve for basic usage

Use Cases

  • Choose dotbot for more complex setups or cross-platform compatibility
  • Opt for rcm if you prefer a simpler, Unix-style approach or better system integration

Both tools effectively manage dotfiles, but cater to different preferences and requirements.

A set of vim, zsh, git, and tmux configuration files.

Pros of dotfiles

  • Provides a comprehensive set of pre-configured dotfiles for immediate use
  • Includes additional tools and configurations beyond just dotfiles management
  • Offers a more opinionated setup, which can be beneficial for beginners

Cons of dotfiles

  • Less flexible for users who want to maintain their own custom dotfiles
  • Requires more effort to customize or remove unwanted configurations
  • May include unnecessary tools or settings for some users

Code comparison

rcm:

rcup -v
lsrc
mkrc ~/.vimrc

dotfiles:

git clone https://github.com/thoughtbot/dotfiles.git ~/dotfiles
env RCRC=$HOME/dotfiles/rcrc rcup

The rcm repository focuses on providing a tool for managing dotfiles, while dotfiles offers a pre-configured set of dotfiles along with the rcm tool. rcm allows for more granular control over individual dotfiles, whereas dotfiles provides a more complete, opinionated setup out of the box.

rcm is better suited for users who want to maintain their own dotfiles and have full control over the management process. dotfiles is ideal for those who prefer a ready-to-use configuration or want to adopt thoughtbot's recommended setup.

Both repositories use rcm for dotfile management, but dotfiles includes additional configurations and tools that extend beyond basic dotfile management.

📦 Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask and the Mac App Store.

Pros of homebrew-bundle

  • Integrates seamlessly with Homebrew, allowing for easy management of packages, casks, and taps
  • Supports a wider range of software installations beyond dotfiles
  • Can be used to set up a complete development environment with a single command

Cons of homebrew-bundle

  • Limited to macOS and Linux systems that use Homebrew
  • Doesn't handle complex dotfile configurations or symlinking
  • May require more setup time for users not familiar with Homebrew

Code Comparison

homebrew-bundle (Brewfile):

tap "homebrew/cask"
brew "git"
cask "visual-studio-code"
mas "Xcode", id: 497799835

rcm (.rcrc):

DOTFILES_DIRS="$HOME/dotfiles"
EXCLUDES="README.md LICENSE"
SYMLINK_DIRS="vim zsh"

Key Differences

  • rcm focuses specifically on managing dotfiles and creating symlinks
  • homebrew-bundle is part of a larger package management ecosystem
  • rcm is more platform-agnostic, while homebrew-bundle is tied to Homebrew
  • homebrew-bundle can manage a broader range of software installations
  • rcm provides more granular control over dotfile management and symlinking

Both tools serve different purposes but can be complementary in a comprehensive development environment setup strategy.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

rcm

This is a management suite for dotfiles. See the tutorial to get started quickly.

It assumes that you have a separate dotfiles directory, or are interested in creating one.

The programs provided are rcup(1), mkrc(1), rcdn(1), and lsrc(1). They are explained in the tutorial and configured using rcrc(5).

Installation

Alpine Linux:

sudo apk add rcm

Arch Linux:

https://aur.archlinux.org/packages/rcm/

Debian (see further down for Ubuntu):

sudo wget -q https://apt.tabfugni.cc/thoughtbot.gpg.key -O /etc/apt/trusted.gpg.d/thoughtbot.gpg
echo "deb https://apt.tabfugni.cc/debian/ stable main" | sudo tee /etc/apt/sources.list.d/thoughtbot.list
sudo apt-get update
sudo apt-get install rcm

Fedora:

sudo dnf install rcm

FreeBSD:

sudo pkg install rcm

Gentoo:

emerge app-admin/rcm

Korora:

64-bit Korora 23:

sudo dnf copr enable seeitcoming/rcm fedora-23-x86_64
sudo dnf install rcm

Korora is similar to Fedora but with an additional version and architecture specification. Replace fedora-23-x86_64 as appropriate.

macOS with Homebrew:

brew install rcm

macOS with MacPorts:

port install rcm

OpenBSD:

doas pkg_add rcm

openSUSE/RHEL/CentOS: instructions

Ubuntu (19.04 or later):

sudo apt update
sudo apt install rcm

Ubuntu (12.04, 14.04, 16.04, 18.04, or 18.10):

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:martin-frost/thoughtbot-rcm
sudo apt-get update
sudo apt-get install rcm

Void Linux:

sudo xbps-install -S rcm

Elsewhere:

This uses the standard GNU autotools, so it's the normal dance:

curl -LO https://thoughtbot.github.io/rcm/dist/rcm-1.3.4.tar.gz &&

# Use sha256sum with GNU coreutils, sha256 on BSD and macOS
sha=$(sha256sum rcm-1.3.4.tar.gz | cut -f1 -d' ') &&
[ "$sha" = "9b11ae37449cf4d234ec6d1348479bfed3253daba11f7e9e774059865b66c24a" ] &&

tar -xvf rcm-1.3.4.tar.gz &&
cd rcm-1.3.4 &&

./configure &&
make &&
sudo make install

For more, see INSTALL.

Programs

  • rcup(1) is the main program. It is used to install and update dotfiles, with support for tags, host-specific files, and multiple source directories.
  • rcdn(1) is the opposite of rcup(1).
  • mkrc(1) is for introducing a dotfile into your dotfiles directory, with support for tags and multiple source directories.
  • lsrc(1) shows you all your dotfiles and where they would be symlinked to. It is used by rcup(1) but is provided for your own use, too.

Support

Pull requests welcome; see CONTRIBUTING.md.

License

Copyright 2013 Mike Burns. BSD license. Copyright 2014 thoughtbot. BSD license.

About thoughtbot

thoughtbot

This repo is maintained and funded by thoughtbot, inc. The names and logos for thoughtbot are trademarks of thoughtbot, inc.

We love open source software! See our other projects. We are available for hire.