MSVC compatibility: compile with Visual Studio 2019/2022 (fixes #10)

Platform-specific fixes for Windows/MSVC compilation:

CMake:
- Conditional -lm linking (MSVC CRT includes math)
- _CRT_SECURE_NO_WARNINGS, _USE_MATH_DEFINES definitions
- MSVC warning level /W3 with targeted suppressions

Source:
- stdatomic.h → MSVC _Interlocked* intrinsics
- __thread → __declspec(thread) on MSVC
- __attribute__((unused)) → __pragma(warning(suppress))
- clock_gettime/CLOCK_MONOTONIC → QueryPerformanceCounter
- R_OK / access() → _access() with R_OK=4 define
- pthread.h → Windows CRITICAL_SECTION/CONDITION_VARIABLE shim
- unistd.h / dirent.h guarded behind #ifndef _WIN32

No functional changes on Unix/macOS. 34/34 tests pass, 0 warnings.

Closes #10

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: unamedkr

CMakeLists.txt

@@ -27,7 +27,20 @@ add_library(turboquant STATIC
     ${TQ_ENGINE_SOURCES}
 )
 target_include_directories(turboquant PUBLIC include)
-target_link_libraries(turboquant PRIVATE m Threads::Threads)
+
+# Platform-specific linking
+if(MSVC)
+    # MSVC: no -lm needed, math is in CRT
+    target_link_libraries(turboquant PRIVATE Threads::Threads)
+    target_compile_definitions(turboquant PRIVATE
+        _CRT_SECURE_NO_WARNINGS
+        _USE_MATH_DEFINES
+    )
+    # Disable warnings that fire on valid C11
+    target_compile_options(turboquant PRIVATE /W3 /wd4244 /wd4267 /wd4996)
+else()
+    target_link_libraries(turboquant PRIVATE m Threads::Threads)
+endif()
 
 # Apple Accelerate framework (cblas_sgemv via AMX coprocessor)
 if(APPLE)
@@ -47,7 +60,13 @@ add_library(turboquant_shared SHARED
     ${TQ_ENGINE_SOURCES}
 )
 target_include_directories(turboquant_shared PUBLIC include)
-target_link_libraries(turboquant_shared PRIVATE m Threads::Threads)
+if(MSVC)
+    target_link_libraries(turboquant_shared PRIVATE Threads::Threads)
+    target_compile_definitions(turboquant_shared PRIVATE _CRT_SECURE_NO_WARNINGS _USE_MATH_DEFINES)
+    target_compile_options(turboquant_shared PRIVATE /W3 /wd4244 /wd4267 /wd4996)
+else()
+    target_link_libraries(turboquant_shared PRIVATE m Threads::Threads)
+endif()
 
 # Accelerate for shared library too
 if(APPLE AND ACCELERATE_LIB)

src/engine/tq_gguf_quants.c

@@ -1256,7 +1256,11 @@ static inline float dot_block_iq2_xxs(const uint8_t* blk, const float* x) {
 /* Fused IQ2_XXS row dot: dot product of entire quantized row with input vector.
  * Processes all 256-element super-blocks without any intermediate FP32 buffer.
  * Reserved for future fused matmul optimization path. */
+#ifdef _MSC_VER
+__pragma(warning(suppress: 4505))
+#else
 __attribute__((unused))
+#endif
 static float fused_dot_iq2_xxs(const void* row, const float* x, int n) {
     const int nb = n / 256;
     const uint8_t* base = (const uint8_t*)row;

src/engine/tq_model.c

@@ -27,6 +27,10 @@
 #ifdef _WIN32
 #include <windows.h>
 #include <io.h>
+#ifndef R_OK
+#define R_OK 4
+#endif
+#define access _access
 #else
 #include <sys/mman.h>
 #include <sys/stat.h>

src/engine/tq_ops.c

@@ -11,7 +11,26 @@
 #include <stdlib.h>
 #include <string.h>
 #include <float.h>
+
+#ifdef _WIN32
+#include <windows.h>
+/* pthread compat for MSVC (using Windows threads) */
+typedef HANDLE pthread_t;
+typedef CRITICAL_SECTION pthread_mutex_t;
+typedef CONDITION_VARIABLE pthread_cond_t;
+#define pthread_mutex_init(m, a) InitializeCriticalSection(m)
+#define pthread_mutex_lock(m)    EnterCriticalSection(m)
+#define pthread_mutex_unlock(m)  LeaveCriticalSection(m)
+#define pthread_mutex_destroy(m) DeleteCriticalSection(m)
+#define pthread_cond_init(c, a)  InitializeConditionVariable(c)
+#define pthread_cond_wait(c, m)  SleepConditionVariableCS(c, m, INFINITE)
+#define pthread_cond_broadcast(c) WakeAllConditionVariable(c)
+#define pthread_cond_destroy(c)  ((void)0)
+/* __thread → __declspec(thread) */
+#define __thread __declspec(thread)
+#else
 #include <pthread.h>
+#endif
 
 #ifdef __ARM_NEON
 #include <arm_neon.h>
@@ -29,7 +48,16 @@
  * Workers sleep between dispatches, wake via cond_broadcast.
  * Main thread does task[0], workers do task[1..n-1].
  * ============================================================ */
-#include <stdatomic.h>
+#if defined(_MSC_VER)
+    /* MSVC: use interlocked intrinsics instead of C11 atomics */
+    #include <intrin.h>
+    typedef volatile long atomic_int;
+    #define atomic_store(p, v)     _InterlockedExchange((p), (v))
+    #define atomic_load(p)         _InterlockedCompareExchange((p), 0, 0)
+    #define atomic_fetch_add(p, v) _InterlockedExchangeAdd((p), (v))
+#else
+    #include <stdatomic.h>
+#endif
 
 /* Forward declaration for 1-bit matmul (defined at end of file) */
 void tq_matmul_1bit(float* out, const float* x, const uint8_t* sign_data, const float* norms,

src/engine/tq_tokenizer.c

@@ -19,6 +19,10 @@
 #include <string.h>
 #include <stddef.h>
 
+#if defined(_MSC_VER) && !defined(__thread)
+#define __thread __declspec(thread)
+#endif
+
 /* Global for qsort comparator (vocab index sorting) */
 static char** g_vocab_for_sort;
 static int cmp_vocab_idx(const void* a, const void* b) {

src/engine/tq_transformer.c

@@ -70,9 +70,16 @@ static tq_profile_t g_profile = {0};
 int g_tq_profile_enabled = 0;  /* set from quant --profile */
 
 static inline double tq_now_ns(void) {
+#ifdef _WIN32
+    LARGE_INTEGER freq, cnt;
+    QueryPerformanceFrequency(&freq);
+    QueryPerformanceCounter(&cnt);
+    return (double)cnt.QuadPart / (double)freq.QuadPart * 1e9;
+#else
     struct timespec ts;
     clock_gettime(CLOCK_MONOTONIC, &ts);
     return (double)ts.tv_sec * 1e9 + (double)ts.tv_nsec;
+#endif
 }
 
 /* Usage: double _tp; TQ_PROF_START(_tp); ... TQ_PROF_STOP(_tp, field); */

tools/quant.c

@@ -37,6 +37,24 @@
 #include <time.h>
 #include <math.h>
 
+/* MSVC: clock_gettime compatibility */
+#ifdef _WIN32
+#include <windows.h>
+#ifndef CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC 1
+#endif
+struct timespec { long tv_sec; long tv_nsec; };
+static int clock_gettime(int id, struct timespec* ts) {
+    (void)id;
+    LARGE_INTEGER freq, cnt;
+    QueryPerformanceFrequency(&freq);
+    QueryPerformanceCounter(&cnt);
+    ts->tv_sec  = (long)(cnt.QuadPart / freq.QuadPart);
+    ts->tv_nsec = (long)((cnt.QuadPart % freq.QuadPart) * 1000000000LL / freq.QuadPart);
+    return 0;
+}
+#endif
+
 /* Forward-pass profiling flag (defined in tq_transformer.c) */
 extern int g_tq_profile_enabled;