How It Works

This page follows one app from the old PC to the new one, and back out again. Each step links to the page with the detail.

flowchart TD
    A["Old PC: pick an app"] --> B["See what goes in, and choose"]
    B --> C["Build the installer"]
    C --> D["Copy it to the new PC"]
    D --> E["Check it, and see what it will set up"]
    E --> F["Install, and check every file"]
    F --> G{"Did everything work?"}
    G -->|Yes| H["App installed, with an entry in Settings"]
    G -->|"No, or you cancelled"| I["What changed is put back"]
    H --> J["Later: uninstall from Settings"]

1. List the apps. The app reads the same list of installed apps that Windows keeps for Settings. It leaves out entries Windows itself hides, which are parts of other apps, and it does not list Microsoft Store apps. It can read this list from the PC it runs on, or from a drive taken out of another PC, or an image of one. That PC can also have an older Windows, such as Windows 7. See Moving from a connected drive or a disk image. It can also read an old PC that still runs, over your network, through a small program you run there, WinAppMigrator Client. See Moving from a PC over the network.

2. Look at one app. When you click an app, the app looks at it in the background. This is called a scan. It reads:

• how the app was installed, from the records its setup left behind (MSI, Inno Setup, or NSIS);
• its folders, and folders named exactly for it;
• its settings in the registry;
• its services, scheduled tasks, startup items, and shortcuts;
• what ties it into Windows, such as file types and COM classes;
• the runtimes it needs;
• its license data and user data, if you ask for them.

It also looks for things that are probably part of the app but are not named exactly for it, and offers them for you to tick. These are near matches. Nothing is built yet.

3. See and choose. The screen says how big the installer can be, whether it fits, and what it holds, in groups. You can untick what you do not want. If that leaves a service or shortcut with nothing to run, it goes too, and the screen says so. See Building an installer.

4. Build. When you click Create Installer, the app:

1. checks there is room on the drive;
2. downloads the runtimes the app needs, if it can, so they can go inside;
3. reads each file once, takes its hash, and compresses it into the installer;
4. with the User Data option off, looks over what the installer says about the app, not the app's own files, for anything that still names you or your PC (the "last look");
5. reads the finished installer back and checks every hash.

You get one .exe, or for a very big app an .exe and a .wamdata file. See Big apps.

5. Copy it over. Use a USB drive, a network folder, or anything else. If there is a .wamdata file, copy it too, into the same folder, with the same name. If you built it on the new PC, reading the old one over the network, it is already there. Treat an installer as private. It can hold more than you expect. See Privacy and security.

6. Open and check. Double-click the installer and approve the administrator prompt. Before you can click anything, the installer checks its whole package by hash, and checks whether the app can run on this PC at all. See Installing on the new PC.

7. See what it will do. The window shows where it will install, how much room that needs, whether the installer is signed, and a list of everything it sets up beyond its files and its own settings: services, startup items, file types, firewall rules, and so on. What the rules do not allow is listed as left out. You can click Preview Changes to see the changes themselves without making any.

8. Install. When you click Install, it:

1. checks again that the list on screen is still what it would do, and that there is room;
2. unpacks the package into a private folder, checking each file's hash as it comes out;
3. writes a journal entry before each change, saying what it is about to replace;
4. installs runtimes, then files, services, drivers (no test of the project has loaded one), registry settings, firewall rules, licenses, scheduled tasks, shortcuts, and environment variables;
5. adds the app to Settings, with this project's uninstaller;
6. reads back every file it installed and checks its hash;
7. starts the services that are meant to start by themselves.

9. If anything goes wrong. A failure, or a click on Cancel, puts back what the install had done, in reverse order, and says if anything could not be put back. A runtime it installed stays, since other programs may use it. This is a rollback. An install cut off by a crash or a power cut is undone when you next click Install in any installer built by WinAppMigrator on that PC. A preview only says it is there.

10. Uninstall. The app now has an entry in Settings, like any other app. Uninstalling it runs a small uninstaller that reads the journal and undoes only what the install did. A file you changed since stays. A file the install replaced comes back, or, if the file over it has changed since, goes beside it as a .before-install copy. Runtimes stay. Your data and licenses stay unless you ask for them to go. See Undoing an install.

The two pieces never do each other's job:

• The app builds, and never installs. It reads the old PC and writes one installer. It never restores anything, on any PC.
• The installer installs, and never builds. Everything that changes a PC lives in the installer.

WinAppMigrator Client does neither. It only lets the app read the old PC over the network, and builds nothing there.

For how this is laid out in the code, see Project layout.

Last changed 2026-11-11. Describes WinAppMigrator as of its latest release, 0.6.0.