Skip to content

PKG vs. DMG: Mac app deployment for Windows admins

PDQ Team
PDQ team|November 19, 2026
General2 2026
General2 2026

TL;DR: A PKG is an installer package that macOS Installer can run with the installer command, usually without notifying the user. A DMG is a disk image, which is a container that can hold an app, a PKG, or other files along with it. You need to mount it as an extra step. Before you deploy either one, you should inspect the contents and read the vendor’s installation instructions. PDQ can deploy PKG and DMG files to Macs from the same console you use for Windows, but each app should still get its own test run first.

On Windows the installation process is quite trivial and doesn’t usually get a second glance. An MSI usually means that you can expect a clean silent install. An EXE sometimes means that you’ll have to go hunting for switches if installing from a command line or console. To the uninitiated, it can be quite jarring when someone hands over a Mac app and the download is a .dmg that opens a window with an app icon and an arrow pointing at a folder.

That’s a challenge for PKG vs. DMG Mac app deployment. The file you download could be a container, an installer, or the app itself, but the extension doesn’t always tell you which you’re looking at. If you’re running Windows and macOS side by side, the installation workflow is quite short. A PKG gets a signature check and goes through Installer, and a DMG gets mounted first. An app inside it gets copied to /Applications, a PKG inside it gets installed, and anything else should send you back to the vendor’s docs.

What is inside a PKG and a DMG?

A PKG installer bundles payload files, instructions for where they go, and sometimes scripts that run before or after the install. The macOS Installer app unpacks it and writes a receipt, so the Mac keeps a record of what it installed.

A DMG installer is really a disk image that’s closer to an ISO file than an MSI. You can mount one, and you might find an app bundle to drag into /Applications, a PKG the vendor placed inside, or an installer app that does its own thing altogether.

The good news is that you can inspect both without double-clicking anything. Replace the example filenames and paths with your actual values. For the DMG, use the mount path reported by hdiutil attach; for the PKG, use the package’s actual location. 

hdiutil attach Vendor.dmg -nobrowse -readonly
ls /Volumes/Vendor
pkgutil --payload-files Vendor.pkg
pkgutil --expand Vendor.pkg ~/Desktop/vendor-expanded

The -nobrowse flag keeps the mounted volume out of Finder. pkgutil --payload-files lists what a package would install without installing it, and pkgutil --expand unpacks it into a folder so you can read any scripts that might be present.

PKG

DMG

What it is

Installer package

Disk image (a container)

How it installs

macOS Installer or the installer command

Mount it, then copy the app or run the PKG inside

Inspect with

pkgutil --payload-files or --expand

hdiutil attach -nobrowse -readonly

Check the signature with

pkgutil --check-signature

spctl -a -v on the app inside

Leaves an install receipt

Usually

Mounting or copying an app does not; running an installer from the image may create one

How do you deploy each format safely?

It’s usually best to start with the signature. pkgutil --check-signature Vendor.pkg shows you if a package is signed and who signed it. For an app, spctl -a -v Vendor.app asks Gatekeeper for a verdict, and Apple’s docs show a notarized app reporting source=Notarized Developer ID.

Next, you’ll want to read the vendor’s deployment notes. Some apps require a config file or a license key, and others might want a specific install order. The admin guide may be the only place that tells you what to expect.

For a PKG, the silent install is usually one line that you can run as root:

sudo installer -pkg /path/to/Vendor.pkg -target /

For a DMG, you might need to script the steps. Mount it, install the PKG inside or copy the app across, then detach the image:

hdiutil attach Vendor.dmg -nobrowse -readonly -mountpoint /tmp/vendor
ditto /tmp/vendor/Vendor.app /Applications/Vendor.app
hdiutil detach /tmp/vendor

Prompts are where Mac deployments can get tricky. An app that’s open during an update could block it, and some permissions, like Full Disk Access, can only be preapproved through an MDM privacy profile. A script can’t click “Allow” for the user, unfortunately.

Then the next step is to pilot it. You’ll want to follow the same endpoint management best practices that you already use with Windows. Try to include an older macOS release if you have access to one, and, if you still have them, an Intel Mac, because some vendors ship separate builds per chip type.

In PDQ, a custom package install step can accept PKG and DMG files, and you can add Bash or Zsh script steps for anything that a vendor’s format needs. For common apps, PDQ’s Package Library has prebuilt macOS packages that you can deploy and automate patching for.

How do you verify installation and updates?

A green deployment status can only tell you that the deployment reported success; it does not by itself confirm that the app works as expected. You can check the app itself on a pilot Mac before committing to a live rollout:

codesign -dv /Applications/Vendor.app
defaults read /Applications/Vendor.app/Contents/Info.plist CFBundleShortVersionString

The first command shows the bundle identifier and signing information. Compare these with the expected app and vendor; displaying signing information does not verify the signature. The second shows the version. For PKGs, pkgutil --pkgs lists installed receipts, but an app that was dragged in from a DMG doesn’t leave a receipt at all. Next, you’ll want to launch the app as a standard user to catch any first-run prompts or dialogs.

It’s a good idea to plan the update and removal path before you first install an app. Some Mac apps update themselves, but others need you to push each new version, which is why third-party patch management is so useful. Removing a dragged-in app usually requires you to delete its bundle, and a PKG could leave helpers and background services behind, so it’s sometimes best to look for a vendor uninstaller instead of reinventing the wheel.

None of this covers macOS updates and upgrades, though. Those run through Apple’s software update process and through your MDM on managed Macs. That’s why you’ll want to keep them on a separate track.


Want to push PKG and DMG installs to Macs from the same console as your Windows fleet? Start a free trial.

PDQ Team
PDQ team

The PDQ content team writes practical guides for sysadmins on patching, software deployment, and endpoint management. Built for sysadmins, by sysadmins, our content is shaped by real-world IT experience and the tools we create — like PDQ Connect, a cloud-based platform for remotely managing Windows and macOS devices. We focus on simple, secure, and pretty damn quick solutions you can use in real environments, whether you're managing 15 devices or 15,000. The goal is always faster fixes, fewer surprises, and healthier fleets.

Related articles