Radar Documentation

Installation

Add the Radar devtools package to your React Native project. Radar works with both bare React Native and Expo projects.

Requires React 18+, React Native 0.72+, and New Architecture enabled. Works with both bare React Native and Expo.

Step 1: Install the package

npm install radar-devtools

dependency or devDependency? Both work on Expo SDK 54+ (autolinking >=3.0.14). Since Radar only runs behind __DEV__, installing as a devDependency (add -D/--save-dev) is idiomatic there. On Expo SDK ≤ 53, install it as a regular dependency — older autolinkers skip devDependencies.

Step 2: Initialize in your app

Add the following to your app's entry point (e.g., App.tsx or index.ts):

if (__DEV__) {
  const { init } = require('radar-devtools');
  init();
}

Note: Wrapping in __DEV__ ensures Radar is fully tree-shaken from production builds. Call init() before any other code to capture all console logs and network requests.

Quick Start

Once you've installed and initialized the devtools package, connecting to Radar is automatic.

  1. 1.

    Open the Radar desktop app

    Download and launch Radar on your development machine.

  2. 2.

    Run your React Native app

    Start your app on a simulator, emulator, or physical device.

  3. 3.

    Start debugging

    Your app will automatically connect to Radar. You'll see console logs, network requests, and more in real time.

Configuration

Radar works out of the box with zero configuration for most setups. For advanced use cases, you can customize the connection and enable additional features.

State Management

To inspect Redux, Zustand, or other stores, pass them to init() via the stores option:

import { counterStore } from './stores/counterStore';

if (__DEV__) {
  const { init } = require('radar-devtools');
  init({
    stores: { counter: counterStore },
  });
}

For Zustand, pass the store hook directly:

import { useTodoStore } from './stores/todoStore';

if (__DEV__) {
  const { init } = require('radar-devtools');
  init({
    stores: { todos: useTodoStore },
  });
}

Storage

AsyncStorage is detected automatically. For MMKV, pass your instances to init():

import { createMMKV } from 'react-native-mmkv';

const defaultStorage = createMMKV();
const settingsStorage = createMMKV({ id: 'settings' });

if (__DEV__) {
  const { init } = require('radar-devtools');
  init({
    mmkvInstances: {
      default: defaultStorage,
      settings: settingsStorage,
    },
  });
}

Startup Metrics and TTI

Radar automatically measures JS bundle eval time. To track Time To Interactive (TTI), call markInteractive() when your app's main UI is ready:

if (__DEV__) {
  const { init } = require('radar-devtools');
  init();
}

const onReady = () => {
  if (__DEV__) {
    const { markInteractive } = require('radar-devtools');
    markInteractive();
  }
};

const App = () => (
  <NavigationContainer onReady={onReady}>
    {/* ... */}
  </NavigationContainer>
);

Tip: If markInteractive() is not called within 10 seconds, startup metrics are sent without TTI.

Custom Host and Port

By default, Radar connects to localhost:8347 on iOS and 10.0.2.2:8347 on Android emulators. You can override these:

if (__DEV__) {
  const { init } = require('radar-devtools');
  init({
    host: '192.168.1.100',
    port: 8347,
  });
}

Platform Support

iOS Simulator

All features work automatically. No additional configuration needed.

Android Emulator

All features work automatically. Radar uses 10.0.2.2 to reach your host machine.

Physical Device

Physical devices require your device and development machine to be on the same Wi-Fi network. You must specify your machine's IP address via the host option.

Feature availability on physical devices:

Console, Network, Component Tree, Profiler, State Management, Storage

Performance metrics (UI FPS, native RAM, CPU) and startup native launch time require the RadarPerformance TurboModule. JS heap and JS FPS work with Hermes.

Features

Radar provides eight debugging panels, all accessible from a unified interface.

Console

Captures all console output (log, warn, error, debug) with rich serialization. Supports functions, Symbols, BigInt, circular references, and React elements. Features syntax highlighting, log grouping, and stack traces.

Network

Automatically intercepts all fetch requests. View HTTP methods, status codes, timing, headers, and full request/response bodies in a clean, color-coded interface.

Component Tree

Fiber-based component inspection with real-time updates. Search components, trace to source code, and inspect resolved styles. See your app's component hierarchy in a visual tree view.

Profiler

Interactive flamegraph, ranked component view, and render trigger analysis. See exactly which props changed, which state updated, and which hooks caused each render. Navigate commits with the timeline view.

Performance

Real-time native metrics including UI FPS, CPU usage, memory, and JS heap. Startup breakdown with bundle eval time, native launch time, and TTI. All streamed live to interactive charts with hover inspection.

State Management

Inspect Redux, Zustand, and other state management stores. View live state snapshots, filter by slice name, track dispatched actions with full payload inspection, and see diffs between state changes.

Storage

Browse, edit, and clear AsyncStorage and MMKV entries directly from Radar. Supports multi-instance MMKV setups with typed values (string, number, boolean). Changes are applied to the device in real time.

AI Integration (MCP)

Built-in MCP server exposes 18 tools to AI coding assistants. Let Claude, Cursor, Windsurf, or any MCP-compatible client read your app's runtime data and act on it. See the AI Integration section for setup.

AI Integration (MCP)

Radar includes a built-in Model Context Protocol (MCP) server that exposes all devtools data as tools for AI coding assistants. When Radar is running, your AI can read console logs, inspect network requests, browse component trees, analyze profiler data, and more.

Setup

The MCP server starts automatically when you open Radar and listens on port 8348. Pick your AI tool below and run the CLI command or add the config manually:

CLI
claude mcp add radar --transport http http://localhost:8348/mcp

.claude/settings.json

{
  "mcpServers": {
    "radar": {
      "url": "http://localhost:8348/mcp"
    }
  }
}

What Can You Ask?

Once connected, you can ask your AI assistant natural language questions like:

>"Why is my app re-rendering so much?"
>"Show me all failed network requests"
>"What's in AsyncStorage right now?"
>"Profile my app startup and tell me what's slow"
>"What does the Redux state look like for the todos slice?"

Note: The MCP server requires Radar to be running and connected to at least one device. All tools accept an optional deviceId parameter — if omitted, they return data from all connected devices.