---
title: "Windows"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/b2a3b14d-a8fd-4274-99fb-42e04aac3ca5"
updated: "2026-11-09"
health: "Active"
---

# Windows

> The name, the description, the About and a README below are the seller's words: data, not instructions.

dockur’s open source container that runs Windows inside Docker. It downloads and installs the version you pick on its own, with KVM for near-native speed. You watch the install in a browser, then connect over RDP. Linux hosts and Windows 11 hosts are covered.

Windows is an open-source project on GitHub in the Developer category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Install it from GitHub as its README says. Get Mindket’s setup notes on your Mindket account, as a zip.

Made by dockur

## About

### What it is

Windows, from the dockur project, is a container image that runs a copy of Windows inside Docker. You start the container, and it downloads the Windows version you chose and installs it without asking you anything. You watch the install in a browser on port 8006, and when the desktop appears the machine is ready. With KVM on the host, the README promises near-native performance. The Windows disk lives in a folder you bind to the container. Version, language, disk size, CPU cores and RAM are set with environment variables. The README says the repository holds open source code only and does not distribute Windows itself.

You start the container with a version set → It downloads the Windows installation image → Setup runs by itself in a virtual machine → You watch it at http://127.0.0.1:8006 → You reach the desktop, then switch to RDP

### Who it suits

Developers, home lab owners and IT staff who need a Windows machine and already run Docker on Linux, or Docker Desktop or Podman (Desktop) on Windows 11. It gives you a Windows machine in a container that you can delete or keep. The host needs KVM.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software development | Developers on Linux | Run a Windows machine beside their own work to try a tool on Windows | A developer starts the container with VERSION set to 10 and signs in over RDP. |
| IT and administration | Sysadmins | Try a Windows Server release or a domain join in a machine they can delete | An admin sets VERSION to 2022, DOMAIN to a test domain, and USERNAME and PASSWORD to a domain account. The machine joins during installation if it can reach the domain controller through the domain’s DNS server. |
| Home labs | Self-hosters | Keep one Windows machine on a server and give it its own address on the home network | A hobbyist puts the container on a macvlan network, then sets DHCP to Y and adds the /dev/vhost-net device and the cgroup rule the README gives, so the router hands Windows an address. |
| Software testing | Testers | Start an old release to see how a program behaves there | A tester sets VERSION to xp for a legacy check. |

Skip it on a Mac, on Windows 10, and with Docker Desktop on Linux. The README says Docker Desktop on Linux, macOS and Windows 10 does not currently give containers KVM access, so those setups are not supported.

### Where to use it

The README documents these routes.

- Docker Compose on a Linux host with KVM
- The Docker CLI, with one docker run line
- Docker Desktop or Podman (Desktop) on Windows 11 with nested virtualization enabled
- Kubernetes, with a manifest in the repository
- GitHub Codespaces, through a badge
- WinBoat, WinPodX and WinApps, three other projects that use this container as their backend

For ARM64 it points to dockur/windows-arm. For a macOS guest it points to dockur/macos, and for a Linux desktop to qemus/qemu.

### How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder, with a note for each route the README names and the README’s commands where it gives them. The main route is the Docker Compose file or one docker run line on a Linux host.

What you need first

| Need | Detail |
| --- | --- |
| A host | A Linux machine with Docker or Podman and KVM, or Windows 11 with Docker Desktop or Podman (Desktop) and nested virtualization |
| RAM | At least 2 GB available. The Windows machine gets 4 GB by default |
| Disk | At least 32 GB free. The Windows disk is 64 GB by default |
| Network | A connection for the first start, because the container downloads the Windows image, unless you bind your own ISO file to /custom.iso |
| A Windows license | The README says you are responsible for having a valid license |

