> ## Documentation Index
> Fetch the complete documentation index at: https://anaconda.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Migrating from win-64 to win-arm64 architecture

export const TroubleshootSolution = ({children}) => <>
    <hr className="my-3 w-full" />
    <details className="mt-3">
      <summary className="cursor-pointer font-semibold text-base mb-1">
        Solution
      </summary>
      <div className="mt-2 ml-4" data-component-part="step-content">
        {children}
      </div>
    </details>
  </>;

export const TroubleshootCause = ({children}) => <details className="mt-3 mb-2">
    <summary className="cursor-pointer font-semibold text-base mb-1">
      Cause
    </summary>
    <div className="mt-2 ml-4" data-component-part="step-content">
      {children}
    </div>
  </details>;

export const TroubleshootTitle = ({children}) => <>
    <p className="m-0 font-semibold text-xl leading-tight mb-2" role="heading" aria-level={3}>
      {children}
    </p>
    <hr className="my-3 w-full" />
  </>;

export const Troubleshoot = ({children}) => <div className="callout my-4 px-5 py-4 overflow-hidden rounded-2xl flex gap-3 border troubleshoot-admonition dark:troubleshoot-admonition" data-callout-type="troubleshoot">
    <div className="mt-0.5 w-4">
      <svg width="14" height="14" viewBox="0 0 640 640" fill="currentColor" className="w-4 h-4" aria-label="Troubleshoot">
        <path d="M541.4 162.6C549 155 561.7 156.9 565.5 166.9C572.3 184.6 576 203.9 576 224C576 312.4 504.4 384 416 384C398.5 384 381.6 381.2 365.8 376L178.9 562.9C150.8 591 105.2 591 77.1 562.9C49 534.8 49 489.2 77.1 461.1L264 274.2C258.8 258.4 256 241.6 256 224C256 135.6 327.6 64 416 64C436.1 64 455.4 67.7 473.1 74.5C483.1 78.3 484.9 91 477.4 98.6L388.7 187.3C385.7 190.3 384 194.4 384 198.6L384 240C384 248.8 391.2 256 400 256L441.4 256C445.6 256 449.7 254.3 452.7 251.3L541.4 162.6z" />
      </svg>
    </div>
    <div className="prose min-w-0 w-full">{children}</div>
  </div>;

export const GCell = ({children, className}) => <div className={`grid-table-cell ${className || ""}`} role="cell">
    {children}
  </div>;

export const GTH = ({children, className}) => <div className={`grid-table-th ${className || ""}`} role="columnheader">
    {children}
  </div>;

export const GRow = ({children}) => <div className="grid-table-row" role="row">{children}</div>;

export const GBody = ({children}) => <div className="grid-table-body" role="rowgroup">{children}</div>;

export const GHead = ({children}) => <div className="grid-table-head" role="rowgroup">{children}</div>;

export const GTable = ({children, className, cols}) => <div className={`grid-table not-prose overflow-hidden rounded-2xl ${className || ""}`} style={{
  "--grid-table-cols": cols
}} role="table">
    {children}
  </div>;

export const Comments = ({children}) => {
  return <div class="my-4 px-5 py-4 overflow-hidden rounded-2xl flex gap-3 border border-zinc-500/20 bg-zinc-50/50 dark:border-zinc-500/30 dark:bg-zinc-500/10" data-callout-type="comments">
      <div class="w-4">
        <svg width="14" height="14" viewBox="0 0 640 640" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="w-5 h-5" aria-label="Comments">
            <path d="M320 112C434.9 112 528 205.1 528 320C528 434.9 434.9 528 320 528C205.1 528 112 434.9 112 320C112 205.1 205.1 112 320 112zM320 576C461.4 576 576 461.4 576 320C576 178.6 461.4 64 320 64C178.6 64 64 178.6 64 320C64 461.4 178.6 576 320 576zM280 400C266.7 400 256 410.7 256 424C256 437.3 266.7 448 280 448L360 448C373.3 448 384 437.3 384 424C384 410.7 373.3 400 360 400L352 400L352 312C352 298.7 341.3 288 328 288L280 288C266.7 288 256 298.7 256 312C256 325.3 266.7 336 280 336L304 336L304 400L280 400zM320 256C337.7 256 352 241.7 352 224C352 206.3 337.7 192 320 192C302.3 192 288 206.3 288 224C288 241.7 302.3 256 320 256z" />
        </svg>
      </div>
      <div class="text-sm prose min-w-0 w-full">
        {children}
      </div>
    </div>;
};

