awesome-repositories.com
© 2026 Bringes Technology SRL·VAT RO45896025·hello@bringes.io
MCPSitemapPrivacyTerms
Expo | Awesome Repository
← All repositories

expo/expo

0
View on GitHub↗
47,373 stars·11,023 forks·TypeScript·mit·0 viewsdocs.expo.dev↗

Expo

Features

  • Cross-Platform Frameworks - Building native iOS and Android applications from a single codebase using web-standard technologies and shared business logic.
  • Mobile CI/CD Pipelines - Streamlining the mobile release lifecycle by automating native binary compilation, code signing, and app store submission processes.
  • Over-the-Air Update Services - A deployment mechanism that pushes JavaScript and asset changes directly to user devices to bypass traditional app store review cycles.
  • Build Automation - Expo enables creating custom native Android development builds for testing application code by running build commands with specific development profiles.
  • Cloud Build Services - Offloads the resource-intensive process of building and signing native application binaries to a managed remote infrastructure.
  • Core Component Libraries - Expo enables the use of built-in components and APIs by importing them directly from the core package to build fundamental application logic.
  • File-Based Routing - Expo supports defining navigation routes using a file-based system where directories automatically map to pages and URL paths.
  • Native Build Orchestrators - Expo provides commands to compile and launch native applications on Android or iOS devices and simulators, replacing standard community CLI build tools.
  • Native Configuration Plugins - Programmatically modifies native project files during the build process to integrate modules without manual intervention.
  • Navigation Systems - Expo supports navigating between pages imperatively using hooks to push, replace, or go back in the navigation stack.
  • Cloud Build Services - Expo provides cloud-based build orchestration by generating configuration files and setting up environment-specific requirements like dependencies and signing credentials.
  • Continuous Integration Services - Expo supports triggering remote builds for Android or iOS platforms, including options for local testing or generating signed binaries for distribution.
  • Mobile Build Services - A managed infrastructure that automates the compilation, signing, and distribution of native mobile application binaries for app stores.
  • Development Runtimes - Provides a unified runtime environment that supports dynamic loading of native modules and debugging tools during development.
  • Device Hardware SDKs - Expo allows accessing device and system functionality like camera, audio, and maps by importing libraries from the official SDK.
  • Native Project Automation - Expo provides specialized plugins that wrap platform-specific configuration tasks to modify native Android and iOS project files during the prebuild process.
  • Over-the-Air Update Tools - Expo enables publishing code changes directly to users by uploading update bundles to servers, bypassing the need for full app store submissions.
  • Over-the-Air Updates - Enables instant deployment of code and asset updates to end-user devices, bypassing traditional app store review processes.
  • Routing Systems - Expo enables defining application routes using file-system conventions, including dynamic parameters, route groups, and custom error handling.
  • Stack Navigation Frameworks - Expo supports implementing stack-based navigation to automatically treat files as routes and provide native back-button behavior.
  • File-Based Routing Systems - Expo enables defining application navigation structure by organizing files within a directory where each file automatically corresponds to a specific route.
  • Build Configuration Management - Expo enables defining build profiles in configuration files to manage environment variables, node versions, and platform-specific build settings.
  • App Store Deployment Tools - Expo allows submitting app binaries to the App Store or Play Store by specifying build IDs or local file paths.
  • Build Tooling - Expo supports creating custom native iOS development builds for testing on simulators by configuring development profiles and running build commands.
  • Development Clients - Expo allows adding the development client library to enable the launcher interface, developer menu, and over-the-air update testing.
  • Dynamic Routing - Expo allows navigating to dynamic routes by passing path parameters and query strings, retrieving values using search parameter hooks.
  • Native Build Plugins - Expo supports chaining multiple configuration plugins to apply sequential modifications to native code, ensuring dependencies are respected and configuration remains readable.
  • Native Integration Environments - Expo supports building custom development versions to include native libraries and assets not available in standard environments.
  • Native Integration Tooling - Expo enables native integration by installing necessary libraries and defining target identifiers for iOS and Android build artifacts.
  • Native Integration Workflows - Expo provides workflows for integrating tools into existing native applications, supporting both integrated and isolated development strategies.
  • Native Module Configuration Tools - Expo provides tools to verify library compatibility by checking for native code requirements and configuration plugins to support custom native setups.
  • Native Module Development - Expo supports creating local native modules within existing projects to extend application functionality using platform-specific code.
  • Native Module Integrators - Expo enables the integration of native modules into existing projects using automated command-line tools to handle configuration and dependency setup.
  • Native View Integrations - Expo enables embedding native platform views as subviews within custom components, ensuring layout synchronization with the cross-platform engine.
  • Navigation Libraries - Expo allows creating tab-based navigation using JavaScript components or native platform tabs to organize routes into bottom tab bars.
  • Navigation Routing Systems - Expo enables redirecting users to different routes automatically without rendering the current page using declarative components.
  • Over-the-Air Update Services - Expo allows previewing updates in development builds using the dashboard, pull requests, or the built-in interface provided by the development client.
  • Permission Management - Expo supports requesting and managing camera and microphone permissions at runtime to ensure access to device hardware.
  • Project Configuration Systems - Expo allows defining project metadata such as app names, icons, and service keys using a centralized configuration file to manage build-time settings.
  • Navigation Components - Expo enables linking to pages declaratively using components that trigger navigation on press.
  • Safe Area Layouts - Automatically adjusts component padding to respect device-specific screen boundaries and notches.
  • Dynamic Configuration Systems - Enables programmatic definition of project settings to support environment-specific build logic.
  • Error Reporting - Expo displays fatal crashes and non-fatal warnings during development to help identify and resolve logic issues before production release.
  • Build Configuration Plugins - Expo allows passing custom parameters to configuration plugins from the app configuration file to dynamically adjust native project modifications.
  • File-Based Routing Systems - Maps directory structures directly to navigation paths to define application structure without manual route configuration.
  • Native Build Services - Expo allows rebuilding the custom development client whenever new native dependencies are added to ensure native code is correctly linked.
  • Native UI Extensions - Expo enables implementing custom native views with properties and events using Kotlin or Swift to render platform-specific UI components.
  • Declarative Animations - Supports the creation of fluid, high-performance UI animations through a declarative API.
  • Layout Management Systems - Expo allows rendering child routes within layouts without navigators to wrap pages with shared UI elements like headers or footers.
  • Key-Value Stores - Expo provides a simple and persistent asynchronous key-value storage mechanism for saving non-sensitive data like user preferences or application state.
  • Build Pipeline Orchestration - Expo allows defining named groups of build parameters to manage different build types and share configurations between profiles using inheritance.
  • Web Deployment Pipelines - Provides integrated command-line tools for building and deploying web applications to hosting services.
  • Camera Integration - Expo allows rendering camera previews on device screens to capture photos, record videos, and scan barcodes.
  • Deployment Configuration Profiles - Expo supports defining submission profiles to automate the upload of application binaries to app stores, including authentication credentials and release tracks.
  • Development Launchers - Expo enables opening applications on physical devices or emulators by scanning QR codes or using keyboard shortcuts to connect with the server.
  • Location Permission Managers - Expo allows requesting and managing location permissions for foreground and background access to read device coordinates.
  • Native Debugging Tools - Expo allows inspecting the native runtime and application state using platform-specific development tools to resolve issues occurring outside the primary environment.
  • Native Event Bridges - Expo allows emitting events from native code to JavaScript subscribers to notify the application whenever native state or data values change.
  • Native Module Tooling - Expo enables generating new native modules with dedicated example applications to facilitate isolated development and testing.
  • Nested Navigation - Expo allows nesting stack navigators inside tab navigators to create intuitive navigation hierarchies with independent navigation history.
  • Push Notification Services - Expo supports obtaining push notification tokens for native or managed services to enable remote notifications.
  • Update Stream Configuration - Expo allows configuring update channels to direct specific builds to designated update streams for isolated testing and production management.
  • Runtime Debugging Tools - Expo provides access to the development menu during runtime to trigger debugging tools, switch versions, or inspect build functions.
  • Asset Management - Facilitates the bundling and runtime loading of local project assets like images and data files.
  • Modal Overlays - Expo enables presenting focused overlays that slide up from the bottom to capture user input while blocking background interaction.
  • Local Databases - Expo enables managing persistent SQLite databases to store and query structured data across mobile and web platforms.
  • Cloud Build Interfaces - Expo provides a command-line interface to interact with cloud-based build services directly from the terminal for managing app builds.
  • Development Lifecycle Management - Expo supports standard workflows for interface creation, testing, native module integration, and app store submission.
  • Environment Variable Management - Expo provides tools to manage environment variables across development and production by configuring visibility and syncing local files.
  • Build Configurations - Expo enables configuring build environments by specifying tool versions and selecting virtual machine resource classes to optimize build performance.
  • Environment Configuration Managers - Enables the application of specific environment configurations and variables during the update and build process to ensure consistency across deployments.
  • Audio Playback - Expo supports playing audio files from local or remote sources with playback controls and background playback capabilities.
  • Audio Recording - Expo enables recording audio from device microphones with configurable quality presets and background recording support.
  • Video Players - Expo supports rendering video content using cross-platform components that provide playback controls and fullscreen modes.
  • Asset Management Systems - Uses configuration files to define and bundle local assets and remote resources for consistent cross-platform delivery.
  • Geolocation Services - Expo enables reading device geolocation by polling for coordinates or subscribing to continuous location update events.
  • Google Play Store Integrations - Expo enables submitting Android applications to the Google Play Store by configuring service account credentials and using automated command-line tools.
  • Local Notification Schedulers - Expo supports scheduling local notifications to trigger once or repeatedly using calendar dates or time intervals.
  • Native Build Modifiers - Expo allows access to project metadata and file data during the execution of configuration plugins to perform custom modifications on native project configurations.
  • Native Development Toolchains - Expo allows the integration of native libraries and development tools into existing projects to access extended standard libraries and professional CI/CD workflows.
  • Native Host Integration - Expo supports integrating pre-built library artifacts into native projects by adding dependencies and initializing hosts to display screens within native applications.
  • Native Module Interfaces - Expo allows defining component props in native modules to pass data from the cross-platform layer to native views with automatic type conversion.
  • Notification Event Handlers - Expo enables listening for incoming notifications and user interactions, with custom handlers for notification presentation.
  • Platform-Specific Navigation - Expo supports implementing platform-specific navigation layouts by using file extensions to load different tab components for mobile and web.
  • Project Configuration Utilities - Expo allows configuring the project entry point to initialize the routing system, supporting custom side-effects and global service initialization.
  • Runtime Configuration Providers - Expo provides a dedicated constant object to access non-sensitive project configuration values at runtime, ensuring processed and safe data retrieval.
  • Runtime Update Channel Management - Expo allows switching the update channel of a running application at runtime by overriding request headers for flexible testing.
  • Access Control Guards - Expo enables restricting access to specific routes by wrapping them in authentication guards that redirect users based on login state.
  • Secure Storage - Expo allows encrypting and storing sensitive key-value pairs locally on a device to ensure data remains protected from unauthorized access.
  • Error Reporting - Expo provides real-time reporting of production crashes and exceptions with detailed stack traces and custom context to help reproduce and resolve errors.
  • Mobile Debugging Tools - Expo captures system-level logs from mobile devices to identify crash reasons, native module failures, and hardware warnings.
  • Bottom Sheets - Provides interactive bottom sheet components with support for multiple snap points and automatic sizing.
  • Font Management - Enables the integration and application of custom font assets within the application UI.
  • Splash Screen Management - Enables declarative configuration of the application splash screen appearance.
  • Web Deployment Services - Enables the deployment of web projects with integrated environment variable management for client-side and server-side configurations.

    • Expo is a universal mobile framework designed to build native iOS and Android applications from a single codebase using web-standard technologies. It provides a comprehensive development environment that includes a unified runtime for testing, cloud-based infrastructure for compiling and signing native binaries, and automated tools for managing the entire mobile release lifecycle, including app store submission.

    The framework distinguishes itself through a plugin-based native configuration engine that programmatically modifies project files, allowing developers to integrate native modules without manual intervention. It also features a file-based routing system that maps directory structures directly to navigation paths, and an over-the-air update service that enables the deployment of JavaScript and asset changes directly to user devices, bypassing traditional app store review cycles.

    Beyond these core capabilities, the platform offers a wide range of integrated services for managing project metadata, environment variables, and persistent data storage. It includes a robust set of UI components and utilities for handling hardware-level features such as camera access, geolocation, audio and video playback, and push notifications. Developers can also leverage managed cloud services to orchestrate custom build profiles and automate CI/CD workflows.

    The project is managed via a command-line interface that facilitates project setup, native module integration, and the generation of custom development builds. Documentation and tooling are provided to support both standalone applications and the integration of Expo into existing native projects.