# Switching from Docker Desktop to OrbStack on macOS
For years, Docker Desktop has been the go-to tool for containerization — but let’s be honest, it hasn’t always been smooth sailing. If you're a macOS user, you might have faced [sluggish performance, unexpected crashes](https://www.reddit.com/r/docker/comments/vwq724/wtf_is_up_with_docker_desktop_on_macos), or your computer using many resources.
Fortunately, there's a better way. Enter [OrbStack](https://docs.orbstack.dev/) — a sleek, lightning-fast alternative that addresses many of Docker Desktop’s pain points. OrbStack provides a native macOS experience with faster startup times, efficient resource usage, and features like automatic container domain name assignment. The result? A smoother workflow and a more productive development experience.
This guide walks you through installing OrbStack, migrating from Docker Desktop, and leveraging its features.
[ad-uptime]
## Prerequisites
Before you start, ensure you have the following:
- Basic familiarity with Docker.
- Homebrew installed on your macOS machine.
## What is OrbStack?
OrbStack is a lightweight and easy-to-use platform that combines container and Linux virtual machine management into a single, streamlined app. Think of it as a supercharged alternative to Docker Desktop built specifically with macOS users in mind.
What makes OrbStack suitable is its fast startup, low CPU and memory usage, optimized networking, and battery-friendly performance. And, it’s simple to use, with features like automatic domain names, seamless file sharing, and built-in debugging tools.
Beyond containers, OrbStack also supports Kubernetes and Linux distributions, allowing you to manage everything you need from one interface. Whether you're debugging, exploring volume files, or running containers, OrbStack makes it all effortless.
## Why switch to OrbStack?
OrbStack offers several advantages over Docker Desktop:
- Faster startup times and better resource utilization.
- Minimal setup, automatic HTTPS, and built-in debugging tools.
- Supports standard Docker CLI, Compose, and third-party tools like VS Code.
Here's how it compares to Docker Desktop:
| Feature | OrbStack | Docker Desktop |
|------------------------------|-------------------------------------------|-----------------------------------------|
| Performance | Near-native performance, instant startup | Slower startup, higher resource usage |
| Resource usage | Low CPU and memory usage | High CPU and memory usage |
| Networking | Automatic domain names, wildcards, HTTPS | Limited networking support |
| Debugging tools | Built-in Debug Shell | Limited to `docker exec` |
| File sharing | Two-way file sharing | One-way file sharing |
| GUI | Native macOS app | Electron-based app |
| Pricing | Free for personal use, $8/user/month | Free for personal use, enterprise-tier pricing |
To put these advantages into perspective, the benchmarks speak for themselves. The following screenshot demonstrates that OrbStack performs general tasks approximately 1.3 times faster than Docker Desktop:
Another benchmark highlights its superiority in building both ARM64 and AMD64 images, where OrbStack proves to be about 1.2 times faster than Docker Desktop:
The advantages extend beyond speed. Resource usage tests show that OrbStack is about 1.7 times more efficient in background power consumption, resulting in quieter fans, extended battery life, and less overall wear on your system.
## Installing OrbStack
Install OrbStack using Homebrew for a quick and hassle-free setup. Open your terminal and run:
```command
brew install orbstack
```
Once installed, launch OrbStack and follow the installation wizard. The interface should look like this when finished:
OrbStack includes all necessary tools, including:
- Docker CLI
- Docker Compose
- Compatibility with VS Code Dev Containers
Verify that OrbStack has switched your Docker context by running:
```command
docker context show
```
```text
[output]
orbstack
```
Now that you have installed OrbStack on your machine, you will migrate data from Docker Desktop.
## Migrating data from Docker Desktop
If you’ve been using Docker Desktop, you likely have a range of existing containers, images, and volumes. OrbStack makes it easy to migrate this data and ensures that your existing setup functions smoothly. OrbStack provides a CLI tool called `orb` that allows you to manage various aspects of your Docker environment directly from the command line.
Before proceeding with the migration, it’s a good idea to restart the OrbStack Docker engine to ensure a clean slate. You can do this simply by running:
```command
orb restart docker
```
By taking this step, you help ensure that all your previously running containers, images, and volumes will integrate smoothly into the OrbStack environment.
Then click on **Migrate** in the OrbStack app:
Alternatively, you can run the following command:
```command
orb migrate docker
```
The migration may take a few minutes. Once complete, your Docker data will appear in OrbStack.
With the Docker data migrated from Docker Desktop, you can proceed in the next section to learn more about how OrbStack interacts with containers.
## Getting started with OrbStack
After installing OrbStack and migrating your Docker Desktop data, you can now manage containers, images, and volumes through an intuitive graphical interface. Instead of relying solely on the command line, you can interact with your environment directly from the OrbStack application.
Begin by opening the **Images** tab, where you will find all imported or pulled images:
You can examine detailed metadata for any image, including tags, labels, and supported architectures, simply by clicking on it:
If you have many images, use the search feature to quickly locate the one you need:
Next, switch to the **Volumes** tab to review and manage your existing volumes:
Here, you can see how much space each volume occupies and, by clicking on one, view which services are using it as well as when it was created:
To view all currently running containers, switch to the **Containers** tab:
From here, you can easily see how many containers are active. Each container has controls for tasks like stopping or removing it. For example, to pause a container, select the stop button (◼):
If you need to start a container that is currently stopped, click the start button (▶):
### Using the OrbStack menu bar app
OrbStack’s menu bar application provides even faster access to essential features. By clicking the OrbStack icon in your Mac’s menu bar, you can quickly view running containers, images, and volumes:
In the following screenshot, you can see all running services, with options to start or stop them without opening the main interface:
With this overview of the OrbStack UI, you are now ready to take advantage of its streamlined environment for managing your containerized applications.
## Automatic container domains
OrbStack simplifies service access by automatically assigning domain names to containers, following the `container-name.orb.local` pattern. Domains are structured as `service.project.orb.local` for Docker Compose projects.
To access a container’s service, navigate to the **Containers** tab in OrbStack and click the link icon (🔗) associated with the desired container:
You’ll also see the ports the container uses, making it easy to know which services are available. Clicking the link icon will open the service interface in your default browser.
When you open a container’s web interface in your browser, you’ll notice that the domain name does not include a port number. OrbStack automatically detects standard web ports and routes your service to a user-friendly domain like `https://container-name.orb.local/`, so you don’t need to remember or specify ports for typical web services.
If you need to specify a custom port, OrbStack still allows. In addition, OrbStack handles HTTPS configuration out of the box, including generating and installing certificates for you. There’s no need to spend time setting up a reverse proxy or dealing with self-signed certificates.
Alternatively, visiting `orb.local` in your browser provides an index of all running containers, allowing for easy access to each service:
If you need even more flexibility, OrbStack allows you to configure custom domains and wildcards, making it easy to mirror your production environment or use domain structures that suit your workflow.
For example, to assign custom domains to a container, add the `dev.orbstack.domains` label. Suppose you want your `nginx` container to respond to both `foo.local` and `bar.local`:
```command
docker run --rm -l dev.orbstack.domains=foo.local,bar.local nginx
```
Or with a `docker-compose.yml` file:
```yaml
services:
nginx:
image: nginx
labels:
- dev.orbstack.domains=foo.local,bar.local
```
OrbStack also supports wildcard domains. For instance, setting `dev.orbstack.domains=*.foo.local,*.bar.local` allows any subdomain of `foo.local` and `bar.local` to resolve to your container. This can be especially useful for microservices architectures or multi-tenant scenarios with numerous subdomains.
## Inspecting logs and files with OrbStack
OrbStack allows you to inspect logs and access files directly from its intuitive interface. These features are essential for troubleshooting issues, monitoring container activity, and maintaining control over your containerized applications.
To view logs, open the OrbStack application and navigate to the **Containers** tab. Select the container you want to inspect, and in the right sidebar, click **Logs**:
This opens a real-time view of the container’s output, showing critical information such as application errors, startup details, or runtime messages:
Logs can help diagnose issues quickly, such as identifying missing dependencies or configuration errors that prevent a container from starting successfully.
OrbStack also allows you to access and manage container files directly from macOS. Select the container in the same **Containers** tab and click the **Files** button in the sidebar.
This action opens the container’s file system in Finder, where you can view, edit, add, or delete files:
With that, let's look at how to debug containers with OrbStack.
## Debugging containers
OrbStack’s Debug Shell makes container debugging effortless with a built-in terminal environment that outshines the traditional `docker exec` command found in Docker Desktop. Its features are tailored to enhance troubleshooting and performance optimization, even for minimal or distroless containers without built-in commands or shell environments. Key features include:
- Access powerful utilities like `htop`, `curl`, `strace`, and `ip` directly from the Debug Shell.
- Shell auto-completion and syntax highlighting
- Integrated editors like `nano` or `vim` for in-container file editing
- Colorful output
- Built-in package manager that can install over 80,000 packages using the `dctl` command or through auto-install prompts
- Support for minimal containers
With these features, OrbStack’s Debug Shell provides unmatched flexibility and functionality, making it an invaluable tool for debugging and managing containers effectively.
This feature is handy for troubleshooting and optimizing performance, even for minimal or distroless containers that lack built-in commands or shell environments.
To start a Debug Shell, you can click the **Debug** button in the OrbStack app:
Alternatively, you can open the Debug Shell directly from the terminal using the following command:
```command
orb debug
```
This launches a terminal session inside the selected container, giving you instant access to tools and utilities without modifying the container itself. Here’s how the Debug Shell appears:
For instance, if you need to monitor resource usage or pinpoint processes consuming excessive CPU or memory, you can run `htop`:
```command
htop
```
Here is an example of the Debug Shell running `htop`:
As mentioned, OrbStack’s Debug Shell goes far beyond Docker Desktop’s `docker exec` by including features such as colorful `ls` output, editors like `vim` and `nano`, and access to a wide range of commands like `curl`, `strace`, and `ip`. It even allows package installation with the `dctl` command. For example, you can install and run Neovim with:
```command
dctl install nvim
```
The screenshot below demonstrates Neovim being installed in OrbStack’s Debug Shell using the built-in package manager:
Once installed, Neovim can be launched directly within the Debug Shell for efficient in-container editing. Here’s an example of Neovim running in the terminal:
OrbStack simplifies package management further. If a command isn’t found, the Debug Shell will automatically prompt you to install the necessary package.
Installed packages remain available across all containers within the Debug Shell environment, without altering the container itself, ensuring that even read-only containers remain debuggable.
## Using Linux machines
OrbStack isn’t limited to containers—it can also run full Linux machines that integrate seamlessly with macOS. These machines behave similarly to traditional VMs, but with significantly less overhead, offering a near-native experience.
To create a new Linux machine, open the **Linux Machines** tab in the OrbStack app and click **New Machine**:
A dialog will appear where you can specify the machine’s name, distribution, version, and CPU type. After entering your details, click **Create**:
Once the machine is ready, you can open a terminal session directly into it:
From here, installing packages and managing services works exactly as it does in a typical Linux environment:
Your Mac’s files are also accessible from within the Linux machine, allowing for effortless file sharing. Clicking the **Folder** icon in the OrbStack interface opens Finder:
Inside the machine, you’ll find your Mac’s files mounted under `/mnt/linux`. You can view and modify the machine’s filesystem directly from Finder, just as you did with containers:
## Final thoughts
This guide provided step-by-step instructions on installing OrbStack, migrating from Docker Desktop, and using its powerful features to enhance your containerization experience.
OrbStack represents a significant improvement in container and Linux VM management for macOS users, addressing many of the performance and usability issues commonly associated with Docker Desktop.
To continue learning more about Docker, see our [tutorial series](https://betterstack.com/community/guides/scaling-docker/)