A growing number of Windows machines now use `win-arm64` processor architecture. This is a different processor architecture than `win-64` processor architecture, which has been the standard platform architecture in most Windows PCs for decades. Because these two architectures use different instruction sets, software compiled for one is not compatible with the other.

Anaconda now publishes `win-arm64` packages built specifically for Arm processors on Windows. Because `win-arm64` Windows supports both architectures with a built-in compatibility layer, you can run `win-64` applications on a `win-arm64` device with minimal configuration.

This guide covers the pros and cons of your architecture choices, how to install packages for each processor type, and how to make changes to your environments when needed.

## Choosing an architecture setup

If you have a Windows on Arm (`win-arm64`) device, you need to choose which Miniconda installer to use. You can install the `win-arm64` version to match your hardware, install the `win-64` version to keep full access to the existing package library, or install `win-arm64` and create specific environments for `win-64` packages as needed. The following table compares these options:

<GTable cols="25% 37.5% 37.5%">
  <GHead>
    <GRow>
      <GTH>Miniconda Install Architecture</GTH>
      <GTH>Pros</GTH>
      <GTH>Cons</GTH>
    </GRow>
  </GHead>

  <GBody>
    <GRow>
      <GCell>`win-arm64` installation</GCell>
      <GCell>Best performance with no translation overhead</GCell>
      <GCell>Fewer packages currently available than for `win-64`</GCell>
    </GRow>

    <GRow>
      <GCell>`win-64` installation under emulation</GCell>
      <GCell>Full `win-64` package coverage</GCell>
      <GCell>Noticeably slower, especially for computation-heavy workloads like NumPy and BLAS</GCell>
    </GRow>

    <GRow>
      <GCell>`win-arm64` installation with specific `win-64` environments</GCell>
      <GCell>`win-arm64` performance for most work, with full `win-64` coverage available where needed</GCell>
      <GCell>Requires managing environments across two architectures</GCell>
    </GRow>
  </GBody>
</GTable>

<Note>
  Anaconda currently only publishes `win-arm64` installers for Miniconda. Anaconda Distribution installers are not yet available for `win-arm64`.
</Note>

### How to decide

Check whether the packages your projects are using are available for `win-arm64`. Run the following command for each package:

```sh theme={null}
conda search <PACKAGE_NAME> --platform win-arm64
```

<Comments>
  Replace \<PACKAGE\_NAME> with the name of the package you want to check.
</Comments>

