aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-06-10 15:49:59 +0200
committerOnur Gündüz <ogunduz@gmail.com>2026-06-14 08:27:03 +0200
commit7fe02715aac68b958250b43f9d48d641af0a045c (patch)
tree7bc866f87999991ef0a3ffa0dd36ce91444e5172
parente8259865f41ceb50dd28b267186d11c62a465135 (diff)
downloadffwd-7fe02715aac68b958250b43f9d48d641af0a045c.tar.gz
ffwd-7fe02715aac68b958250b43f9d48d641af0a045c.zip
build: export only the public API from the shared library
-rw-r--r--Makefile4
-rw-r--r--embed.h71
-rw-r--r--embed_distributed.h25
-rw-r--r--embed_mlx.h63
-rw-r--r--embed_server.h13
-rw-r--r--qwen_kernels.h17
-rw-r--r--qwen_tokenizer.h29
7 files changed, 145 insertions, 77 deletions
diff --git a/Makefile b/Makefile
index 33501f9..76de83c 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,9 @@ CC = gcc
# not assume finite math or approximate libm calls: full -ffast-math produced
# NaN embeddings on GCC/OpenBLAS Linux builds (-ffinite-math-only and
# -fapprox-func are the unsafe parts and stay off).
-CFLAGS_BASE = -Wall -Wextra -O3 -march=native -fPIC \
+# -fvisibility=hidden pairs with PPLX_API in the public headers: a new
+# public function without the annotation will be missing from the shared lib.
+CFLAGS_BASE = -Wall -Wextra -O3 -march=native -fPIC -fvisibility=hidden \
-fno-math-errno -ffp-contract=fast -fno-trapping-math \
-fno-signed-zeros -fassociative-math -freciprocal-math
LDFLAGS = -lm -lpthread
diff --git a/embed.h b/embed.h
index 9b905e5..2098e9e 100644
--- a/embed.h
+++ b/embed.h
@@ -7,6 +7,17 @@
#ifndef PPLX_EMBED_H
#define PPLX_EMBED_H
+/* Public-API export annotation. The libraries are built with
+ * -fvisibility=hidden, so only declarations carrying PPLX_API are exported
+ * from the shared library; everything else stays internal. */
+#ifndef PPLX_API
+#if defined(__GNUC__)
+#define PPLX_API __attribute__((visibility("default")))
+#else
+#define PPLX_API
+#endif
+#endif
+
#include <stddef.h>
#include <stdint.h>
@@ -75,7 +86,7 @@ typedef struct {
* Reads config.json to determine model size (0.6B vs 4B).
* Returns NULL on error.
*/
-pplx_model_t *pplx_model_load(const char *model_dir);
+PPLX_API pplx_model_t *pplx_model_load(const char *model_dir);
/*
* Load one contiguous transformer layer range for distributed execution.
@@ -85,20 +96,20 @@ pplx_model_t *pplx_model_load(const char *model_dir);
* loads the final RMSNorm. Safetensors remain mmap-backed, so unselected
* weights are not touched.
*/
-pplx_model_t *pplx_model_load_slice(const char *model_dir,
+PPLX_API pplx_model_t *pplx_model_load_slice(const char *model_dir,
int layer_start, int layer_end);
-void pplx_model_free(pplx_model_t *model);
+PPLX_API void pplx_model_free(pplx_model_t *model);
/*
* Allocate/free mutable scratch buffers for a model. The model must outlive
* workspaces created from it.
*/
-pplx_workspace_t *pplx_workspace_new(const pplx_model_t *model);
-void pplx_workspace_free(pplx_workspace_t *ws);
+PPLX_API pplx_workspace_t *pplx_workspace_new(const pplx_model_t *model);
+PPLX_API void pplx_workspace_free(pplx_workspace_t *ws);
/* Config accessor for opaque model ownership. */
-const pplx_config_t *pplx_model_config(const pplx_model_t *model);
+PPLX_API const pplx_config_t *pplx_model_config(const pplx_model_t *model);
/*
* Current mutable workspace memory owned by this workspace, in bytes.
@@ -106,7 +117,7 @@ const pplx_config_t *pplx_model_config(const pplx_model_t *model);
* This includes the workspace struct, scratch buffers, and RoPE cache capacity.
* It does not include immutable mmap'd model weights.
*/
-size_t pplx_workspace_nbytes(const pplx_workspace_t *ws);
+PPLX_API size_t pplx_workspace_nbytes(const pplx_workspace_t *ws);
/*
* Compute embedding for a token sequence.
@@ -122,14 +133,14 @@ size_t pplx_workspace_nbytes(const pplx_workspace_t *ws);
*
* Returns malloc'd float[hidden_size] (caller frees). NULL on error.
*/
-float *pplx_model_embed(const pplx_model_t *model, pplx_workspace_t *ws,
+PPLX_API float *pplx_model_embed(const pplx_model_t *model, pplx_workspace_t *ws,
const int *token_ids, int n_tokens);
/*
* Compute one embedding into caller-provided out[hidden_size].
* Returns 0 on success, -1 on error.
*/
-int pplx_model_embed_into(const pplx_model_t *model, pplx_workspace_t *ws,
+PPLX_API int pplx_model_embed_into(const pplx_model_t *model, pplx_workspace_t *ws,
const int *token_ids, int n_tokens,
float *out_embedding);
@@ -142,7 +153,7 @@ int pplx_model_embed_into(const pplx_model_t *model, pplx_workspace_t *ws,
*
* Returns 0 on success, -1 on error.
*/
-int pplx_model_embed_batch(const pplx_model_t *model, pplx_workspace_t *ws,
+PPLX_API int pplx_model_embed_batch(const pplx_model_t *model, pplx_workspace_t *ws,
const pplx_input_t *inputs, int batch,
float *out_embeddings);
@@ -159,7 +170,7 @@ int pplx_model_embed_batch(const pplx_model_t *model, pplx_workspace_t *ws,
*
* This is the core execution boundary used by layer-sharded inference.
*/
-int pplx_model_forward_slice_batch(const pplx_model_t *model,
+PPLX_API int pplx_model_forward_slice_batch(const pplx_model_t *model,
pplx_workspace_t *ws,
const pplx_input_t *inputs, int batch,
const float *input_states,
@@ -173,7 +184,7 @@ int pplx_model_forward_slice_batch(const pplx_model_t *model,
* states is [sum(n_tokens), hidden_size]. seq_lengths contains one positive
* token count per sequence. The states must already include final RMSNorm.
*/
-int pplx_pool_batch(const pplx_config_t *cfg, const float *states,
+PPLX_API int pplx_pool_batch(const pplx_config_t *cfg, const float *states,
const int *seq_lengths, int batch,
float *out_embeddings);
@@ -185,14 +196,14 @@ int pplx_pool_batch(const pplx_config_t *cfg, const float *states,
* Useful for contextual (late-chunking) models where you need
* per-token embeddings before splitting by separator positions.
*/
-float *pplx_model_forward(const pplx_model_t *model, pplx_workspace_t *ws,
+PPLX_API float *pplx_model_forward(const pplx_model_t *model, pplx_workspace_t *ws,
const int *token_ids, int n_tokens);
/*
* Run the transformer forward pass into caller-provided
* out_states[n_tokens * hidden_size]. Returns 0 on success, -1 on error.
*/
-int pplx_model_forward_into(const pplx_model_t *model, pplx_workspace_t *ws,
+PPLX_API int pplx_model_forward_into(const pplx_model_t *model, pplx_workspace_t *ws,
const int *token_ids, int n_tokens,
float *out_states);
@@ -203,7 +214,7 @@ int pplx_model_forward_into(const pplx_model_t *model, pplx_workspace_t *ws,
* pplx_model_forward_into(). Each span is mean pooled into
* out_embeddings[n_spans, hidden_size] without L2 normalization.
*/
-int pplx_pool_spans(const pplx_config_t *cfg, const float *states, int n_tokens,
+PPLX_API int pplx_pool_spans(const pplx_config_t *cfg, const float *states, int n_tokens,
const pplx_span_t *spans, int n_spans,
float *out_embeddings);
@@ -211,7 +222,7 @@ int pplx_pool_spans(const pplx_config_t *cfg, const float *states, int n_tokens,
* Run one contextual sequence and pool selected token spans.
* Returns 0 on success, -1 on error.
*/
-int pplx_model_embed_spans(const pplx_model_t *model, pplx_workspace_t *ws,
+PPLX_API int pplx_model_embed_spans(const pplx_model_t *model, pplx_workspace_t *ws,
const int *token_ids, int n_tokens,
const pplx_span_t *spans, int n_spans,
float *out_embeddings);
@@ -222,7 +233,7 @@ int pplx_model_embed_spans(const pplx_model_t *model, pplx_workspace_t *ws,
* Documents attend independently, RoPE positions restart for each document,
* and out_embeddings contains spans in document order.
*/
-int pplx_model_embed_spans_batch(const pplx_model_t *model,
+PPLX_API int pplx_model_embed_spans_batch(const pplx_model_t *model,
pplx_workspace_t *ws,
const pplx_context_input_t *inputs, int batch,
float *out_embeddings);
@@ -233,13 +244,13 @@ int pplx_model_embed_spans_batch(const pplx_model_t *model,
* Returns 0 on success. Returns -1 for invalid arguments or a zero-length
* vector, which cannot be normalized.
*/
-int pplx_l2_normalize(float *vec, int dim);
+PPLX_API int pplx_l2_normalize(float *vec, int dim);
/*
* Cosine similarity between two vectors.
* Returns 0 for invalid arguments or if either vector has zero length.
*/
-float pplx_cosine_similarity(const float *a, const float *b, int dim);
+PPLX_API float pplx_cosine_similarity(const float *a, const float *b, int dim);
/*
* Late-interaction model API.
@@ -248,21 +259,21 @@ float pplx_cosine_similarity(const float *a, const float *b, int dim);
* projected by the snapshot's 1_Dense head and L2-normalized per token by
* default, matching ColBERT/MaxSim scoring semantics.
*/
-pplx_late_model_t *pplx_late_model_load(const char *model_dir);
-void pplx_late_model_free(pplx_late_model_t *model);
+PPLX_API pplx_late_model_t *pplx_late_model_load(const char *model_dir);
+PPLX_API void pplx_late_model_free(pplx_late_model_t *model);
-pplx_late_workspace_t *pplx_late_workspace_new(const pplx_late_model_t *model);
-void pplx_late_workspace_free(pplx_late_workspace_t *ws);
+PPLX_API pplx_late_workspace_t *pplx_late_workspace_new(const pplx_late_model_t *model);
+PPLX_API void pplx_late_workspace_free(pplx_late_workspace_t *ws);
-const pplx_config_t *pplx_late_model_config(const pplx_late_model_t *model);
-int pplx_late_model_token_dim(const pplx_late_model_t *model);
+PPLX_API const pplx_config_t *pplx_late_model_config(const pplx_late_model_t *model);
+PPLX_API int pplx_late_model_token_dim(const pplx_late_model_t *model);
/*
* Encode token_ids into out_vectors[n_tokens, token_dim].
*
* If normalize is non-zero, every non-zero token vector is L2-normalized.
*/
-int pplx_late_model_encode_tokens(const pplx_late_model_t *model,
+PPLX_API int pplx_late_model_encode_tokens(const pplx_late_model_t *model,
pplx_late_workspace_t *ws,
const int *token_ids, int n_tokens,
int normalize, float *out_vectors);
@@ -270,7 +281,7 @@ int pplx_late_model_encode_tokens(const pplx_late_model_t *model,
/*
* Sum over query tokens of max dot product against document tokens.
*/
-float pplx_late_maxsim(const float *query_vectors, int query_tokens,
+PPLX_API float pplx_late_maxsim(const float *query_vectors, int query_tokens,
const float *doc_vectors, int doc_tokens,
int dim);
@@ -281,13 +292,13 @@ float pplx_late_maxsim(const float *query_vectors, int query_tokens,
* doc_vectors[doc_offsets[i] * dim .. doc_offsets[i + 1] * dim).
* scores is caller-provided [docs].
*/
-int pplx_late_maxsim_batch(const float *query_vectors, int query_tokens,
+PPLX_API int pplx_late_maxsim_batch(const float *query_vectors, int query_tokens,
const float *doc_vectors,
const int *doc_offsets, int docs,
int dim, float *scores);
/* Verbose level: 0=quiet, 1=info, 2=debug */
-extern int pplx_verbose;
-extern int qwen_verbose;
+PPLX_API extern int pplx_verbose;
+PPLX_API extern int qwen_verbose;
#endif /* PPLX_EMBED_H */
diff --git a/embed_distributed.h b/embed_distributed.h
index 4cd32e4..3bd3e48 100644
--- a/embed_distributed.h
+++ b/embed_distributed.h
@@ -5,6 +5,17 @@
#ifndef PPLX_DISTRIBUTED_H
#define PPLX_DISTRIBUTED_H
+/* Public-API export annotation. The libraries are built with
+ * -fvisibility=hidden, so only declarations carrying PPLX_API are exported
+ * from the shared library; everything else stays internal. */
+#ifndef PPLX_API
+#if defined(__GNUC__)
+#define PPLX_API __attribute__((visibility("default")))
+#else
+#define PPLX_API
+#endif
+#endif
+
#include "embed.h"
typedef struct pplx_dist_client pplx_dist_client_t;
@@ -19,17 +30,17 @@ typedef struct {
* Open a coordinator-side connection. The coordinator owns layers
* [0, local_layer_end); the remote worker must own [local_layer_end, N).
*/
-pplx_dist_client_t *pplx_dist_client_open(const char *model_dir,
+PPLX_API pplx_dist_client_t *pplx_dist_client_open(const char *model_dir,
const char *host, int port,
int local_layer_end, int use_mlx);
-pplx_dist_client_t *pplx_dist_client_open_with_options(
+PPLX_API pplx_dist_client_t *pplx_dist_client_open_with_options(
const char *model_dir, const char *host, int port,
int local_layer_end, int use_mlx, const pplx_dist_options_t *opts);
-void pplx_dist_client_free(pplx_dist_client_t *client);
+PPLX_API void pplx_dist_client_free(pplx_dist_client_t *client);
-const pplx_config_t *pplx_dist_client_config(const pplx_dist_client_t *client);
+PPLX_API const pplx_config_t *pplx_dist_client_config(const pplx_dist_client_t *client);
-int pplx_dist_client_embed_batch(pplx_dist_client_t *client,
+PPLX_API int pplx_dist_client_embed_batch(pplx_dist_client_t *client,
const pplx_input_t *inputs, int batch,
float *out_embeddings);
@@ -37,9 +48,9 @@ int pplx_dist_client_embed_batch(pplx_dist_client_t *client,
* Run a final-stage worker until the process is terminated. The worker owns
* [layer_start, layer_end), and layer_end must be the model's final layer.
*/
-int pplx_dist_run_worker(const char *model_dir, const char *host, int port,
+PPLX_API int pplx_dist_run_worker(const char *model_dir, const char *host, int port,
int layer_start, int layer_end, int use_mlx);
-int pplx_dist_run_worker_with_options(
+PPLX_API int pplx_dist_run_worker_with_options(
const char *model_dir, const char *host, int port,
int layer_start, int layer_end, int use_mlx,
const pplx_dist_options_t *opts);
diff --git a/embed_mlx.h b/embed_mlx.h
index 25376e9..52a8801 100644
--- a/embed_mlx.h
+++ b/embed_mlx.h
@@ -7,6 +7,17 @@
#ifndef PPLX_EMBED_MLX_H
#define PPLX_EMBED_MLX_H
+/* Public-API export annotation. The libraries are built with
+ * -fvisibility=hidden, so only declarations carrying PPLX_API are exported
+ * from the shared library; everything else stays internal. */
+#ifndef PPLX_API
+#if defined(__GNUC__)
+#define PPLX_API __attribute__((visibility("default")))
+#else
+#define PPLX_API
+#endif
+#endif
+
#include <stddef.h>
#include <stdint.h>
#include "embed.h"
@@ -25,8 +36,8 @@ typedef struct {
* Load model into MLX arrays from safetensors + config.json.
* Returns NULL on error.
*/
-pplx_mlx_ctx_t *pplx_mlx_load(const char *model_dir);
-pplx_mlx_ctx_t *pplx_mlx_load_with_options(const char *model_dir,
+PPLX_API pplx_mlx_ctx_t *pplx_mlx_load(const char *model_dir);
+PPLX_API pplx_mlx_ctx_t *pplx_mlx_load_with_options(const char *model_dir,
const pplx_mlx_options_t *opts);
/*
@@ -34,26 +45,26 @@ pplx_mlx_ctx_t *pplx_mlx_load_with_options(const char *model_dir,
* Uses the same half-open range and endpoint ownership rules as
* pplx_model_load_slice().
*/
-pplx_mlx_ctx_t *pplx_mlx_load_slice(const char *model_dir,
+PPLX_API pplx_mlx_ctx_t *pplx_mlx_load_slice(const char *model_dir,
int layer_start, int layer_end);
-pplx_mlx_ctx_t *pplx_mlx_load_slice_with_options(
+PPLX_API pplx_mlx_ctx_t *pplx_mlx_load_slice_with_options(
const char *model_dir, int layer_start, int layer_end,
const pplx_mlx_options_t *opts);
-void pplx_mlx_free(pplx_mlx_ctx_t *ctx);
+PPLX_API void pplx_mlx_free(pplx_mlx_ctx_t *ctx);
/*
* Late-interaction MLX path. This is separate from pooled embeddings because
* late snapshots produce one projected token vector per input token for MaxSim
* scoring, not one pooled document vector.
*/
-pplx_mlx_late_ctx_t *pplx_mlx_late_load(const char *model_dir);
-pplx_mlx_late_ctx_t *pplx_mlx_late_load_with_options(
+PPLX_API pplx_mlx_late_ctx_t *pplx_mlx_late_load(const char *model_dir);
+PPLX_API pplx_mlx_late_ctx_t *pplx_mlx_late_load_with_options(
const char *model_dir, const pplx_mlx_options_t *opts);
-void pplx_mlx_late_free(pplx_mlx_late_ctx_t *ctx);
+PPLX_API void pplx_mlx_late_free(pplx_mlx_late_ctx_t *ctx);
-const pplx_config_t *pplx_mlx_late_config(const pplx_mlx_late_ctx_t *ctx);
-int pplx_mlx_late_token_dim(const pplx_mlx_late_ctx_t *ctx);
+PPLX_API const pplx_config_t *pplx_mlx_late_config(const pplx_mlx_late_ctx_t *ctx);
+PPLX_API int pplx_mlx_late_token_dim(const pplx_mlx_late_ctx_t *ctx);
/*
* Encode token_ids into out_vectors[n_tokens, token_dim].
@@ -61,7 +72,7 @@ int pplx_mlx_late_token_dim(const pplx_mlx_late_ctx_t *ctx);
* If normalize is non-zero, every token vector is L2-normalized on device
* before copying back to CPU memory.
*/
-int pplx_mlx_late_encode_tokens(pplx_mlx_late_ctx_t *ctx,
+PPLX_API int pplx_mlx_late_encode_tokens(pplx_mlx_late_ctx_t *ctx,
const int *token_ids, int n_tokens,
int normalize, float *out_vectors);
@@ -72,21 +83,21 @@ int pplx_mlx_late_encode_tokens(pplx_mlx_late_ctx_t *ctx,
* outlive ctx. Copying is optional: MaxSim can consume these handles directly
* and copy back only final candidate scores.
*/
-pplx_mlx_late_vectors_t *pplx_mlx_late_encode_tokens_device(
+PPLX_API pplx_mlx_late_vectors_t *pplx_mlx_late_encode_tokens_device(
pplx_mlx_late_ctx_t *ctx, const int *token_ids, int n_tokens,
int normalize);
-void pplx_mlx_late_vectors_free(pplx_mlx_late_vectors_t *vecs);
-int pplx_mlx_late_vectors_token_count(const pplx_mlx_late_vectors_t *vecs);
-int pplx_mlx_late_vectors_dim(const pplx_mlx_late_vectors_t *vecs);
-int pplx_mlx_late_vectors_copy(const pplx_mlx_late_vectors_t *vecs,
+PPLX_API void pplx_mlx_late_vectors_free(pplx_mlx_late_vectors_t *vecs);
+PPLX_API int pplx_mlx_late_vectors_token_count(const pplx_mlx_late_vectors_t *vecs);
+PPLX_API int pplx_mlx_late_vectors_dim(const pplx_mlx_late_vectors_t *vecs);
+PPLX_API int pplx_mlx_late_vectors_copy(const pplx_mlx_late_vectors_t *vecs,
float *out_vectors);
-pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_concat(
+PPLX_API pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_concat(
pplx_mlx_late_ctx_t *ctx,
const pplx_mlx_late_vectors_t *const *items, int count);
-pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_select(
+PPLX_API pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_select(
pplx_mlx_late_ctx_t *ctx, const pplx_mlx_late_vectors_t *vecs,
const int *token_indices, int count);
-int pplx_mlx_late_maxsim_batch_device(
+PPLX_API int pplx_mlx_late_maxsim_batch_device(
pplx_mlx_late_ctx_t *ctx, const pplx_mlx_late_vectors_t *query,
const pplx_mlx_late_vectors_t *docs, const int *doc_offsets,
int docs_count, float *scores);
@@ -95,13 +106,13 @@ int pplx_mlx_late_maxsim_batch_device(
* Compute embedding for token_ids[0..n_tokens-1].
* Returns malloc'd float[hidden_size] (caller frees). NULL on error.
*/
-float *pplx_mlx_embed(pplx_mlx_ctx_t *ctx, const int *token_ids, int n_tokens);
+PPLX_API float *pplx_mlx_embed(pplx_mlx_ctx_t *ctx, const int *token_ids, int n_tokens);
/*
* Compute one embedding into caller-provided out[hidden_size].
* Returns 0 on success, -1 on error.
*/
-int pplx_mlx_embed_into(pplx_mlx_ctx_t *ctx, const int *token_ids,
+PPLX_API int pplx_mlx_embed_into(pplx_mlx_ctx_t *ctx, const int *token_ids,
int n_tokens, float *out_embedding);
/*
@@ -111,7 +122,7 @@ int pplx_mlx_embed_into(pplx_mlx_ctx_t *ctx, const int *token_ids,
* Padded tokens are masked out of attention keys and mean pooling.
* Returns 0 on success, -1 on error.
*/
-int pplx_mlx_embed_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs,
+PPLX_API int pplx_mlx_embed_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs,
int batch, float *out_embeddings);
/*
@@ -120,7 +131,7 @@ int pplx_mlx_embed_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs,
* Hidden states cross the API boundary as packed float32 rows even though MLX
* executes a padded dense batch internally.
*/
-int pplx_mlx_forward_slice_batch(pplx_mlx_ctx_t *ctx,
+PPLX_API int pplx_mlx_forward_slice_batch(pplx_mlx_ctx_t *ctx,
const pplx_input_t *inputs, int batch,
const float *input_states,
int layer_start, int layer_end,
@@ -131,7 +142,7 @@ int pplx_mlx_forward_slice_batch(pplx_mlx_ctx_t *ctx,
* Run one contextual sequence and pool selected token spans.
* Returns 0 on success, -1 on error.
*/
-int pplx_mlx_embed_spans(pplx_mlx_ctx_t *ctx, const int *token_ids,
+PPLX_API int pplx_mlx_embed_spans(pplx_mlx_ctx_t *ctx, const int *token_ids,
int n_tokens, const pplx_span_t *spans,
int n_spans, float *out_embeddings);
@@ -139,11 +150,11 @@ int pplx_mlx_embed_spans(pplx_mlx_ctx_t *ctx, const int *token_ids,
* Run a padded dense contextual document batch and pool every selected span.
* out_embeddings contains spans in document order.
*/
-int pplx_mlx_embed_spans_batch(pplx_mlx_ctx_t *ctx,
+PPLX_API int pplx_mlx_embed_spans_batch(pplx_mlx_ctx_t *ctx,
const pplx_context_input_t *inputs, int batch,
float *out_embeddings);
/* Get the config (so embed_cli.c can read hidden_size etc.) */
-const pplx_config_t *pplx_mlx_config(const pplx_mlx_ctx_t *ctx);
+PPLX_API const pplx_config_t *pplx_mlx_config(const pplx_mlx_ctx_t *ctx);
#endif /* PPLX_EMBED_MLX_H */
diff --git a/embed_server.h b/embed_server.h
index c38f0ca..179ed0b 100644
--- a/embed_server.h
+++ b/embed_server.h
@@ -1,6 +1,17 @@
#ifndef PPLX_SERVER_H
#define PPLX_SERVER_H
+/* Public-API export annotation. The libraries are built with
+ * -fvisibility=hidden, so only declarations carrying PPLX_API are exported
+ * from the shared library; everything else stays internal. */
+#ifndef PPLX_API
+#if defined(__GNUC__)
+#define PPLX_API __attribute__((visibility("default")))
+#else
+#define PPLX_API
+#endif
+#endif
+
#include <stdbool.h>
typedef struct {
@@ -27,6 +38,6 @@ typedef struct {
const char *api_key;
} pplx_server_config_t;
-int pplx_run_server(const pplx_server_config_t *cfg);
+PPLX_API int pplx_run_server(const pplx_server_config_t *cfg);
#endif
diff --git a/qwen_kernels.h b/qwen_kernels.h
index fd23c02..9b8156c 100644
--- a/qwen_kernels.h
+++ b/qwen_kernels.h
@@ -7,6 +7,17 @@
#ifndef QWEN_KERNELS_H
#define QWEN_KERNELS_H
+/* Public-API export annotation. The libraries are built with
+ * -fvisibility=hidden, so only declarations carrying PPLX_API are exported
+ * from the shared library; everything else stays internal. */
+#ifndef PPLX_API
+#if defined(__GNUC__)
+#define PPLX_API __attribute__((visibility("default")))
+#else
+#define PPLX_API
+#endif
+#endif
+
#include <stddef.h>
#include <stdint.h>
@@ -131,12 +142,12 @@ void qwen_apply_rope_neox(float *x, const float *cos_vals, const float *sin_vals
/* Set number of threads for parallel operations (default: 1).
* Creates a persistent thread pool. Call before inference. */
-void qwen_set_threads(int n);
+PPLX_API void qwen_set_threads(int n);
/* Get number of available CPU cores */
-int qwen_get_num_cpus(void);
+PPLX_API int qwen_get_num_cpus(void);
/* Global verbose flag */
-extern int qwen_verbose;
+PPLX_API extern int qwen_verbose;
#endif /* QWEN_KERNELS_H */
diff --git a/qwen_tokenizer.h b/qwen_tokenizer.h
index c698ea3..4c3834c 100644
--- a/qwen_tokenizer.h
+++ b/qwen_tokenizer.h
@@ -9,6 +9,17 @@
#ifndef QWEN_TOKENIZER_H
#define QWEN_TOKENIZER_H
+/* Public-API export annotation. The libraries are built with
+ * -fvisibility=hidden, so only declarations carrying PPLX_API are exported
+ * from the shared library; everything else stays internal. */
+#ifndef PPLX_API
+#if defined(__GNUC__)
+#define PPLX_API __attribute__((visibility("default")))
+#else
+#define PPLX_API
+#endif
+#endif
+
typedef struct {
char **id_to_text; /* [vocab_size] decoded text strings */
char **id_to_bpe; /* [vocab_size] raw BPE token strings from vocab.json */
@@ -32,29 +43,29 @@ typedef struct {
typedef struct qwen_tokenizer_workspace qwen_tokenizer_workspace_t;
/* Load tokenizer from vocab.json in model directory */
-qwen_tokenizer_t *qwen_tokenizer_load(const char *vocab_json_path);
+PPLX_API qwen_tokenizer_t *qwen_tokenizer_load(const char *vocab_json_path);
/* Decode a single token ID to text. Returns pointer to internal string. */
-const char *qwen_tokenizer_decode(const qwen_tokenizer_t *tok, int token_id);
+PPLX_API const char *qwen_tokenizer_decode(const qwen_tokenizer_t *tok, int token_id);
/* Look up the id of a raw vocab.json token string (e.g. "<|endoftext|>").
* Returns -1 when the token is not in the vocab. */
-int qwen_tokenizer_token_id(const qwen_tokenizer_t *tok, const char *token);
+PPLX_API int qwen_tokenizer_token_id(const qwen_tokenizer_t *tok, const char *token);
/* Encode UTF-8 text into token IDs using BPE.
* Returns malloc'd array of token IDs and sets *out_n_tokens.
* Returns NULL on error (and sets *out_n_tokens to 0). */
-int *qwen_tokenizer_encode(const qwen_tokenizer_t *tok, const char *text, int *out_n_tokens);
+PPLX_API int *qwen_tokenizer_encode(const qwen_tokenizer_t *tok, const char *text, int *out_n_tokens);
/* Reusable scratch for allocation-light repeated encoding. */
-qwen_tokenizer_workspace_t *qwen_tokenizer_workspace_new(void);
-void qwen_tokenizer_workspace_free(qwen_tokenizer_workspace_t *ws);
+PPLX_API qwen_tokenizer_workspace_t *qwen_tokenizer_workspace_new(void);
+PPLX_API void qwen_tokenizer_workspace_free(qwen_tokenizer_workspace_t *ws);
/* Encode into caller-provided out_ids[0..out_cap-1].
* Returns 0 on success, -1 on error, -2 if out_cap is too small.
* In all cases *out_n_tokens is set to the number of tokens needed/emitted
* when out_n_tokens is non-NULL. */
-int qwen_tokenizer_encode_into(const qwen_tokenizer_t *tok,
+PPLX_API int qwen_tokenizer_encode_into(const qwen_tokenizer_t *tok,
qwen_tokenizer_workspace_t *ws,
const char *text,
int *out_ids, int out_cap,
@@ -62,12 +73,12 @@ int qwen_tokenizer_encode_into(const qwen_tokenizer_t *tok,
/* Same tokenization as qwen_tokenizer_encode(), but reuses ws internally and
* performs only the final returned int[] allocation. */
-int *qwen_tokenizer_encode_with_workspace(const qwen_tokenizer_t *tok,
+PPLX_API int *qwen_tokenizer_encode_with_workspace(const qwen_tokenizer_t *tok,
qwen_tokenizer_workspace_t *ws,
const char *text,
int *out_n_tokens);
/* Free tokenizer */
-void qwen_tokenizer_free(qwen_tokenizer_t *tok);
+PPLX_API void qwen_tokenizer_free(qwen_tokenizer_t *tok);
#endif /* QWEN_TOKENIZER_H */