# How to Build AutoRemesher on Windows: Complete Step-by-Step Guide

> Build AutoRemesher on Windows with Visual Studio CMake and Qt. Follow our step-by-step guide to compile and run the AutoRemesher EXE for efficient 3D mesh processing.

- Repository: [Jeremy HU/autoremesher](https://github.com/huxingyi/autoremesher)
- Tags: how-to-guide
- Published: 2026-07-09

---

**Build AutoRemesher on Windows by installing Visual Studio 2022, CMake, and Qt 5.15.2, then compiling the bundled Intel TBB library, generating Qt makefiles with `qmake`, and invoking `nmake` to produce `release\autoremesher.exe`.**

AutoRemesher is a cross-platform C++ application for automatic mesh remeshing that uses Qt for its GUI and Intel TBB for threading. According to the `huxingyi/autoremesher` repository source code, the Windows build process requires specific toolchain configurations and third-party library compilation before the main application can link successfully.

## Prerequisites

Before starting, ensure your development environment includes the correct toolchain versions. The build system relies on specific MSVC compiler features and Qt modules.

- **Visual Studio 2022** with the *Desktop development with C++* workload (provides `cl`, `nmake`, and the Windows SDK)
- **CMake** (required to compile the bundled TBB library)
- **Qt 5.15.2** (specifically the `msvc2019_64` package)

Add CMake and Qt to your system `PATH` so that `cmake.exe` and `qmake.exe` are accessible from the command line (e.g., `C:\Qt\5.15.2\msvc2019_64\bin`).

## Step-by-Step Build Instructions

### 1. Open the Visual Studio Command Prompt

Launch the **x64 Native Tools Command Prompt for VS 2022** from the Start menu. This environment sets up the necessary variables for the MSVC toolchain, ensuring the compiler and linker are available.

### 2. Build Intel TBB

AutoRemesher bundles Intel TBB under `thirdparty/tbb` and must compile it as a shared library before linking. Navigate to the TBB directory and run CMake with specific flags to disable unnecessary components:

```cmd
cd thirdparty\tbb
cmake -B build2 ^
    -DTBB_BUILD_SHARED=ON ^
    -DTBB_BUILD_STATIC=OFF ^
    -DTBB_BUILD_TBBMALLOC=OFF ^
    -DTBB_BUILD_TBBMALLOC_PROXY=OFF ^
    -DTBB_BUILD_TESTS=OFF
cmake --build build2 --config Release
cd ..\..

```

This produces `thirdparty\tbb\build2\Release\tbb.dll` and the corresponding import library that the main project references in `autoremesher.pro` under the `win32` block.

### 3. Generate Qt Project Files

Use `qmake` with the Windows-specific specification to generate the Makefile (actually an NMake file):

```cmd
qmake -spec win32-msvc

```

The `autoremesher.pro` file contains the platform-specific configuration for this step, including the `win32` block that adds `winextras` when available and defines `PLATFORM = "Win32"`. It also includes Windows-specific compiler flags like `/bigobj` and `/MP`.

### 4. Configure Parallel Compilation

Enable MSVC parallel compilation to speed up the build process:

```cmd
set CL=/MP

```

This flag instructs the compiler to process multiple source files simultaneously.

### 5. Compile the Application

Invoke `nmake` using the Release configuration:

```cmd
nmake -f Makefile.Release

```

The `autoremesher.pro` file defines the Release build flags as `/O2 /GL /Qpar /fp:fast`, enabling link-time optimization (`/GL`), aggressive parallel compilation (`/Qpar`), and fast floating-point mode (`/fp:fast`). The resulting binary is placed at `release\autoremesher.exe`.

### 6. Run the Executable

You can now launch the application from the command line:

```cmd
release\autoremesher.exe --help

```

The executable supports both GUI mode and CLI mode for headless processing, accepting arguments like `--input`, `--output`, `--target-quads`, and `--sharp-edge`.

## Architecture Overview

Understanding the project structure helps troubleshoot build issues and customize the compilation.

**Qt Core Modules** – The project file includes `QT += core widgets opengl` and conditionally adds `openglwidgets` for Qt 6 compatibility. The `win32` block adds `winextras` and links against `-luser32` and `-lopengl32`.

**Threading Layer** – AutoRemesher links against the TBB library compiled in step 2 via `-ltbb` in the `win32` block of `autoremesher.pro`.

**Geometry Processing** – The core remeshing algorithms reside in `thirdparty/geogram/` and `thirdparty/isotropicremesher/`, with include paths set in `autoremesher.pro` (`INCLUDEPATH += thirdparty/geogram/...`).

**Source Organization** – The main remeshing logic lives in [`src/AutoRemesher/autoremesher.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/AutoRemesher/autoremesher.cpp) and [`src/AutoRemesher/isotropicremesher.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/AutoRemesher/isotropicremesher.cpp), while the Qt GUI is assembled from [`src/mainwindow.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/mainwindow.cpp), [`src/graphicswidget.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/graphicswidget.cpp), and other widget classes under `src/`.

## Summary

- Install **Visual Studio 2022**, **CMake**, and **Qt 5.15.2** (`msvc2019_64`) before building.
- Compile the bundled **Intel TBB** library in `thirdparty/tbb` using CMake to produce `tbb.dll`.
- Generate makefiles with `qmake -spec win32-msvc` from the Visual Studio Command Prompt.
- Enable parallel compilation with `set CL=/MP` to reduce build times.
- Build the Release binary using `nmake -f Makefile.Release`, which outputs `release\autoremesher.exe`.
- The `autoremesher.pro` file controls all platform-specific settings, compiler flags, and library linking for Windows.

## Frequently Asked Questions

### What compiler version does AutoRemesher require on Windows?

AutoRemesher requires the **MSVC 2019 or 2022 compiler** included with Visual Studio 2022. The `autoremesher.pro` file specifies `win32-msvc` and uses flags like `/bigobj` and `/MP` that are specific to the Microsoft compiler toolchain. While MinGW might work with modifications, the official build instructions and project configuration target the native Visual Studio compiler.

### Why do I need to build TBB separately instead of using a prebuilt binary?

The repository bundles TBB source code under `thirdparty/tbb` and links against it via `-ltbb` in the `win32` block of `autoremesher.pro`. Building from source ensures ABI compatibility with your specific MSVC version and allows the project to control build flags. The CMake configuration explicitly disables unnecessary components (TBBMalloc, tests) to reduce compile time and binary size.

### Can I build AutoRemesher with Qt 6 instead of Qt 5.15.2?

Yes, with minor modifications. The `autoremesher.pro` file contains a conditional block `greaterThan(QT_MAJOR_VERSION, 5): QT += openglwidgets` that handles the OpenGL widget module relocation in Qt 6. However, the primary development and testing target is Qt 5.15.2, so Qt 6 builds may require additional adjustments to the `win32` configuration blocks.

### How do I run AutoRemesher in command-line mode without the GUI?

After building `release\autoremesher.exe`, invoke it from the command prompt with the `--input` and `--output` arguments. The entry point in [`src/main.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/main.cpp) parses CLI arguments and supports headless operation for batch processing, allowing you to specify parameters like `--target-quads` and `--sharp-edge` directly without launching the GUI window.