# Platforms (https://docs.neuralisapp.com/getting-started/platforms)

Neuralis runs the same host on every platform. What differs is how it is
started — in Docker, natively from a clone, or inside the [desktop
app](https://docs.neuralisapp.com/getting-started/desktop-app.md) — and which operating-system sandbox
confines the shells of members who are not the machine's owner. This page is
the one table of those differences; the [installation
guide](https://docs.neuralisapp.com/getting-started/installation.md) has the steps for each install.

## What runs where [#what-runs-where]

| | Linux | Windows with WSL2 | Windows (native) | macOS |
| --- | --- | --- | --- | --- |
| Docker install (image, npm folder) | yes | yes — an in-distro Docker engine | not tested | not tested |
| Native host from a clone (`npx neuralis start`) | yes | yes | not tested | yes (release checks on macOS runners) |
| Desktop app | x64 and arm64 (AppImage, deb) | — (use the Linux build inside WSL, or the Windows app) | x64 (installer, unsigned) | preview, untested: an Intel build (disk image, unsigned) |
| Data folder | `~/.neuralis` (or `$XDG_DATA_HOME/neuralis`) | `~/.neuralis` inside the distribution | `%USERPROFILE%\.neuralis` | `~/.neuralis` (or `$XDG_DATA_HOME/neuralis`) |
| Vector store | Qdrant in Docker, or the bundled Qdrant binary | Qdrant in Docker | Qdrant in Docker Desktop, or the bundled binary | Qdrant in Docker Desktop, or the bundled binary |
| Virtual desktop (machines) | with Docker | with Docker | with Docker Desktop | with Docker Desktop |
| Terminal | yes | yes | built, not yet run on Windows | built, not yet run on an installed Mac |
| Agent commands (`execute`) | yes (bash) | yes (bash) | yes, in PowerShell (pwsh 7 when installed, else Windows PowerShell 5.1) | yes (bash) |

The desktop app and a native host from a clone open the same data folder a
Docker install on that machine uses, never at the same time: whichever starts
second refuses and names the one holding it. A data folder on a WSL share is
never opened from Windows.

On Windows, agent commands are PowerShell, never bash or cmd: a command the
agent runs on a Windows folder is graded and run as PowerShell, and the result
says `shell: "powershell"`. Under the Windows sandbox each command takes about
1–2 s before its own work starts, because every command starts a new PowerShell. Inside the
Windows sandbox a command reaches the internet and the programs listening on the same PC — the
Neuralis host it was started from, a Docker stack's forwarded ports, a local server — as on Linux
and macOS. A server a
command starts inside the Windows sandbox cannot be reached from outside it — not from the host
and not from a browser on the same PC. WSL on the same PC is a separate Linux machine: pair it as its
own device from inside WSL (it reaches a desktop app on the same PC only with
WSL's mirrored networking), and its commands run in bash under Landlock.

## Shell sandbox per platform [#shell-sandbox-per-platform]

Your own commands run as you. Anyone else's — another member's, or an agent
working for them — run only inside the operating system's sandbox, which must
prove itself on the machine before the first such command runs:

| Platform | Sandbox | State |
| --- | --- | --- |
| Linux, Windows with WSL2 | Landlock (and seccomp for sockets), through a small helper Neuralis ships | proven on Linux kernels, live under WSL2; a kernel without Landlock refuses those commands rather than run them unconfined |
| macOS | Seatbelt (`sandbox-exec`) | proven on a macOS CI runner (the probe and a real shell under the profile); not yet run on an installed Mac |
| Windows 11 (build 26100.9278 or later, x64) | Microsoft Execution Containers | proven on one Windows 11 machine: the probe's rows, a denied write outside the folder, no input reaching the desktop, and PowerShell, a Node script and the `neuralis` CLI running inside it |

The proof is a short probe the machine runs at start (the host) or at
`neuralis device install` (a device): its rows must all pass before members'
commands run sandboxed there. Where they do not — an older kernel or Windows
build, Windows on ARM, or a sandbox not yet proven — the machine serves its
owner alone: a member's shell on that host is refused, and a device runs only
after its owner's explicit `neuralis device install --unconfined`. Nothing is
inferred from the platform name. The [security
model](https://docs.neuralisapp.com/enterprise/security.md) describes the confinement itself, and
[devices](https://docs.neuralisapp.com/getting-started/devices.md) who decides what a paired computer allows.

## Native installs [#native-installs]

A native host — from a clone, or the desktop app's own — needs no Docker for
the app itself. It keeps its vectors in a Qdrant container of its own when
Docker answers, else in the bundled Qdrant binary; a data folder a Docker
install set up keeps using that install's Qdrant. The virtual desktop needs
Docker on every platform and stays off without it. The clone install is
[installation](https://docs.neuralisapp.com/getting-started/installation.md#3-git-clone-fork-the-host) §3;
`neuralis up`, `neuralis status` and `neuralis down` supervise a native host
([CLI](https://docs.neuralisapp.com/getting-started/cli.md#run-a-host-on-this-computer)).

## Maturity per platform [#maturity-per-platform]

Each platform has its own maturity row, measured against what it promises and
what is planned for it, and capped where it has not run live yet. The current
rows are on the [maturity](https://docs.neuralisapp.com/getting-started/maturity.md) page.
