Open-Source React Native Apps: 10 Projects to Learn From

Open-source React Native apps are an important learning resource for developers. They allow you to study real codebases, follow how features evolve over time, and understand how production decisions are made.

We compiled a list of React Native open-source projects that our developers recommend if you’re just getting started with the framework or if you want to move beyond basics and learn more complex patterns. These projects show how real applications handle navigation, state, data flow, platform differences, and long-term maintenance.

The apps included here are actively maintained, used by real users, and large enough to reflect real-world constraints. They demonstrate different approaches to structuring features, integrating native code, and managing performance and releases in production environments.

Each project is reviewed using the same structure. We look at what the app does, how the codebase is organized, which technical choices stand out, and where to start reading if your goal is to learn efficiently. 

Together, these examples provide a practical reference for understanding how React Native is used in real products today.

Pick a project by goal

If you’re using these repos as a learning resource, it helps to start with a clear target. Each project teaches something slightly different.

Learning how production-scale React Native apps are structured

Pick these if you care about architecture, feature boundaries, and long-term maintenance in large codebases:

• Bluesky Social App (multi-surface app: mobile + web)
• New Expensify (mobile + web/desktop, heavy tooling)
• Mattermost Mobile v2 (enterprise-grade mobile client)
• Artsy Eigen (long-lived RN product with mature release practices) (artsy.net)
• Standard Notes Mobile (monorepo + cross-platform parity + long-lived maintenance)

Learning Expo workflows and what “shipping” looks like with EAS

Pick these if you want practical examples of environment setup, builds, and fast iteration with Expo:

• Realremote Frontend (Expo + web target + backend integration)
• Shoot! I Smoke (Expo + EAS, clear config and release workflow)

Learn the boring-but-critical production plumbing

Pick these if you want to study staging vs production setup, secrets, signing, and test automation:

• iNaturalist React Native (env separation, signing, optional Firebase, E2E) (inaturalist.org)
• New Expensify (tests, coverage, performance regression tooling)

Learn native boundaries and real integrations

Pick these if your goal is understanding where JavaScript ends and platform/infrastructure work begins:

• Rainbow Wallet (API keys, platform constraints, service integrations)
• Mattermost Mobile v2 (push notification service, platform constraints, build patches)

Learn modularization in a monorepo

Pick this if you’re interested in splitting an app into maintainable libraries and shared modules:

• Öppna Skolplattformen (Nx monorepo with apps/ + libs/, clean boundaries)

In the next section, we’ll go through each project in detail, using the same structure each time so you can compare them and quickly find what’s most relevant to your goals.

Open-source React Native apps list

Bluesky Social App (bluesky-social/social-app)

Functionality:

Bluesky’s official client app for Web, iOS, and Android.  

Structure:

• A React Native codebase written in TypeScript, with dedicated testing folders like __tests__ and __e2e__.  
• The repo is organized like a multi-surface product: you’ll see core app code in src, plus separate folders for web-related pieces such as web and bskyweb, alongside internal packages like bskyembed, bskylink, and bskyogcard.  
• There’s also a small amount of Go code under ./bskyweb/ used for a web service that serves the React Native Web app.  

Integrations:

• Builds on Bluesky’s open-source AT Protocol (“atproto”) TypeScript packages (for example @atproto/api).  
• Includes Expo/EAS-related config in the repo (e.g., eas.json, app.config.js), which is useful if you’re interested in how teams manage builds for production RN apps.  

Why it is useful for developers:

Bluesky is a strong example of a production-scale React Native open-source app that targets multiple platforms without turning into an unreadable monolith. It’s especially useful if you want to learn how a real team structures a large RN codebase, keeps testing/E2E in place, and supports both mobile and web surfaces from a shared foundation. The repo’s build docs are a good starting point before you dive into feature code. 

New Expensify (Expensify/App)

Functionality

New Expensify is Expensify’s rebuilt product, positioned as “a complete re-imagination of financial collaboration, centered around chat.”  

Structure

This is a large, production-grade React Native repo with a lot of real-world plumbing in place:

• Core code in src, plus platform folders ios and android  
• Multi-platform targets in the same codebase (notably web and desktop)  
• Strong testing/tooling footprint: tests, Jest config, Storybook (.storybook), plus CI/release tooling like fastlane  
• Environment configuration is treated as first-class (.env.example, staging/production env files), which is typical of mature apps  
• Very TypeScript-heavy (the repo language breakdown is ~97% TypeScript)  

Integrations

• The README documents a full local development flow and platform-specific setup (including “Running the tests”).  
• Tooling for quality and regression control is explicitly part of the workflow: Jest for unit tests, Codecov for coverage, and Reassure for performance regression monitoring.  
• It also includes optional performance metrics that can be surfaced in Flipper via React-Native-Onyx tooling.  

Why it is useful for developers

New Expensify is the kind of repo that teaches you what React Native looks like when it’s treated as a long-term product platform. It’s useful for learning how teams structure a large codebase across mobile + web/desktop, how they operationalize testing and performance checks, and how they document setup so contributors can actually run and ship changes. The repo’s scale (hundreds of thousands of commits and a very frequent release cadence) makes it a strong reference for maintenance practices. 

Mattermost Mobile v2 (mattermost/mattermost-mobile)

Functionality

Mattermost Mobile v2 is the next-generation iOS and Android client for Mattermost, built in React Native. It’s a production chat/collaboration app you can download from the App Store / Google Play, or build yourself.  

Structure

This is a good example of a “real” RN repo with the typical platform split and production tooling:

• Core app code in app, native projects in ios and android  
• E2E testing with detox, plus test and types  
• Release automation via fastlane, and a share_extension for OS-level sharing workflows  
• Internal reusable modules under libraries/@mattermost (useful for seeing how teams factor shared logic in a large codebase)  

Integrations

• If you self-compile the app, you must also deploy your own Mattermost Push Notification Service.  
• The README documents an Android 16KB page size compatibility patch (auto-applied in CI for Android builds; can be applied locally if needed). This is a great example of the kind of compliance detail production teams have to handle.  

Why it is useful for developers

Mattermost Mobile is worth studying if you want to see how a mature team approaches long-term maintainability: clear platform support targets (server/iOS/Android minimums), documented build constraints, monthly release cadence, and a repo structure that includes testing and release tooling as first-class concerns. 

Artsy Eigen (artsy/eigen)

Functionality

Eigen is Artsy’s mobile app — “The Art World in Your Pocket” — used to discover art and engage with Artsy’s marketplace and platform.  

Structure

• A mature, long-lived React Native codebase with both ios/ and android/ native projects, and core app logic in src/.  
• Strong production tooling footprint: e2e/ tests, fastlane/ for release automation, plus internal scripts and docs (docs/, scripts/).  
• The repo has a substantial history (tens of thousands of commits) and active releases (28 releases listed, with a 2025 “Latest” release visible on the repo page).  

Integrations

• CI on CircleCI (called out in the README meta section and visible via .circleci/).  
• A GraphQL-oriented setup is strongly implied by relay.config.js and .gqlconfig, which makes this repo useful if you want to study RN + GraphQL workflows in a production app.  
• Mixed-language codebase (TypeScript-heavy with Objective-C/Swift present), which is typical for RN apps that integrate native capabilities and evolve over time.  

Why it is useful for developers

Eigen is a strong reference if you want to learn how a real team runs React Native in production over the long term: release processes, CI discipline, E2E testing, and native/platform work living alongside TypeScript application code. It’s also unusually well-documented for an app of this size, with dedicated “Getting Started,” best practices, and deployment docs linked directly from the README.

Standard Notes Mobile (standardnotes/app → packages/mobile)

Functionality

Standard Notes is an end-to-end encrypted note-taking app that runs across platforms. The mobile app is part of the main standardnotes/app monorepo and ships as the official iOS/Android client.  

Structure

• The project is a single shared codebase approach: Standard Notes describes its mobile app as “our web app with access to native mobile functionality,” aiming for close feature parity across platforms.  
• The repository itself is a large monorepo (packages/…), with the mobile client living under packages/mobile.  
• Licensing is AGPL-3.0, which matters if you plan to reuse or redistribute parts of the code in your own product.  