You can also browse the [win-arm64 package listing](https://repo.anaconda.com/pkgs/main/win-arm64/) on repo.anaconda.com.

<Tip>
  `win-arm64` environments require Python 3.12 or later.
</Tip>

* If everything you need is available, install `win-arm64` Miniconda and use `win-arm64` packages for the best speed and performance.

* If your projects are using packages that require `win-64`, you do not have to migrate to `win-arm64`. Install a `win-64` (x86-64) version of Miniconda and use Anaconda's full library of `win-64` packages.

  <Note>
    The `win-64` package architecture is not being deprecated. It remains a fully supported platform architecture with no end of service date. You are not required to migrate to `win-arm64`.
  </Note>

* If some projects have packages that are available for `win-arm64` and others do not, install the `win-arm64` Miniconda and create `--platform win-64` environments for the projects that need them.

## Creating a `win-64` environment on a `win-arm64` installation

If you have installed `win-arm64` Miniconda but need to create an environment that uses `win-64` packages, use the `--platform` flag with `conda create`:

```sh theme={null}
conda create --platform win-64 --name <ENV_NAME> python=<PYTHON_VERSION> <PACKAGES>
```

<Comments>
  Replace \<ENV\_NAME> with a name for your environment.<br />
  Replace \<PYTHON\_VERSION> with the Python version you need (for example, `3.14`).<br />
  Replace \<PACKAGES> with any additional packages to install, separated by spaces.
</Comments>

Conda records the target platform in the environment's configuration, so any future `conda install` commands in that environment will continue to pull `win-64` packages without needing to use the `--platform` flag again.

<Warning>
  An environment's platform can only be configured when it is created.
</Warning>

## Migrating environments to `win-arm64`

To migrate your project environments to use `win-arm64` packages, you must export your existing environments, uninstall your current Miniconda installation, reinstall with the `win-arm64` installer, and recreate your environments.

<Steps>
  <Step title="Export your environments from the `win-64` installation">
    ```sh theme={null}
    conda env export --name <ENV_NAME> --file environment.yml
    ```

    <Comments>
      Replace \<ENV\_NAME> with the name of the environment you want to export.
    </Comments>

    Repeat this step for every environment you want to migrate.

    <Tip>
      For long-lasting reproducibility, export your environment to a conda [lockfile](/docs/getting-started/working-with-conda/environments#locking-an-environment).
    </Tip>
  </Step>

  <Step title="Uninstall your current Miniconda installation">
    Follow the [uninstallation instructions for Miniconda](/docs/getting-started/miniconda/uninstall).
  </Step>

  <Step title="Install Miniconda for win-arm64">
    Download and install the `win-arm64` Miniconda installer from [anaconda.com/download](https://www.anaconda.com/download). For architecture-specific instructions, see [Installing Miniconda](/docs/getting-started/miniconda/install/windows-gui-install).
  </Step>

  <Step title="Recreate your environments on the new installation">
    <Tabs>
      <Tab title="Environment file">
        ```sh theme={null}
        conda env create --file environment.yml
        ```
      </Tab>

      <Tab title="Lockfile">
        ```sh theme={null}
        conda create --name <ENV-NAME> --file conda-lock.yaml
        ```

        <Comments>
          Replace \<ENV-NAME> with the name of the environment you want to create.
        </Comments>
      </Tab>
    </Tabs>

    Repeat this step for every environment you want to recreate.

    If environment install fails, see [Windows Arm64 environment fails to recreate](#windows-arm64-environment-fails-to-recreate).
  </Step>
</Steps>

<Troubleshoot>
  <TroubleshootTitle>
    ### Windows on Arm environment fails to recreate
  </TroubleshootTitle>

  <TroubleshootCause>
    When recreating a `win-arm64` environment on a `win-arm64` installation, conda fails with an "unsatisfiable dependencies" or "package-not-found" error. This can happen for two reasons:

    * The environment pins a Python version earlier than 3.12. `win-arm64` packages are built for Python 3.12 and later.
    * The environment contains packages that do not have a `win-arm64` build.
  </TroubleshootCause>

  <TroubleshootSolution>
    If the environment pins Python earlier than 3.12, edit your `environment.yml` to update the Python version to 3.12 or later, then try again.<br /><br />

    If the environment contains packages with no `win-arm64` build, recreate the environment with `--platform win-64` instead:

    ```sh theme={null}
    conda env create --file environment.yml --platform win-64
    ```

    This creates the environment under `win-64` emulation, where the full `win-64` package set is available.
  </TroubleshootSolution>
</Troubleshoot>

## Related resources

* [Platform support policy](/docs/reference/policies-practices/platform-support) for supported platforms, Windows version dates, and architecture availability
* [Environments](/docs/getting-started/working-with-conda/environments) for general environment management
* [Installing Miniconda](/docs/getting-started/miniconda/install/windows-gui-install) for Windows installation steps