Minimal support for native Windows (#394)

Doesn't include support for vendor libraries, due to the binary parts
of the oneAPI toolkit we need to build the oneAPI support library
being incompatible with our MinGW build environment on Yggdrasil
(as they're MSVC-generated, introducing C++ ABI incompatibilities).

Author: maleadt

Project.toml

@@ -10,36 +10,37 @@ ExprTools = "e2ba6199-217a-4e67-a87a-7c52f15ade04"
 GPUArrays = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7"
 GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55"
 KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
+Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 NEO_jll = "700fe977-ac61-5f37-bbc8-c6c4b2b6a9fd"
-oneAPI_Level_Zero_Headers_jll = "f4bc562b-d309-54f8-9efb-476e56f0410d"
-oneAPI_Level_Zero_Loader_jll = "13eca655-d68d-5b81-8367-6d99d727ab01"
-oneAPI_Support_jll = "b049733a-a71d-5ed3-8eba-7d323ac00b36"
 Preferences = "21216c6a-2e73-6563-6e65-726566657250"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 SPIRV_LLVM_Translator_unified_jll = "85f0d8ed-5b39-5caa-b1ae-7472de402361"
 SPIRV_Tools_jll = "6ac6d60f-d740-5983-97d7-a4482c0689f4"
+SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+oneAPI_Level_Zero_Headers_jll = "f4bc562b-d309-54f8-9efb-476e56f0410d"
+oneAPI_Level_Zero_Loader_jll = "13eca655-d68d-5b81-8367-6d99d727ab01"
+oneAPI_Support_jll = "b049733a-a71d-5ed3-8eba-7d323ac00b36"
 
 [compat]
 Adapt = "4"
 CEnum = "0.4, 0.5"
 ExprTools = "0.1"
 GPUArrays = "10"
 GPUCompiler = "0.23, 0.24, 0.25, 0.26"
-julia = "1.8"
 KernelAbstractions = "0.9.1"
 LLVM = "6"
 NEO_jll = "=24.05.28454"
-oneAPI_Level_Zero_Loader_jll = "1.9"
-oneAPI_Support_jll = "~0.3.1"
 Preferences = "1"
-SpecialFunctions = "1.3, 2"
 SPIRV_LLVM_Translator_unified_jll = "0.3"
+SpecialFunctions = "1.3, 2"
 StaticArrays = "1"
+julia = "1.8"
+oneAPI_Level_Zero_Loader_jll = "1.9"
+oneAPI_Support_jll = "~0.3.1"
 
 [extras]
 libigc_jll = "94295238-5935-5bd7-bb0f-b00942e9bdd5"

lib/level-zero/oneL0.jl

@@ -6,8 +6,14 @@ using CEnum
 
 using Printf
 
-using NEO_jll
-using oneAPI_Level_Zero_Loader_jll
+using Libdl
+
+if Sys.iswindows()
+    const libze_loader = "ze_loader"
+else
+    using NEO_jll
+    using oneAPI_Level_Zero_Loader_jll
+end
 
 include("utils.jl")
 include("pointer.jl")
@@ -85,16 +91,23 @@ function __init__()
     precompiling = ccall(:jl_generating_output, Cint, ()) != 0
     precompiling && return
 
-    if !oneAPI_Level_Zero_Loader_jll.is_available()
-        @error """No oneAPI Level Zero loader found for your platform. Currently, only Linux x86 is supported.
-                  If you have a local oneAPI toolchain, you can use that; refer to the documentation for more details."""
-        return
-    end
+    if Sys.iswindows()
+        if Libdl.dlopen(libze_loader; throw_error=false) === nothing
+            @error "The oneAPI Level Zero loader was not found. Please ensure the Intel GPU drivers are installed."
+            return
+        end
+    else
+        if !oneAPI_Level_Zero_Loader_jll.is_available()
+            @error """No oneAPI Level Zero loader found for your platform. Currently, only Linux x86 is supported.
+                      If you have a local oneAPI toolchain, you can use that; refer to the documentation for more details."""
+            return
+        end
 
-    if !NEO_jll.is_available()
-        @error """No oneAPI driver found for your platform. Currently, only Linux x86_64 is supported.
-                  If you have a local oneAPI toolchain, you can use that; refer to the documentation for more details."""
-        return
+        if !NEO_jll.is_available()
+            @error """No oneAPI driver found for your platform. Currently, only Linux x86_64 is supported.
+                      If you have a local oneAPI toolchain, you can use that; refer to the documentation for more details."""
+            return
+        end
     end
 
     try

lib/support/Support.jl

@@ -22,7 +22,7 @@ end
 function __init__()
     precompiling = ccall(:jl_generating_output, Cint, ()) != 0
     precompiling && return
-
+    
     if !oneAPI_Support_jll.is_available()
         @error """oneAPI support wrapper not available for your platform."""
         return

src/device/opencl/integer.jl

@@ -1,7 +1,7 @@
 # Integer Functions
 
 # TODO: vector types
-const generic_integer_types = [Cchar, Cuchar, Cshort, Cushort, Cint, Cuint, Clong, Culong]
+const generic_integer_types = [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64]
 
 
 # generically typed

src/device/opencl/math.jl

@@ -1,9 +1,9 @@
 # Math Functions
 
 # TODO: vector types
-const generic_types = [Cfloat,Cdouble]
-const generic_types_float = [Cfloat]
-const generic_types_double = [Cdouble]
+const generic_types = [Float32,Float64]
+const generic_types_float = [Float32]
+const generic_types_double = [Float64]
 
 
 # generically typed
@@ -112,10 +112,10 @@ end
 
 for gentypef in generic_types_float
 
-if gentypef !== Cfloat
+if gentypef !== Float32
 @eval begin
-@device_override Base.max(x::$gentypef, y::Cfloat) = @builtin_ccall("fmax", $gentypef, ($gentypef, Cfloat), x, y)
-@device_override Base.min(x::$gentypef, y::Cfloat) = @builtin_ccall("fmin", $gentypef, ($gentypef, Cfloat), x, y)
+@device_override Base.max(x::$gentypef, y::Float32) = @builtin_ccall("fmax", $gentypef, ($gentypef, Float32), x, y)
+@device_override Base.min(x::$gentypef, y::Float32) = @builtin_ccall("fmin", $gentypef, ($gentypef, Float32), x, y)
 end
 end
 
@@ -126,10 +126,10 @@ end
 
 for gentyped in generic_types_double
 
-if gentyped !== Cdouble
+if gentyped !== Float64
 @eval begin
-@device_override Base.min(x::$gentyped, y::Cdouble) = @builtin_ccall("fmin", $gentyped, ($gentyped, Cdouble), x, y)
-@device_override Base.max(x::$gentyped, y::Cdouble) = @builtin_ccall("fmax", $gentyped, ($gentyped, Cdouble), x, y)
+@device_override Base.min(x::$gentyped, y::Float64) = @builtin_ccall("fmin", $gentyped, ($gentyped, Float64), x, y)
+@device_override Base.max(x::$gentyped, y::Float64) = @builtin_ccall("fmax", $gentyped, ($gentyped, Float64), x, y)
 end
 end
 
@@ -138,47 +138,47 @@ end
 
 # specifically typed
 
-# frexp(x::Cfloat{n}, Cint{n} *exp) = @builtin_ccall("frexp", Cfloat{n}, (Cfloat{n}, Cint{n} *), x, exp)
-# frexp(x::Cfloat, Cint *exp) = @builtin_ccall("frexp", Cfloat, (Cfloat, Cint *), x, exp)
-# frexp(x::Cdouble{n}, Cint{n} *exp) = @builtin_ccall("frexp", Cdouble{n}, (Cdouble{n}, Cint{n} *), x, exp)
-# frexp(x::Cdouble, Cint *exp) = @builtin_ccall("frexp", Cdouble, (Cdouble, Cint *), x, exp)
-
-# ilogb(x::Cfloat{n}) = @builtin_ccall("ilogb", Cint{n}, (Cfloat{n},), x)
-@device_function ilogb(x::Cfloat) = @builtin_ccall("ilogb", Cint, (Cfloat,), x)
-# ilogb(x::Cdouble{n}) = @builtin_ccall("ilogb", Cint{n}, (Cdouble{n},), x)
-@device_function ilogb(x::Cdouble) = @builtin_ccall("ilogb", Cint, (Cdouble,), x)
-
-# ldexp(x::Cfloat{n}, k::Cint{n}) = @builtin_ccall("ldexp", Cfloat{n}, (Cfloat{n}, Cint{n}), x, k)
-# ldexp(x::Cfloat{n}, k::Cint) = @builtin_ccall("ldexp", Cfloat{n}, (Cfloat{n}, Cint), x, k)
-@device_override Base.ldexp(x::Cfloat, k::Cint) = @builtin_ccall("ldexp", Cfloat, (Cfloat, Cint), x, k)
-# ldexp(x::Cdouble{n}, k::Cint{n}) = @builtin_ccall("ldexp", Cdouble{n}, (Cdouble{n}, Cint{n}), x, k)
-# ldexp(x::Cdouble{n}, k::Cint) = @builtin_ccall("ldexp", Cdouble{n}, (Cdouble{n}, Cint), x, k)
-@device_override Base.ldexp(x::Cdouble, k::Cint) = @builtin_ccall("ldexp", Cdouble, (Cdouble, Cint), x, k)
-
-# lgamma_r(x::Cfloat{n}, Cint{n} *signp) = @builtin_ccall("lgamma_r", Cfloat{n}, (Cfloat{n}, Cint{n} *), x, signp)
-# lgamma_r(x::Cfloat, Cint *signp) = @builtin_ccall("lgamma_r", Cfloat, (Cfloat, Cint *), x, signp)
-# lgamma_r(x::Cdouble{n}, Cint{n} *signp) = @builtin_ccall("lgamma_r", Cdouble{n}, (Cdouble{n}, Cint{n} *), x, signp)
-# Cdouble lgamma_r(x::Cdouble, Cint *signp) = @builtin_ccall("lgamma_r", Cdouble, (Cdouble, Cint *), x, signp)
-
-# nan(nancode::uintn) = @builtin_ccall("nan", Cfloat{n}, (uintn,), nancode)
-@device_function nan(nancode::Cuint) = @builtin_ccall("nan", Cfloat, (Cuint,), nancode)
-# nan(nancode::Culong{n}) = @builtin_ccall("nan", Cdouble{n}, (Culong{n},), nancode)
-@device_function nan(nancode::Culong) = @builtin_ccall("nan", Cdouble, (Culong,), nancode)
-
-# pown(x::Cfloat{n}, y::Cint{n}) = @builtin_ccall("pown", Cfloat{n}, (Cfloat{n}, Cint{n}), x, y)
-@device_override Base.:(^)(x::Cfloat, y::Cint) = @builtin_ccall("pown", Cfloat, (Cfloat, Cint), x, y)
-# pown(x::Cdouble{n}, y::Cint{n}) = @builtin_ccall("pown", Cdouble{n}, (Cdouble{n}, Cint{n}), x, y)
-@device_override Base.:(^)(x::Cdouble, y::Cint) = @builtin_ccall("pown", Cdouble, (Cdouble, Cint), x, y)
-
-# remquo(x::Cfloat{n}, y::Cfloat{n}, Cint{n} *quo) = @builtin_ccall("remquo", Cfloat{n}, (Cfloat{n}, Cfloat{n}, Cint{n} *), x, y, quo)
-# remquo(x::Cfloat, y::Cfloat, Cint *quo) = @builtin_ccall("remquo", Cfloat, (Cfloat, Cfloat, Cint *), x::Cfloat, y, quo)
-# remquo(x::Cdouble{n}, y::Cdouble{n}, Cint{n} *quo) = @builtin_ccall("remquo", Cdouble{n}, (Cdouble{n}, Cdouble{n}, Cint{n} *), x, y, quo)
-# remquo(x::Cdouble, y::Cdouble, Cint *quo) = @builtin_ccall("remquo", Cdouble, (Cdouble, Cdouble, Cint *), x, y, quo)
-
-# rootn(x::Cfloat{n}, y::Cint{n}) = @builtin_ccall("rootn", Cfloat{n}, (Cfloat{n}, Cint{n}), x, y)
-@device_function rootn(x::Cfloat, y::Cint) = @builtin_ccall("rootn", Cfloat, (Cfloat, Cint), x, y)
-# rootn(x::Cdouble{n}, y::Cint{n}) = @builtin_ccall("rootn", Cdouble{n}, (Cdouble{n}, Cint{n}), x, y)
-# rootn(x::Cdouble, y::Cint) = @builtin_ccall("rootn", Cdouble{n}, (Cdouble, Cint), x, y)
+# frexp(x::Float32{n}, Int32{n} *exp) = @builtin_ccall("frexp", Float32{n}, (Float32{n}, Int32{n} *), x, exp)
+# frexp(x::Float32, Int32 *exp) = @builtin_ccall("frexp", Float32, (Float32, Int32 *), x, exp)
+# frexp(x::Float64{n}, Int32{n} *exp) = @builtin_ccall("frexp", Float64{n}, (Float64{n}, Int32{n} *), x, exp)
+# frexp(x::Float64, Int32 *exp) = @builtin_ccall("frexp", Float64, (Float64, Int32 *), x, exp)
+
+# ilogb(x::Float32{n}) = @builtin_ccall("ilogb", Int32{n}, (Float32{n},), x)
+@device_function ilogb(x::Float32) = @builtin_ccall("ilogb", Int32, (Float32,), x)
+# ilogb(x::Float64{n}) = @builtin_ccall("ilogb", Int32{n}, (Float64{n},), x)
+@device_function ilogb(x::Float64) = @builtin_ccall("ilogb", Int32, (Float64,), x)
+
+# ldexp(x::Float32{n}, k::Int32{n}) = @builtin_ccall("ldexp", Float32{n}, (Float32{n}, Int32{n}), x, k)
+# ldexp(x::Float32{n}, k::Int32) = @builtin_ccall("ldexp", Float32{n}, (Float32{n}, Int32), x, k)
+@device_override Base.ldexp(x::Float32, k::Int32) = @builtin_ccall("ldexp", Float32, (Float32, Int32), x, k)
+# ldexp(x::Float64{n}, k::Int32{n}) = @builtin_ccall("ldexp", Float64{n}, (Float64{n}, Int32{n}), x, k)
+# ldexp(x::Float64{n}, k::Int32) = @builtin_ccall("ldexp", Float64{n}, (Float64{n}, Int32), x, k)
+@device_override Base.ldexp(x::Float64, k::Int32) = @builtin_ccall("ldexp", Float64, (Float64, Int32), x, k)
+
+# lgamma_r(x::Float32{n}, Int32{n} *signp) = @builtin_ccall("lgamma_r", Float32{n}, (Float32{n}, Int32{n} *), x, signp)
+# lgamma_r(x::Float32, Int32 *signp) = @builtin_ccall("lgamma_r", Float32, (Float32, Int32 *), x, signp)
+# lgamma_r(x::Float64{n}, Int32{n} *signp) = @builtin_ccall("lgamma_r", Float64{n}, (Float64{n}, Int32{n} *), x, signp)
+# Float64 lgamma_r(x::Float64, Int32 *signp) = @builtin_ccall("lgamma_r", Float64, (Float64, Int32 *), x, signp)
+
+# nan(nancode::uintn) = @builtin_ccall("nan", Float32{n}, (uintn,), nancode)
+@device_function nan(nancode::UInt32) = @builtin_ccall("nan", Float32, (UInt32,), nancode)
+# nan(nancode::UInt64{n}) = @builtin_ccall("nan", Float64{n}, (UInt64{n},), nancode)
+@device_function nan(nancode::UInt64) = @builtin_ccall("nan", Float64, (UInt64,), nancode)
+
+# pown(x::Float32{n}, y::Int32{n}) = @builtin_ccall("pown", Float32{n}, (Float32{n}, Int32{n}), x, y)
+@device_override Base.:(^)(x::Float32, y::Int32) = @builtin_ccall("pown", Float32, (Float32, Int32), x, y)
+# pown(x::Float64{n}, y::Int32{n}) = @builtin_ccall("pown", Float64{n}, (Float64{n}, Int32{n}), x, y)
+@device_override Base.:(^)(x::Float64, y::Int32) = @builtin_ccall("pown", Float64, (Float64, Int32), x, y)
+
+# remquo(x::Float32{n}, y::Float32{n}, Int32{n} *quo) = @builtin_ccall("remquo", Float32{n}, (Float32{n}, Float32{n}, Int32{n} *), x, y, quo)
+# remquo(x::Float32, y::Float32, Int32 *quo) = @builtin_ccall("remquo", Float32, (Float32, Float32, Int32 *), x::Float32, y, quo)
+# remquo(x::Float64{n}, y::Float64{n}, Int32{n} *quo) = @builtin_ccall("remquo", Float64{n}, (Float64{n}, Float64{n}, Int32{n} *), x, y, quo)
+# remquo(x::Float64, y::Float64, Int32 *quo) = @builtin_ccall("remquo", Float64, (Float64, Float64, Int32 *), x, y, quo)
+
+# rootn(x::Float32{n}, y::Int32{n}) = @builtin_ccall("rootn", Float32{n}, (Float32{n}, Int32{n}), x, y)
+@device_function rootn(x::Float32, y::Int32) = @builtin_ccall("rootn", Float32, (Float32, Int32), x, y)
+# rootn(x::Float64{n}, y::Int32{n}) = @builtin_ccall("rootn", Float64{n}, (Float64{n}, Int32{n}), x, y)
+# rootn(x::Float64, y::Int32) = @builtin_ccall("rootn", Float64{n}, (Float64, Int32), x, y)
 
 
 # TODO: half and native

src/device/opencl/synchronization.jl

@@ -2,11 +2,11 @@
 
 export barrier
 
-const cl_mem_fence_flags = Cuint
+const cl_mem_fence_flags = UInt32
 const CLK_LOCAL_MEM_FENCE = cl_mem_fence_flags(1)
 const CLK_GLOBAL_MEM_FENCE = cl_mem_fence_flags(2)
 
-#barrier(flags=0) = @builtin_ccall("barrier", Cvoid, (Cuint,), flags)
+#barrier(flags=0) = @builtin_ccall("barrier", Cvoid, (UInt32,), flags)
 barrier(flags=0) = Base.llvmcall(("""
         declare void @_Z7barrierj(i32) #0
         define void @entry(i32 %0) #1 {

src/device/opencl/work_item.jl

@@ -12,19 +12,19 @@ export get_work_dim,
 
 # TODO: 1-indexed dimension selection?
 
-get_work_dim() = @builtin_ccall("get_work_dim", Cuint, ()) % Int
+get_work_dim() = @builtin_ccall("get_work_dim", UInt32, ()) % Int
 
-get_global_size(dimindx::Integer=0) = @builtin_ccall("get_global_size", Csize_t, (Cuint,), dimindx) % Int
-get_global_id(dimindx::Integer=0) = @builtin_ccall("get_global_id", Csize_t, (Cuint,), dimindx) % Int + 1
+get_global_size(dimindx::Integer=0) = @builtin_ccall("get_global_size", UInt, (UInt32,), dimindx) % Int
+get_global_id(dimindx::Integer=0) = @builtin_ccall("get_global_id", UInt, (UInt32,), dimindx) % Int + 1
 
-get_local_size(dimindx::Integer=0) = @builtin_ccall("get_local_size", Csize_t, (Cuint,), dimindx) % Int
-get_enqueued_local_size(dimindx::Integer=0) = @builtin_ccall("get_enqueued_local_size", Csize_t, (Cuint,), dimindx) % Int
-get_local_id(dimindx::Integer=0) = @builtin_ccall("get_local_id", Csize_t, (Cuint,), dimindx) % Int + 1
+get_local_size(dimindx::Integer=0) = @builtin_ccall("get_local_size", UInt, (UInt32,), dimindx) % Int
+get_enqueued_local_size(dimindx::Integer=0) = @builtin_ccall("get_enqueued_local_size", UInt, (UInt32,), dimindx) % Int
+get_local_id(dimindx::Integer=0) = @builtin_ccall("get_local_id", UInt, (UInt32,), dimindx) % Int + 1
 
-get_num_groups(dimindx::Integer=0) = @builtin_ccall("get_num_groups", Csize_t, (Cuint,), dimindx) % Int
-get_group_id(dimindx::Integer=0) = @builtin_ccall("get_group_id", Csize_t, (Cuint,), dimindx) % Int + 1
+get_num_groups(dimindx::Integer=0) = @builtin_ccall("get_num_groups", UInt, (UInt32,), dimindx) % Int
+get_group_id(dimindx::Integer=0) = @builtin_ccall("get_group_id", UInt, (UInt32,), dimindx) % Int + 1
 
-get_global_offset(dimindx::Integer=0) = @builtin_ccall("get_global_offset", Csize_t, (Cuint,), dimindx) % Int + 1
+get_global_offset(dimindx::Integer=0) = @builtin_ccall("get_global_offset", UInt, (UInt32,), dimindx) % Int + 1
 
-get_global_linear_id() = @builtin_ccall("get_global_linear_id", Csize_t, ()) % Int + 1
-get_local_linear_id() = @builtin_ccall("get_local_linear_id", Csize_t, ()) % Int + 1
+get_global_linear_id() = @builtin_ccall("get_global_linear_id", UInt, ()) % Int + 1
+get_local_linear_id() = @builtin_ccall("get_local_linear_id", UInt, ()) % Int + 1

src/device/utils.jl

@@ -19,6 +19,10 @@ macro builtin_ccall(name, ret, argtypes, args...)
             "l"
         elseif T == Culong
             "m"
+        elseif T == Clonglong
+            "x"
+        elseif T == Culonglong
+            "y"
         elseif T == Cshort
             "s"
         elseif T == Cushort

src/oneAPI.jl

@@ -17,14 +17,12 @@ using Core: LLVMPtr
 
 using SPIRV_LLVM_Translator_unified_jll, SPIRV_Tools_jll
 
-export oneL0, SYCL
+export oneL0
 
 # core library
 include("../lib/utils/APIUtils.jl")
 include("../lib/level-zero/oneL0.jl")
-include("../lib/support/Support.jl")
-include("../lib/sycl/SYCL.jl")
-using .oneL0, .SYCL
+using .oneL0
 functional() = oneL0.functional[]
 
 # device functionality (needs to be loaded first, because of generated functions)
@@ -54,9 +52,17 @@ include("compiler/compilation.jl")
 include("compiler/execution.jl")
 include("compiler/reflection.jl")
 
+if Sys.islinux()
+# library interop
+include("../lib/support/Support.jl")
+include("../lib/sycl/SYCL.jl")
+using .SYCL
+export SYCL
+
 # array libraries
 include("../lib/mkl/oneMKL.jl")
 export oneMKL
+end
 
 # integrations and specialized functionality
 include("broadcast.jl")
@@ -73,13 +79,15 @@ function __init__()
     precompiling = ccall(:jl_generating_output, Cint, ()) != 0
     precompiling && return
 
-    if !Sys.islinux()
-        @error("oneAPI.jl is only supported on Linux")
-        return
+    if Sys.iswindows()
+        @warn """oneAPI.jl support for native Windows is experimental and incomplete.
+                 For the time being, it is recommended to use WSL or Linux instead."""
     end
 
-    # ensure that the OpenCL runtime dispatcher finds the ICD files from our artifacts
-    ENV["OCL_ICD_VENDORS"] = oneL0.NEO_jll.libigdrcl
+    if Sys.islinux()
+        # ensure that the OpenCL runtime dispatcher finds the ICD files from our artifacts
+        ENV["OCL_ICD_VENDORS"] = oneL0.NEO_jll.libigdrcl
+    end
 end
 
 function set_debug!(debug::Bool)

src/utils.jl

@@ -8,20 +8,22 @@ function versioninfo(io::IO=stdout)
     deps = Pkg.dependencies()
     versions = Dict(map(uuid->deps[uuid].name => deps[uuid].version, collect(keys(deps))))
 
-    println(io, "Binary dependencies:")
-    for jll in [oneL0.NEO_jll, oneL0.NEO_jll.libigc_jll, oneL0.NEO_jll.gmmlib_jll,
-                SPIRV_LLVM_Translator_unified_jll, SPIRV_Tools_jll]
-        name = string(jll)
-        print(io, "- $(name[1:end-4]): $(versions[name])")
-        if jll.host_platform !== nothing
-            debug = tryparse(Bool, get(jll.host_platform.tags, "debug", "false"))
-            if debug === true
-                print(io, " (debug)")
+    if Sys.islinux()
+        println(io, "Binary dependencies:")
+        for jll in [oneL0.NEO_jll, oneL0.NEO_jll.libigc_jll, oneL0.NEO_jll.gmmlib_jll,
+                    SPIRV_LLVM_Translator_unified_jll, SPIRV_Tools_jll]
+            name = string(jll)
+            print(io, "- $(name[1:end-4]): $(versions[name])")
+            if jll.host_platform !== nothing
+                debug = tryparse(Bool, get(jll.host_platform.tags, "debug", "false"))
+                if debug === true
+                    print(io, " (debug)")
+                end
             end
+            println(io)
         end
         println(io)
     end
-    println(io)
 
     println(io, "Toolchain:")
     println(io, "- Julia: $VERSION")