Free tools Windows power users keep installed
One-click scans. No signup required.
iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
A native file can compile into an app without being registered as an Expo module. Expo’s own expo-modules-autolinking changelog documents compile-only inline module files, so a successful native build does not by itself prove that Expo can discover or call a module. That is a documented mechanism—not evidence of what happened in any particular project. To diagnose a real failure, check the module’s format, its platform registration configuration, the autolinking output, and the exact runtime error.
How can a module compile without being registered?
Compilation and registration are separate outcomes. A native build can include source files in its target while Expo’s module discovery and provider-generation steps omit the class that should make the module available through Expo’s module system.
Expo’s autolinking changelog says, under release 57.0.6 dated July 15, 2026: “Added support for compile-only inline module files, which are compiled into the target without being registered as Expo modules.” This establishes that compile-only inline files are a supported case. It does not establish that a specific app had an accidental registration failure or that its module appeared in every build.
First identify what kind of native module you have
Expo’s registration configuration applies to Expo modules; it does not make every arbitrary native source file an Expo module automatically. Determine whether the code is an inline Expo module, a local Expo module, or a package module before changing configuration.
#1 Best Overall
- Inline module: Native files live in the app project. Check the autolinking version and its inline-module discovery behavior, especially on Android.
- Local Expo module: Check that the module has the expected Expo module configuration and platform class declaration.
- Package module: Check the package’s configuration and whether the app resolves the expected installed copy.
Expo’s autolinking documentation describes how discovery participates in Android Gradle and iOS CocoaPods builds. Discovery requires a root expo-module.config.json with a platforms entry matching the platform being resolved.
Check the module configuration and generated provider
Open the module’s root expo-module.config.json. Confirm that it names the platform you are building and includes the expected native class in that platform’s modules list. Expo uses the Apple list to generate its provider for Swift module classes and the Android list for fully qualified Kotlin module classes. A class present in a target is not a substitute for the correct entry in this configuration.
Rank #2
- For iOS, confirm the expected Swift module class is listed under the Apple platform configuration.
- For Android, confirm the expected fully qualified Kotlin module class is listed under Android.
- Inspect the generated provider output for the build platform and verify that it includes the class you expect.
If the config looks correct but the provider omits the class, record the installed Expo SDK and expo-modules-autolinking versions. The configuration, generated provider, and autolinking version help distinguish a discovery problem from a later runtime or JavaScript issue.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsUse autolinking diagnostics before changing dependencies
Run these commands from the app’s project directory:
Rank #3
npx expo-modules-autolinking verify --verbose
npx expo-doctorThe verbose autolinking verification output can show which native modules were discovered and surface duplicate warnings. Expo Doctor can help identify duplicate packages. Compare the discovered module list with the module you expect, then inspect the dependency tree if multiple copies of a native package are installed.
Duplicate native dependency versions matter because Metro and the compiled native app can resolve different copies. That can leave JavaScript asking one version for a native module that another version supplied—or did not register. Expo’s guidance is to deduplicate native modules when duplicate installations are present.
Rank #4
Check monorepo resolution against your Expo SDK
In a monorepo, verify which package copy Metro resolves and which copy the native build includes. Expo documents an opt-in experiments.autolinkingModuleResolution alignment beginning with SDK 54, and says it is enabled by default for monorepo apps in SDK 55. Confirm the app’s actual SDK and configuration before enabling or changing this setting; the SDK version alone does not prove a resolution mismatch.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
For Android inline modules, check the scanner version
The 57.0.6 autolinking changelog also records a specific Android issue: Kotlin files with long comments before the package declaration could be silently skipped during registration scanning, and the release note records a fix. If your module is an Android inline module, compare the installed autolinking version with that fix and inspect whether the file has a long leading comment. Verify the version in your project before deciding whether an upgrade applies; this known issue is not a general explanation for every missing module.
Separate registration failures from other runtime errors
Messages such as “Verify that a module by this name is registered in the native binary” or “Cannot find native module” are useful clues, but they do not establish a shared root cause. An Expo registration problem is only one possibility. The failure may involve a different native-module interface, dependency-resolution mismatch, or a JavaScript import exception that prevents the application from starting normally.
Use the exact error and the point at which it occurs to narrow the path: compare the module’s format, platform, generated provider, autolinking output, and dependency resolution. Do not infer a registration cause solely from the fact that native compilation succeeded.
What to collect to diagnose a specific project
The available facts do not identify the cause of the incident implied by this title. For a project-specific diagnosis, gather:
Quick Recap
- Expo SDK and installed
expo-modules-autolinkingversions. - Whether the module is inline, local, or provided by a package.
- The platform and exact runtime error.
- The root
expo-module.config.jsonand the relevant generated provider contents. - Output from
npx expo-modules-autolinking verify --verboseandnpx expo-doctor. - The package-manager dependency tree, including whether more than one copy of a native dependency is installed.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
