Go into your WSL distro (Run wsl in powershell) and check if KVM is enabled by using the kvm-ok command. The output should look like this:

INFO: /dev/kvm exists
KVM acceleration can be used

Use the command sudo apt -y install bridge-utils cpu-checker libvirt-clients libvirt-daemon qemu qemu-kvm to install it if it isn't.

Now download and install Docker for Windows if it is not already installed.

After installation, go into Settings and check these 2 boxes:

General -> "Use the WSL2 based engine";
Resources -> WSL Integration -> "Enable integration with my default WSL distro",

Ensure x11-apps is installed. Use the command sudo apt install x11-apps -y to install it if it isn't.

Finally, there are 3 ways to get video output:

• WSLg: This is the simplest and easiest option to use. There may be some issues such as the keyboard not being fully passed through or seeing a second mouse on the desktop - Issue on WSLg - but this option is recommended.

-e "DISPLAY=${DISPLAY:-:0.0}" \
-v /mnt/wslg/.X11-unix:/tmp/.X11-unix \

-e "DISPLAY=${DISPLAY:-:0}" \
-v /mnt/wslg/.X11-unix:/tmp/.X11-unix \

For Ubuntu 20.x on Windows, see https://github.com/sickcodes/Docker-OSX/discussions/458

• VNC: See the VNC section for more information. You could also add -vnc argument to qemu. Connect to your mac VM via a VNC Client. Here is a how to
• Desktop Environment: This will give you a full desktop linux experience but it will use a bit more of the computer's resources. Here is an example guide, but there are other guides that help set up a desktop environment. DE Example

Additional boot instructions for when you are creating your container

• Boot the macOS Base System (Press Enter)

• Click Disk Utility

• Erase the BIGGEST disk (around 200gb default), DO NOT MODIFY THE SMALLER DISKS.

• (optional) Create a partition using the unused space to house the OS and your files if you want to limit the capacity. (For Xcode 12 partition at least 60gb.)

• Click Reinstall macOS

• The system may require multiple reboots during installation

Troubleshooting

Routine checks

This is a great place to start if you are having trouble getting going, especially if you're not that familiar with Docker just yet.

Just looking to make a container quickly? Check out our container creation examples section.

More specific/advanced troubleshooting questions and answers may be found in More Questions and Answers. You should also check out the closed issues. Someone else might have gotten a question like yours answered already even if you can't find it in this document!

Confirm that your CPU supports virtualization

See initial setup.

Docker Unknown Server OS error

docker: unknown server OS: .
See 'docker run --help'.

This means your docker daemon is not running.

pgrep dockerd should return nothing

Therefore, you have a few choices.

sudo dockerd for foreground Docker usage. I use this.

Or

sudo systemctl --start dockerd to start dockerd this now.

Or

sudo systemctl --enable --now dockerd for start dockerd on every reboot, and now.

Use more CPU Cores/SMP

Examples:

-e EXTRA='-smp 6,sockets=3,cores=2'

-e EXTRA='-smp 8,sockets=4,cores=2'

-e EXTRA='-smp 16,sockets=8,cores=2'

Note, unlike memory, CPU usage is shared. so you can allocate all of your CPU's to the container.

Confirm your user is part of the Docker group, KVM group, libvirt group

Add yourself to the Docker group

If you use sudo dockerd or dockerd is controlled by systemd/systemctl, then you must be in the Docker group. If you are not in the Docker group:

sudo usermod -aG docker "${USER}"

sudo usermod -aG libvirt "${USER}"
sudo usermod -aG kvm "${USER}"

See also: initial setup.

Is the docker daemon enabled?

# run ad hoc
sudo dockerd
or daemonize it
sudo nohup dockerd &
enable it in systemd (it will persist across reboots this way)
sudo systemctl enable --now docker
or just start it as your user with systemd instead of enabling it
systemctl start docker

More Questions and Answers

Big thank you to our contributors who have worked out almost every conceivable issue so far!

https://github.com/sickcodes/Docker-OSX/blob/master/CREDITS.md

Start the same container later (persistent disk)