Integrations

• The mobile client is actively kept up to date with the RN ecosystem: in their 2025 update, Standard Notes says they upgraded to React Native 0.78.1 to support the new architecture, and they also updated Android storage by moving to the latest AsyncStorage implementation.  

Why it is useful for developers

Standard Notes is a strong repo to study if you care about long-lived product engineering in React Native: encryption-driven requirements, cross-platform parity goals, and the kind of “foundation work” (RN architecture upgrades, storage changes) that mature apps have to do to stay stable over years. It’s also a useful reference for how teams position a mobile client inside a broader monorepo, rather than treating mobile as a standalone project.  

Realremote Frontend (4TWIGGERS/realremote-front)

Functionality

Realremote is a curated platform for remote job opportunities. This repo contains the frontend for the Realremote website, and the project also ships as a mobile app on iOS and Android.  

Structure

The repo is built with React Native + Expo, and it’s clearly set up as a cross-platform codebase:

• App code in src, with platform folders like ios/ present in the repo  
• A dedicated web/ directory for the web build target  
• Expo/EAS configuration files (app.config.js, eas.json) plus .expo-shared and patches  

Integrations

• Expo-based workflow (“built only using React Native with expo”), which is useful if you’re learning how teams target web + mobile from one codebase.  
• Uses environment configuration via an env.js file (the repo provides env.demo.js as the example).  
• The README links to a separate backend repo, which makes this a good “full-stack integration” example (frontend consuming its own API).  

Why it is useful for developers

Realremote is a solid learning repo if you want a practical example of a React Native + Expo project that targets both web and mobile and ships a real product flow: search/filter listings, details pages, and application links. It’s also useful for seeing a clean onboarding path for contributors (clone → install → create env file → run).  

Shoot! I Smoke (shootismoke/mobile-app)

Functionality

Shoot! I Smoke shows your city’s air pollution as an easy-to-grasp metric: how many cigarettes you “smoke” per day based on local pollution levels. It’s available on iOS and Android, and the repo includes links to the App Store / Google Play versions.  

Structure

• Built with Expo, with a straightforward app layout (App/, assets/) plus standard project tooling and config (tsconfig.json, ESLint/Prettier).  
• Uses EAS for builds/updates (eas.json, app.config.js), and provides a working Expo “Try it” link so you can run the app quickly without setting up native projects first.  
• Has contributor docs (CONTRIBUTING.md) and a public changelog (CHANGELOG.md).  

Integrations

The README is unusually clear about external dependencies and the “real app” configs you’ll need:

• Uses environment variables (copy .env.example → .env).  
• Lists API tokens and services used by the app, including Geoapify (geocoding), World Air Quality Index (AQICN), plus optional Sentry and Amplitude, and optional Google Maps setup for iOS/Android.  
• Notes that required tokens are pre-filled in eas.json for development, with guidance for using your own keys.  

Why it is useful for developers

This is a solid project to study if you want a practical example of a production Expo app with real-world concerns: external APIs, secret management, release channels, and EAS-based shipping workflows (including remote updates). It’s also refreshingly honest about its weaknesses: the README calls out limited test coverage and points contributors to where tests exist and which issue to start with if they want to improve it. 

iNaturalist React Native (inaturalist/iNaturalistReactNative)

Functionality

This is an official iNaturalist client written in React Native, intended to eventually replace iNaturalist’s existing native iOS and Android apps (they explicitly mention they’re working toward feature parity).  

Structure

The repo looks like a mature RN production app, with the usual platform split and a lot of supporting tooling:

• Core app code in src, native projects in ios and android  
• Strong testing footprint: tests plus an e2e folder, and CI workflows surfaced right in the README (test + iOS/Android E2E badges)  
• Release and automation tooling via fastlane, plus contributor-focused tooling like .husky  
• It’s a TypeScript project (tsconfig.json, jest.config.ts) with additional hints of legacy/interop choices (there’s a .flowconfig and flow-typed folder)  

Integrations