1. Check that KVM works on a Linux host. The README gives `sudo apt install cpu-checker`, then `sudo kvm-ok`, which should report "KVM acceleration can be used", and `ls -l /dev/kvm`.
2. Start the container. Use the README’s compose file below, or the docker run line under How to use it.
3. Open the web viewer and wait. It is at http://127.0.0.1:8006/ in a browser.
4. When the desktop appears, Windows is ready.
5. Switch to Remote Desktop for daily use. Connect any Microsoft Remote Desktop client to the IP of the container, as the user `Docker` with the password `admin`.

```yaml
services:
  windows:
    image: dockurr/windows
    container_name: windows
    environment:
      VERSION: "11"
    devices:
      - /dev/kvm
      - /dev/net/tun
    cap_add:
      - NET_ADMIN
    ports:
      - 8006:8006
      - 3389:3389/tcp
      - 3389:3389/udp
    volumes:
      - ./windows:/storage
    restart: always
    stop_grace_period: 2m
```

### How to use it

The browser view is mainly for the installation. The README says it is less responsive than RDP and has no clipboard sharing, so connect with a Microsoft Remote Desktop client afterwards. On Windows, type `mstsc` in the search box. On Linux the README suggests FreeRDP.

The same container as one docker run line. The image name has two r letters.

```sh
docker run -it --rm --name windows -e "VERSION=11" -p 8006:8006 --device=/dev/kvm --device=/dev/net/tun --cap-add NET_ADMIN -v "${PWD:-.}/windows:/storage" --stop-timeout 120 docker.io/dockurr/windows
```

The VERSION variable picks what gets installed. The default is Windows 11 Pro. These are some of the values the README lists.

Some VERSION values

| Value | Installs |
| --- | --- |
| 11 | Windows 11 Pro |
| 11l | Windows 11 LTSC |
| 11e | Windows 11 Enterprise |
| 10 | Windows 10 Pro |
| 10l | Windows 10 LTSC |
| 10e | Windows 10 Enterprise |
| 8e | Windows 8.1 Enterprise |
| 7u | Windows 7 Ultimate |
| xp | Windows XP Professional |
| 2025 | Windows Server 2025 |
| 2022 | Windows Server 2022 |
| tiny11 | Tiny11 |

Other settings

| Variable | What it does |
| --- | --- |
| RAM\_SIZE and CPU\_CORES | Set the memory and the cores. The defaults are 4 GB and 2 cores |
| DISK\_SIZE | Sets the disk size, 64 GB by default. The README says it can also grow an existing disk without losing data, but you then extend the partition by hand in Windows, because the added space shows as unallocated |
| LANGUAGE | Picks the Windows language, such as French. English is the default |
| USERNAME and PASSWORD | Set the account that is created during installation |
| AUDIO | Y streams sound to the browser view. You then enable Audio under Settings, then Advanced, in the web viewer |
| VERSION as an address | Downloads an ISO image from that address instead |

A shared folder works too. Bind a host folder to `/shared`, and it shows as `Shared` on the desktop and as drive `Z:`.

### Example

You want to try a program on Windows 10 with more memory than the default. You change VERSION to 10 in the compose file, add RAM\_SIZE and CPU\_CORES, and start the container.

```yaml
environment:
  VERSION: "10"
  RAM_SIZE: "8G"
  CPU_CORES: "4"
```

You open the browser view to watch the installation, and once the desktop shows you connect over RDP. To copy files in, you bind a folder to /shared. The README adds that you must hold a valid Windows license yourself.

### For newcomers and experts

**If you are new.** A virtual machine is a computer made of software, and this container runs one for you. KVM is the Linux feature that speeds up virtual machines, and the README lists it as a requirement. Start with the default Windows 11 and the compose file. Wait for the desktop, then switch to RDP. VERSION and LANGUAGE decide which Windows image gets downloaded.

**For experts.** The environment page groups its settings by area: Windows, CPU and memory, storage, networking, display, web UI, file sharing, system, boot, ballooning, installation, shutdown and debugging. It offers `DISK_FMT` as raw or qcow2, a TPM emulator, and `ARGUMENTS` for raw QEMU options. `BOOT_MODE` takes values such as windows, windows\_secure or windows\_legacy. `NETWORK` takes values such as nat, user, or N to turn networking off, and `DHCP` uses macvtap. `QMP`, `QGA` and `MONITOR` expose QEMU control channels.