Created a container with docker run and want to reuse the underlying image again later?

NB: see container creation examples first for how to get to the point where this is applicable.

This is for when you want to run the SAME container again later. You may need to use docker commit to save your container before you can reuse it. Check if your container is persisted with docker ps --all.

If you don't run this you will have a new image every time.

# look at your recent containers and copy the CONTAINER ID
docker ps --all
docker start the container ID
docker start -ai abc123xyz567
if you have many containers, you can try automate it with filters like this
docker ps --all --filter "ancestor=sickcodes/docker-osx"
for locally tagged/built containers
docker ps --all --filter "ancestor=docker-osx"

You can also pull the .img file out of the container, which is stored in /var/lib/docker, and supply it as a runtime argument to the :naked Docker image.

See also: here.

I have used Docker-OSX before and want to restart a container that starts automatically

Containers that use sickcodes/docker-osx:auto can be stopped while being started.

# find last container
docker ps -a
docker start old container with -i for interactive, -a for attach STDIN/STDOUT
docker start -ai -i <Replace this with your ID>

LibGTK errors "connection refused"

You may see one or more libgtk-related errors if you do not have everything set up for hardware virtualisation yet. If you have not yet done so, check out the initial setup section and the routine checks section as you may have missed a setup step or may not have all the needed Docker dependencies ready to go.

See also: here.

Permissions denied error

If you have not yet set up xhost, try the following:

echo $DISPLAY
ARCH
sudo pacman -S xorg-xhost
UBUNTU DEBIAN
sudo apt install x11-xserver-utils
CENTOS RHEL FEDORA
sudo yum install xorg-x11-server-utils
then run
xhost +

RAM over-allocation

If you are trying to allocate more RAM to the container than you currently have available, you may see an error like the following: cannot set up guest memory 'pc.ram': Cannot allocate memory. See also: here, here.

For example (below) the buff/cache already contains 20 Gigabytes of allocated RAM:

[user@hostname ~]$ free -mh
               total        used        free      shared  buff/cache   available
Mem:            30Gi       3.5Gi       7.0Gi       728Mi        20Gi        26Gi
Swap:           11Gi          0B        11Gi

Clear the buffer and the cache:

sudo tee /proc/sys/vm/drop_caches <<< 3

Now check the RAM again:

[user@hostname ~]$ free -mh
               total        used        free      shared  buff/cache   available
Mem:            30Gi       3.3Gi        26Gi       697Mi       1.5Gi        26Gi
Swap:           11Gi          0B        11Gi

PulseAudio

Use PulseAudio for sound

Note: AppleALC, alcid and VoodooHDA-OC do not have codec support. However, IORegistryExplorer does show the controller component working.

docker run \
    --device /dev/kvm \
    -e AUDIO_DRIVER=pa,server=unix:/tmp/pulseaudio.socket \
    -v "/run/user/$(id -u)/pulse/native:/tmp/pulseaudio.socket" \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    sickcodes/docker-osx

PulseAudio debugging

docker run \
    --device /dev/kvm \
    -e AUDIO_DRIVER=pa,server=unix:/tmp/pulseaudio.socket \
    -v "/run/user/$(id -u)/pulse/native:/tmp/pulseaudio.socket" \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    -e PULSE_SERVER=unix:/tmp/pulseaudio.socket \
    sickcodes/docker-osx pactl list

PulseAudio with WSLg

docker run \
    --device /dev/kvm \
    -e AUDIO_DRIVER=pa,server=unix:/tmp/pulseaudio.socket \
    -v /mnt/wslg/runtime-dir/pulse/native:/tmp/pulseaudio.socket \
    -v /mnt/wslg/.X11-unix:/tmp/.X11-unix \
    sickcodes/docker-osx

Forward additional ports (nginx hosting example)

It's possible to forward additional ports depending on your needs. In this example, we'll use Mac OSX to host nginx:

host:10023 <-> 10023:container:10023 <-> 80:guest

On the host machine, run:

docker run -it \
    --device /dev/kvm \
    -p 50922:10022 \
    -e ADDITI \
    -p 10023:10023 \
    sickcodes/docker-osx:auto

