diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index e0b2955..40621a0 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -48,17 +48,17 @@ jobs:
           tag="${{ inputs.tag || github.ref_name }}"
           version="${tag#v}"
           go build -trimpath -ldflags="-s -w -X main.version=${version}" \
-            -o "msvc-go-wine-linux-${{ matrix.goarch }}" ./cmd/msvc-go-wine
+            -o "vintner-linux-${{ matrix.goarch }}" ./cmd/vintner
 
       - name: Verify it runs
         if: matrix.goarch == 'amd64'
-        run: ./msvc-go-wine-linux-amd64 version
+        run: ./vintner-linux-amd64 version
 
       - name: Upload artifact
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
-          name: msvc-go-wine-linux-${{ matrix.goarch }}
-          path: msvc-go-wine-linux-${{ matrix.goarch }}
+          name: vintner-linux-${{ matrix.goarch }}
+          path: vintner-linux-${{ matrix.goarch }}
           if-no-files-found: error
           retention-days: 14
 
@@ -71,11 +71,11 @@ jobs:
       - name: Download all architectures
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
-          pattern: msvc-go-wine-linux-*
+          pattern: vintner-linux-*
           merge-multiple: true
 
       - name: Checksums
-        run: sha256sum msvc-go-wine-linux-* > SHA256SUMS
+        run: sha256sum vintner-linux-* > SHA256SUMS
 
       - name: Create or update GitHub Release
         env:
@@ -85,10 +85,10 @@ jobs:
           tag="${{ inputs.tag || github.ref_name }}"
           if ! gh release view "$tag" >/dev/null 2>&1; then
             gh release create "$tag" \
-              --title "msvc-go-wine $tag" \
+              --title "vintner $tag" \
               --notes "Linux amd64/arm64 binaries built by CI from this tag. See README.md for install instructions."
           fi
           gh release upload "$tag" \
-            msvc-go-wine-linux-* \
+            vintner-linux-* \
             SHA256SUMS \
             --clobber
diff --git a/.gitignore b/.gitignore
index 18451b6..0dab7c5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,3 @@
-/msvc-go-wine
+/vintner
 *.test
 .claude/
diff --git a/LICENSE.txt b/LICENSE.txt
index d8ad75f..334c752 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -20,6 +20,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-This license covers msvc-go-wine's own source code. It does not cover the
-Microsoft Visual C++ Build Tools / Windows SDK that `msvc-go-wine download`
+This license covers vintner's own source code. It does not cover the
+Microsoft Visual C++ Build Tools / Windows SDK that `vintner download`
 fetches and unpacks, which remain governed by Microsoft's own license terms.
