Skip to content

Most visited

Recently visited



The ndk-build file is a shell script introduced in Android NDK r4. Its purpose is to invoke the right NDK build script.


Running the ndk-build script is equivalent to running the following command:

$GNUMAKE -f <ndk>/build/core/

$GNUMAKE points to GNU Make 3.81 or later, and <ndk> points to your NDK installation directory. You can use this information to invoke ndk-build from other shell scripts, or even your own make files.

Invoking from the Command Line

The ndk-build file lives in the top level the NDK installation directory. To run it from the command line, invoke it while in or under your application project directory. For example:

cd <project>
$ <ndk>/ndk-build

In this example, <project> points to your project’s root directory, and <ndk> is the directory where you installed the NDK.


All parameters to ndk-build are passed directly to the underlying GNU make command that runs the NDK build scripts. Combine ndk-build and options in the form ndk-build <option>. For example:

$ ndk-build clean

The following options are available:

Remove any previously generated binaries.

Note: On Mac OS X, running ndk-build clean with a high number of parallel executions may result in a build error that includes the following message:

rm: fts_read: No such file or directory

To avoid this issue, consider not using the -jN modifier or selecting a smaller value for N, such as 2.

Launch build, and display build commands.
Force a complete rebuild.
-B V=1
Force a complete rebuild, and display build commands.
Display internal NDK log messages (used for debugging the NDK itself).
Force a debuggable build (see table 1).
Force a release build (see table 1).
Always use the toolchain in 32-bit mode (see 64-bit and 32-bit Toolchains).
Build, using a specific file pointed to by the NDK_APPLICATION_MK variable.
-C <project>
Build the native code for the project path located at <project>. Useful if you don't want to cd to it in your terminal.

Debuggable versus Release builds

Use the NDK_DEBUG option and, in certain cases, AndroidManifest.xml to specify debug or release build, optimization-related behavior, and inclusion of symbols. Table 1 shows the results of each possible combination of settings.

Table 1. Results of NDK_DEBUG (command line) and android:debuggable (manifest) combinations.

Manifest SettingNDK_DEBUG=0 NDK_DEBUG=1NDK_DEBUG not specified
android:debuggable="true" Debug; Symbols; Optimized*1 Debug; Symbols; Not optimized*2 (same as NDK_DEBUG=1)
android:debuggable="false"Release; Symbols; Optimized Release; Symbols; Not optimizedRelease; No symbols; Optimized*3
*1: Useful for profiling.
*2: Default for running ndk-gdb.
*3: Default mode.

Note: NDK_DEBUG=0 is the equivalent of APP_OPTIM=release, and complies with the GCC -O2 option. NDK_DEBUG=1 is the equivalent of APP_OPTIM=debug in, and complies with the GCC -O0 option. For more information about APP_OPTIM, see

The syntax on the command line is, for example:

$ ndk-build NDK_DEBUG=1

If you are using build tools from prior to SDK r8, you must also modify your AndroidManifest.xml file to specify debug mode. The syntax for doing so resembles the following:

<application android:label="@string/app_name"
From SDK r8 onward, you do not need to touch AndroidManifest.xml. Building a debug package (e.g. with ant debug or the corresponding option of the ADT plugin) causes the tool automatically to pick the native debug files generated with NDK_DEBUG=1.

64-Bit and 32-Bit Toolchains

Some toolchains come with both 64-bit and 32-bit versions. For example, directories <ndk>/toolchain/<name>/prebuilt/ and <ndk>/prebuilt/ may contain both linux-x86 and linux-x86_64 folders for Linux tools in 32-bit and 64-bit modes, respectively. The ndk-build script automatically chooses a 64-bit version of the toolchain if the host OS supports it. You can force the use of a 32-bit toolchain by using NDK_HOST_32BIT=1 either in your environment or on the ndk-build command line.

Note that 64-bit tools utilize host resources better (for instance, they are faster, and handle larger programs), and they can still generate 32-bit binaries for Android.


You need GNU Make 3.81 or later to use ndk-build or the NDK in general. The build scripts will detect a non-compliant Make tool, and generate an error message.

If you have GNU Make 3.81 installed, but the default make command doesn’t launch it, define GNUMAKE in your environment to point to it before launching ndk-build. For example:

$ export GNUMAKE=/usr/local/bin/gmake
$ ndk-build

You can override other host prebuilt tools in $NDK/prebuilt/<OS>/bin/ with the following environment variables:

$ export NDK_HOST_AWK=<path-to-awk>
$ export NDK_HOST_ECHO=<path-to-echo>
$ export NDK_HOST_CMP=<path-to-cmp>
This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields


Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience. (Dec 2017 Android Platform & Tools Survey)