Fix symbol export

c/CMakeLists.txt

@@ -115,6 +115,8 @@ set_target_properties(
              POSITION_INDEPENDENT_CODE ON
              INTERFACE_POSITION_INDEPENDENT_CODE ON
              EXPORT_NAME c_api
+             CXX_VISIBILITY_PRESET hidden
+             VISIBILITY_INLINES_HIDDEN ON
 )
 
 # Setup the VERSION and SOVERSION of our library

c/include/cuvs/cluster/kmeans.h

@@ -10,6 +10,8 @@
 #include <dlpack/dlpack.h>
 #include <stdint.h>
 
+#include <cuvs/core/export.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -119,15 +121,15 @@ typedef struct cuvsKMeansParams* cuvsKMeansParams_t;
  * @param[in] params cuvsKMeansParams_t to allocate
  * @return cuvsError_t
  */
-cuvsError_t cuvsKMeansParamsCreate(cuvsKMeansParams_t* params);
+CUVS_EXPORT cuvsError_t cuvsKMeansParamsCreate(cuvsKMeansParams_t* params);
 
 /**
  * @brief De-allocate KMeans params
  *
  * @param[in] params
  * @return cuvsError_t
  */
-cuvsError_t cuvsKMeansParamsDestroy(cuvsKMeansParams_t params);
+CUVS_EXPORT cuvsError_t cuvsKMeansParamsDestroy(cuvsKMeansParams_t params);
 
 /**
  * @brief Type of k-means algorithm.
@@ -173,7 +175,7 @@ typedef enum { CUVS_KMEANS_TYPE_KMEANS = 0, CUVS_KMEANS_TYPE_KMEANS_BALANCED = 1
  *                              closest cluster center.
  * @param[out]    n_iter        Number of iterations run.
  */