In a Terminal session running the container, run:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install nginx sudo sed -i -e 's/8080/80/' /usr/local/etc/nginx/nginx.confcd 
sudo nginx -s stop
 sudo nginx

nginx should now be reachable on port 10023.

Additionally, you can string multiple statements together, for example:

-e ADDITI
    -p 10023:10023 \
    -p 10043:10043 \

Bridged networking

You might not need to do anything with the default setup to enable internet connectivity from inside the container. Additionally, curl may work even if ping doesn't.

See discussion here and here and here.

Enable IPv4 forwarding for bridged network connections for remote installations

This is not required for LOCAL installations.

Additionally note it may cause the host to leak your IP, even if you're using a VPN in the container.

However, if you're trying to connect to an instance of Docker-OSX remotely (e.g. an instance of Docker-OSX hosted in a datacenter), this may improve your performance:

# enable for current session
sudo sysctl -w net.ipv4.ip_forward=1
OR
sudo tee /proc/sys/net/ipv4/ip_forward <<< 1
enable permanently
sudo touch /etc/sysctl.conf
sudo tee -a /etc/sysctl.conf <<EOF
net.ipv4.ip_forward = 1
EOF
or edit manually with the editor of your choice
nano /etc/sysctl.conf || vi /etc/sysctl.conf || vim /etc/sysctl.conf
now reboot

Share folder with Docker-OSX QEMU macOS

Sharing a folder with guest is quite simple.

Your folder, will go to /mnt/hostshare inside the Arch container which is then passed over QEMU.

Then mount using sudo -S mount_9p hostshare from inside the mac.

For example,

FOLDER=~/somefolder

-v "${FOLDER}:/mnt/hostshare" \
    -e EXTRA="-virtfs local,path=/mnt/hostshare,mounttag=hostshare,securitymodel=passthrough,id=hostshare" \

Full example:

# stat machddng.img
SHARE=~/somefolder
docker run -it \     --device /dev/kvm \     -p 50922:10022 \     -v /tmp/.X11-unix:/tmp/.X11-unix \     -e "DISPLAY=${DISPLAY:-:0.0}" \     -v "${PWD}/machddng.img:/home/arch/OSX-KVM/machddng.img" \     -v "${SHARE}:/mnt/hostshare" \     -e EXTRA="-virtfs local,path=/mnt/hostshare,mounttag=hostshare,securitymodel=passthrough,id=hostshare" \     sickcodes/docker-osx:latest
!!! Open Terminal inside macOS and run the following command to mount the virtual file system
sudo -S mount_9p hostshare

Share Linux NFS Drive into macOS

To share a folder using NFS, setup a folder for on the host machine, for example, /srv/nfs/share and then append to /etc/exports:

/srv/nfs/share      127.0.0.1/0(insecure,rw,allsquash,anonuid=1000,anongid=985,nosubtree_check)

You may need to reload exports now, which will begin sharing that directory.

# reload shared folders
sudo exportfs -arv

Source & Explanation

Give permissions on the shared folder for the anonuid and anongid, where anonuid and anongid matches that of your linux user; id -u

id -u ; id -g will print userid:groupid

chown 1000:985 /srv/nfs/share chmod u+rwx /srv/nfs/share

Start the Docker-OSX container with the additional flag --network host

Create and mount the nfs folder from the mac terminal:

mkdir -p ~/mnt sudo mount_nfs -o locallocks 10.0.2.2:/srv/nfs/share ~/mnt

Share USB Drive into macOS over QEMU

Mount USB Drive (Hotplug/Hot Plug USB)

Start your container.

Pick a port, for example, 7700.

lsusb to get vid:pid

On Linux: sudo usbredirserver -p 7700 1e3d:2096

Now, in the Docker window hit Enter to see the (qemu) console.

You can add/remove the disk using commands like this, even once the machine is started:

chardev-add socket,id=usbredirchardev1,port=7700,host=172.17.0.1

device_add usb-redir,chardev=usbredirchardev1,id=usbredirdev1,debug=4