diff --git a/README.md b/README.md
index 3b24526..670ce7e 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# msvc-go-wine
+# vintner
 
 Cross compile with MSVC on Linux, using Wine — a single-binary Go tool
 inspired by [mstorsjo/msvc-wine](https://github.com/mstorsjo/msvc-wine)'s
@@ -6,13 +6,14 @@ approach (download the real MSVC/WinSDK, wrap the compiler under Wine),
 implemented independently.
 
 Once installed, you invoke the real Microsoft toolchain exactly like on
-Windows: `cl`, `link`, `lib`, `rc`, `midl`, `mt`, `dumpbin`, `msbuild`,
-`nmake`, `ml`, `ml64`, `armasm`, `armasm64` all just work from your `PATH`.
+Windows: `cl`, `link`, `lib`, `rc`, `midl`, `mc`, `mt`, `dumpbin`, `msbuild`,
+`nmake`, `ml`, `ml64`, `armasm`, `armasm64`, plus trivial `cmd`/`findstr`
+shims, all just work from your `PATH`.
 
 ## How it works
 
-`msvc-go-wine` is one Go binary that behaves differently depending on the
-name it's invoked as (a "multi-call binary", like busybox):
+`vintner` is one Go binary that behaves differently depending on the name
+it's invoked as (a "multi-call binary", like busybox):
 
 - Invoked as `cl`, `link`, `lib`, ... → it loads a small per-architecture
   `env.json`, builds the `INCLUDE`/`LIB`/`WINEPATH` environment Wine needs,
@@ -21,22 +22,23 @@ name it's invoked as (a "multi-call binary", like busybox):
   runs the real `.exe` under `wine`/`wine64`, and rewrites the tool's output
   back from `z:\...` paths to plain unix paths so your build system's error
   parsing keeps working.
-- Invoked as `msvc-go-wine` → it exposes the `download`, `install`, `env` and
-  `version` management subcommands described below.
+- Invoked as `vintner` → it exposes the `download`, `install`, `env` and
+  `version` management subcommands described below (each also has a short
+  alias: `dl`, `i`, `e`, `v`; `help`/`h` prints usage).
 
 ## Quick start
 
 ```bash
-# 1. Download and unpack MSVC + Windows SDK into ~/.msvc-go-wine (requires
+# 1. Download and unpack MSVC + Windows SDK into ~/.vintner (requires
 #    accepting Microsoft's Visual Studio Build Tools license, and msitools
 #    for unpacking .msi payloads). Pass --dest <dir> for a different location.
-msvc-go-wine download --accept-license
+vintner download --accept-license
 
 # 2. Wire up the tool wrappers
-msvc-go-wine install
+vintner install
 
 # 3. Add the toolchain to PATH and build
-export PATH=~/.msvc-go-wine/bin/x64:$PATH
+export PATH=~/.vintner/bin/x64:$PATH
 cl /nologo /EHsc hello.cpp
 ```
 
@@ -56,20 +58,23 @@ pkcon install wine msitools
 ## Commands
 
 ```
-msvc-go-wine download --accept-license [--dest <dir>] [options]   fetch and unpack MSVC/WinSDK
-msvc-go-wine install [dir]                                        wire up wrappers for a downloaded MSVC
-msvc-go-wine env --bin <dir>/bin/<arch>                           print INCLUDE/LIB for native clang-cl/lld-link use
-msvc-go-wine version                                              print the version
+vintner download (dl) --accept-license [--dest <dir>] [options]   fetch and unpack MSVC/WinSDK/WDK
+vintner install (i) [dir]                                         wire up wrappers for a downloaded MSVC
+vintner env (e) --bin <dir>/bin/<arch>                            print INCLUDE/LIB for native clang-cl/lld-link use
+vintner version (v)                                               print the version
+vintner help (h)                                                  print usage
 ```
 
-`--dest`/`[dir]` both default to `~/.msvc-go-wine` when omitted.
+`--dest`/`[dir]` both default to `~/.vintner` when omitted.
 
-`download` supports `--msvc-version`, `--sdk-version`, `--architecture`,
-`--host-arch`, `--with-*` component toggles, `--ignore`, `--only-download`,
-`--only-unpack`, `--keep-unpack`, `--cache`, `--language`,
-`--include-optional`, `--skip-recommended`, `--major`, `--preview`,
-`--manifest`, `--list-workloads`, `--list-components`, `--print-deps-tree`.
-Run `msvc-go-wine download -h` for the full list.
+`download`'s main options: `--msvc-version`, `--sdk-version`,
+`--architecture`, `--host-arch`, `--only-host`, `--with-wdk` (also fetch the
+Windows Driver Kit, for building KMDF/UMDF drivers), `--ignore`,
+`--only-download`, `--only-unpack`, `--keep-unpack`, `--skip-patch`,
+`--cache`, `--language`, `--include-optional`, `--skip-recommended`,
+`--major`, `--preview`, `--manifest`, `--list-workloads`,
+`--list-components`, `--print-deps-tree`. Run `vintner download -h` for the
+full list with descriptions.
 
 `--list-workloads`/`--list-components` print every workload/component id
 (with its human-readable title) available in the fetched manifest and exit
@@ -78,13 +83,31 @@ package id or via `--with-*`. `--print-deps-tree` prints the dependency tree
 of whatever would actually be selected (honoring every other flag), also
 without downloading.
 
+### Building drivers (WDK)
+
+`vintner download --with-wdk` additionally fetches the Windows Driver Kit
+(headers, import libs, and the MSBuild `WindowsKernelModeDriver10.0`/
+`WindowsUserModeDriver10.0` PlatformToolsets) so `msbuild` can build real
+KMDF/UMDF drivers - compiling, linking, INF stamping and the `Inf2Cat`
+signability check (with `SignMode=off`) all work under Wine. Verified
+end-to-end against a real sample driver from
+[microsoft/Windows-driver-samples](https://github.com/microsoft/Windows-driver-samples).
+Only x64 and arm64 targets have a WDK package upstream (no x86/arm).
+
+### Language
+
+CLI messages (usage text, progress lines, prompts) are in English by
+default. Set `VINTNER_LANG=ru` (or have a `ru`-prefixed `LC_ALL`/
+`LC_MESSAGES`/`LANG`, e.g. `ru_RU.UTF-8`) for Russian. Deeper error text
+bubbled up from internal packages stays in English.
+
 ### Using clang-cl/lld-link instead of Wine
 
 You don't need Wine at all if you drive the (nonredistributable) MSVC/WinSDK
 headers and libraries with Clang/LLD in MSVC-compatible mode:
 
 ```bash
-eval "$(msvc-go-wine env --bin ~/.msvc-go-wine/bin/x64)"
+eval "$(vintner env --bin ~/.vintner/bin/x64)"
 clang-cl -c hello.c
 lld-link hello.obj -out:hello.exe
 ```
@@ -92,7 +115,7 @@ lld-link hello.obj -out:hello.exe
 ## Building from source
 
 ```bash
-go build -o msvc-go-wine ./cmd/msvc-go-wine
+go build -o vintner ./cmd/vintner
 ```
 
 Go 1.23+ is all you need to build it; `wine`/`msitools` are only needed at
@@ -124,14 +147,14 @@ telemetry, and don't hard-fail devcmd setup when an optional component
 
 ## Known gaps
 
-- `download` doesn't yet support installing the Windows Driver Kit via
-  `--with-wdk-installers`; the core selection/download/unpack/install
-  pipeline, dependency tree printing, and workload/component listing are all
-  fully implemented.
+None currently tracked. Download/select/unpack/install, general MSBuild
+projects, WDK driver builds, dependency-tree printing, and
+workload/component listing are all implemented and verified against real
+projects.
 
 ## License
 
-MIT, see [LICENSE.txt](LICENSE.txt) - covers msvc-go-wine's own source only.
-The MSVC Build Tools / Windows SDK that `download` fetches remain governed
+MIT, see [LICENSE.txt](LICENSE.txt) - covers vintner's own source only. The
+MSVC Build Tools / Windows SDK / WDK that `download` fetches remain governed
 by Microsoft's own license (accepted via `--accept-license`), same as with
 any other way of obtaining them.
diff --git a/assets/patches/Common7/Tools/VsDevCmd.bat.patch b/assets/patches/Common7/Tools/VsDevCmd.bat.patch
index 8ac84a9..873d0e8 100644
--- a/assets/patches/Common7/Tools/VsDevCmd.bat.patch
+++ b/assets/patches/Common7/Tools/VsDevCmd.bat.patch
@@ -1,4 +1,4 @@
-msvc-go-wine: skip VsDevCmd's telemetry upload.
+vintner: skip VsDevCmd's telemetry upload.
 
 There's no telemetry endpoint reachable (or wanted) under Wine. Rather than
 touching the conditional logic below, just set the opt-out switch the
diff --git a/assets/patches/Common7/Tools/vsdevcmd/core/vsdevcmd_start.bat.patch b/assets/patches/Common7/Tools/vsdevcmd/core/vsdevcmd_start.bat.patch
index 43d0e29..b699822 100644
--- a/assets/patches/Common7/Tools/vsdevcmd/core/vsdevcmd_start.bat.patch
+++ b/assets/patches/Common7/Tools/vsdevcmd/core/vsdevcmd_start.bat.patch
@@ -1,4 +1,4 @@
-msvc-go-wine: always record the starting directory.
+vintner: always record the starting directory.
 
 vsdevcmd_start.bat only saved __VSCMD_CURRENT_DIR when the caller passed
 -startdir=none, which doesn't hold up under Wine's cmd.exe (see
diff --git a/assets/patches/Common7/Tools/vsdevcmd/core/winsdk.bat.patch b/assets/patches/Common7/Tools/vsdevcmd/core/winsdk.bat.patch
index 3fc976a..89843ca 100644
--- a/assets/patches/Common7/Tools/vsdevcmd/core/winsdk.bat.patch
+++ b/assets/patches/Common7/Tools/vsdevcmd/core/winsdk.bat.patch
@@ -1,4 +1,4 @@
-msvc-go-wine: find the Windows SDK/UCRT dirs on disk before trying the registry.
+vintner: find the Windows SDK/UCRT dirs on disk before trying the registry.
 
 winsdk.bat locates the Windows 10/11 SDK and Universal CRT SDK by querying
 the Windows Registry, which doesn't have real SDK installation entries
diff --git a/assets/patches/Common7/Tools/vsdevcmd/ext/ConnectionManagerExe.bat.patch b/assets/patches/Common7/Tools/vsdevcmd/ext/ConnectionManagerExe.bat.patch
index 7eb7d49..2caff0f 100644
--- a/assets/patches/Common7/Tools/vsdevcmd/ext/ConnectionManagerExe.bat.patch
+++ b/assets/patches/Common7/Tools/vsdevcmd/ext/ConnectionManagerExe.bat.patch
@@ -1,4 +1,4 @@
-msvc-go-wine: don't hard-fail devcmd setup when ConnectionManagerExe is missing.
+vintner: don't hard-fail devcmd setup when ConnectionManagerExe is missing.
 
 Not every MSVC/WinSDK download selection includes the Linux
 ConnectionManagerExe component; a missing optional component shouldn't
diff --git a/assets/patches/Common7/Tools/vsdevcmd/ext/cmake.bat.patch b/assets/patches/Common7/Tools/vsdevcmd/ext/cmake.bat.patch
index 11e53a3..1967ad7 100644
--- a/assets/patches/Common7/Tools/vsdevcmd/ext/cmake.bat.patch
+++ b/assets/patches/Common7/Tools/vsdevcmd/ext/cmake.bat.patch
@@ -1,4 +1,4 @@
-msvc-go-wine: don't hard-fail devcmd setup when the bundled CMake/Ninja is missing.
+vintner: don't hard-fail devcmd setup when the bundled CMake/Ninja is missing.
 
 Same reasoning as the ConnectionManagerExe fix: a missing optional
 component shouldn't abort the whole Developer Command Prompt setup.
diff --git a/assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/msvc-go-wine.props.remove b/assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/msvc-go-wine.props.remove
new file mode 100644
index 0000000..e69de29
diff --git a/assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/msvc-go-wine.props b/assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/vintner.props
similarity index 94%
rename from assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/msvc-go-wine.props
rename to assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/vintner.props
index e01cfa7..05d3f0a 100644
--- a/assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/msvc-go-wine.props
+++ b/assets/patches/MSBuild/Microsoft/VC/v180/ImportBefore/Default/vintner.props
@@ -1,5 +1,5 @@
 <!--
-  msvc-go-wine: make MSBuild resolve the Windows SDK / UCRT / preferred tool
+  vintner: make MSBuild resolve the Windows SDK / UCRT / preferred tool
   architecture from the VS install layout directly, since there's no
   Windows Registry under Wine for the stock .props files to query.
 
diff --git a/assets/patches/MSBuild/Microsoft/VC/v180/Microsoft.Cpp.WindowsSDK.props.patch b/assets/patches/MSBuild/Microsoft/VC/v180/Microsoft.Cpp.WindowsSDK.props.patch
index 0f3c4a1..302e153 100644
--- a/assets/patches/MSBuild/Microsoft/VC/v180/Microsoft.Cpp.WindowsSDK.props.patch
+++ b/assets/patches/MSBuild/Microsoft/VC/v180/Microsoft.Cpp.WindowsSDK.props.patch
@@ -1,8 +1,8 @@
-msvc-go-wine: let MSBuild find the Windows SDK without the registry.
+vintner: let MSBuild find the Windows SDK without the registry.
 
 GetLatestSDKTargetPlatformVersion normally resolves the SDK via the
 registry, which has nothing to find under Wine. Pass it an extra list of
-roots (populated by msvc-go-wine.props, see the ImportBefore directory next
+roots (populated by vintner.props, see the ImportBefore directory next
 to this file) so it can also look directly under the VS install root.
 
 diff --git a/MSBuild/Microsoft/VC/v180/Microsoft.Cpp.WindowsSDK.props b/MSBuild/Microsoft/VC/v180/Microsoft.Cpp.WindowsSDK.props
diff --git a/assets/vendor/toolrelay.cpp b/assets/vendor/toolrelay.cpp
index ac451d6..6939f24 100644
--- a/assets/vendor/toolrelay.cpp
+++ b/assets/vendor/toolrelay.cpp
@@ -1,5 +1,5 @@
 // toolrelay.exe - a thin native launcher for a Wine-hosted MSVC tool
-// invocation, built and used by msvc-go-wine (see internal/install's
+// invocation, built and used by vintner (see internal/install's
 // buildToolRelay and internal/wrapper's runViaToolRelay).
 //
 // It exists to solve two problems that are only solvable from inside a
diff --git a/cmd/msvc-go-wine/download.go b/cmd/vintner/download.go
similarity index 90%
rename from cmd/msvc-go-wine/download.go
rename to cmd/vintner/download.go
index a797fd5..57ec428 100644
--- a/cmd/msvc-go-wine/download.go
+++ b/cmd/vintner/download.go
@@ -8,13 +8,13 @@ import (
 	"path/filepath"
 	"runtime"
 
-	"github.com/Cheviiot/msvc-go-wine/internal/download"
-	"github.com/Cheviiot/msvc-go-wine/internal/i18n"
+	"github.com/Cheviiot/vintner/internal/download"
+	"github.com/Cheviiot/vintner/internal/i18n"
 )
 
 func runDownload(args []string) int {
 	fs := flag.NewFlagSet("download", flag.ContinueOnError)
-	dest := fs.String("dest", "", "directory to install into (default: ~/.msvc-go-wine)")
+	dest := fs.String("dest", "", "directory to install into (default: ~/.vintner)")
 	cacheDir := fs.String("cache", "", "directory to use as a persistent download cache (default: a temp dir, removed afterwards)")
 	major := fs.Int("major", 18, "the major VS version to download")
 	preview := fs.Bool("preview", false, "download the preview/insiders channel instead of release/stable")
@@ -63,7 +63,7 @@ func runDownload(args []string) int {
 	if manifestURL == "" {
 		url, err := download.FetchChannelManifest(*major, *preview)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+			fmt.Fprintln(os.Stderr, "vintner download:", err)
 			return 1
 		}
 		manifestURL = url
@@ -73,7 +73,7 @@ func runDownload(args []string) int {
 
 	manifest, err := download.FetchInstallerManifest(manifestURL)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+		fmt.Fprintln(os.Stderr, "vintner download:", err)
 		return 1
 	}
 
@@ -105,7 +105,7 @@ func runDownload(args []string) int {
 	}
 
 	if err := download.ResolveSelection(opts, idx); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+		fmt.Fprintln(os.Stderr, "vintner download:", err)
 		return 1
 	}
 
@@ -116,7 +116,7 @@ func runDownload(args []string) int {
 
 	selected, err := download.ExpandSelection(idx, opts)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+		fmt.Fprintln(os.Stderr, "vintner download:", err)
 		return 1
 	}
 	var downloadSize, installSize int64
@@ -130,9 +130,9 @@ func runDownload(args []string) int {
 	cache := *cacheDir
 	removeCache := false
 	if cache == "" {
-		tmp, err := os.MkdirTemp("", "msvc-go-wine-cache-")
+		tmp, err := os.MkdirTemp("", "vintner-cache-")
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+			fmt.Fprintln(os.Stderr, "vintner download:", err)
 			return 1
 		}
 		cache = tmp
@@ -145,7 +145,7 @@ func runDownload(args []string) int {
 	if !*onlyDownload && *dest == "" {
 		def, err := defaultToolchainDir()
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+			fmt.Fprintln(os.Stderr, "vintner download:", err)
 			return 1
 		}
 		*dest = def
@@ -153,7 +153,7 @@ func runDownload(args []string) int {
 	}
 
 	if err := download.FetchPayloads(selected, cache, *onlyDownload); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+		fmt.Fprintln(os.Stderr, "vintner download:", err)
 		return 1
 	}
 	if *onlyDownload {
@@ -162,7 +162,7 @@ func runDownload(args []string) int {
 
 	destAbs, err := filepath.Abs(*dest)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+		fmt.Fprintln(os.Stderr, "vintner download:", err)
 		return 1
 	}
 
@@ -171,7 +171,7 @@ func runDownload(args []string) int {
 		unpack = filepath.Join(destAbs, "unpack")
 	}
 	if err := download.UnpackSelectedPackages(selected, cache, unpack); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+		fmt.Fprintln(os.Stderr, "vintner download:", err)
 		return 1
 	}
 
@@ -180,14 +180,14 @@ func runDownload(args []string) int {
 	for _, hostArch := range []string{"amd64", "arm64"} {
 		msbuildExe := filepath.Join(unpack, "MSBuild", "Current", "Bin", hostArch, "MSBuild.exe")
 		if err := download.CopyRedirectedAssemblies(msbuildExe); err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+			fmt.Fprintln(os.Stderr, "vintner download:", err)
 			return 1
 		}
 	}
 
 	if !*onlyUnpack {
 		if err := download.RelocateBuildTools(unpack, destAbs); err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+			fmt.Fprintln(os.Stderr, "vintner download:", err)
 			return 1
 		}
 		if !*keepUnpack {
@@ -195,7 +195,7 @@ func runDownload(args []string) int {
 		}
 		if !*skipPatch && *major == 18 {
 			if err := download.ApplyCompatibilityFixes(destAbs); err != nil {
-				fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+				fmt.Fprintln(os.Stderr, "vintner download:", err)
 				return 1
 			}
 		}
@@ -203,7 +203,7 @@ func runDownload(args []string) int {
 
 	if opts.WithWDK && !*onlyUnpack {
 		if err := downloadWDK(opts, selected, cache, destAbs, *major); err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine download:", err)
+			fmt.Fprintln(os.Stderr, "vintner download:", err)
 			return 1
 		}
 	}
diff --git a/cmd/msvc-go-wine/env.go b/cmd/vintner/env.go
similarity index 82%
rename from cmd/msvc-go-wine/env.go
rename to cmd/vintner/env.go
index a4923d2..939e208 100644
--- a/cmd/msvc-go-wine/env.go
+++ b/cmd/vintner/env.go
@@ -6,17 +6,17 @@ import (
 	"os"
 	"strings"
 
-	"github.com/Cheviiot/msvc-go-wine/internal/i18n"
-	"github.com/Cheviiot/msvc-go-wine/internal/wineenv"
+	"github.com/Cheviiot/vintner/internal/i18n"
+	"github.com/Cheviiot/vintner/internal/wineenv"
 )
 
 // runEnv prints shell `export` statements for INCLUDE/LIB (converted from
 // wine's "z:\..." notation to plain unix paths) and TARGET_TRIPLE, for
 // driving clang-cl/lld-link directly without Wine.
-// Usage: eval "$(msvc-go-wine env --bin <dest>/bin/<arch>)"
+// Usage: eval "$(vintner env --bin <dest>/bin/<arch>)"
 func runEnv(args []string) int {
 	fs := flag.NewFlagSet("env", flag.ContinueOnError)
-	bin := fs.String("bin", "", "the <dest>/bin/<arch> directory produced by `msvc-go-wine install`")
+	bin := fs.String("bin", "", "the <dest>/bin/<arch> directory produced by `vintner install`")
 	if err := fs.Parse(args); err != nil {
 		return 2
 	}
@@ -27,12 +27,12 @@ func runEnv(args []string) int {
 
 	cfg, err := wineenv.Load(*bin)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine env:", err)
+		fmt.Fprintln(os.Stderr, "vintner env:", err)
 		return 1
 	}
 	baseUnix, err := wineenv.FindBaseUnix(*bin)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine env:", err)
+		fmt.Fprintln(os.Stderr, "vintner env:", err)
 		return 1
 	}
 	paths := wineenv.NewPaths(cfg, baseUnix)
diff --git a/cmd/msvc-go-wine/install.go b/cmd/vintner/install.go
similarity index 69%
rename from cmd/msvc-go-wine/install.go
rename to cmd/vintner/install.go
index 21949f4..7f1ee3f 100644
--- a/cmd/msvc-go-wine/install.go
+++ b/cmd/vintner/install.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/Cheviiot/msvc-go-wine/internal/i18n"
-	"github.com/Cheviiot/msvc-go-wine/internal/install"
+	"github.com/Cheviiot/vintner/internal/i18n"
+	"github.com/Cheviiot/vintner/internal/install"
 )
 
 func runInstall(args []string) int {
@@ -20,7 +20,7 @@ func runInstall(args []string) int {
 	} else {
 		def, err := defaultToolchainDir()
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "msvc-go-wine install:", err)
+			fmt.Fprintln(os.Stderr, "vintner install:", err)
 			return 1
 		}
 		dest = def
@@ -29,12 +29,12 @@ func runInstall(args []string) int {
 
 	self, err := os.Executable()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine install:", err)
+		fmt.Fprintln(os.Stderr, "vintner install:", err)
 		return 1
 	}
 
 	if err := install.Install(dest, self); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine install:", err)
+		fmt.Fprintln(os.Stderr, "vintner install:", err)
 		return 1
 	}
 	fmt.Println(i18n.T("install.done", dest+"/bin/<arch>"))
diff --git a/cmd/msvc-go-wine/main.go b/cmd/vintner/main.go
similarity index 81%
rename from cmd/msvc-go-wine/main.go
rename to cmd/vintner/main.go
index c32e5f3..5882eef 100644
--- a/cmd/msvc-go-wine/main.go
+++ b/cmd/vintner/main.go
@@ -1,7 +1,7 @@
-// Command msvc-go-wine cross compiles with the real MSVC toolchain on Linux
+// Command vintner cross compiles with the real MSVC toolchain on Linux
 // via Wine. It's a multi-call binary that behaves as `cl`, `link`, `lib`,
 // `rc`, `midl`, `mt`, `dumpbin`, `msbuild`, etc. when invoked under one of
-// those names (via symlinks set up by `msvc-go-wine install`), and
+// those names (via symlinks set up by `vintner install`), and
 // otherwise exposes the `download`/`install`/`env`/`version` management
 // subcommands.
 package main
@@ -12,8 +12,8 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/Cheviiot/msvc-go-wine/internal/i18n"
-	"github.com/Cheviiot/msvc-go-wine/internal/wrapper"
+	"github.com/Cheviiot/vintner/internal/i18n"
+	"github.com/Cheviiot/vintner/internal/wrapper"
 )
 
 // version is set at build time via -ldflags "-X main.version=X.Y.Z";
@@ -48,7 +48,7 @@ func runCLI(args []string) int {
 	case "env", "e":
 		return runEnv(args[1:])
 	case "version", "v", "--version":
-		fmt.Println("msvc-go-wine " + version)
+		fmt.Println("vintner " + version)
 		return 0
 	case "-h", "--help", "help", "h":
 		printUsage()
diff --git a/cmd/msvc-go-wine/paths.go b/cmd/vintner/paths.go
similarity index 68%
rename from cmd/msvc-go-wine/paths.go
rename to cmd/vintner/paths.go
index 981dd73..a965a10 100644
--- a/cmd/msvc-go-wine/paths.go
+++ b/cmd/vintner/paths.go
@@ -6,12 +6,12 @@ import (
 )
 
 // defaultToolchainDir is where `download`/`install` operate when the user
-// doesn't specify a directory: a hidden ~/.msvc-go-wine, so it doesn't
+// doesn't specify a directory: a hidden ~/.vintner, so it doesn't
 // clutter a plain `ls ~`.
 func defaultToolchainDir() (string, error) {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return "", err
 	}
-	return filepath.Join(home, ".msvc-go-wine"), nil
+	return filepath.Join(home, ".vintner"), nil
 }
diff --git a/go.mod b/go.mod
index 05b1e14..656abb1 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
-module github.com/Cheviiot/msvc-go-wine
+module github.com/Cheviiot/vintner
 
 go 1.23
diff --git a/internal/download/manifest.go b/internal/download/manifest.go
index 9c2bce1..9858d38 100644
--- a/internal/download/manifest.go
+++ b/internal/download/manifest.go
@@ -186,7 +186,7 @@ var httpClient = &http.Client{Timeout: 5 * time.Minute}
 
 func init() {
 	// --manifest points at a local file, fetched through this same client
-	// via a "file:" URL (see cmd/msvc-go-wine's runDownload) - so it needs a
+	// via a "file:" URL (see cmd/vintner's runDownload) - so it needs a
 	// registered "file" handler alongside the default http/https transport.
 	t := http.DefaultTransport.(*http.Transport).Clone()
 	t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
diff --git a/internal/download/patch.go b/internal/download/patch.go
index 7e413af..2610c02 100644
--- a/internal/download/patch.go
+++ b/internal/download/patch.go
@@ -8,7 +8,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/Cheviiot/msvc-go-wine/assets"
+	"github.com/Cheviiot/vintner/assets"
 )
 
 // ApplyCompatibilityFixes applies the embedded Wine compatibility patches
@@ -63,7 +63,7 @@ func applyGitPatch(dest, embeddedPath, target string) error {
 		return err
 	}
 
-	tmp, err := os.CreateTemp("", "msvc-go-wine-*.patch")
+	tmp, err := os.CreateTemp("", "vintner-*.patch")
 	if err != nil {
 		return err
 	}
diff --git a/internal/download/select.go b/internal/download/select.go
index 32672b8..2f75435 100644
--- a/internal/download/select.go
+++ b/internal/download/select.go
@@ -50,7 +50,7 @@ type Options struct {
 	// selection - unlike everything else it depends on, it's opt-in via
 	// --with-wdk, since the actual driver headers/libs come from a separate
 	// NuGet package download handled outside ExpandSelection entirely (see
-	// wdk.go and cmd/msvc-go-wine's runDownload).
+	// wdk.go and cmd/vintner's runDownload).
 	WithWDK bool
 }
 
diff --git a/internal/i18n/i18n.go b/internal/i18n/i18n.go
index e57c692..892fc1c 100644
--- a/internal/i18n/i18n.go
+++ b/internal/i18n/i18n.go
@@ -1,4 +1,4 @@
-// Package i18n provides minimal message localization for msvc-go-wine's own
+// Package i18n provides minimal message localization for vintner's own
 // CLI chrome (usage text, progress lines, prompts). It does not localize
 // error messages bubbled up from deeper packages - those stay in English,
 // matching how most cross-platform dev tools keep diagnostic text technical
@@ -20,13 +20,13 @@ const (
 
 var current = detect()
 
-// detect picks the active language from MSVC_GO_WINE_LANG (checked first, so
+// detect picks the active language from VINTNER_LANG (checked first, so
 // it always overrides the locale), falling back to the POSIX locale
 // variables in their usual priority order (LC_ALL, LC_MESSAGES, LANG). Any
 // value starting with "ru" (case-insensitive) selects Russian; anything else
 // falls back to English.
 func detect() Lang {
-	for _, key := range []string{"MSVC_GO_WINE_LANG", "LC_ALL", "LC_MESSAGES", "LANG"} {
+	for _, key := range []string{"VINTNER_LANG", "LC_ALL", "LC_MESSAGES", "LANG"} {
 		v := os.Getenv(key)
 		if v == "" {
 			continue
@@ -65,55 +65,55 @@ func T(key string, args ...any) string {
 
 var catalog = map[string]map[Lang]string{
 	"main.usage": {
-		EN: `msvc-go-wine - cross compile with MSVC on Linux via Wine
+		EN: `vintner - cross compile with MSVC on Linux via Wine
 
 Usage:
-  msvc-go-wine download (dl) --accept-license [--dest <dir>] [options]
-                                                  fetch and unpack MSVC/WinSDK/WDK
-  msvc-go-wine install (i) [dir]                 wire up wrappers for a downloaded MSVC
-  msvc-go-wine env (e) --bin <dir/bin/arch>       print INCLUDE/LIB for native clang-cl/lld-link use
-  msvc-go-wine version (v)                       print the version
-  msvc-go-wine help (h)                          show this message
+  vintner download (dl) --accept-license [--dest <dir>] [options]
+                                        fetch and unpack MSVC/WinSDK/WDK
+  vintner install (i) [dir]            wire up wrappers for a downloaded MSVC
+  vintner env (e) --bin <dir/bin/arch> print INCLUDE/LIB for native clang-cl/lld-link use
+  vintner version (v)                  print the version
+  vintner help (h)                     show this message
 
-Run "msvc-go-wine <command> --help" for that command's own options - download
+Run "vintner <command> --help" for that command's own options - download
 has many, including --with-wdk, --list-workloads, --list-components and
 --print-deps-tree.
 
---dest/[dir] default to ~/.msvc-go-wine if omitted.
-Language: set MSVC_GO_WINE_LANG=ru (or LANG=ru_RU...) for Russian output.
+--dest/[dir] default to ~/.vintner if omitted.
+Language: set VINTNER_LANG=ru (or LANG=ru_RU...) for Russian output.
 
 Once installed, add <dir>/bin/<arch> to PATH and invoke the tools directly:
   cl, link, lib, ml, ml64, mc, midl, mt, rc, dumpbin, msbuild, nmake, armasm, armasm64, cmd, findstr
 `,
-		RU: `msvc-go-wine — кросс-компиляция настоящим MSVC на Linux через Wine
+		RU: `vintner — кросс-компиляция настоящим MSVC на Linux через Wine
 
 Использование:
-  msvc-go-wine download (dl) --accept-license [--dest <каталог>] [опции]
-                                                  скачать и распаковать MSVC/WinSDK/WDK
-  msvc-go-wine install (i) [каталог]             настроить обёртки для скачанного MSVC
-  msvc-go-wine env (e) --bin <dir/bin/arch>      вывести INCLUDE/LIB для clang-cl/lld-link напрямую
-  msvc-go-wine version (v)                       показать версию
-  msvc-go-wine help (h)                          показать эту справку
+  vintner download (dl) --accept-license [--dest <каталог>] [опции]
+                                        скачать и распаковать MSVC/WinSDK/WDK
+  vintner install (i) [каталог]        настроить обёртки для скачанного MSVC
+  vintner env (e) --bin <dir/bin/arch> вывести INCLUDE/LIB для clang-cl/lld-link напрямую
+  vintner version (v)                  показать версию
+  vintner help (h)                     показать эту справку
 
-Запустите «msvc-go-wine <команда> --help» для параметров конкретной команды —
+Запустите «vintner <команда> --help» для параметров конкретной команды —
 у download их много, включая --with-wdk, --list-workloads, --list-components
 и --print-deps-tree.
 
---dest/[каталог] по умолчанию — ~/.msvc-go-wine.
-Язык: установите MSVC_GO_WINE_LANG=en (или LANG=en_US...) для вывода на английском.
+--dest/[каталог] по умолчанию — ~/.vintner.
+Язык: установите VINTNER_LANG=en (или LANG=en_US...) для вывода на английском.
 
 После установки добавьте <dir>/bin/<arch> в PATH и вызывайте инструменты напрямую:
   cl, link, lib, ml, ml64, mc, midl, mt, rc, dumpbin, msbuild, nmake, armasm, armasm64, cmd, findstr
 `,
 	},
 	"main.unknown_subcommand": {
-		EN: "msvc-go-wine: unknown subcommand %q\n\n",
-		RU: "msvc-go-wine: неизвестная подкоманда %q\n\n",
+		EN: "vintner: unknown subcommand %q\n\n",
+		RU: "vintner: неизвестная подкоманда %q\n\n",
 	},
 
 	"install.usage": {
-		EN: "usage: msvc-go-wine install (i) [dest]  (default: ~/.msvc-go-wine)",
-		RU: "использование: msvc-go-wine install (i) [каталог]  (по умолчанию: ~/.msvc-go-wine)",
+		EN: "usage: vintner install (i) [dest]  (default: ~/.vintner)",
+		RU: "использование: vintner install (i) [каталог]  (по умолчанию: ~/.vintner)",
 	},
 	"install.default_dir": {
 		EN: "No directory given, using default: %s",
@@ -125,12 +125,12 @@ Once installed, add <dir>/bin/<arch> to PATH and invoke the tools directly:
 	},
 
 	"env.usage": {
-		EN: "usage: msvc-go-wine env (e) --bin <dest>/bin/<arch>",
-		RU: "использование: msvc-go-wine env (e) --bin <dest>/bin/<arch>",
+		EN: "usage: vintner env (e) --bin <dest>/bin/<arch>",
+		RU: "использование: vintner env (e) --bin <dest>/bin/<arch>",
 	},
 	"env.unknown_arch": {
-		EN: "msvc-go-wine env: unknown arch %q\n",
-		RU: "msvc-go-wine env: неизвестная архитектура %q\n",
+		EN: "vintner env: unknown arch %q\n",
+		RU: "vintner env: неизвестная архитектура %q\n",
 	},
 
 	"download.host_arch": {
@@ -146,8 +146,8 @@ Once installed, add <dir>/bin/<arch> to PATH and invoke the tools directly:
 		RU: "--dest не указан, используется значение по умолчанию: %s",
 	},
 	"download.done": {
-		EN: "Done. Next: msvc-go-wine install %s",
-		RU: "Готово. Далее: msvc-go-wine install %s",
+		EN: "Done. Next: vintner install %s",
+		RU: "Готово. Далее: vintner install %s",
 	},
 	"download.wdk_skip": {
 		EN: "--with-wdk: no x64/arm64 target architecture selected, skipping (no WDK package exists for x86/arm)",
diff --git a/internal/install/install.go b/internal/install/install.go
index 774ed21..73c03f4 100644
--- a/internal/install/install.go
+++ b/internal/install/install.go
@@ -1,4 +1,4 @@
-// Package install wires up a downloaded MSVC/WinSDK tree so the msvc-go-wine
+// Package install wires up a downloaded MSVC/WinSDK tree so the vintner
 // wrapper commands can find it: locating the installed toolchain/SDK
 // versions, fixing up header/library name casing, laying out the
 // per-architecture tool symlinks, and building the toolrelay helper.
@@ -14,16 +14,16 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/Cheviiot/msvc-go-wine/assets"
-	"github.com/Cheviiot/msvc-go-wine/internal/wineenv"
+	"github.com/Cheviiot/vintner/assets"
+	"github.com/Cheviiot/vintner/internal/wineenv"
 )
 
 var archs = []string{"x86", "x64", "arm", "arm64"}
 
 // Install wires up dest (a directory previously populated by
-// `msvc-go-wine download --dest dest`) with the tool wrapper symlinks and
+// `vintner download --dest dest`) with the tool wrapper symlinks and
 // env.json config the wrapper runtime expects. selfBinary is the path to
-// the currently running msvc-go-wine executable, copied into dest/bin so
+// the currently running vintner executable, copied into dest/bin so
 // the arch-specific tool symlinks have something to point at.
 func Install(dest, selfBinary string) error {
 	dest, err := filepath.Abs(dest)
@@ -86,7 +86,7 @@ func Install(dest, selfBinary string) error {
 
 	kits10 := filepath.Join(dest, "kits", "10")
 	if !isDir(kits10) {
-		return fmt.Errorf("%s not found - expected a Windows SDK already unpacked by `msvc-go-wine download`", kits10)
+		return fmt.Errorf("%s not found - expected a Windows SDK already unpacked by `vintner download`", kits10)
 	}
 	if err := lnS("Lib", filepath.Join(kits10, "lib")); err != nil {
 		return err
@@ -148,7 +148,7 @@ func Install(dest, selfBinary string) error {
 	if err := os.MkdirAll(destBin, 0o755); err != nil {
 		return err
 	}
-	sharedBinary := filepath.Join(destBin, "msvc-go-wine")
+	sharedBinary := filepath.Join(destBin, "vintner")
 	if err := copyFile(selfBinary, sharedBinary, 0o755); err != nil {
 		return fmt.Errorf("installing shared binary: %w", err)
 	}
@@ -288,7 +288,7 @@ func renameHostDirs(binDir string) error {
 }
 
 // setupWrapperDir creates <destBin>/<arch> with its own local copy of the
-// msvc-go-wine binary (not a symlink to the shared one in destBin), and
+// vintner binary (not a symlink to the shared one in destBin), and
 // symlinks every tool name to that LOCAL copy.
 //
 // This matters: the wrapper runtime locates its own install root via
@@ -297,23 +297,23 @@ func renameHostDirs(binDir string) error {
 // PATH-resolved absolute path as argv[0] (some just pass the bare command
 // name, e.g. "cl", which would make a naive argv[0]-based lookup resolve
 // against the caller's cwd instead of the install dir). A same-directory
-// symlink (cl -> msvc-go-wine) resolves to a binary that's still in the
-// right arch dir; a symlink to a binary one level up (cl -> ../msvc-go-wine)
+// symlink (cl -> vintner) resolves to a binary that's still in the
+// right arch dir; a symlink to a binary one level up (cl -> ../vintner)
 // would not be.
 func setupWrapperDir(destBin, selfBinary, arch, host, dotnetHost, msvcVer, sdkVer string) error {
 	archDir := filepath.Join(destBin, arch)
 	if err := os.MkdirAll(archDir, 0o755); err != nil {
 		return err
 	}
-	localBinary := filepath.Join(archDir, "msvc-go-wine")
+	localBinary := filepath.Join(archDir, "vintner")
 	if err := copyFile(selfBinary, localBinary, 0o755); err != nil {
 		return fmt.Errorf("installing per-arch binary: %w", err)
 	}
 	for name := range toolNames {
-		if err := lnS("msvc-go-wine", filepath.Join(archDir, name)); err != nil {
+		if err := lnS("vintner", filepath.Join(archDir, name)); err != nil {
 			return err
 		}
-		if err := lnS("msvc-go-wine", filepath.Join(archDir, name+".exe")); err != nil {
+		if err := lnS("vintner", filepath.Join(archDir, name+".exe")); err != nil {
 			return err
 		}
 	}
diff --git a/internal/wineenv/config.go b/internal/wineenv/config.go
index 3f79b7b..92f35ea 100644
--- a/internal/wineenv/config.go
+++ b/internal/wineenv/config.go
@@ -10,7 +10,7 @@ import (
 )
 
 // ConfigFileName is the per-architecture config dropped next to the tool
-// symlinks by `msvc-go-wine install`.
+// symlinks by `vintner install`.
 const ConfigFileName = "env.json"
 
 // Config is the per-architecture info generated at install time.
diff --git a/internal/wrapper/msbuildenv.go b/internal/wrapper/msbuildenv.go
index 08c88a4..40bedf1 100644
--- a/internal/wrapper/msbuildenv.go
+++ b/internal/wrapper/msbuildenv.go
@@ -6,7 +6,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/Cheviiot/msvc-go-wine/internal/wineenv"
+	"github.com/Cheviiot/vintner/internal/wineenv"
 )
 
 var reToolsetDir = regexp.MustCompile(`^v(\d+)$`)
diff --git a/internal/wrapper/run.go b/internal/wrapper/run.go
index be52d81..aa82871 100644
--- a/internal/wrapper/run.go
+++ b/internal/wrapper/run.go
@@ -12,7 +12,7 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/Cheviiot/msvc-go-wine/internal/wineenv"
+	"github.com/Cheviiot/vintner/internal/wineenv"
 )
 
 // pipeDrainGrace bounds how long we wait for a tool's stdout/stderr copy
@@ -24,7 +24,7 @@ import (
 // `| tail`, CI log capture) long after the actual build finished.
 const pipeDrainGrace = 500 * time.Millisecond
 
-// toolRelayName is where `msvc-go-wine install` places the compiled
+// toolRelayName is where `vintner install` places the compiled
 // toolrelay.exe helper, shared across all arch bin dirs.
 const toolRelayName = "toolrelay.exe"
 
@@ -37,7 +37,7 @@ func Run(tool string, args []string) int {
 
 	s, ok := Tools[tool]
 	if !ok {
-		fmt.Fprintf(os.Stderr, "msvc-go-wine: unknown tool %q\n", tool)
+		fmt.Fprintf(os.Stderr, "vintner: unknown tool %q\n", tool)
 		return 127
 	}
 
@@ -50,19 +50,19 @@ func Run(tool string, args []string) int {
 	// <dest>/bin/<arch>, not <dest>/bin.
 	exePath, err := os.Executable()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	scriptDir := filepath.Dir(exePath)
 
 	cfg, err := wineenv.Load(scriptDir)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine: loading install config:", err)
+		fmt.Fprintln(os.Stderr, "vintner: loading install config:", err)
 		return 1
 	}
 	baseUnix, err := wineenv.FindBaseUnix(scriptDir)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine: locating installation root:", err)
+		fmt.Fprintln(os.Stderr, "vintner: locating installation root:", err)
 		return 1
 	}
 	paths := wineenv.NewPaths(cfg, baseUnix)
@@ -71,7 +71,7 @@ func Run(tool string, args []string) int {
 
 	wineBin, err := wineenv.FindWine()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 
@@ -119,17 +119,17 @@ func Run(tool string, args []string) int {
 // observes the real 32-bit exit code via Win32 before translating and
 // re-exiting with a value that fits in a byte.
 func runViaToolRelay(wineBin, relayExe, exePath string, args []string, paths *wineenv.Paths, stdoutF, stderrF lineFilter) int {
-	stdoutFifo := filepath.Join(os.TempDir(), fmt.Sprintf("msvc-go-wine.stdout.%d", os.Getpid()))
-	stderrFifo := filepath.Join(os.TempDir(), fmt.Sprintf("msvc-go-wine.stderr.%d", os.Getpid()))
+	stdoutFifo := filepath.Join(os.TempDir(), fmt.Sprintf("vintner.stdout.%d", os.Getpid()))
+	stderrFifo := filepath.Join(os.TempDir(), fmt.Sprintf("vintner.stderr.%d", os.Getpid()))
 	os.Remove(stdoutFifo)
 	os.Remove(stderrFifo)
 	if err := syscall.Mkfifo(stdoutFifo, 0o600); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	defer os.Remove(stdoutFifo)
 	if err := syscall.Mkfifo(stderrFifo, 0o600); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	defer os.Remove(stderrFifo)
@@ -144,7 +144,7 @@ func runViaToolRelay(wineBin, relayExe, exePath string, args []string, paths *wi
 	}
 
 	if err := cmd.Start(); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 
@@ -176,7 +176,7 @@ func runViaToolRelay(wineBin, relayExe, exePath string, args []string, paths *wi
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			return exitErr.ExitCode()
 		}
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	return 0
@@ -191,17 +191,17 @@ func runViaToolRelay(wineBin, relayExe, exePath string, args []string, paths *wi
 func runRawStdout(cmd *exec.Cmd) int {
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	stderr, err := cmd.StderrPipe()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 
 	if err := cmd.Start(); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 
@@ -218,7 +218,7 @@ func runRawStdout(cmd *exec.Cmd) int {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			return exitErr.ExitCode()
 		}
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	return 0
@@ -265,17 +265,17 @@ func buildEnv(p *wineenv.Paths) []string {
 func runFiltered(cmd *exec.Cmd, stdoutF, stderrF lineFilter) int {
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	stderr, err := cmd.StderrPipe()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 
 	if err := cmd.Start(); err != nil {
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 
@@ -292,7 +292,7 @@ func runFiltered(cmd *exec.Cmd, stdoutF, stderrF lineFilter) int {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			return exitErr.ExitCode()
 		}
-		fmt.Fprintln(os.Stderr, "msvc-go-wine:", err)
+		fmt.Fprintln(os.Stderr, "vintner:", err)
 		return 1
 	}
 	return 0
diff --git a/internal/wrapper/tools.go b/internal/wrapper/tools.go
index 8f2adaf..a93b4a3 100644
--- a/internal/wrapper/tools.go
+++ b/internal/wrapper/tools.go
@@ -4,7 +4,7 @@
 // filtering its output.
 package wrapper
 
-import "github.com/Cheviiot/msvc-go-wine/internal/wineenv"
+import "github.com/Cheviiot/vintner/internal/wineenv"
 
 // dirKind selects which install directory a tool's real .exe lives in.
 type dirKind int