The world runs on C++. Celoce makes it run everywhere.
The native delivery layer for modern software.
Compile, package, and ship C++ to WebAssembly, iOS, Android, and JavaScript from a single workflow — what used to take specialist engineers weeks now takes minutes.
The performance layer is trapped outside modern software.
For decades, the industry made a trade-off. C++ delivered extraordinary performance, but it was expensive to write and maintain. So software moved to higher-level languages and frameworks. More apps got built. But on a slower foundation.
AI is changing that equation. Generating and maintaining high-performance native code is becoming easier. The world's fastest, most battle-tested software libraries are ready to be used more widely than ever: the ones powering geospatial systems, cryptography, databases, media processing, compression, computer vision, and embedded AI.
The bottleneck has shifted. It is no longer writing C++. It is delivering it.
So why isn’t the world’s best native code already everywhere?
Because getting it into modern software still means fragmented toolchains, hand-written bindings, platform-specific packaging, and maintenance glue. Web, iOS, Android, React Native, Node, edge runtimes — every target needs its own toolchain, breaks on its own, and has to be rebuilt on every update. The same work, repeated by every team, on every project.
Performance stays locked on the server
Every target platform, from WebAssembly to iOS to Android, has its own toolchain. Without unified infrastructure, native capability lives on cloud servers instead of running where it is actually needed.
Hand-written bridges that rot over time
Manually written bindings create permanent maintenance overhead. They rarely cover the full API surface and degrade every time the underlying library is updated.
The same work done over and over
Build environments are ephemeral. The same artefacts are recompiled from scratch across developers and CI systems, burning time and compute on work that has already been done.
A separate pipeline for every new platform
Each new target adds another build pipeline and another operational burden. What should be one workflow becomes a permanent engineering tax across web, mobile, and backend.
That is the gap Celoce fills.
One workflow instead of many.
Celoce unifies compilation, bindings, packaging, caching, and distribution into a single path — from .cpp to every target.
JavaScript can now import C++ natively, everywhere.
2
3
4
import { Dataset } from './gdal.h';
const ds = new Dataset('map.tif');
.wasmcpp.js binds C++ APIs to JavaScript without hand-written binding code. Import C++ headers like ES modules; cpp.js plugins generate the bindings for you. C++ classes, functions, and types from C++11 and C++14 appear as native JavaScript objects. It compiles to WebAssembly for web and Node.js, and to native machine code for iOS and Android, and integrates with Webpack, Rollup, Vite, Rspack, React Native, Metro, Gradle, and CocoaPods.
In one matrix benchmark, cpp.js ran up to 6.75x faster than the equivalent JavaScript. Results vary by workload.
When native code runs everywhere, new things become possible.
This is not about faster build times. It is about what software can do when the performance layer is no longer locked away.
Offline AI on device
Run native inference components locally without cloud dependency. Faster, private, and available without a network.
Offline maps and geospatial processing
GDAL-class capability inside a browser or mobile app. Geospatial workflows that run entirely on the client.
Local document and data processing
Process sensitive data without sending it to an external server. Privacy and compliance by architecture, not by policy.
Lower cloud cost
Move compute-heavy work from servers to the client or edge where appropriate. Cloud bills shrink when clients do more of the work.
Modern interfaces for critical software
Decades of proven native libraries inside web and mobile products. No rewrites. No performance regressions.
Faster apps without rewriting the stack
Bring native performance into existing software incrementally. Specific bottlenecks, solved with the right tool.
Two kinds of companies. The same fundamental problem.
Without unified tooling, both fall back on costly workarounds — and pay for them in different ways.
Already shipping — on a slower foundation
Their apps work, but reaching new platforms means rewriting proven native libraries in JavaScript — and parking compute-heavy work on cloud servers.
- Rewrite native libraries in JS just to ship them
- Performance regresses; maintenance cost climbs
- Heavy compute stays on servers, metered by the hour
Native is the only right tool
Geospatial, security, media, robotics, simulation, embedded AI — they know C and C++ are the answer, so they build the delivery layer by hand.
- Hire specialists to compile and hand-write bridges
- Stand up large toolchains and duplicate CI per platform
- Repeat for web, iOS, Android, React Native, Node
- Every target breaks independently — redone on every update
For both types, Celoce is the same answer: native performance inside modern software, without building and maintaining the delivery infrastructure themselves.
The second type feel the pain immediately. That is where we start.
We started with one of the hardest native libraries in existence.
We did not start with “Hello World.” We built Celoce by compiling GDAL — one of the most complex open-source native libraries in existence — into a browser-ready artifact, now used across 200+ open-source and production geospatial projects.
GDAL is a widely used geospatial library across open-source and commercial GIS workflows, including QGIS-based workflows.
Compiled through the cpp.js workflow, gdal3.js delivers 160+ raster and vector format support directly in browsers and mobile applications.
Start open source. Scale to cloud. Deploy privately in enterprise.
Three layers. One consistent path from C and C++ source to production artefacts across every modern runtime.
Compiles C++ libraries for multiple platform targets from a single configuration. Handles dependency resolution, bindings generation, and cross-platform packaging.
- Direct C++ header imports in JavaScript (
./foo.h→ JS module) - Native mobile compilation (iOS, Android)
- Automatic bindings generation
- CMake integration
- Cross-platform packaging
Distributed compilation and content-addressed caching cut build time and remove local toolchain setup.
- Remote build execution
- Distributed compilation
- Content-addressed artifact caching
- Pay-per-build pricing
- CI acceleration
Private build infrastructure on your own systems. Internal binary registries, reproducible builds, and full operational control.
- Private build infrastructure
- Internal binary registries
- Reproducible builds
- RBAC and audit logging (planned)
- SSO integration (planned)
- Air-gapped environments
Drops into the tools you already ship with.
Celoce is a neutral delivery layer — it doesn’t lock you into another framework or ecosystem. Compiled artefacts plug straight into the bundlers, mobile build systems, and runtimes your team already uses.
Web & bundlers
Import C++ headers like ES modules straight into your existing build. Output is plain .wasm and .js.
Mobile
Native compilation for iOS and Android, packaged as .xcframework and .so for the toolchains you already run.
Runtimes & edge
The same artefact runs in the browser, on the server, and at the edge — no per-target rewrite.
A growing native-library network, free to use.
Celoce Hub is the library catalog powered by cpp.js. Use maintained, prebuilt C and C++ packages, or bring your own code to web, mobile, backend, edge, and AI workflows.
Roadmap.
What we've shipped, what we're building now, and what's coming next.
- cpp.js v1: cross-platform build system
- Multi-target builds: web, iOS, Android
- gdal3.js: 240k+ downloads
- 16 prebuilt libraries shipped: gdal, proj, spatialite, geos, sqlite3, openssl, curl, iconv, zlib, zstd, geotiff, tiff, jpegturbo, lerc, webp, expat
- Cloud Build private beta
- Native AI-agent integrations: Claude Code, Cursor, Codex CLI, Copilot CLI, Gemini CLI, OpenCode
- cpp.js v2 beta, migrated all official libraries to v2 infrastructure
- Universal MCP server (@cpp.js/mcp) with Skills CLI fallback
- Cloud Build public launch with Git integration and PR previews
- Celoce Registry for sharing compiled modules
- Team workspaces and SSO
- Rust interoperability support
- Additional language targets (Go, Kotlin, Swift)
- Desktop targets: Windows, macOS, Linux
- Native Node.js addons (N-API)
- Self-hosted enterprise build control plane
- SOC 2 and ISO 27001
Ship native software everywhere,
from a single workflow.
Start locally with cpp.js. Scale to managed cloud builds when you are ready.