Mount USB Drive inside macOS at boot Docker OSX

PORT=7700
IP_ADDRESS=172.17.0.1
-e EXTRA="-chardev socket,id=usbredirchardev1,port=${PORT},host=${IP_ADDRESS} -device usb-redir,chardev=usbredirchardev1,id=usbredirdev1,debug=4" \</code></pre>

Fedora: enable internet connectivity with a bridged network
Fedora's default firewall settings may prevent Docker's network interface from reaching the internet. In order to resolve this, you will need to whitelist the interface in your firewall:
<pre><code class="lang-bash"># Set the docker0 bridge to the trusted zone sudo firewall-cmd --permanent --zone=trusted --add-interface=docker0 sudo firewall-cmd --reload</code></pre>
Nested Hardware Virtualization
Check if your machine has hardware virtualization enabled:
<pre><code class="lang-bash">sudo tee /sys/module/kvm/parameters/ignore_msrs &lt;&lt;&lt; 1
egrep -c &#39;(svm|vmx)&#39; /proc/cpuinfo</code></pre>
Virtual network adapters
Fast internet connectivity
-e NETWORKING=vmxnet3

Slow internet connectivity
-e NETWORKING=e1000-82545em

CI/CD Related Improvements
Tips for reducing the size of the image
Start the container as usual, and remove unnecessary files. A useful way
  to do this is to use du -sh * starting from the / directory, and find
  large directories where files can be removed. E.g. unnecessary cached files,
  Xcode platforms, etc.
Once you are satisfied with the amount of free space, enable trim with sudo trimforce enable, and reboot.

Zero out the empty space on the disk with dd if=/dev/zero of=./empty && rm -f empty

Shut down the VM and copy out the qcow image with docker cp stoppedcontainer:/home/arch/OSX-KVM/machddng.img .

Run qemu-img check -r all machddng.img to fix any errors.

Run qemu-img convert -O qcow2 machddng.img deduped.img and check for errors again

OPTIONAL: Run qemu-img convert -c -O qcow2 deduped.img compressed.img to further compress the image. This may reduce the runtime speed though, but it should reduce the size by roughly 25%.

Check for errors again, and build a fresh docker image. E.g. with this Dockerfile

<pre><code class="lang-">FROM sickcodes/docker-osx
USER arch
COPY --chown=arch ./deduped.img /home/arch/OSX-KVM/machddng.img</code></pre>
Run Docker-OSX headlessly with Telnet
First make sure autoboot is enabled
Next, you will want to set up SSH to be automatically started.
<pre><code class="lang-bash">sudo systemsetup -setremotelogin on</code></pre>
Make sure to commit the new docker image and save it, or rebuild as described in the section on reducing disk space.
Then run it with these arguments.
<pre><code class="lang-bash"># Run with the -nographic flag, and enable a telnet interface   docker run \     --device /dev/kvm \     -p 50922:10022 \     -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \     -e EXTRA=&quot;-monitor telnet::45454,server,nowait -nographic -serial null&quot; \     mycustomimage</code></pre>
What mirrors are appropriate to use to build Docker-OSX locally?
If you are building Docker-OSX locally, you'll probably want to use Arch Linux's mirrors.
Mirror locations can be found here (uses two-letter country codes): https://archlinux.org/mirrorlist/all/
<pre><code class="lang-bash">docker build -t docker-osx:latest \     --build-arg RANKMIRRORS=true \     --build-arg MIRROR_COUNTRY=US \     --build-arg MIRROR_COUNT=10 \     --build-arg SHORTNAME=catalina \     --build-arg SIZE=200G .</code></pre>
Custom QEMU Arguments (passthrough devices)
Pass any devices/directories to the Docker container & the QEMU arguments using the handy runtime argument provider option -e EXTRA=.