-cuvsError_t cuvsKMeansFit(cuvsResources_t res,
+CUVS_EXPORT cuvsError_t cuvsKMeansFit(cuvsResources_t res,
                           cuvsKMeansParams_t params,
                           DLManagedTensor* X,
                           DLManagedTensor* sample_weight,
@@ -200,7 +202,7 @@ cuvsError_t cuvsKMeansFit(cuvsResources_t res,
  * @param[out]    inertia          Sum of squared distances of samples to
  *                                 their closest cluster center.
  */
-cuvsError_t cuvsKMeansPredict(cuvsResources_t res,
+CUVS_EXPORT cuvsError_t cuvsKMeansPredict(cuvsResources_t res,
                               cuvsKMeansParams_t params,
                               DLManagedTensor* X,
                               DLManagedTensor* sample_weight,
@@ -222,7 +224,7 @@ cuvsError_t cuvsKMeansPredict(cuvsResources_t res,
  * @param[out] cost           Resulting cluster cost
  *
  */
-cuvsError_t cuvsKMeansClusterCost(cuvsResources_t res,
+CUVS_EXPORT cuvsError_t cuvsKMeansClusterCost(cuvsResources_t res,
                                   DLManagedTensor* X,
                                   DLManagedTensor* centroids,
                                   double* cost);

c/include/cuvs/core/c_api.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -10,6 +10,8 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include <cuvs/core/export.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -27,13 +29,13 @@ typedef enum { CUVS_ERROR = 0, CUVS_SUCCESS = 1 } cuvsError_t;
 /** @brief Returns a string describing the last seen error on this thread, or
  *         NULL if the last function succeeded.
  */
-const char* cuvsGetLastErrorText();
+CUVS_EXPORT const char* cuvsGetLastErrorText();
 
 /**
  * @brief Sets a string describing an error seen on the thread. Passing NULL
  *        clears any previously seen error message.
  */
-void cuvsSetLastErrorText(const char* error);
+CUVS_EXPORT void cuvsSetLastErrorText(const char* error);
 
 /** @} */
 
@@ -58,11 +60,11 @@ typedef enum {
 
 /** @brief Returns the current log level
  */
-cuvsLogLevel_t cuvsGetLogLevel();
+CUVS_EXPORT cuvsLogLevel_t cuvsGetLogLevel();
 
 /** @brief Sets the log level
  */
-void cuvsSetLogLevel(cuvsLogLevel_t);
+CUVS_EXPORT void cuvsSetLogLevel(cuvsLogLevel_t);
 
 /** @} */
 
@@ -83,15 +85,15 @@ typedef uintptr_t cuvsResources_t;
  * @param[in] res cuvsResources_t opaque C handle
  * @return cuvsError_t
  */
-cuvsError_t cuvsResourcesCreate(cuvsResources_t* res);
+CUVS_EXPORT cuvsError_t cuvsResourcesCreate(cuvsResources_t* res);
 
 /**
  * @brief Destroy and de-allocate opaque C handle for C++ type `raft::resources`
  *
  * @param[in] res cuvsResources_t opaque C handle
  * @return cuvsError_t
  */
-cuvsError_t cuvsResourcesDestroy(cuvsResources_t res);
+CUVS_EXPORT cuvsError_t cuvsResourcesDestroy(cuvsResources_t res);
 
 /**
  * @brief Set cudaStream_t on cuvsResources_t to queue CUDA kernels on APIs
@@ -101,7 +103,7 @@ cuvsError_t cuvsResourcesDestroy(cuvsResources_t res);
  * @param[in] stream cudaStream_t stream to queue CUDA kernels
  * @return cuvsError_t
  */
-cuvsError_t cuvsStreamSet(cuvsResources_t res, cudaStream_t stream);
+CUVS_EXPORT cuvsError_t cuvsStreamSet(cuvsResources_t res, cudaStream_t stream);
 
 /**
  * @brief Get the cudaStream_t from a cuvsResources_t
@@ -110,15 +112,15 @@ cuvsError_t cuvsStreamSet(cuvsResources_t res, cudaStream_t stream);
  * @param[out] stream cudaStream_t stream to queue CUDA kernels
  * @return cuvsError_t
  */
-cuvsError_t cuvsStreamGet(cuvsResources_t res, cudaStream_t* stream);
+CUVS_EXPORT cuvsError_t cuvsStreamGet(cuvsResources_t res, cudaStream_t* stream);
 
 /**
  * @brief Syncs the current CUDA stream on the resources object
  *
  * @param[in] res cuvsResources_t opaque C handle
  * @return cuvsError_t
  */
-cuvsError_t cuvsStreamSync(cuvsResources_t res);
+CUVS_EXPORT cuvsError_t cuvsStreamSync(cuvsResources_t res);
 
 /**
  * @brief Get the id of the device associated with this cuvsResources_t
@@ -127,7 +129,7 @@ cuvsError_t cuvsStreamSync(cuvsResources_t res);
  * @param[out] device_id int the id of the device associated with res
  * @return cuvsError_t
  */
-cuvsError_t cuvsDeviceIdGet(cuvsResources_t res, int* device_id);
+CUVS_EXPORT cuvsError_t cuvsDeviceIdGet(cuvsResources_t res, int* device_id);
 
 /**
  * @brief Create an Initialized opaque C handle for C++ type `raft::device_resources_snmg`
@@ -136,7 +138,7 @@ cuvsError_t cuvsDeviceIdGet(cuvsResources_t res, int* device_id);
  * @param[in] res cuvsResources_t opaque C handle
  * @return cuvsError_t
  */
-cuvsError_t cuvsMultiGpuResourcesCreate(cuvsResources_t* res);
+CUVS_EXPORT cuvsError_t cuvsMultiGpuResourcesCreate(cuvsResources_t* res);
 
 /**
  * @brief Create an Initialized opaque C handle for C++ type `raft::device_resources_snmg`
@@ -146,7 +148,7 @@ cuvsError_t cuvsMultiGpuResourcesCreate(cuvsResources_t* res);
  * @param[in] device_ids DLManagedTensor* containing device IDs to use
  * @return cuvsError_t
  */
-cuvsError_t cuvsMultiGpuResourcesCreateWithDeviceIds(cuvsResources_t* res,
+CUVS_EXPORT cuvsError_t cuvsMultiGpuResourcesCreateWithDeviceIds(cuvsResources_t* res,
                                                      DLManagedTensor* device_ids);
 
 /**
@@ -155,7 +157,7 @@ cuvsError_t cuvsMultiGpuResourcesCreateWithDeviceIds(cuvsResources_t* res,
  * @param[in] res cuvsResources_t opaque C handle
  * @return cuvsError_t
  */
-cuvsError_t cuvsMultiGpuResourcesDestroy(cuvsResources_t res);
+CUVS_EXPORT cuvsError_t cuvsMultiGpuResourcesDestroy(cuvsResources_t res);
 
 /**
  * @brief Set a memory pool on all devices managed by the multi-GPU resources
@@ -164,7 +166,7 @@ cuvsError_t cuvsMultiGpuResourcesDestroy(cuvsResources_t res);
  * @param[in] percent_of_free_memory Percent of free memory to allocate for the pool
  * @return cuvsError_t
  */
-cuvsError_t cuvsMultiGpuResourcesSetMemoryPool(cuvsResources_t res, int percent_of_free_memory);
+CUVS_EXPORT cuvsError_t cuvsMultiGpuResourcesSetMemoryPool(cuvsResources_t res, int percent_of_free_memory);
 /** @} */
 
 /**
@@ -181,7 +183,7 @@ cuvsError_t cuvsMultiGpuResourcesSetMemoryPool(cuvsResources_t res, int percent_
  * @param[in] bytes Size in bytes to allocate
  * @return cuvsError_t
  */
-cuvsError_t cuvsRMMAlloc(cuvsResources_t res, void** ptr, size_t bytes);
+CUVS_EXPORT cuvsError_t cuvsRMMAlloc(cuvsResources_t res, void** ptr, size_t bytes);
 
 /**
  * @brief Deallocates device memory using RMM
@@ -191,7 +193,7 @@ cuvsError_t cuvsRMMAlloc(cuvsResources_t res, void** ptr, size_t bytes);
  * @param[in] bytes Size in bytes to allocate
  * @return cuvsError_t
  */
-cuvsError_t cuvsRMMFree(cuvsResources_t res, void* ptr, size_t bytes);
+CUVS_EXPORT cuvsError_t cuvsRMMFree(cuvsResources_t res, void* ptr, size_t bytes);
 
 /**
  * @brief Switches the working memory resource to use the RMM pool memory resource, which will
@@ -207,30 +209,30 @@ cuvsError_t cuvsRMMFree(cuvsResources_t res, void* ptr, size_t bytes);
  * @param[in] managed Whether to use a managed memory resource as upstream resource or not
  * @return cuvsError_t
  */
-cuvsError_t cuvsRMMPoolMemoryResourceEnable(int initial_pool_size_percent,
+CUVS_EXPORT cuvsError_t cuvsRMMPoolMemoryResourceEnable(int initial_pool_size_percent,
                                             int max_pool_size_percent,
                                             bool managed);
 /**
  * @brief Resets the memory resource to use the default memory resource (cuda_memory_resource)
  * @return cuvsError_t
  */
-cuvsError_t cuvsRMMMemoryResourceReset();
+CUVS_EXPORT cuvsError_t cuvsRMMMemoryResourceReset();
 
 /**
  * @brief Allocates pinned memory on the host using RMM
  * @param[out] ptr Pointer to allocated host memory
  * @param[in] bytes Size in bytes to allocate
  * @return cuvsError_t
  */
-cuvsError_t cuvsRMMHostAlloc(void** ptr, size_t bytes);
+CUVS_EXPORT cuvsError_t cuvsRMMHostAlloc(void** ptr, size_t bytes);
 
 /**
  * @brief Deallocates pinned memory on the host using RMM
  * @param[in] ptr Pointer to allocated host memory to free
  * @param[in] bytes Size in bytes to deallocate
  * @return cuvsError_t
  */
-cuvsError_t cuvsRMMHostFree(void* ptr, size_t bytes);
+CUVS_EXPORT cuvsError_t cuvsRMMHostFree(void* ptr, size_t bytes);
 
 /**
  * @brief Get the version of the cuVS library
@@ -239,7 +241,7 @@ cuvsError_t cuvsRMMHostFree(void* ptr, size_t bytes);
  * @param[out] patch Patch version
  * @return cuvsError_t
  */
-cuvsError_t cuvsVersionGet(uint16_t* major, uint16_t* minor, uint16_t* patch);
+CUVS_EXPORT cuvsError_t cuvsVersionGet(uint16_t* major, uint16_t* minor, uint16_t* patch);
 
 /**
  * @brief Copy a matrix
@@ -256,7 +258,7 @@ cuvsError_t cuvsVersionGet(uint16_t* major, uint16_t* minor, uint16_t* patch);
  * @param[in] src Pointer to DLManagedTensor to copy
  * @param[out] dst Pointer to DLManagedTensor to receive copy of data
  */
-cuvsError_t cuvsMatrixCopy(cuvsResources_t res, DLManagedTensor* src, DLManagedTensor* dst);
+CUVS_EXPORT cuvsError_t cuvsMatrixCopy(cuvsResources_t res, DLManagedTensor* src, DLManagedTensor* dst);
 
 /**
  * @brief Slices rows from a matrix
@@ -267,7 +269,7 @@ cuvsError_t cuvsMatrixCopy(cuvsResources_t res, DLManagedTensor* src, DLManagedT
  * @param[in] end Last row index to include in the output
  * @param[out] dst Pointer to DLManagedTensor to receive slice from matrix
  */
-cuvsError_t cuvsMatrixSliceRows(
+CUVS_EXPORT cuvsError_t cuvsMatrixSliceRows(
   cuvsResources_t res, DLManagedTensor* src, int64_t start, int64_t end, DLManagedTensor* dst);
 /** @} */
 

c/include/cuvs/core/export.h

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+// Symbol visibility macros for cuVS shared libraries.
+// When CXX_VISIBILITY_PRESET is set to hidden, only symbols explicitly
+// marked with CUVS_EXPORT will be visible in the shared library.
+// CUVS_HIDDEN can be used to explicitly mark symbols as hidden.
+#if (defined(__GNUC__) && !defined(__MINGW32__) && !defined(__MINGW64__))
+#define CUVS_EXPORT __attribute__((visibility("default")))
+#define CUVS_HIDDEN __attribute__((visibility("hidden")))
+#else
+#define CUVS_EXPORT
+#define CUVS_HIDDEN
+#endif

c/include/cuvs/distance/distance.h

@@ -1,9 +1,11 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
 
+#include <cuvs/core/export.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif

c/include/cuvs/distance/pairwise_distance.h

@@ -8,6 +8,8 @@
 #include <cuvs/core/c_api.h>
 #include <cuvs/distance/distance.h>
 
+#include <cuvs/core/export.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -45,7 +47,7 @@ extern "C" {
  * @param[in] metric distance to evaluate
  * @param[in] metric_arg metric argument (used for Minkowski distance)
  */
-cuvsError_t cuvsPairwiseDistance(cuvsResources_t res,
+CUVS_EXPORT cuvsError_t cuvsPairwiseDistance(cuvsResources_t res,
                                  DLManagedTensor* x,
                                  DLManagedTensor* y,
                                  DLManagedTensor* dist,

c/include/cuvs/neighbors/all_neighbors.h

@@ -12,6 +12,8 @@
 #include <dlpack/dlpack.h>
 #include <stdint.h>
 
+#include <cuvs/core/export.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -67,7 +69,7 @@ typedef struct cuvsAllNeighborsIndexParams* cuvsAllNeighborsIndexParams_t;
  *
  * @return cuvsError_t
  */
-cuvsError_t cuvsAllNeighborsIndexParamsCreate(cuvsAllNeighborsIndexParams_t* index_params);
+CUVS_EXPORT cuvsError_t cuvsAllNeighborsIndexParamsCreate(cuvsAllNeighborsIndexParams_t* index_params);
 
 /**
  * @brief Destroy an all-neighbors index parameters struct.
@@ -76,7 +78,7 @@ cuvsError_t cuvsAllNeighborsIndexParamsCreate(cuvsAllNeighborsIndexParams_t* ind
  *
  * @return cuvsError_t
  */
-cuvsError_t cuvsAllNeighborsIndexParamsDestroy(cuvsAllNeighborsIndexParams_t index_params);
+CUVS_EXPORT cuvsError_t cuvsAllNeighborsIndexParamsDestroy(cuvsAllNeighborsIndexParams_t index_params);
 
 /** @} */
 
@@ -103,7 +105,7 @@ cuvsError_t cuvsAllNeighborsIndexParamsDestroy(cuvsAllNeighborsIndexParams_t ind
  * datasets, `n_clusters` must be 1 (no batching); `overlap_factor` is ignored.
  * Outputs always reside in device memory.
  */
-cuvsError_t cuvsAllNeighborsBuild(cuvsResources_t res,
+CUVS_EXPORT cuvsError_t cuvsAllNeighborsBuild(cuvsResources_t res,
                                   cuvsAllNeighborsIndexParams_t params,
                                   DLManagedTensor* dataset,
                                   DLManagedTensor* indices,