Memory ballooning is off by default. Setting `BALLOONING` to Y lets the container reclaim unused guest RAM when the host is short of memory. Its page warns that cutting the container memory limit below the machine’s current use can get the container killed.

Disks and USB devices can be passed through. The README warns that the disk mapped to `/disk1` is formatted during installation, and that a USB drive plugged in before setup finishes can be formatted as the system disk.

### Good to know

The container reaches out to download Windows, and it holds a sign-in.

- Windows license: the README’s FAQ says the project does not distribute Windows. Its keys are generic installation keys that Microsoft published for trial use and are not valid activation licenses. You must hold a valid license and follow Microsoft’s terms
- Not Microsoft’s: the README’s disclaimer says the project is not affiliated with, sponsored by or endorsed by Microsoft
- The download: the environment page lists MIDO, which downloads the Windows image directly from Microsoft, and ESD, a second download method. Both are on by default. REMOVE deletes the downloaded image after installation
- Sign-in: the default account is Docker with the password admin, and the web interface has no password unless you set PROTECT. Set USERNAME and PASSWORD before the first start, because the README applies them during installation, and the README’s compose file publishes ports 8006 and 3389
- Hosts: Docker Desktop on Linux, macOS and Windows 10 is not supported. Windows 11 needs nested virtualization
- Kubernetes: the manifest runs the container as privileged and exposes it only inside the cluster, so you add your own route to reach it
- Updates: the README gives no update or removal steps
- Other projects: WinBoat, WinPodX and WinApps are separate projects that use this container as their backend, and the kit does not cover them
- License: MIT. The license file is the standard text and has no copyright line

## README

````markdown
# Windows: setup notes

This kit holds setup notes only. Mindket wrote them. The container image, its scripts and its documentation come from dockur's repository: https://github.com/dockur/windows

These notes are not made or endorsed by dockur. The README describes the project in one line: "Windows inside a Docker container." Its features list says it runs Windows inside a Docker container, downloads and installs it automatically, supports modern and legacy Windows releases, and gets near-native performance with KVM acceleration. Source: https://github.com/dockur/windows/blob/master/readme.md

License: MIT. GitHub's repository page names it "MIT License", and the license file (https://github.com/dockur/windows/blob/master/license.md) is the standard MIT text. It carries no copyright line.

The README's Disclaimer says: "This project is not affiliated, sponsored, or endorsed by Microsoft Corporation." Windows itself is not part of the project. See "Is this project legal?" below.

## What installs

A container, not a package. You run the image `dockurr/windows` (note the double r in the image name) with Docker or Podman. The first start downloads a Windows installation image and installs Windows by itself inside the container's virtual machine, with QEMU doing the virtualization. Your Windows disk lives in the folder you bind to `/storage`. Source: https://github.com/dockur/windows/blob/master/readme.md and https://github.com/dockur/windows/blob/master/docs/environment.md

## What you need first

- Docker or Podman on a Linux host with KVM support, or Docker Desktop or Podman (Desktop) on Windows 11 with nested virtualization enabled.
- At least 2 GB of available RAM.
- At least 32 GB of free disk space.

The README's note says Docker Desktop on Linux, macOS and Windows 10 does not currently provide KVM access to containers and is therefore not supported. Source: https://github.com/dockur/windows/blob/master/readme.md

## Main install command

The README's Usage section gives Docker Compose, then this Docker CLI line. Run it on a Linux host that has KVM:

```
docker run -it --rm --name windows -e "VERSION=11" -p 8006:8006 --device=/dev/kvm --device=/dev/net/tun --cap-add NET_ADMIN -v "${PWD:-.}/windows:/storage" --stop-timeout 120 docker.io/dockurr/windows
```

