September 19, 2026

React Native Android Development Without Android Studio

React NativeAndroidCLImacOSWindowsLinux
React Native Android development workflow using command-line tools and a physical Android phone without Android Studio

React Native Android development usually starts with installing Android Studio.

That works, but Android Studio also includes many tools you may not need if you already use VS Code or Cursor and prefer testing on a physical Android phone.

If your workflow is mainly:

Write React Native code
        ↓
Build Android app
        ↓
Install on physical phone
        ↓
Test and debug

then Android Studio itself is optional.

This guide shows how to build a lightweight React Native Android environment on macOS, Windows, and Linux without installing the full Android Studio suite.

Goal

We will create an Android development environment using:

  • Node.js
  • JDK 17
  • Android SDK Command-Line Tools
  • Android Platform Tools
  • Android Build Tools
  • ADB
  • Gradle Wrapper
  • A physical Android phone

The final workflow looks like:

VS Code / Cursor
       │
       ▼
React Native
       │
       ▼
Node.js + Metro
       │
       ▼
Gradle
       │
       ▼
Android SDK
       │
       ▼
ADB
       │
       ▼
Physical Android Phone

No Android Studio.

No emulator.

No Android Virtual Device.

Prerequisites

Before starting, you need:

  • macOS, Windows, or Linux
  • A physical Android phone
  • A USB cable that supports data transfer
  • Internet access for initial dependency downloads
  • Developer Options enabled on the phone
  • USB Debugging enabled

Why use this setup?

This setup is useful if you:

  • already use VS Code or Cursor
  • prefer testing on real Android devices
  • want to reduce disk usage
  • do not need Android Emulator
  • mainly work with React Native instead of native Kotlin or Java
  • want a smaller development environment

A full Android Studio installation may also include:

  • Android Emulator
  • System images
  • Virtual devices
  • AVD snapshots
  • IDE caches
  • Profiler components
  • Native Android debugging tools

If you do not need those tools, you can avoid installing them.

1. Install Node.js

React Native requires Node.js.

Using a Node version manager is useful because different projects may require different Node versions.

macOS

Install NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Restart your terminal, then install Node 22:

nvm install 22
nvm use 22
nvm alias default 22

Verify:

node -v
npm -v

Linux

Install NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Reload your shell:

source ~/.bashrc

Install Node:

nvm install 22
nvm use 22
nvm alias default 22

Verify:

node -v
npm -v

Windows

You can install Node directly or use a Windows Node version manager.

Using Chocolatey:

choco install -y nodejs-lts

Verify:

node -v
npm -v

2. Install JDK 17

Android builds require Java.

JDK 17 is a good default for current React Native Android development.

macOS

Using Homebrew:

brew install --cask zulu@17

Verify:

java -version

Find Java 17:

/usr/libexec/java_home -v 17

Add this to ~/.zshrc:

export JAVA_HOME=$(/usr/libexec/java_home -v 17)

Reload:

source ~/.zshrc

Check:

echo $JAVA_HOME

Windows

Using Chocolatey:

choco install -y microsoft-openjdk17

Verify:

java -version

Check:

echo $env:JAVA_HOME

Linux

Ubuntu or Debian:

sudo apt update
sudo apt install openjdk-17-jdk

Verify:

java -version

Find Java:

readlink -f $(which java)

Add JAVA_HOME to ~/.bashrc.

Example:

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64

Reload:

source ~/.bashrc

The exact Java path may differ depending on your Linux distribution and CPU architecture.

3. Install Watchman

Watchman improves filesystem watching during React Native development.

macOS

Install:

brew install watchman

Verify:

watchman --version

Windows

You can skip this step.

Linux

Watchman is optional.

You can start without it and install it later if needed.

4. Install Android SDK Command-Line Tools

This is the main part that allows us to avoid Android Studio.

The Android SDK command-line package gives access to tools such as:

  • sdkmanager
  • avdmanager
  • lint
  • apkanalyzer

