crossbind
GitHub

Import C++ and Rust
like JavaScript modules.

No bindings, no glue, no second build system. One import runs in the browser, on iOS and Android, in Node, on Workers, and as a WASI command.

Read the quick start

Free and open source under the MIT license.

src/main.js
import { initNative, Matrix } from './native/Matrix.h';
import { GDALVersionInfo } from '@crossbind/port-gdal/gdal.h';
 
await initNative();
 
const a = new Matrix(1210000, 1);
const b = new Matrix(1210000, 2);
const result = a.multiple(b);
 
console.log(result.get(0), GDALVersionInfo('RELEASE_NAME'));
src/main.js
import { initNative, Uuid } from 'cargo:uuid';
import { Version, VersionReq } from 'cargo:semver';
 
await initNative();
 
const id = Uuid.newV4().toString();
const ok = new VersionReq('^1.2').matches(new Version('1.4.0'));
 
console.log(id, ok);
✓SAME CALL · FIVE RUNTIMES
Browser
Chrome · Firefox · Safari
Node.js
CJS or ESM
React Native
iOS + Android · JSI
CF Workers
Edge · same wasm
WASI
wasmtime 47+ · wasip3

Set up with an AI agent

1

Install the skill

RECOMMENDED

Your agent gets the project inspector, the current port catalog and the per-framework playbooks, then wires the project up without being prompted.

npx skills add https://github.com/crossbind/crossbind/tree/main/agents/skills --global --yes

Drop --global to install it into this project only.

2

Or paste this prompt

For clients that cannot install skills. Paste into Claude Code, Cursor, Copilot…

Add crossbind to this project so I can call C++ (or Rust) from JavaScript.

First inspect the repo and tell me what you found: package manager, bundler (Vite, Webpack, Rspack, Rollup, Metro), whether it targets the browser, Node, Cloudflare Workers or React Native, and any existing C++/Rust sources or CMake project.

Then:

1. Install `crossbind@beta` and the plugin matching my bundler (`@crossbind/plugin-vite@beta`, `@crossbind/plugin-webpack@beta` for Webpack or Rspack, `@crossbind/plugin-rollup@beta`, `@crossbind/plugin-metro@beta`).
2. Create `crossbind.config.js` at the repo root and register the plugin in my bundler config. Keep the change idempotent - do not duplicate an existing entry.
3. If I already have C++ or Rust sources, wire those up. Otherwise add one small example: a header under `src/native/`, imported directly from JavaScript.
4. Call `await initNative()` once at my app's entry point, before the first native call - import it from the header or crate the app already imports, not from a separate runtime package.
5. Run my build and report what changed, including the size of the generated WebAssembly.

Rules: do not hand-write binding or glue code - crossbind generates it from the header. Do not add a second build system. If I need a prebuilt library (GDAL, OpenSSL, SQLite, GEOS, PROJ and more), install the matching `@crossbind/port-*` instead of compiling it from source. Install every crossbind package, ports included, from the npm `beta` tag - the default tag is older.

Reference: https://crossbind.dev/guide/introduction/

Start fresh in under a minute.

The scaffolder asks five questions and prints a working repo — framework, bundler, target, and a sample C++ binding already wired. npm run dev works on the spot.

RUN
npm create crossbind@beta
FRAMEWORKS
ReactVueSvelteVanilla
BUNDLERS
ViteRspackWebpackRollupMetro
TARGETS
Web (WASM)React NativeNode.jsCloudflare Workers
terminal · ~/projects
> npm create crossbind@beta

FULL CAPABILITY MATRIX

26 capabilities · 9 platform details

Write it

The native API you expose to JavaScript