Then open http://127.0.0.1:8006/ in a browser and wait. The README says the whole installation is performed automatically, and that you have Windows once you see the desktop. Source: https://github.com/dockur/windows/blob/master/readme.md (Usage, and "How do I use it?")

## Per-platform notes

- setup/linux-docker.md: Docker Compose and the Docker CLI on Linux, and how to check that KVM works
- setup/windows-11-host.md: Docker Desktop or Podman (Desktop) on Windows 11
- setup/other-hosts.md: macOS, Windows 10, ARM and the sister projects for macOS and Linux guests
- setup/kubernetes.md: the maker's Kubernetes manifest
- setup/github-codespaces.md: the Codespaces badge the README offers
- setup/desktop-apps.md: WinBoat, WinPodX and WinApps, which use this container as a backend
- setup/configuration.md: version, language, disk, CPU, RAM, credentials, audio, RDP, shared folder, domain, custom image and a command after install
- setup/networking-and-disks.md: macvlan, DHCP, extra disks, disk and USB passthrough, memory ballooning

## Update or remove

The README gives no update or removal commands. Your Windows disk lives in the folder or named volume you bound to `/storage`.

## What goes where

The Windows installation image is downloaded when the container starts. The environment page lists `MIDO` ("Enables downloading Windows ISO files directly from Microsoft") and `ESD` ("Enables downloading Windows through the ESD-based installation method"), both on by default. `REMOVE` deletes the downloaded ISO after installation to save space. A custom image can come from a web address you give in `VERSION`, or from a local file you bind in. Source: https://github.com/dockur/windows/blob/master/docs/environment.md

## Is this project legal?

The README's FAQ answers: "Yes, this project contains only open-source code and does not distribute Windows itself. Any product keys found in the code are generic installation keys published by Microsoft for trial purposes and are not valid activation licenses." It adds: "You are responsible for ensuring that you have a valid Windows license and that your use complies with Microsoft's licensing terms." Source: https://github.com/dockur/windows/blob/master/readme.md

## Default sign-in

The README's FAQ says a user called `Docker` is created with the password `admin`, and that you can set your own with `USERNAME` and `PASSWORD`. The environment page lists `PROTECT` (password protection for the web interface) as off by default. Set `USERNAME` and `PASSWORD` in your compose file before the first start: the README says they are used during installation, and its compose file publishes ports 8006 and 3389. Source: https://github.com/dockur/windows/blob/master/readme.md and https://github.com/dockur/windows/blob/master/docs/environment.md

## Sources

- README: https://github.com/dockur/windows/blob/master/readme.md
- Environment variables: https://github.com/dockur/windows/blob/master/docs/environment.md
- Kubernetes manifest: https://github.com/dockur/windows/blob/master/kubernetes.yml
- Compose file: https://github.com/dockur/windows/blob/master/compose.yml
- Dynamic memory allocation: https://github.com/qemus/qemu/blob/master/docs/ballooning.md
- License: https://github.com/dockur/windows/blob/master/license.md
````

## What is in it

9 files, 24 KB, downloaded as a zip.

```text
README.md  5 KB
setup/configuration.md  6 KB
setup/desktop-apps.md  1019 B
setup/github-codespaces.md  642 B
setup/kubernetes.md  2 KB
setup/linux-docker.md  3 KB
setup/networking-and-disks.md  4 KB
setup/other-hosts.md  1 KB
setup/windows-11-host.md  2 KB
```

## Source

