Local first
Your debugging data stays on your machine.
Our goal
One debugging environment.
None of the usual friction.
NativeScope is a modular React Native debugging environment: fully local, account-free and simple enough to adopt in the middle of a difficult debugging session.0logins
0cloud dependencies
1config file, modules declared
Nmodules, only when needed
The honest premise
New is not automatically better.
Most debugging categories already exist. We are not interested in pretending otherwise. We begin with workflows the community already understands, identify where they become slow, fragmented or difficult to adopt, and improve those points in ways we can prove.
That means naming the tools that inspired us, explaining the pain we felt while using them and being transparent about trade-offs. The user should leave with enough evidence to choose, even when that choice is not NativeScope.
Borrow openly. Improve measurably. Prove everything.
The proof is growing
Storage began the proof. Logs puts the cause in context.
We started with storage because its problems are concrete: hidden app state, fragmented providers, stale UI after edits and inspectors that collapse under real datasets. Network extends the same contract to capture, replay and request context. Logs and Timeline connect the line that failed to the request and state change around it.
01
Performance
02A window, not a copy
The budgets, cursor pagination, streams and virtualization behind fluid inspection at gigabyte scale.
Architecture
03Plug-and-play, by construction
How Metro interception and release guards make plug-and-play an engineering property instead of a slogan.
Choice
A factual comparison
The integration trade-offs beside another capable ecosystem, with sources and without declaring a winner.
The environment
One Studio for the questions that interrupt your work.
Storage, Network and Logs are live today. Timeline is the shared lens that connects them. Future modules will follow real community needs: performance, state, navigation, files and device events. Familiar capabilities can live beside deeper purpose-built tools without turning installation into a platform migration.
The non-negotiable
Capability may grow. Integration may not.
The React Native community includes people shipping their first app and engineers maintaining products used by millions. Neither group should have to restructure an app, understand our internals or maintain a second inventory just to inspect it.
You enable each module with a line in the single root config file, while storage instances are still discovered automatically. Adding a capability should mean adding a line, not adopting a new architecture.
- One guided integration surface
- Advanced control without an advanced entry price
- Modules disappear cleanly when removed
import { defineNativeScopeConfig } from
"react-native-nativescope/app"
export default defineNativeScopeConfig({
modules: {
storage: {
indicator: true,
reactQuery: true,
},
network: true,
logs: true,
// Product direction: one config block per module
// performance: {
// enabled: true,
// },
// navigation: {
// enabled: true,
// },
},
})Storageavailable now
+ Networkavailable now
+ Logsavailable now
+ Performanceone future config block
+ Navigationone future config block
Our contract
The rules every module has to keep.
No account
A useful local tool should not begin with a signup form.
Simple by default
A beginner gets the same safe path as an experienced engineer.
Dev-only
Instrumentation belongs in development and is checked out of release bundles.
Modular
Install the capability you need. The Studio reflects what is present.
Evidence over claims
We publish mechanisms, constraints and trade-offs.
Built in the open
Three modules already share the contract.
Inspect how they work, challenge the decisions and use the evidence to decide whether NativeScope belongs in your workflow.