05
01Bindings you never writeImport a header and what it exposes is already bound — classes, inheritance, overloads, vectors, maps, enums. C++ exceptions arrive as JS exceptions, and there is no .delete() to remember: shared_ptr owns the objects.C++ HEADERS · EXCEPTIONS · NO .delete()02Rust through the same importDeclare a crate, then import cargo:uuid. Structs become classes, Result throws, i64 crosses as BigInt, and you write no proc-macros. Two gaps to know up front: WASI has no Rust target yet, and the mt runtime needs a nightly toolchain.cargo: CRATES · NO PROC-MACROS · WEB + iOS + ANDROID03Native code that calls you backemscripten::val hands C++ any JavaScript value, a callback included. Rust gets JsValue and JsFunction by identity, plus serde_json::Value when a deep copy is the safer boundary. Synchronous callbacks need a non-worker runtime.val · JsFunction · JSON04TypeScript, generatedEvery header and Rust import gets a .d.ts, written under .crossbind/ and never into your source tree. One extends line wires the lot. Worker mode? Set dts: 'promise' and the types follow.C++ & RUST · WORKER-AWARE05Hot reload for C++ & RustSave a header or a .rs file, watch the browser refresh. The edit-save-see loop web developers live in, now for native code.EDIT THE .H OR .RS · BROWSER REFRESHES

Resolve it

How packages become a target-ready dependency graph

04
06The whole native graph, resolvedInstall the package you asked for. crossbind expands its transitive native dependencies, orders prerequisites before dependents and carries the same graph through library, app and WASI builds — no hand-sorted linker list.TRANSITIVE GRAPH · DEPENDENCY-ORDERED07The right artifact for this targetResolution filters every package across platform, architecture, st/mt runtime, release/debug build type and browser/edge/Node environment. Each dependency contributes only the variant the current target can consume.5 TARGET SELECTORS · VALID VARIANTS ONLY08Prebuilt first. Source when you ask.Published artifacts are the fast path. Pass --rebuild-deps with one package or the whole set and crossbind switches to its published source recipe without changing how the dependency is installed or imported.PREBUILT FAST PATH · SOURCE ON DEMAND09Rebuild one dependency, not all of themName the source dependencies to rebuild and every other package stays on its cached or prebuilt artifact. Per-directory locks keep concurrent build commands from racing over the same dependency cache.SELECTIVE REBUILD · PARALLEL-SAFE CACHE

Build it

How source turns into every required target

06
10One command, the full build matrixcrossbind build spans every valid target by default, with wasm64 kept opt-in. Platform, architecture, runtime, release/debug and runtime-environment filters compose — each accepts comma-separated values when a release needs only part of the matrix.5 COMPOSABLE FILTERS · 30 BUILD TARGETS11CMake, Autotools or your own runnerA package recipe can fetch or generate source, run CMake or configure + make, inject flags and environment variables, patch upstream files, copy assets or replace the build step entirely.CMAKE · AUTOTOOLS · CUSTOM HOOKS12No toolchain to installemscripten, the Android NDK and wasi-sdk arrive together in one digest-pinned Docker image — nothing to set up, identical builds on any machine. iOS still goes through local Xcode, and Rust through your own cargo.JUST DOCKER FOR WASM · ANDROID · WASI13Nothing rebuilds twiceHeaders, bridges and libraries are content-hashed, so an unchanged one comes back as (cached) in the build log instead of recompiling. Cargo keeps its own incremental cache, and the Docker image is pulled once.CONTENT-HASHED · PER-TARGET CACHE14Only what you useDead-code elimination on top of -O3, plus platform-split downloads: you ship what you call and nothing else. Android is the exception — it links the whole library.DCE + -O3 · PLATFORM-SPLIT DOWNLOADS15Override anythingTwenty documented override points: swap flags per target, patch sources, drop a dependency from the graph, or rebuild any prebuilt from source.20 OVERRIDE POINTS · REBUILD FROM SOURCE

Run it

Where the same API executes

