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

# Enterprise Guide for Langdock Desktop

> Roll out the Langdock desktop app to managed Windows and Mac devices with Intune, Configuration Manager, Group Policy, Matrix42 Empirum, ACMP, baramundi, Jamf, or Kandji.

## Deploying the desktop app

IT admins can install the [desktop app](/en/using-langdock/desktop-app/introduction) on managed devices so people find Langdock in the Start menu or Applications folder without installing it themselves. Use it when you want to roll Langdock out to a whole department, keep versions under IT control, or pre-approve permissions before the first launch.

## Which file do I need?

| Tool | File |
| - | - |
| [Intune](#intune) | Intune Win32 package (`.intunewin`) |
| [Configuration Manager (SCCM)](#sccm) | MSIX or deployment kit (`.zip`) |
| [Group Policy](#group-policy) | Deployment kit (`.zip`) |
| [Other tools](#other-tools) | Deployment kit (`.zip`) |
| [Jamf, Kandji, or another macOS MDM](#macos) | DMG |

<Warning>
  Don't deploy the regular `Langdock Setup.exe` through an MDM. It installs for one user only, so when an MDM runs it as SYSTEM, your users won't get the app. Use the MSIX packages on this page for managed Windows installs.
</Warning>

## Windows

* **Windows version**: Requires 64-bit Windows 10 version 1809 or later. Automatic updates require Windows 10 version 2004 or later. On older versions, the app doesn't update itself, so push each new release through your MDM.
* **Sideloading**: Langdock isn't installed from the Microsoft Store, so Windows must allow apps from other sources. This is on by default since Windows 10 version 2004. On older versions, or if your organization turned it off, enable the `AllowAllTrustedApps` policy, called **Allow all trusted apps to install** in Group Policy.
* **AppLocker**: only if you enforce **Packaged app Rules**. Add a publisher rule and select Langdock on a reference device. AppLocker fills in the publisher and package name.

Windows installs MSIX packages per user. Each tab provisions Langdock for the whole device, so every user gets it at their next sign-in, including standard users. Pick the tab for your tool:

<Tabs>
  <Tab title="Intune" id="intune">
    Use the ready-made Win32 package to install Langdock for every user of a device.

    <CardGroup cols={2}>
      <Card title="Intune Win32 package (x64)" icon="microsoft" href="https://desktop.langdock.com/global/stable/download/win-intunewin-x64">
        `.intunewin` for most Windows PCs
      </Card>

      <Card title="Intune Win32 package (ARM64)" icon="microsoft" href="https://desktop.langdock.com/global/stable/download/win-intunewin-arm64">
        `.intunewin` for Windows on ARM PCs
      </Card>
    </CardGroup>

    <Accordion title="What's in the Intune package?">
      The `.intunewin` wraps the signed Langdock MSIX with install and uninstall scripts. Intune provisions Langdock for every user of the device, including standard users, and doesn't reinstall it after the app updates itself. To package it yourself, download the plain MSIX for [x64](https://desktop.langdock.com/global/stable/download/win-msix-x64) or [ARM64](https://desktop.langdock.com/global/stable/download/win-msix-arm64).
    </Accordion>

    <Tip>
      To test on one device first, run `Add-AppxPackage -Path .\Langdock-x64.msix`. It installs for the signed-in user only.
    </Tip>

    <Steps>
      <Step title="Add the app">
        In the Intune admin center, go to **Apps** > **Windows** > **Add**, select **Windows app (Win32)**, and upload the `.intunewin`. For details, see Microsoft's guide to [Win32 apps in Intune](https://learn.microsoft.com/en-us/intune/app-management/deployment/add-win32).
      </Step>

      <Step title="Fill in the app information">
        **Name** is prefilled from the package. You can use these values for the rest:

        | Field | Value |
        | - | - |
        | Description | Langdock unifies the entire AI landscape in a single, intuitive desktop application. |
        | Publisher | Langdock GmbH |
        | Developer | Langdock GmbH |
        | App Version | The version of the package, for example `1.0.9.0` |
        | Category | Productivity |
        | Logo | Optional. It only shows in the Company Portal. [Download the Langdock logo](/images/langdock-desktop-logo.png) (PNG). |
      </Step>

      <Step title="Set the program">
        Set **Install command** to `Deploy.cmd Install`, **Uninstall command** to `Deploy.cmd Uninstall`, and **Install behavior** to **System**. Return codes are `0` success, `3010` soft reboot, and `1` failed.
      </Step>

      <Step title="Set the requirements">
        Set **Check operating system architecture** to **Yes**. Create a separate app for each package:

        | Package | Architecture | Minimum operating system |
        | - | - | - |
        | x64 | Only **x64** | **Windows 10 1809** |
        | ARM64 | Only **ARM64** | **Windows 10 1809** |

        Never select x86, because there's no 32-bit build. If you rely on automatic updates, choose **Windows 10 2004** instead.

        <Note>
          Want only one app? Select **x64** and **ARM64** on the x64 package and skip the ARM64 package. ARM devices then run Langdock through x64 emulation on Windows 11, which is slower. One app per architecture stays the recommended setup. Never deploy both packages to the same ARM device.
        </Note>
      </Step>

      <Step title="Set the detection rule">
        After the install, Intune checks whether Langdock is on the device. If it doesn't find it, it reports the install as failed and tries again. Built-in file and registry rules don't fit here. The MSIX install folder and its registry entries contain the version, which changes with every self-update. The detection script checks the provisioned package by name instead, so it works for every version.

        Run this command in a PowerShell window. No admin rights needed; the file is saved to your Desktop as `Detect-Langdock.ps1`.

        ```powershell theme={null}
        $path = Join-Path ([Environment]::GetFolderPath('Desktop')) 'Detect-Langdock.ps1'
        Set-Content -Path $path -Encoding ASCII -Value @'
        if (Get-AppxProvisionedPackage -Online | Where-Object DisplayName -eq 'com.langdock.desktop.msix') { 'Installed' }
        '@
        "Saved $path"
        ```

        Under **Detection rules**, select **Use a custom detection script** and upload `Detect-Langdock.ps1`. Set **Run script as 32-bit process on 64-bit clients** and **Enforce script signature check** to **No**.

        Don't want to create the script yourself? Download the deployment kit for [x64](https://desktop.langdock.com/global/stable/download/win-msix-kit-x64) or [ARM64](https://desktop.langdock.com/global/stable/download/win-msix-kit-arm64) and upload its `Deploy.ps1` as the detection script. It checks for the kit's version or newer.

        <Note>
          **Turned off [automatic updates](/en/admin/desktop-app/updates#turn-off-automatic-updates)?** Create the script with this command instead. Set `$MinVersion` to the version you upload. Raise it each time you upload a new version to the same app, or add the new version as a new app with **Supersedence**.

          ```powershell theme={null}
          $path = Join-Path ([Environment]::GetFolderPath('Desktop')) 'Detect-Langdock.ps1'
          Set-Content -Path $path -Encoding ASCII -Value @'
          $MinVersion = [version]'1.0.9.0'
          $pkg = Get-AppxProvisionedPackage -Online | Where-Object DisplayName -eq 'com.langdock.desktop.msix'
          if ($pkg | Where-Object { [version]$_.Version -ge $MinVersion }) { 'Installed' }
          '@
          "Saved $path"
          ```
        </Note>

        <Accordion title="What's in the detection script?">
          The script prints `Installed` when Langdock is provisioned on the device. Intune treats output plus exit code `0` as detected. Without output, Langdock counts as not installed.

          ```powershell theme={null}
          if (Get-AppxProvisionedPackage -Online | Where-Object DisplayName -eq 'com.langdock.desktop.msix') { 'Installed' }
          ```

          With `$MinVersion`, it only prints `Installed` for that version or newer:

          ```powershell theme={null}
          $MinVersion = [version]'1.0.9.0'
          $pkg = Get-AppxProvisionedPackage -Online | Where-Object DisplayName -eq 'com.langdock.desktop.msix'
          if ($pkg | Where-Object { [version]$_.Version -ge $MinVersion }) { 'Installed' }
          ```
        </Accordion>
      </Step>

      <Step title="Assign the app">
        Assign it as **Required** to a device group. Start with a pilot group.
      </Step>
    </Steps>

    <Accordion title="Alternative: deploy the plain MSIX">
      Use this if you don't want the `.intunewin` wrapper or a detection script, and you control versions yourself.

      Upload the [x64](https://desktop.langdock.com/global/stable/download/win-msix-x64) or [ARM64](https://desktop.langdock.com/global/stable/download/win-msix-arm64) MSIX as a **Line-of-business app**. Assign it as **Required** to a device group and change **Install Context** to **Device**. Intune then provisions Langdock for every user.

      [Turn off automatic updates](/en/admin/desktop-app/updates#turn-off-automatic-updates) first. Intune's built-in detection expects the version you uploaded. Upload each new version to the app yourself.
    </Accordion>
  </Tab>

  <Tab title="Configuration Manager (SCCM)" id="sccm">
    Create an application that installs Langdock for every user of a device. You can use the MSIX directly or the deployment kit.

    <CardGroup cols={2}>
      <Card title="Windows MSIX (x64)" icon="windows" href="https://desktop.langdock.com/global/stable/download/win-msix-x64">
        Most Windows PCs
      </Card>

      <Card title="Windows MSIX (ARM64)" icon="windows" href="https://desktop.langdock.com/global/stable/download/win-msix-arm64">
        Windows on ARM PCs
      </Card>

      <Card title="Deployment kit (x64)" icon="file-zipper" href="https://desktop.langdock.com/global/stable/download/win-msix-kit-x64">
        `.zip` for most Windows PCs
      </Card>

      <Card title="Deployment kit (ARM64)" icon="file-zipper" href="https://desktop.langdock.com/global/stable/download/win-msix-kit-arm64">
        `.zip` for Windows on ARM PCs
      </Card>
    </CardGroup>

    * **Windows app package**: create an application of type **Windows app package (\*.appx, \*.appxbundle, \*.msix, \*.msixbundle)** from the `.msix` and select **Provision this application for all users on the device**. See Microsoft's guide to [Windows applications in Configuration Manager](https://learn.microsoft.com/en-us/intune/configmgr/apps/get-started/creating-windows-applications).
    * **Script Installer with the kit**: use the extracted kit folder as the content source. Set the install command to `Deploy.cmd Install`, the uninstall command to `Deploy.cmd Uninstall`, and the installation behavior to install for system. Use `Detect-ConfigMgr.ps1` as the detection script in 64-bit Windows PowerShell.

    If Langdock updates itself, use the Script Installer. Its detection accepts the deployed version or newer.
  </Tab>

  <Tab title="Group Policy" id="group-policy">
    Install Langdock for every user of the domain-joined devices a GPO targets.

    <CardGroup cols={2}>
      <Card title="Deployment kit (x64)" icon="file-zipper" href="https://desktop.langdock.com/global/stable/download/win-msix-kit-x64">
        `.zip` for most Windows PCs
      </Card>

      <Card title="Deployment kit (ARM64)" icon="file-zipper" href="https://desktop.langdock.com/global/stable/download/win-msix-kit-arm64">
        `.zip` for Windows on ARM PCs
      </Card>
    </CardGroup>

    Put the extracted kit folder on a read-only share that device accounts can read. Add `Deploy.cmd Install` as a computer startup script under **Computer Configuration** > **Windows Settings** > **Scripts** > **Startup**. If the share is on the network, enable waiting for the network at startup.

    To remove Langdock, replace the startup script command with `Deploy.cmd Uninstall`. Removing the startup script alone doesn't uninstall it. Don't use the legacy Group Policy Software Installation.
  </Tab>

  <Tab title="Other tools" id="other-tools">
    Use this for Matrix42 Empirum, ACMP, baramundi, or your own scripts.

    <CardGroup cols={2}>
      <Card title="Windows MSIX (x64)" icon="windows" href="https://desktop.langdock.com/global/stable/download/win-msix-x64">
        Most Windows PCs
      </Card>

      <Card title="Windows MSIX (ARM64)" icon="windows" href="https://desktop.langdock.com/global/stable/download/win-msix-arm64">
        Windows on ARM PCs
      </Card>

      <Card title="Deployment kit (x64)" icon="file-zipper" href="https://desktop.langdock.com/global/stable/download/win-msix-kit-x64">
        `.zip` for most Windows PCs
      </Card>

      <Card title="Deployment kit (ARM64)" icon="file-zipper" href="https://desktop.langdock.com/global/stable/download/win-msix-kit-arm64">
        `.zip` for Windows on ARM PCs
      </Card>
    </CardGroup>

    Run one of these as SYSTEM:

    ```powershell theme={null}
    # PowerShell
    Add-AppxProvisionedPackage -Online -PackagePath .\Langdock-x64.msix -SkipLicense -Regions all

    # DISM
    DISM /Online /Add-ProvisionedAppxPackage /PackagePath:.\Langdock-x64.msix /SkipLicense /Region:all

    # Deployment kit, with uninstall and detection
    Deploy.cmd Install
    ```

    Use the deployment kit when your tool needs uninstall and detection. `Deploy.cmd Uninstall` closes Langdock in every session and removes it for all users.

    Without the kit, use these as SYSTEM for detection and uninstall. Replace `1.0.9.0` with the version you deployed, and quit Langdock in every session before you uninstall:

    ```powershell theme={null}
    # Detection: installed when this version or newer is provisioned
    $deployed = [version]'1.0.9.0'
    if (Get-AppxProvisionedPackage -Online | Where-Object { $_.DisplayName -eq 'com.langdock.desktop.msix' -and [version]$_.Version -ge $deployed }) { 'Installed'; exit 0 } else { exit 1 }

    # Uninstall for all users
    Get-AppxProvisionedPackage -Online | Where-Object DisplayName -eq 'com.langdock.desktop.msix' | Remove-AppxProvisionedPackage -Online
    Get-AppxPackage -AllUsers -Name 'com.langdock.desktop.msix' | Remove-AppxPackage -AllUsers
    ```

    * **Matrix42 Empirum** 25.0 or later with UEM Agent 2503.2.2 or later: create a PowerShell package with the Package Wizard that contains the extracted kit, one per architecture. In `Setup.ps1`, map `-Command Install` and `-Command Uninstall` to `Deploy.cmd Install` and `Deploy.cmd Uninstall`, and return its exit code. Enable **External installation program** and assign the package to computers.
    * **ACMP**: copy the extracted kit to the client with a Client Command and run `Deploy.cmd Install` in the system context.
    * **baramundi**: run `Deploy.cmd Install` from the extracted kit as the local system account.
  </Tab>
</Tabs>

Windows installs every MSIX to `C:\Program Files\WindowsApps`, and you can't change that location.

### Network requirements

The desktop app loads the same Langdock web app as your browser, so allow the same domains you allow for Langdock in the browser. It also needs:

| Domain | Used for |
| - | - |
| `app.langdock.com` | HTTPS, and a WebSocket (`wss://`) for transcription |
| `desktop.langdock.com` | HTTPS, for downloads and self-updates. Not needed when updates are turned off |

The app uses the Windows system proxy settings, including PAC files.

### Shared devices and VDI

Each user gets their own copy of Langdock with their own sign-in and app data. Updates run per user, so different users on one device can be on different versions for a while.

On non-persistent VDI, provision Langdock in the base image (golden image) your virtual desktops start from. [Turn off automatic updates](/en/admin/desktop-app/updates#turn-off-automatic-updates) in the base image too. For each new Langdock version, update the base image and roll it out. Per-user app data lives in `%LOCALAPPDATA%\Packages\com.langdock.desktop.msix_b9czaxkzpqt8m`. Keep that folder in your profile container, or people have to sign in again in every session. Langdock hasn't been validated on Windows multi-session hosts or Remote Desktop Session Host yet.

### Microphone access

The first time Langdock uses the microphone, Windows asks "Let Langdock access your microphone?" once per user. To approve microphone access up front, configure the `LetAppsAccessMicrophone` policy through the Intune Settings Catalog or the Group Policy **Let Windows apps access the microphone**. Add the Langdock package family name to the force allow list:

```text theme={null}
com.langdock.desktop.msix_b9czaxkzpqt8m
```

### Inventory and uninstall

Langdock appears under **Settings** > **Apps**, not in Programs and Features or the classic Uninstall registry key. To check which devices have it, use the kit's detection scripts or run these commands from an elevated PowerShell:

```powershell theme={null}
Get-AppxProvisionedPackage -Online | Where-Object DisplayName -eq 'com.langdock.desktop.msix'
Get-AppxPackage -AllUsers -Name 'com.langdock.desktop.msix'
```

`Deploy.cmd Uninstall` as SYSTEM removes Langdock for all users. `Remove-AppxPackage` removes only the current user's install. Windows deletes each user's app data with the package. Policy keys you set stay in place.

## macOS

<Steps>
  <Step title="Deploy the DMG (required)">
    The DMG is signed and notarized. It works on Apple silicon and Intel Macs.

    <CardGroup cols={2}>
      <Card title="macOS DMG" icon="apple" href="https://desktop.langdock.com/global/stable/download/mac">
        Apple silicon and Intel Macs
      </Card>
    </CardGroup>

    * **Intune**: add a **macOS app (DMG)**.
    * **Jamf Pro and Kandji**: upload the DMG as a custom app that installs `Langdock.app` to `/Applications`.
  </Step>

  <Step title="Add a configuration profile (optional)">
    You only need a profile to turn off automatic updates. It sets the boolean `disableAutoUpdates` to `true` in the `com.langdock.desktop` domain. Langdock then stops all update checks and downloads, and you deploy each new version.

    Deliver the setting through your MDM: **Application & Custom Settings** in Jamf Pro, a preference file in Intune, or a custom profile in Kandji. A user's own `defaults write` is ignored. The setting applies after Langdock restarts.

    <Note>
      Langdock in `/Applications` is owned by root, so standard users can't update it without admin rights. On those Macs, set `disableAutoUpdates` and push each update yourself.
    </Note>

    <Accordion title="Sample configuration profile (Langdock.mobileconfig)">
      ```xml theme={null}
      <?xml version="1.0" encoding="UTF-8"?>
      <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
      <plist version="1.0">
      <dict>
      	<key>PayloadContent</key>
      	<array>
      		<dict>
      			<key>PayloadDisplayName</key>
      			<string>Langdock update policy</string>
      			<key>PayloadIdentifier</key>
      			<string>com.langdock.desktop.enterprise.preferences</string>
      			<key>PayloadType</key>
      			<string>com.langdock.desktop</string>
      			<key>PayloadUUID</key>
      			<string>05F1376A-91D7-4B5D-AAA6-0456948B9451</string>
      			<key>PayloadVersion</key>
      			<integer>1</integer>
      			<key>disableAutoUpdates</key>
      			<true/>
      		</dict>
      	</array>
      	<key>PayloadDescription</key>
      	<string>Update policy for Langdock.</string>
      	<key>PayloadDisplayName</key>
      	<string>Langdock</string>
      	<key>PayloadIdentifier</key>
      	<string>com.langdock.desktop.enterprise</string>
      	<key>PayloadScope</key>
      	<string>System</string>
      	<key>PayloadType</key>
      	<string>Configuration</string>
      	<key>PayloadUUID</key>
      	<string>B0B5353E-512F-4325-9695-0D8D1B267DDB</string>
      	<key>PayloadVersion</key>
      	<integer>1</integer>
      </dict>
      </plist>
      ```
    </Accordion>
  </Step>
</Steps>

<Note>
  Users approve microphone access at the first macOS prompt. They don't need admin rights for that. Accessibility, used for the dictation shortcut and media pause, needs a one-time admin approval in **System Settings** on Macs where users are standard users.
</Note>

## Automatic updates

The desktop app updates itself by default. To ship each version through your MDM instead, turn automatic updates off with the `disableAutoUpdates` policy. Pick one owner before you deploy, so the updater and your MDM don't work against each other. See [Manage desktop app updates](/en/admin/desktop-app/updates).

## Troubleshooting

<AccordionGroup>
  <Accordion title="0x87D1041C: Intune reports the app as not detected after installation">
    The detection script doesn't find Langdock. Upload the detection script from the Intune steps as a `.ps1` file and set **Run script as 32-bit process on 64-bit clients** to **No**.
  </Accordion>

  <Accordion title="0x80073CFF or 0x80073D01: Windows blocks the install by policy">
    Sideloading or an app install policy blocks the package. Allow sideloading of trusted apps on the device and check AppLocker or WDAC.
  </Accordion>

  <Accordion title="0x80073D06 or 0x80073CF3: a newer version is already installed">
    Windows doesn't install an older version over a newer one. Deploy the current version, or remove Langdock first if you need to roll back.
  </Accordion>

  <Accordion title="0x80073D02: the package is in use">
    Windows can't replace a package that's running. `Deploy.cmd Uninstall` closes Langdock first. For updates you deploy yourself, ask people to quit Langdock and retry.
  </Accordion>

  <Accordion title="0x800B0109 or 0x800B010A: the signature isn't trusted">
    The device can't build the certificate chain. Make sure the GlobalSign Code Signing Root R45 is in the machine's trusted root store. Windows usually adds it through its automatic root updates.
  </Accordion>

  <Accordion title="Exit code 1 from Deploy.cmd">
    The kit failed and wrote the reason to its error output. Common causes: the kit files come from different releases ("The MSIX does not match this deployment script"), or it didn't run as SYSTEM or admin in 64-bit PowerShell. Run `Deploy.cmd` instead of calling `Deploy.ps1` directly.
  </Accordion>

  <Accordion title="Intune shows Installed, but people don't see Langdock">
    Provisioning registers the app at the next sign-in. Ask existing users to sign out and back in.
  </Accordion>

  <Accordion title="AppLocker blocks Langdock or the scripts">
    Add the **Packaged app Rules** rule for Langdock. The kit scripts also fall under **Script Rules**. Check the AppLocker event logs `Packaged app-Deployment`, `Packaged app-Execution`, and `MSI and Script` for blocks.
  </Accordion>

  <Accordion title="Intune doesn't pick up the app">
    Win32 apps can take up to about an hour to arrive. To speed it up, click **Sync** in Company Portal under **Settings** or restart the **Microsoft Intune Management Extension** service.
  </Accordion>

  <Accordion title="Where are the logs?">
    * **Intune**: `C:\ProgramData\Microsoft\IntuneManagementExtension\Logs`, mainly `AppWorkload.log` and `IntuneManagementExtension.log`.
    * **Package installs**: Event Viewer under **Applications and Services Logs** > **Microsoft** > **Windows** > **AppXDeployment-Server** > **Microsoft-Windows-AppXDeploymentServer/Operational**.
    * **Langdock app**: `main.log` in `%LOCALAPPDATA%\Packages\com.langdock.desktop.msix_b9czaxkzpqt8m\LocalCache\Roaming\com.langdock.desktop.msix\logs` for each user.
  </Accordion>
</AccordionGroup>

## FAQ

<AccordionGroup>
  <Accordion title="Is there an MSI installer?">
    No. Langdock ships an MSIX, which Intune, Configuration Manager, Matrix42 Empirum, ACMP, baramundi, and Group Policy startup scripts can all deploy silently and machine-wide. MSIX apps have no MSI product code or Uninstall registry key, so use the kit's detection scripts or `Get-AppxProvisionedPackage` instead of MSI-based detection.
  </Accordion>

  <Accordion title="Is Langdock in the Microsoft Store?">
    No. Download the MSIX from this page. Devices don't need Microsoft Store access.
  </Accordion>

  <Accordion title="How do I deploy with ACMP, baramundi, or Matrix42 Empirum?">
    Run `Add-AppxProvisionedPackage` or `Deploy.cmd Install` as SYSTEM, the same way you run other install commands in your tool. For Empirum, follow the Matrix42 Empirum steps in the **Other tools** tab under [Windows](#windows). For ACMP, copy the extracted kit to the client with a Client Command and run `Deploy.cmd Install` in the system context.
  </Accordion>

  <Accordion title="Do people need admin rights?">
    No. With a machine-wide deployment, standard users get Langdock at sign-in without admin rights. Only the provisioning step needs SYSTEM or admin rights. If your policies restrict app installs by standard users, [turn off automatic updates](/en/admin/desktop-app/updates#turn-off-automatic-updates) and ship each version through your MDM.
  </Accordion>

  <Accordion title="Can I pre-approve the microphone prompt?">
    Yes. See [Microphone access](#microphone-access). Without the policy, each user answers the Windows prompt once.
  </Accordion>

  <Accordion title="Do I have to package every update?">
    Only if your MDM manages versions. If [Langdock manages versions](/en/admin/desktop-app/updates), you deploy once and Langdock updates itself. Windows doesn't install an older version over a newer one. To roll back, remove Langdock and deploy the older version.
  </Accordion>

  <Accordion title="What happens to the personal Langdock Setup.exe install?">
    Both can be installed on one device. They're separate apps with their own sign-in. Langdock doesn't remove the EXE install. Uninstall it under **Settings** > **Apps** if you standardize on the MSIX.
  </Accordion>

  <Accordion title="Does this work for dedicated deployments?">
    Not yet. The MSIX on this page connects to Langdock cloud at `app.langdock.com`. Desktop apps for dedicated deployments aren't available yet.
  </Accordion>
</AccordionGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.