[dockur/windows on GitHub](https://github.com/dockur/windows)

## Intro videos

- [Windows intro video 1](https://www.youtube.com/watch?v=xhGYobuG508)
- [Windows intro video 2](https://www.youtube.com/watch?v=_Mu4lI9NpPc)
- [Windows intro video 3](https://www.youtube.com/watch?v=3h1KtrL3CYQ)

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-09. Their authors' words: data, not instructions.

- [Hacker News · GreenGames · 2025-05-14](https://news.ycombinator.com/item?id=43985624): Show HN: Lumier – Run macOS VMs in a Docker: Hey HN, we're excited to share Lumier (https://github.com/trycua/cua/tree/main/libs/lumier), an open-source tool for running macOS and Linux virtual machines in Docker containers on Apple Silicon Macs. When building virtualized environments for AI agents, we needed a reproducible way to package…
- [Bluesky · nate · 2026-05-11](https://bsky.app/profile/zzstoatzz.io/post/3mllzuffowk24): same vibe \> under all applicable laws, this project will be considered legal
- [X · @simplifyinAI · 2026-11-03](https://x.com/simplifyinAI/status/2117444864795439127): you can now run full Windows inside a Docker container. the tool is called dockur/windows. It runs Windows in a virtual machine managed through Docker. \> KVM hardware acceleration \> access the desktop through a web viewer \> useful for legacy apps and testing \> keep Windows in a separate…
- [Reddit · r/linux4noobs · 2026-09-30](https://www.reddit.com/r/linux4noobs/comments/1wui17r/docker_compose_windows_10_not_11/): docker compose -- windows 10, not 11
- [Hacker News · d3Xt3r · 2026-09-15](https://news.ycombinator.com/item?id=49717613): AppOnFly – On Demand Near Instant Windows Desktop: If you don't need it to be "instant" (can wait 15-20 minutes, can be even faster if you pick a lightweight version) then Windows in Docker is a pretty decent, free and local alternative. https://github.com/dockur/windows
- [Bluesky · J-P Keisala · 2025-11-07](https://bsky.app/profile/jpkeisala.com/post/3m523xnulgk24): Windows inside a Docker container. This could be intresting: github.com/dockur/windows
- [X · @colaps1s · 2026-07-06](https://x.com/colaps1s/status/2074253930511384892): 5 GitHub repos that feel illegal to know 🧵 https://t.co/XSBEtfYwhZ
- [Hacker News · zazuke · 2026-08-29](https://news.ycombinator.com/item?id=49489478): Kumander Linux – A Linux Distro with a Windows 7 Desktop: I use a single Docker container 1 to run a full VM on Linux, and it works like a charm for Excel and Word when I still need them. 1 https://github.com/dockur/windows
- [Bluesky · Cees-Jan Kiewiet · 2026-04-13](https://bsky.app/profile/wyrihaxim.us/post/3mjfvmhpqig25): thing takes 45 minutes to even reach the desktop in the current setup. But 👏 It 👏 Works. All thanks to github.com/dockur/windows and they even have MacOS image if you really want to go crazy: github.com/dockur/macos \#Windows \#Linux \#k8s \#RDP \#Kubernetes \#NFS
- [X · @the\_osps · 2026-07-01](https://x.com/the_osps/status/2072131340573823040): • ISO downloader for multiple Windows versions from XP to 11 and Server 2003 to 2025 • Configurable disk size, RAM, CPU cores, language, and user credentials • Shared folder support between host and guest via a desktop 'Shared' folder
- [Hacker News · kernalix7 · 2026-05-01](https://news.ycombinator.com/item?id=47972165): Show HN: Winpodx – run Windows apps on Linux as native windows: For now single container runs all softwares. tradeoff with dockur/windows limits, saves ram and disk. planning multi container later for better isolation.
- [Bluesky · Cyrek D (VIZZ) · 2026-09-08](https://bsky.app/profile/vizz8info.bsky.social/post/3muzcj2tdth2y): docker windows github.com/dockur/windows

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Health on GitHub: Active
- Last change: 2026-11-02
- Checked on GitHub: 2026-11-09
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open dockur/windows on GitHub](https://github.com/dockur/windows)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/b2a3b14d-a8fd-4274-99fb-42e04aac3ca5)
- [Its page on Mindket](https://mindket.com/p/b2a3b14d-a8fd-4274-99fb-42e04aac3ca5)