04
16One codebase, every platformWebAssembly in the browser, in Node and on the edge. Native machine code on iOS and Android through JSI. A wasip3 command for WASI. One API in front of a 30-target build matrix.4 PLATFORMS · 30 BUILD TARGETS · WASM · JSI · WASIP317On-device by defaultYour C++ and Rust run where your user is. No backend to build or pay for, no request latency, no data leaving the device. It even works offline.NO BACKEND · PRIVATE · OFFLINE18Off the main threadSIMD is on for every wasm build. runtime: 'mt' adds a warm pool of two pthread workers in the browser — iOS and Android get real OS threads — and useWorker: true moves the module off the main thread entirely, so even new returns a Promise. Production needs the two COOP/COEP headers; the dev server already sends them.SIMD · 2-WORKER WASM POOL · NATIVE THREADS ON DEVICE19Big files, browser and NodeMulti-gigabyte files through OPFS: they persist across reloads and never need to fit in one upload. Mount straight from an <input type=file> — with useWorker: true, because OPFS is worker-only. On Node the same code reads real paths on your disk.OPFS · NEEDS useWorker · NODE REAL PATHS

Ship it

What reaches apps, npm and the command line

04
20One graph, every artifactThe build emits browser, edge and Node .js + .wasm pairs; target-scoped headers and static libraries; and an iOS XCFramework. The WASI path produces the standalone WebAssembly command instead of JavaScript glue.JS + WASM · NATIVE LIBS · XCFRAMEWORK21Libraries as npm dependenciesGDAL, OpenSSL, SQLite, GEOS, PROJ and 11 more, precompiled from the real upstream sources at pinned versions. Or publish your own — prebuilt binaries, C++ sources, a CMake project or a Rust crate. Either way the right platform variant installs itself.16 PREBUILT · 4 PACKAGE TYPES22Data files, auto-wiredCoordinate databases, format tables — declare them once. crossbind ships the files to every platform and wires the env vars for you.ASSETS · ENV VARS · EVERY PLATFORM23Ship a CLI, no runtimeplatform: 'wasi' turns C++ into a single .wasm command with no JS glue. 68 classic tools already ship as <tool>-wasi npm commands — gdalinfo, sqlite3, openssl and friends.68 PREBUILT COMMANDS · WASIP3

Trust it

What you can inspect before depending on it

03
24A supply chain you can auditEvery upstream source is sha256-pinned and fetched over https. crossbind licenses writes a THIRD-PARTY-NOTICES file and a CycloneDX SBOM for exactly what you compiled, and --check fails the build on a missing or non-SPDX license.SHA256-PINNED · SBOM · LICENSE GATE25You can see what it didThe build prints one timed line per target, cached steps included. crossbind config list --type all dumps the fully resolved configuration, and initNative({ logHandler, errorHandler }) routes native stdout and stderr wherever your app already logs.TIMED BUILD LOG · RESOLVED CONFIG · LOG HOOKS26Tested on the platforms it claimsThe sample apps are built and driven in CI, not merely compiled: Playwright across React, Vue, Svelte, vanilla and a Cloudflare Worker; wasmtime for the WASI commands; Maestro on an Android emulator and an iOS simulator. Core unit tests run against coverage thresholds on Linux, macOS and Windows.PLAYWRIGHT WEB E2E · MAESTRO iOS + ANDROID · LINUX · MACOS · WINDOWS

Platform & tooling details

  • Expo config plugin
  • memory64 targets
  • JSPI async (experimental)
  • SWIG escape hatch
  • Android arm64 + x86_64
  • monorepo paths
  • write your own bundler plugin
  • CommonJS + ESM modules
  • clean dependency cache command

Platform caveats stay explicit: Rust targets, browser threads and Android linking are documented per capability.

Browse the complete guide
PREBUILT LIBRARIES

Drop in real C++ libraries.

View all 16 →
GDAL
The geospatial stack — 200+ raster and vector formats
geo · 3.13.3install →
OpenSSL
TLS and crypto, real https from a WASI command
crypto · 4.0.2install →
SQLite
The database, in the browser and on device
database · 3.53.4install →
PROJ
Coordinate transforms with the EPSG database
geo · 9.8.1install →
GEOS
Planar geometry — buffers, overlays, predicates
geo · 3.14.1install →
libTIFF
TIFF read/write with JPEG, ZSTD and LERC codecs
image · 4.7.2install →
WebP
WebP encode and decode anywhere
image · 1.6.0install →
SpatiaLite
Spatial SQL on top of SQLite
database · 5.1.0install →
Type to search every guide page and section.
↑↓ navigate↵ openesc close