<pre><code class="lang-bash"># example customizations docker run \     -e RAM=4 \     -e SMP=4 \     -e CORES=4 \     -e EXTRA=&#39;-usb -device usb-host,hostbus=1,hostaddr=8&#39; \     -e INTERNALSSHPORT=23 \     -e MAC_ADDRESS=&quot;$(xxd -c1 -p -l 6 /dev/urandom | tr &#39;\n&#39; &#39;:&#39; | cut -c1-17)&quot; \     -e AUDIO_DRIVER=alsa \     -e IMAGE_PATH=/image \     -e SCREENSHAREPORT=5900 \     -e DISPLAY=:0 \     -e NETWORKING=vmxnet3 \     --device /dev/kvm \     --device /dev/snd \     -v /tmp/.X11-unix:/tmp/.X11-unix \     docker-osx:latest</code></pre>
Generating serial numbers
Generate serial numbers in ./custom OR make docker generate them at runtime (see below).

At any time, verify your serial number before logging into iCloud, etc.
<pre><code class="lang-bash"># this is a quick way to check your serial number via cli inside OSX ioreg -l | grep IOPlatformSerialNumber
test some commands
sshpass -p &#39;alpine&#39; ssh user@localhost -p 50922 &#39;ping google.com&#39;
check your serial number
sshpass -p &#39;alpine&#39; ssh user@localhost -p 50922 &#39;ioreg -l | grep IOPlatformSerialNumber&#39;</code></pre>
Getting started with serial numbers
<pre><code class="lang-bash"># ARCH pacman -S libguestfs
UBUNTU DEBIAN
apt install libguestfs -y
RHEL FEDORA CENTOS
yum install libguestfs -y</code></pre>
Inside the ./custom folder you will find 4 scripts.

config-nopicker-custom.plist

opencore-image-ng.sh


These two files are from OSX-KVM.
You don't need to touch these two files.
The config.plist has 5 values replaced with placeholders. Click here to see those values for no reason.
generate-unique-machine-values.sh

This script will generate serial numbers, with Mac Addresses, plus output to CSV/TSV, plus make a bootdisk image.
You can create hundreds, ./custom/generate-unique-machine-values.sh --help

<pre><code class="lang-bash">./custom/generate-unique-machine-values.sh \     --count 1 \     --tsv ./serial.tsv \     --bootdisks \     --output-bootdisk OpenCore.qcow2 \     --output-env source.env.sh</code></pre>
Or if you have some specific serial numbers...
generate-specific-bootdisk.sh

<pre><code class="lang-bash">generate-specific-bootdisk.sh \
    --model &quot;${DEVICE_MODEL}&quot; \
    --serial &quot;${SERIAL}&quot; \
    --board-serial &quot;${BOARD_SERIAL}&quot; \
    --uuid &quot;${UUID}&quot; \
    --mac-address &quot;${MAC_ADDRESS}&quot; \
    --output-bootdisk OpenCore-nopicker.qcow2</code></pre>
This example generates a random set of serial numbers at runtime, headlessly
<pre><code class="lang-bash"># proof of concept only, generates random serial numbers, headlessly, and quits right after. docker run --rm -it \     --device /dev/kvm \     -p 50922:10022 \     -e NOPICKER=true \     -e GENERATE_UNIQUE=true \     -e DEVICE_MODEL=&quot;iMacPro1,1&quot; \     sickcodes/docker-osx:auto
-e OSX_COMMANDS=&#39;ioreg -l | grep IOPlatformSerialNumber&#39; \</code></pre>
This example generates a specific set of serial numbers at runtime
<pre><code class="lang-bash"># run the same as above 17gb auto image, with SSH, with nopicker, and save the bootdisk for later. 
you don&#39;t need to save the bootdisk IF you supply specific serial numbers!

