Basalt

Libraries

A library that is JavaScript works here because the JavaScript is React Native's. A library with a native half needs that half to exist for GTK, AppKit or Win32, and this page is what does.

The rule for everything below: install it the way its own documentation says, and install the Basalt package beside it if there is one. Nothing here is a fork, and no library is patched.

react-navigation

npm install basalt-navigation

Native screens, through react-native-screens' own ScreenContext, with no patch and no fork. Navigation is the page: what each desktop gives you, which navigators work, and what headers do.

React Native Skia

npm install basalt-skia

Both lines of it work here, and which one you get is which one your app installed. Nothing in the package is patched: basalt-skia and each host supply the platform half that react-native-skia leaves for a platform to write, and the C++ above it is react-native-skia's own.

@shopify/react-native-skia 2.x, GaneshLinux, macOS and Windows. Metal on macOS; a CPU surface on the other two, with Skia built from source by scripts/build_skia_linux.sh and its Windows counterpart
react-native-skia 3.x, Graphite over DawnmacOS and Windows. Linux needs a prebuilt Graphite Skia, which nothing builds yet

Both halves of the API: the imperative one (Skia.Path, image decoding, typefaces) and <Canvas>.

On Windows, 3.x is further along than it sounds. A video editor with two <Canvas> call sites builds against it, reports Skia installed, over Graphite, and paints its composition. On macOS the tests go through an offscreen surface, so what has not been watched there is a frame reaching the CAMetalLayer itself.

Skia's suites are the one part of this repository that CI does not run, because the package is borrowed from the app rather than vendored and CI has no app. That is a real gap and it is the price of not vendoring a 300MB dependency. Both suites were last run by hand on 2026-10-11, against 2.14.0 and 3.4.0.

Reanimated and react-native-gesture-handler

Both run. There is nothing to install beyond the libraries themselves, and --build wires in worklets and Reanimated when the app has them.

Which Reanimated

4.5 to 4.7, which is one definition covering every 4.x that ships the interfaces this uses. Pinned at 4.7.1 with react-native-worklets 0.13.0 -- what Expo SDK 58 installs -- in e2e/package.json.

CI holds that on Linux and macOS. Both suites build Reanimated on every push and run a scenario driving a useSharedValue to a known width through withTiming, reading the value back out of the mounted view -- so a worklet that stops reaching the UI runtime fails a build rather than somebody's app. It was written by removing the fix it was meant to catch and watching it fail.

Linux took a port to get there, and not of Reanimated: react-native-worklets is built on Android and Apple and assumed both. It called pthread_setname_np the Apple way where glibc takes the thread as well, and used std::remove_if, std::upper_bound, std::logic_error and std::istream_iterator without including the headers that declare them -- which libc++ leaks and libstdc++ does not, so the files compiled on macOS and not on Linux. core/WorkletsCompat.h fills both in, the same way core/ReanimatedCompat.h already did for Reanimated, and neither package is patched or vendored.

Windows is not watched: that job configures CMake directly and does not ask for either package, so it skips the scenario.

Reanimated moves these interfaces between minors, and until recently nothing here built it on any platform -- which is how the glue drifted two minors before an expo-router app found out.

They are also the answer to a fair question about this project, which is whether the TurboModule and Fabric seam actually takes third-party code. These two are the hardest common case, and they were the proof.

Expo

An Expo app starts and renders, and basalt init writes the Metro config on expo/metro-config when it finds one. globalThis.expo is installed from the app's own expo-modules-core.

What exists after that is module by module:

@react-native-async-storage/async-storageWorks with nothing else installed: basalt-core carries the native half, over files, compiled only when your app has async-storage. The first third-party native module ported here
expo-notificationsbasalt-notifications implements its contract natively
expo-imagerenders on Linux and macOS. Windows does not mount one yet
expo-asset, expo-constantsstubs, there so that start-up survives
everything elseeach its own port

So an Expo app that is mostly React Native components and JavaScript runs. One leaning on Expo's native modules will find the ones it needs missing, and that is the honest state of it rather than a schedule.

Your own native code

A package with native code of its own, including the app itself, points at a CMakeLists.txt from its package.json:

{"basalt": {"native": "native/CMakeLists.txt"}}

The build picks it up with no registration anywhere else. See app.json for the shape, and Native modules for writing one.

What has not happened yet

No third-party native module has been ported end to end through codegen. The seam is proven and the libraries above run, but nothing has gone through the codegen path from scratch, so what porting an arbitrary module costs is still a guess. It is the largest unknown in the project.

On this page