For this setup, the most important tool is sdkmanager.

macOS

Install the Android command-line tools:

brew install --cask android-commandlinetools

Check your Homebrew prefix:

brew --prefix

On Apple Silicon Macs, this is usually:

/opt/homebrew

On Intel Macs:

/usr/local

Add this to ~/.zshrc:

export ANDROID_HOME="$(brew --prefix)/share/android-commandlinetools"
export PATH="$ANDROID_HOME/platform-tools:$PATH"
export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"
export JAVA_HOME=$(/usr/libexec/java_home -v 17)

Reload:

source ~/.zshrc

Verify:

sdkmanager --version

Windows

Download the Android SDK Command line tools only package for Windows.

Create:

C:\Users\<YOUR_USERNAME>\AppData\Local\Android\Sdk

Inside it, create:

cmdline-tools\latest

The final structure should look like:

Sdk
└── cmdline-tools
    └── latest
        ├── bin
        ├── lib
        ├── NOTICE.txt
        └── source.properties

Create the environment variable:

ANDROID_HOME

Set its value to:

%LOCALAPPDATA%\Android\Sdk

Add these to your Windows Path:

%ANDROID_HOME%\cmdline-tools\latest\bin
%ANDROID_HOME%\platform-tools

Open a new PowerShell window.

Verify:

echo $env:ANDROID_HOME
sdkmanager --version

Linux

Create the SDK directory:

mkdir -p "$HOME/Android/Sdk/cmdline-tools"

Download Android SDK Command line tools only for Linux.

Extract it so the structure becomes:

~/Android/Sdk/
└── cmdline-tools/
    └── latest/
        ├── bin/
        ├── lib/
        ├── NOTICE.txt
        └── source.properties

Make sure you do not accidentally create:

cmdline-tools/latest/cmdline-tools/bin

The correct structure is:

cmdline-tools/latest/bin

Add this to ~/.bashrc:

export ANDROID_HOME="$HOME/Android/Sdk"
export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"
export PATH="$ANDROID_HOME/platform-tools:$PATH"

Reload:

source ~/.bashrc

Verify:

sdkmanager --version

If you use Zsh, put the same configuration in ~/.zshrc.

5. Accept Android SDK licenses

Run:

sdkmanager --licenses

Accept the required licenses by entering:

y

6. Install required Android SDK packages

Install the packages needed for React Native Android builds:

sdkmanager \
  "platform-tools" \
  "platforms;android-35" \
  "build-tools;36.0.0"

On Windows PowerShell:

sdkmanager "platform-tools" "platforms;android-35" "build-tools;36.0.0"

This installs:

platform-tools
    └── adb

platforms
    └── android-35

build-tools
    └── 36.0.0

Verify ADB:

adb version

You should see something similar to:

Android Debug Bridge version ...

7. Verify the development environment

Before connecting your phone, check everything.

macOS / Linux

node -v
npm -v
java -version
echo $JAVA_HOME
echo $ANDROID_HOME
sdkmanager --version
adb version

Windows

node -v
npm -v
java -version
echo $env:JAVA_HOME
echo $env:ANDROID_HOME
sdkmanager --version
adb version

If all commands work, the Android development environment is ready.

8. Connect a physical Android phone

On your Android device, open:

Settings
→ About Phone
→ Build Number

Tap Build Number several times until Developer Options are enabled.

Then open:

Settings
→ Developer Options

Enable:

USB Debugging

Connect the phone using USB.

Run:

adb devices

The first time, your phone may show:

Allow USB debugging?

Tap Allow.

Run again:

adb devices

Expected output:

List of devices attached
R58XXXXXXXX    device

Your computer can now communicate with the phone.

Windows device driver note

Windows may require an OEM USB driver.

If:

adb devices

does not detect your phone, check whether your manufacturer provides a USB driver.