docker run -it \     --device /dev/kvm \     -p 50922:10022 \     -e NOPICKER=true \     -e GENERATE_SPECIFIC=true \     -e DEVICE_MODEL=&quot;iMacPro1,1&quot; \     -e SERIAL=&quot;C02TW0WAHX87&quot; \     -e BOARD_SERIAL=&quot;C027251024NJG36UE&quot; \     -e UUID=&quot;5CCB366D-9118-4C61-A00A-E5BAF3BED451&quot; \     -e MAC_ADDRESS=&quot;A8:5C:2C:9A:46:2F&quot; \     -e OSX_COMMANDS=&#39;ioreg -l | grep IOPlatformSerialNumber&#39; \     sickcodes/docker-osx:auto</code></pre>
This example generates a specific set of serial numbers at runtime, with your existing image, at 1000x1000 display resolution
<pre><code class="lang-bash"># run an existing image in current directory, with a screen, with SSH, with nopicker.
stat machddng.img # make sure you have an image if you&#39;re using :naked
docker run -it \     -v &quot;${PWD}/machddng.img:/image&quot; \     --device /dev/kvm \     -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \     -v /tmp/.X11-unix:/tmp/.X11-unix \     -p 50922:10022 \     -e NOPICKER=true \     -e GENERATE_SPECIFIC=true \     -e DEVICE_MODEL=&quot;iMacPro1,1&quot; \     -e SERIAL=&quot;C02TW0WAHX87&quot; \     -e BOARD_SERIAL=&quot;C027251024NJG36UE&quot; \     -e UUID=&quot;5CCB366D-9118-4C61-A00A-E5BAF3BED451&quot; \     -e MAC_ADDRESS=&quot;A8:5C:2C:9A:46:2F&quot; \     -e WIDTH=1000 \     -e HEIGHT=1000 \     sickcodes/docker-osx:naked</code></pre>
If you want to generate serial numbers, either make them at runtime using     -e GENERATE_UNIQUE=true \

Or you can generate them inside the ./custom folder. And then use: <pre><code class="lang-bash">-e GENERATE_SPECIFIC=true \     -e SERIAL=&quot;&quot; \     -e BOARD_SERIAL=&quot;&quot; \     -e UUID=&quot;&quot; \     -e MAC_ADDRESS=&quot;&quot; \</code></pre>

Making serial numbers persist across reboots
<pre><code class="lang-bash">stat machddng_testing.img touch ./output.env
generate fresh random serial numbers, with a screen, using your own image, and save env file with your new serial numbers for later.
docker run -it \     --device /dev/kvm \     -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \     -v /tmp/.X11-unix:/tmp/.X11-unix \     -p 50922:10022 \     -e NOPICKER=true \     -e GENERATE_UNIQUE=true \     -e GENERATE_SPECIFIC=true \     -e DEVICE_MODEL=&quot;iMacPro1,1&quot; \     -v &quot;${PWD}/output.env:/env&quot; \     -v &quot;${PWD}/machddng_testing.img:/image&quot; \     sickcodes/docker-osx:naked</code></pre>
To use iMessage or iCloud you need to change 5 values.

SERIAL

BOARD_SERIAL

UUID

MAC_ADDRESS


ROM is just the lowercased mac address, without : between each word.
You can tell the container to generate them for you using -e GENERATE_UNIQUE=true

Or tell the container to use specific ones using -e GENERATE_SPECIFIC=true

<pre><code class="lang-bash">-e GENERATE_SPECIFIC=true \     -e DEVICE_MODEL=&quot;iMacPro1,1&quot; \     -e SERIAL=&quot;C02TW0WAHX87&quot; \     -e BOARD_SERIAL=&quot;C027251024NJG36UE&quot; \     -e UUID=&quot;5CCB366D-9118-4C61-A00A-E5BAF3BED451&quot; \     -e MAC_ADDRESS=&quot;A8:5C:2C:9A:46:2F&quot; \</code></pre>
Changing display resolution
The display resolution is controlled by this line:
https://github.com/sickcodes/Docker-OSX/blob/master/custom/config-nopicker-custom.plist#L819
Instead of mounting that disk, Docker-OSX will generate a new OpenCore.qcow2 by using this one cool trick:

<pre><code class="lang-bash">-e GENERATE_UNIQUE=true \ -e WIDTH=800 \ -e HEIGHT=600 \</code></pre>
To use WIDTH/HEIGHT, you must use with either -e GENERATEUNIQUE=true or -e GENERATESPECIFIC=true.

It will take around 30 seconds longer to boot because it needs to make a new boot partition using libguestfs.

