$ npm install -g prebuild
- Builds native modules for any version of Node.js, N-API, Electron or NW.js, without having to switch between different versions to do so. This works by only downloading the correct headers and telling
node-gypto use those instead of the ones installed on your system.
- Upload (
--upload) prebuilt binaries to GitHub.
- Support for stripping (
--strip) debug information. Strip command defaults to
stripbut can be overridden by the
- Install prebuilt modules via
Supported ABI versions may change over time without a new prebuild release.
Alternatively, to build for some specific versions you can do:
prebuild -t 0.10.42 -t 0.12.10 -t 4.3.0
To build for N-API, do:
prebuild -t 3 -r napi
To build against Electron headers, do:
prebuild -t 1.4.10 -r electron
To build against NW.js headers, do:
prebuild -t 0.26.6 -r node-webkit
allTargets for all available versions.
For more options run
prebuild --help. The prebuilds created are compatible with node-pre-gyp
If you'd like to include other files with your prebuilds like additional
.node files or other native libraries, you can pass a file-matching regular
prebuild -t 8.0.0 --include-regex "\.(node|a)$"
Note that if you include multiple
.node files, you will need to use the
--binary-name parameter to indicate which file should be
prebuild-install --binary-name main-binary.node
The build file format is selected automatically by
node-gyp, however it is possible to specify needed format explicitly with
This is particularly useful if unusual flavor is required, which could be specified in 'format-flavor' form
(there is no comprehensive list of formats/flavors available so one has to find possible combinations from
node-gyp source code).
For example, in order to build using Makefiles but assume Android cross-compilation:
prebuild --format make-android
When using the cmake-js backend additional parameters can be passed through.
prebuild --backend cmake-js -- --prefer-clang --CDUV_INCLUDE_DIR=...
A prepack script can be specified that is executed once the
.node module has been created but before it is compressed and moved. This can be used to perform code signing.
prebuild --prepack 'codesign -v -s MyCompany'
--prepack parameters can take either a shell command or JS file to be executed.
prebuild supports uploading prebuilds to GitHub releases. If the release doesn't exist, it will be created for you. To upload prebuilds simply add the
-u <github-token> option:
$ prebuild --all -u <github-token>
If you don't want to use the token on cli you can put it in
--upload will only upload the targets that was built and stored in
prebuild -u <github-token> -t 4.3.0 will only upload the binary for the
You can use
prebuild --upload-all to upload all files from the
You can use
prebuild --upload --tag-prefix <prefix> for specific tag prefixes for the release. The default prefix is
v and will result in a tag with an appended version number, for example
v1.0.0. For lerna you can use the package name e.g.
prebuild --tag-prefix some-package@ and the binaries will be released on the appropriate package's tags, for example
Create GitHub Token
A GitHub token is needed for two reasons:
- Create a GitHub release (leveldown example)
- Upload the prebuilt binaries to that release
To create a token:
- Go to this page
- Click the
Generate new tokenbutton
- Give the token a name and click the
Generate tokenbutton, see below
The default scopes should be fine.
Declaring Supported N-API Versions
Native modules that are designed to work with N-API must explicitly declare the N-API version(s) against which they can build. This is accomplished by including a
binary property on the module's
package.json file. For example:
In the absence of a need to compile against a specific N-API version, the value
3 is a good choice as this is the N-API version that was supported when N-API left experimental status.
Modules that are built against a specific N-API version will continue to operate indefinitely, even as later versions of N-API are introduced.
The N-API header files supplied with Node use the
NAPI_VERSION preprocessor value supplied by the user to configure each build to the specific N-API version for which the native addon is being built. In addition, the module's C/C++ code can use this value to conditionally compile code based on the N-API version it is being compiled against.
The following code must be included in the
binding.gyp file of modules targeting N-API:
The following line must be included in the
CMakeLists.txt file of modules targeting N-API:
--runtime argument must be
napi to request N-API builds. When requesting N-API builds, the module's
package.json file must include a
binary property as described above. And the
binding.gyp file must include a define for
NAPI_VERSION as described above.
One or more
--target arguments may be specified to request builds for specific N-API versions. N-API versions are positive integer values. Alternatively,
--all may be used to request builds for all N-API versions supported by the module.
In the absence of both
prebuild will build the most current version of the module supported by the Node instance performing the build.
$ prebuild -h prebuild [options] --target -t version (version to build or install for) --runtime -r runtime (Node runtime [node, napi, electron or node-webkit] to build or install for, default is node) --all (prebuild for all known abi versions) --upload -u [gh-token] (upload prebuilds to github) --upload-all -u [gh-token] (upload all files from ./prebuilds folder to github) --tag-prefix <prefix> (github tag prefix, default is "v") --preinstall -i script (run this script before prebuilding) --prepack -c script (run this script before packing, can be used to codesign) --path -p path (make a prebuild here) --include-regex (regex to match files that will be distributed [default: '\.node$']) --libc (use provided libc rather than system default) --backend (specify build backend, default is 'node-gyp') --format (specify additional parameters for `node-gyp` backend) --strip (strip debug information) --debug (set Debug or Release configuration) --verbose (log verbosely) --version (print prebuild version and exit)
var prebuild =
.build(opts, version, cb)
.gypProvide a custom
.backendProvide a custom
node-gypinstance via string. Alternatives are
'cmake-js'(optional, defaults to
.argsAdditional command line arguments to
--debugon command line to gyp backend (optional)
.debugDownload or build a debug build (default:
.archProcessor architecture (default:
If you want to hack on
prebuild you need an environment to play around with. We recommend a setup similar
to the following:
- A fork of
- A GitHub token (see above)
- A native node module
$ git clone firstname.lastname@example.org:<your-nick>/prebuild$ cd prebuild && npm link && cd ..$ git clone email@example.com:<your-nick>/some-native-module
Since you did
npm link on
prebuild it will be installed globally. Now you can go ahead and try things out.
$ cd some-native-module$ prebuild --all --strip -u <github-token>
This command would:
some-native-modulefor all supported targets and store them in
- Strip binaries from debug information
- Create a release on GitHub, if needed
- Upload all binaries to that release, if not already uploaded
Before you commit your changes and send us a pull request, do run