Understanding Executable Shims

Table of contents

• What is a Shim?
• Why Do We Need Shims?
• How Do Shims Work?
• Example: Chocolatey and Scoop Shims
• Benefits of Using Shims

What is a Shim?

In the world of computing, a "shim" is a small piece of code that acts as an intermediary between two software components. Think of it as a translator or a bridge that ensures smooth communication. In the context of executables, a shim is a lightweight wrapper around an actual executable file.

Why Do We Need Shims?

Shims solve several common problems:

• Managing Multiple Versions: Shims are very useful when you have multiple versions of the same program installed on your system. For example, you might have several versions of Python or Node.js. Shims can help you easily switch between them without messing up your system's configuration.

• Simplifying Access: Shims can create a simplified way to access executables. Instead of typing a long path to a program, you can use a shorter, more convenient command provided by the shim.

• Compatibility: Shims can help older programs work on newer systems by providing a compatibility layer. They can intercept and modify function calls to match what the older program expects.

• Environment Management: Tools like rbenv (for Ruby) and nvm (for Node.js), Chocolatey, and Scoop use shims to manage project-specific environments. When you switch to a different project or environment, the shims automatically point to the correct version of the required tools.

How Do Shims Work?

1. Installation: When you install a tool that uses shims, the shim files are usually placed in a directory that's included in your system's PATH environment variable. This ensures that you can access them from anywhere in your terminal.

2. Execution: When you type a command, your shell first looks for a matching executable in the directories listed in your PATH. If it finds a shim, it executes that shim instead of the actual program.

3. Redirection: The shim then does some preparatory work, such as setting up the correct environment or selecting the appropriate program version. Finally, it redirects the execution to the actual executable.

Example: Chocolatey and Scoop Shims

Let's consider how Chocolatey and Scoop, popular Windows package managers, use shims.

Chocolatey:

When you install a package with Chocolatey that includes executable files, Chocolatey often creates shims for those executables. These shims are placed in the Chocolatey bin directory, which is added to your system's PATH.

For example, if you install git using Chocolatey (choco install git), Chocolatey might create a git.exe shim. When you run the git command in your terminal, the git.exe shim is executed. This shim then calls the actual git executable, which could be located in a different directory. This system allows Chocolatey to manage where the actual executables are stored while providing easy access through the command line.

Scoop:

Scoop also uses shims to manage access to installed programs. When you install a package with Scoop (e.g., scoop install curl), Scoop creates a shim for the curl executable and places it in its shims directory. This directory is also in your PATH, allowing you to run curl from anywhere in your terminal.

The Scoop shim then locates and executes the actual curl executable. This design allows Scoop to install programs in a structured way (typically within your user directory) without requiring you to modify your PATH manually for each program.

Benefits of Using Shims

• Clean System: Shims keep your system clean by preventing the need to modify global settings or create complex directory structures.

• Easy Switching: They make it easy to switch between different program versions or environments.

• Consistency: Shims ensure that the correct program version is used, regardless of where you execute the command from.

• Extensibility: Shims can be customized to add extra functionality or modify the behavior of existing commands.

In summary, shims are a powerful tool that simplifies the management of executables, especially in complex environments with multiple versions or dependencies. By acting as smart proxies, they provide a cleaner, more organized, and more flexible way to interact with your programs.