<pre><code class="lang-bash">-e GENERATE_SPECIFIC=true \ -e WIDTH=1920 \ -e HEIGHT=1080 \ -e SERIAL=&quot;&quot; \ -e BOARD_SERIAL=&quot;&quot; \ -e UUID=&quot;&quot; \ -e MAC_ADDRESS=&quot;&quot; \</code></pre>
Change Docker-OSX Resolution Examples
<pre><code class="lang-bash"># using an image in your current directory stat machddng.img
docker run -it \     --device /dev/kvm \     -p 50922:10022 \     -v &quot;${PWD}/machddng.img:/image&quot; \     -v /tmp/.X11-unix:/tmp/.X11-unix \     -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \     -e GENERATE_SPECIFIC=true \     -e DEVICE_MODEL=&quot;iMacPro1,1&quot; \     -e SERIAL=&quot;C02TW0WAHX87&quot; \     -e BOARD_SERIAL=&quot;C027251024NJG36UE&quot; \     -e UUID=&quot;5CCB366D-9118-4C61-A00A-E5BAF3BED451&quot; \     -e MAC_ADDRESS=&quot;A8:5C:2C:9A:46:2F&quot; \     -e MASTERPLISTURL=https://raw.githubusercontent.com/sickcodes/Docker-OSX/master/custom/config-nopicker-custom.plist \     -e WIDTH=1600 \     -e HEIGHT=900 \     sickcodes/docker-osx:naked</code></pre>
<pre><code class="lang-bash"># generating random serial numbers, using the DIY installer, along with the screen resolution changes. docker run -it \     --device /dev/kvm \     -p 50922:10022 \     -v /tmp/.X11-unix:/tmp/.X11-unix \     -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \     -e GENERATE_UNIQUE=true \     -e WIDTH=800 \     -e HEIGHT=600 \     sickcodes/docker-osx:latest</code></pre>
Here's a few other resolutions! If your resolution is invalid, it will default to 800x600.
<pre><code class="lang-">-e WIDTH=800 \     -e HEIGHT=600 \</code></pre>
<pre><code class="lang-">-e WIDTH=1280 \     -e HEIGHT=768 \</code></pre>
<pre><code class="lang-">-e WIDTH=1600 \     -e HEIGHT=900 \</code></pre>
<pre><code class="lang-">-e WIDTH=1920 \     -e HEIGHT=1080 \</code></pre>
<pre><code class="lang-">-e WIDTH=2560 \     -e HEIGHT=1600 \</code></pre>
This example shows how to change resolution after the container is created.
First step is to stop the docker daemon <pre><code class="lang-">sudo systemctl stop docker</code></pre> The second step is to change container config in  <pre><code class="lang-">/var/lib/docker/containers/[container-id]/config.v2.json</code></pre> (Suppose your original WIDTH is 1024 and HEIGHT is 768, you can search 1024 and replace it with the new value. Same for 768.)
The last step is to restart the docker daemon <pre><code class="lang-">sudo systemctl restart docker</code></pre>
Mounting physical disks in Mac OSX
Pass the disk into the container as a volume and then pass the disk again into QEMU command line extras with.
Use the config-custom.plist because you probably want to see the boot menu, otherwise omit the first line:

<pre><code class="lang-bash">DISKTWO=&quot;${PWD}/mountme.img&quot;</code></pre> <pre><code class="lang-dockerfile">-e MASTERPLISTURL=&#39;https://raw.githubusercontent.com/sickcodes/osx-serial-generator/master/config-custom.plist&#39; \ -v &quot;${DISK_TWO}:/disktwo&quot; \ -e EXTRA=&#39;-device ide-hd,bus=sata.5,drive=DISK-TWO -drive id=DISK-TWO,if=none,file=/disktwo,format=qcow2&#39; \</code></pre>
Physical disk mounting example
<pre><code class="lang-bash">OSXIMAGE=&quot;${PWD}/machddngxcode_bigsur.img&quot; DISKTWO=&quot;${PWD}/mountme.img&quot;
docker run -it \     --device /dev/kvm \     -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \     -v /tmp/.X11-unix:/tmp/.X11-unix \     -e MASTERPLISTURL=&#39;https://raw.githubusercontent.com/sickcodes/osx-serial-generator/master/config-custom.plist&#39; \     -v &quot;${OSX_IMAGE}&quot;:/image \     -v &quot;${DISK_TWO}&quot;:/disktwo \     -e EXTRA=&#39;-device ide-hd,bus=sata.5,drive=DISK-TWO -drive id=DISK-TWO,if=none,file=/disktwo,format=qcow2&#39; \     sickcodes/docker-osx:naked</code></pre>
See also: here.
Extracting the APFS disk on Linux
In Docker-OSX, we are using qcow2 images.

