Symptom: Your Expo project installs a package, but Expo Go still says a native module is missing.
Fastest fix: If the project needs native code that Expo Go does not include, stop reinstalling Expo Go and switch to a development build. You can edit on Windows and use a cloud build; use macOS when you need to run the iOS Simulator or work directly with Xcode.
This guide is for students following an Expo or React Native course who have hit their first native module error.
It also helps Windows users distinguish a cloud build from a simulator running on their own computer.
If your project already uses native dependencies, use the verification steps to check whether your development build is ready.
Diagnose the failure before changing the app
An error mentioning a module does not automatically mean Expo Go is the problem. First work out whether the failure happens while installing a dependency, while running JavaScript, or when the app tries to call native code. Those are different problems, and they need different fixes.
A JavaScript package is code your project can install. A native module also needs a matching implementation inside the app that runs on the phone or simulator. Expo Go is a prebuilt app with a defined set of native libraries; installing another JavaScript package does not add new native code to Expo Go. Check the Expo third-party library overview to see whether a library is supported and how Expo describes its setup.
| What you see | Likely problem | What to check next |
|---|---|---|
| The package manager cannot download or install a dependency | Install, network, or dependency-resolution problem | Read the first install error. Check the package name, the project’s dependency setup, and whether the package manager reports a network or version conflict. |
| The app starts, then shows a JavaScript exception | JavaScript logic or configuration problem | Read the first exception and its file location. Check the code that calls the package before changing the build type. |
| The app says a native module or native implementation is unavailable | The running app may not contain the package’s native code | Check the package’s Expo instructions and whether its native implementation is included in Expo Go. |
| The module appears supported, but its feature still fails | Required setup may be missing or the project may need a configuration change | Follow the library’s documented configuration steps and confirm the app was rebuilt if native settings changed. |
Why Expo Go can’t see a project’s native module: Expo Go already contains a fixed selection of native libraries. A project dependency can make JavaScript available to your app, but it cannot alter the native code inside the installed Expo Go app. Expo’s development-build FAQ explains this boundary and when a project should use its own development build.
Do not repeatedly clear caches or reinstall Expo Go as your first response to a confirmed missing native implementation. Those actions can help with certain stale JavaScript or install issues, but they cannot add native code to an app that was not built with it.
Switch to a development build when the app needs native code
An Expo development build is your project’s own practice app: it includes the native dependencies your project needs and provides development tools. It is not an add-on that installs plugins into Expo Go. Expo’s development-build introduction describes this as a way to create a development version of your app with the libraries and native configuration required by the project.
When should you leave Expo Go? Move to a development build when the library’s official instructions require native code that Expo Go does not include, or when your project’s native configuration needs to be built into the app. If the problem is a JavaScript exception or a failed package download, diagnose that first; changing build type may not solve it.
Use the library’s documentation to confirm what it needs. Expo’s custom native code guide can help you understand when a project’s native code or configuration must be customized. Avoid assuming that every package with a native component is automatically incompatible with Expo Go. The deciding question is whether the required implementation and setup are available in the app you are running.
For a beginner, the trade-off is simple:
- Expo Go: quick to start and useful for learning features supported by its built-in libraries. It cannot gain a missing native implementation just because you install another package.
- Development build: closer to the app your project needs, but it must be built with the project’s native dependencies and configuration.
- Cloud build: can create an iOS app build without turning your Windows computer into a Mac. It does not give Windows a local iOS Simulator.
Check before rebuilding: Read the package’s Expo-specific installation notes. If they require native configuration, adding the package in JavaScript alone is not the complete setup.
Choose a build and test route that matches your computer
A build and a test device are not the same thing. EAS Build is Expo’s cloud build service: it can build an iOS app remotely. The iOS Simulator is a Mac app for running and checking an iOS app on macOS. A cloud build does not install a simulator on Windows. Expo’s iOS Simulator guide explains the macOS requirement, and its EAS simulator-build tutorial covers creating a build intended for the simulator.
| Route | Where you edit | Where the build happens | Where you test | Best fit |
|---|---|---|---|---|
| Keep using Expo Go | Windows or another computer | No custom native app build for the supported workflow | A compatible physical device with Expo Go | Basic course work that uses supported built-in libraries |
| Use EAS Build | Windows or another computer | In the cloud | A compatible physical device, or a simulator build used on macOS | You need a project-specific iOS build but do not have a local Mac |
| Use a school Mac | On the Mac, or in your existing editor workflow | On the Mac or through the cloud | iOS Simulator or a physical iPhone | Your school provides access and the course requires simulator or Xcode work |
| Use a remote Mac | On your own computer or through a remote session | On the remote Mac or through the cloud | The Mac’s available development environment, subject to your connection and project setup | You need macOS tools for a defined task but do not own a Mac |
Can you create an iOS development build without owning a Mac? You can edit the project on Windows and use EAS Build for cloud iOS builds. That does not mean you can run the iOS Simulator on Windows. For a simulator check, use a Mac available through school or another suitable macOS environment. Expo’s guide to using development builds explains the development-build workflow; check its current instructions for the build type and device you intend to use.
For a course project, choose the route that matches the assignment rather than the most elaborate setup. If the assignment only asks you to demonstrate a JavaScript feature and Expo Go supports the required libraries, keep using it. If it requires a native dependency, build a project-specific app. If it specifically asks for simulator screenshots or Xcode debugging, plan access to macOS.
Follow a recovery sequence that avoids unnecessary rebuilds
Use these steps after you identify a likely native-module issue:
- Save your work. Confirm your source files are saved and note the exact action that triggers the error. Keep credentials and project secrets out of public repositories and messages.
- Read the first meaningful error. Separate package installation failures from JavaScript exceptions and messages about a missing native implementation. Later errors can be consequences of the first one.
- Check the package’s Expo instructions. Confirm whether the library supports Expo Go, requires a development build, or needs additional native configuration. Use the official library instructions rather than relying only on a copied course command.
- Choose the app you will run. If Expo Go contains what the project needs, keep testing there. If the native implementation is missing, prepare a development build for the project instead.
- Build for the intended destination. A physical iPhone and an iOS Simulator need compatible builds. If you use a simulator build, plan to run it on macOS. Follow the current EAS simulator build tutorial rather than treating a cloud build as a local Windows simulator.
- Rebuild after native changes. Adding or changing a native dependency, native configuration, or other build-time input can require a new development build. A JavaScript-only change usually does not mean the native app must be rebuilt; confirm the project’s workflow and library instructions before starting another build.
- Protect environment values. If the project uses API keys or other secrets, check where they are stored and who can access them. Expo documents the available EAS environment variable options; do not paste credentials into public code or share them as a shortcut for remote troubleshooting.
If a new dependency still will not work in a development build: check whether the installed app was built after that native dependency or configuration was added. The development build is a compiled app, not a live container that automatically absorbs later native changes. Rebuild when native inputs change; do not assume that refreshing JavaScript updates the app’s native layer.
Verify the course project on the device you actually use
A successful build is not the final check. Reopen the same course project and test the feature that caused the original error. Confirm that the development app launches, the target module can be called, and a small JavaScript edit appears as expected. Then compare what you see with the assignment’s requirements.
Use this acceptance list:
- The project starts with the intended app: Expo Go or the project’s development build.
- The target feature runs on the device or simulator you selected.
- The build matches that destination; a simulator build is not a substitute for a physical-device test.
- After a JavaScript-only edit, the change appears without an unnecessary native rebuild.
- After a native dependency or configuration change, you rebuilt the development app before testing again.
- Any keys or credentials are supplied through a suitable private configuration method, not committed to a public repository.
- The result meets the course brief. If the assignment asks for simulator evidence, a successful cloud build alone does not provide that evidence.
For a student working on Windows, a practical case might look like this: the app works in Expo Go until a course exercise adds a library that needs native code. The right next move is to verify the library’s Expo instructions, create a development build, and test on a supported destination. If the assignment only needs a working feature on a physical phone, a simulator may not be necessary. If it requires simulator behavior or Xcode inspection, arrange macOS access before the deadline.
Use macOS only when the task calls for Mac tools
You do not need to rent a Mac just to learn JavaScript or to run every Expo project. Expo Go remains a good fit for supported exercises, and a cloud build can handle iOS build work without running Xcode on your Windows machine. A school Mac can be the simplest option if you can use it when needed.
The gap appears when your task specifically depends on the iOS Simulator or direct Xcode work. A Windows computer cannot run Apple’s iOS Simulator locally, and a cloud-generated app is not the same as a simulator session you can inspect. A shared school computer may also have limited availability or prevent you from installing project tools. Those are workflow constraints, not proof that every Expo learner needs a Mac.
If you need macOS for a course checkpoint, compare school access with a remote session before buying hardware. Check that the project, connection method, and required tools suit the task. You can review MACCOME’s remote Mac options for a temporary macOS environment, and use the Xcode and iOS Simulator workflow as a starting point for deciding what you need to verify. Remote access can help with Xcode and simulator checks, but it does not remove the need to match the build to the target device or to meet your course’s requirements.
Your current Windows setup may be enough for editing and cloud builds, but it cannot provide a local iOS Simulator, and school access may not be available when you need to test. If you have reached a required Xcode or simulator checkpoint and do not have a suitable Mac, renting a remote Mac from MACCOME can give you macOS access for that task without making a hardware purchase. If you only need Expo Go or a cloud build, stay with that simpler route; if the assignment needs Mac-based verification, check the remote environment before you schedule the test.