This may apply to devices from manufacturers such as:

  • Samsung
  • Xiaomi
  • Motorola
  • Google
  • OnePlus

Linux permission note

Linux may require additional udev permissions.

If:

adb devices

shows a permission problem, configure Android udev rules for your distribution.

This normally only needs to be done once.

9. Run the React Native app

Navigate into your project:

cd my-react-native-app

Install dependencies:

npm install

Start Metro:

npm start

Keep that terminal open.

Open another terminal and run:

npx react-native run-android

Or:

npm run android

The process looks like:

React Native Project
        ↓
Gradle
        ↓
Android Build Tools
        ↓
APK
        ↓
ADB
        ↓
Android Phone

Android Studio is not involved.

10. What Gradle does

You normally do not need to install Gradle globally.

React Native Android projects include the Gradle Wrapper.

Inside:

android/

you should see:

gradlew
gradlew.bat
gradle/

On macOS and Linux:

cd android
./gradlew assembleDebug

On Windows:

cd android
.\gradlew.bat assembleDebug

The Gradle Wrapper automatically uses the Gradle version required by the project.

11. Useful ADB commands

Check connected devices:

adb devices

View logs:

adb logcat

List installed packages:

adb shell pm list packages

Install an APK manually:

adb install app-debug.apk

12. Disk usage

One of the main advantages of this setup is storage.

A lightweight environment mainly contains:

Node.js
JDK
Android SDK Command-Line Tools
Platform Tools
Android Platform
Build Tools
Gradle Cache

A full Android Studio environment may additionally contain:

Android Studio IDE
Android Emulator
System images
Virtual devices
AVD snapshots
IDE caches
Profiler components
Additional SDK components

Emulator system images and virtual devices can consume several gigabytes.

If you use a physical Android phone, you can avoid those entirely.

Check disk usage on macOS

echo "===== ANDROID SDK ====="
du -sh "$ANDROID_HOME" 2>/dev/null

echo
echo "===== GRADLE ====="
du -sh ~/.gradle 2>/dev/null

echo
echo "===== NVM ====="
du -sh ~/.nvm 2>/dev/null

echo
echo "===== JAVA ====="
du -sh /Library/Java/JavaVirtualMachines 2>/dev/null

echo
echo "===== HOMEBREW CACHE ====="
du -sh ~/Library/Caches/Homebrew 2>/dev/null

Check free space:

df -h /

Check disk usage on Linux

echo "===== ANDROID SDK ====="
du -sh "$ANDROID_HOME" 2>/dev/null

echo
echo "===== GRADLE ====="
du -sh ~/.gradle 2>/dev/null

echo
echo "===== NVM ====="
du -sh ~/.nvm 2>/dev/null

echo
echo "===== DISK ====="
df -h /

Check disk usage on Windows

Write-Host "===== ANDROID SDK ====="
(Get-ChildItem $env:ANDROID_HOME -Recurse -ErrorAction SilentlyContinue |
Measure-Object Length -Sum).Sum / 1GB

Write-Host "===== GRADLE ====="
(Get-ChildItem "$HOME\.gradle" -Recurse -ErrorAction SilentlyContinue |
Measure-Object Length -Sum).Sum / 1GB

Write-Host "===== FREE DISK ====="
Get-PSDrive C

13. Android Studio vs CLI-only setup

CLI-only setup

Node.js
JDK
Android SDK
Platform Tools
Build Tools
Gradle
ADB
Physical Device

Advantages:

  • smaller disk usage
  • simpler environment
  • no emulator overhead
  • good for VS Code and Cursor users
  • ideal for physical-device testing

Full Android Studio setup

A typical full setup may include:

Android Studio
Android SDK
JDK
Android Emulator
System Images
Virtual Devices
Snapshots
Gradle Cache
IDE Cache
Profilers
Device Manager

Android Studio provides more tooling, but the complete environment is significantly larger.

14. Optional: Wireless ADB