The setup section is a good example of real-world configuration requirements:

• Uses environment files (env.example → .env / .env.staging) because secrets like OAuth client IDs are not stored in the repo  
• Android signing requires a keystore properties file (android/keystore.properties)  
• Firebase is optional, but if enabled it requires platform-specific config files (GoogleService plist/json) that are also not part of the repo  
• iOS setup explicitly requires Xcode 15+ and CocoaPods install steps (pod install)  

Why it is useful for developers

This repo is especially useful if you want a grounded example of what it takes to ship and maintain a real cross-platform app: environment separation (staging vs production), secrets management, signing, optional third-party services, and a serious E2E testing setup. It’s also a good reference for teams migrating toward a unified React Native client while working toward parity with existing native apps—something many organizations go through.  

Rainbow Wallet (rainbow-me/rainbow)

Functionality:

Rainbow is a production Ethereum wallet — “the Ethereum wallet that lives in your pocket” — with public builds on iOS and Android.  

Structure:

The repo has a classic large React Native layout, with a clear separation between app code and platform code: src for the core application, ios and android for native projects, plus e2e, scripts, patches, and a dedicated types directory.  

It’s also a heavily TypeScript-first codebase (the language breakdown is overwhelmingly TypeScript), which makes it a good reference if you want to see how a real RN product uses typing at scale.  

Integrations:

Rainbow’s development setup is a good example of what “real app” configuration looks like. It expects a .env based on env.example, and some features require you to generate your own API keys. The README points to providers such as Etherscan, Infura, ETH Gas Station, and Imgix.  

It also explicitly requires adding a google-services.json (Firebase config) so Android builds don’t fail.  

Why it is useful for developers:

Rainbow is a strong reference if you want to study a security- and infra-heavy consumer app in React Native. The repo is very explicit about environment setup, platform constraints (for example, iOS builds require macOS/Xcode, while Linux environments can’t build Darwin targets), and the practical realities of managing third-party service keys in an open-source project.  

Öppna Skolplattformen (kolplattformen/skolplattformen)

Functionality

Öppna Skolplattformen is a civic-tech project built by parents in Stockholm. They reverse-engineered the City of Stockholm’s school administration platform API to deliver a simpler, faster, more consistent experience for parents and guardians.  

Structure

• The repo is an Nx monorepo that contains both the mobile app and the website in one place.  
• The runnable applications live under /apps (including the skolplattformen app and a website).  
• Shared logic lives under /libs, with clear boundaries between libraries (API base + multiple API implementations, hooks, curriculum data, etc.).  
• The mobile app is written in TypeScript using React Native and UI Kitten.  

Integrations

• Uses React Native Kitten (UI Kitten) for UI components and theming.  
• Includes multiple API implementations (e.g., api-skolplattformen, api-hjarntorget, api-vklass) plus a shared api base and a hooks library to make API usage easier in the app.  
• The repo also contains the project website, built with Next.js.  

Why it is useful for developers

This repo is a great case study in how to structure a React Native app as part of a larger, long-lived product. The Nx monorepo setup and the /libs boundaries make it especially useful if you want to learn how to split a growing app into maintainable modules (API layer, hooks, domain data) without turning the codebase into a monolith. The project’s real-world constraints—reverse-engineering a complex external platform and shielding the app from that complexity—also make the architecture more instructive than a typical demo app.  

Conclusion

Open-source React Native apps won’t give you a single “right” way to build with React Native. But they will show you what real teams do when an app grows: how they structure features, how they handle platform differences, how they ship safely, and what they invest in to keep the codebase maintainable.

If you want to level up, pick one project from this list and trace a single feature end-to-end. Follow it from UI to state to API calls to native boundaries. That’s where the real learning happens.

And if you’re building something similar and want a second opinion on architecture, performance, or release strategy, Apiko can help. We are a React Native app development company, and can help you choose the right approach before expensive mistakes become permanent. 

If you’d like to go deeper, you’re also welcome to check out our other React Native articles at Apiko. We’ve covered the most common React Native limitations (and how teams work around them), as well as what React Native for Web looks like in real projects.