This means the image grows as you use it, but the guest OS thinks you have 200GB available.
READ ONLY
<pre><code class="lang-bash"># mount the qemu image like a real disk sudo modprobe nbd max_part=8 sudo qemu-nbd --connect=/dev/nbd0 ./image.img sudo fdisk /dev/nbd0 -l
mkdir -p ./mnt sudo mount /dev/nbd0p1 ./mnt
inspect partitions (2 partitions)
sudo fdisk /dev/nbd0 -l
mount using apfs-linux-rw OR apfs-fuse
mkdir -p ./part
sudo mount /dev/nbd0p2 ./part sudo apfs-fuse -o allow_other /dev/nbd0p2 ./part</code></pre>
When you are finishing looking at your disk, you can unmount the partition, the disk, and remove the loopback device:
<pre><code class="lang-bash">sudo umount ./part sudo umount ./mnt sudo qemu-nbd --disconnect /dev/nbd0 sudo rmmod nbd</code></pre>
USB Passthrough
Firstly, QEMU must be started as root.
It is also potentially possible to accomplish USB passthrough by changing the permissions of the device in the container. See here.
For example, create a new Dockerfile with the following
<pre><code class="lang-bash">FROM sickcodes/docker-osx USER arch RUN sed -i -e s/exec\ qemu/exec\ sudo\ qemu/ ./Launch.sh COPY --chown=arch ./newimage.img /home/arch/OSX-KVM/machdd_ng.img</code></pre>
Where new_image.img is the qcow2 image you extracted. Then rebuild with docker build .

Next we need to find out the bus and port numbers of the USB device we want to pass through to the VM:
<pre><code class="lang-bash">lsusb -t /:  Bus 02.Port 1: Dev 1, Class=roothub, Driver=xhcihcd/6p, 5000M /:  Bus 01.Port 1: Dev 1, Class=roothub, Driver=xhcihcd/12p, 480M     |__ Port 2: Dev 5, If 0, Class=Human Interface Device, Driver=usbhid, 12M     |__ Port 2: Dev 5, If 1, Class=Chip/SmartCard, Driver=, 12M     |__ Port 3: Dev 2, If 0, Class=Wireless, Driver=, 12M     |__ Port 3: Dev 2, If 1, Class=Wireless, Driver=, 12M     |__ Port 5: Dev 3, If 0, Class=Video, Driver=uvcvideo, 480M     |__ Port 5: Dev 3, If 1, Class=Video, Driver=uvcvideo, 480M</code></pre>
In this example, we want to pass through a smartcard device. The device we want is on bus 1 and port 2.
There may also be differences if your device is usb 2.0 (ehci) vs usb 3.0 (xhci). See here for more details.
<pre><code class="lang-bash"># hostbus and hostport correspond to the numbers from lsusb 
runs in privileged mode to enable access to the usb devices.
 docker run \   --privileged \   --device /dev/kvm \   -e RAM=4 \   -p 50922:10022 \   -e &quot;DISPLAY=${DISPLAY:-:0.0}&quot; \   -e EXTRA=&quot;-device virtio-serial-pci -device usb-host,hostbus=1,hostport=2&quot; \   mycustomimage</code></pre>

You should see the device show up when you do system_profiler SPUSBDataType` in the MacOS shell.
Important Note: this will cause the host system to lose access to the USB device while the VM is running!
Container creation examples
Quick Start your own image (naked co

README truncated. View on GitHub