Modern Android versions support wireless debugging.

That means your development flow can become:

Computer
    │
    │ Wi-Fi
    ▼
Android Phone

USB is still useful for the initial setup and troubleshooting.

15. Clean up unused Android SDK packages

List installed packages:

sdkmanager --list_installed

Remove an unused package:

sdkmanager --uninstall "PACKAGE_NAME"

For example:

sdkmanager --uninstall "platforms;android-34"

Only remove platforms you know your projects no longer need.

If you do not plan to use the Android Emulator, avoid installing packages such as:

system-images;
emulator

Troubleshooting

adb: command not found

Check:

echo $ANDROID_HOME

Make sure this path is included:

$ANDROID_HOME/platform-tools

On Windows:

%ANDROID_HOME%\platform-tools

sdkmanager: command not found

Make sure this directory is in your PATH:

$ANDROID_HOME/cmdline-tools/latest/bin

Windows:

%ANDROID_HOME%\cmdline-tools\latest\bin

JAVA_HOME is not set

Verify Java:

java -version

Check:

echo $JAVA_HOME

Windows:

echo $env:JAVA_HOME

Make sure it points to JDK 17.

Device shows unauthorized

Run:

adb devices

Unlock the phone and accept the USB debugging prompt.

If needed:

adb kill-server
adb start-server
adb devices

Device does not appear

Check that:

  • USB Debugging is enabled
  • the phone is unlocked
  • the USB cable supports data transfer
  • USB mode allows data transfer
  • Windows OEM drivers are installed if required
  • Linux udev permissions are configured if required

Then run:

adb devices

again.

Gradle cannot find Android SDK

You can explicitly define the SDK location inside:

android/local.properties

macOS example:

sdk.dir=/Users/yourname/Library/Android/sdk

Linux example:

sdk.dir=/home/yourname/Android/Sdk

Windows example:

sdk.dir=C:\\Users\\yourname\\AppData\\Local\\Android\\Sdk

Normally environment variables should be enough, but local.properties can help when troubleshooting SDK detection problems.

Trade-offs

This setup provides everything required to build and run React Native Android apps, but you will not have Android Studio's graphical tools.

That includes:

  • Android Emulator
  • AVD Manager
  • Layout Inspector
  • Android Profiler
  • Logcat UI
  • Device Explorer
  • Native Java/Kotlin debugger
  • APK Analyzer
  • graphical SDK Manager

Many of these tools have command-line alternatives, but Android Studio provides a more convenient interface for advanced Android-specific development.

When Android Studio still makes sense

Android Studio is useful if you regularly need:

  • Android Emulator
  • native Kotlin or Java development
  • CPU and memory profiling
  • Layout Inspector
  • advanced Gradle debugging
  • APK analysis
  • native Android debugging
  • Device Manager

You can always start with the lightweight setup and install Android Studio later.

Your React Native project does not need to change.

iOS limitation

This guide only replaces Android Studio for Android development.

React Native Android apps can be developed from:

macOS
Windows
Linux

Native iOS builds are different.

To build React Native iOS apps locally, you still need:

macOS
+
Xcode

Windows and Linux cannot locally compile native iOS applications using Apple's normal toolchain.

Conclusion

If your workflow looks like:

React Native
+
VS Code / Cursor
+
Physical Android Device

then Android Studio is optional.

A lightweight environment can use:

Node.js
JDK 17
Android SDK CLI
Platform Tools
Build Tools
Gradle Wrapper
ADB

The final workflow becomes:

macOS / Windows / Linux
          │
          ▼
VS Code / Cursor
          │
          ▼
React Native
          │
          ▼
Gradle
          │
          ▼
Android SDK
          │
          ▼
ADB
          │
          ▼
Physical Android Phone

For React Native developers who prefer real-device testing and want to avoid a large Android Studio installation, this is a clean and practical alternative.

Back to BlogView ProjectsHomepage