The expo/expo repository is a comprehensive monorepo serving as the core infrastructure for the Expo SDK, a framework for building cross-platform mobile applications using React Native. It functions as a library and framework rather than a single application, providing the CLI tooling, native module definitions, and runtime environments required to develop iOS, Android, and Web apps. The architecture is split into multiple packages (e.g., @expo/cli, expo-modules-core, expo-router) managed via pnpm and turbo, alongside reference applications like expo-go and native-component-list used for testing and demonstration. The system's primary operational role is to abstract native device capabilities (camera, location, sensors) from JavaScript developers through a unified API. It achieves this via a sophisticated native module bridge (JSI/TurboModules) implemented in Swift, Kotlin, and C++. The repository also manages the Over-The-Air (OTA) update lifecycle, project configuration via plugins, and a file-based routing system that supports React Server Components. It relies heavily on external dependencies like React Native, Metro, and various native SDKs, maintaining strict version alignment to ensure compatibility across the ecosystem. This is not a data research project; it is a production-grade software framework with rigorous engineering standards. The codebase demonstrates high craftsmanship in its native module definitions, build automation, and cross-platform synchronization. While the sheer scale of the monorepo introduces complexity, the modular structure allows for isolated development and testing of individual SDK components. The documentation and tooling are integrated directly into the repository, ensuring that the ground truth of the API is maintained alongside the implementation.
react-native-reusables is a React Native UI component library that adapts the shadcn/ui copy-paste component model to React Native. It is a pnpm/Turborepo monorepo containing a Next.js/Fumadocs documentation site (apps/docs), an Expo SDK 56 showcase app for live cross-platform previews (apps/showcase), a scaffolding CLI built on Effect-TS (apps/cli), and a shared registry package (packages/registry) with roughly 30 styled components — Button, Dialog, Select, Accordion, Dropdown Menu, Tooltip, and others — plus higher-level authentication blocks (sign-in, sign-up, forgot/reset password, verify email) with optional Clerk integration. There is no data science or analytics code; it is purely a component library and developer-tooling project. The central architectural decision is dual styling-engine support: every component is implemented twice, once for Nativewind and once for Uniwind, both wrapping @rn-primitives (Radix-style primitives ported to React Native). Components use class-variance-authority for variant management, a Slot primitive for asChild composition, a TextClassContext that propagates text styles down component hierarchies (a non-obvious workaround for React Native's lack of CSS style cascading), and a portal/overlay system that uses iOS FullWindowOverlay on native platforms and fragments on web. The target platforms are iOS, Android, and web via Expo. Component source is serialized into shadcn-compatible registry JSON files (public/r/nativewind/*.json and public/r/uniwind/*.json) consumed by both the docs site and the CLI, with catalogs.dev YAML metadata driving publishing and discoverability. The CLI's init/add/doctor commands wrap the shadcn installation machinery with additional project intelligence: the doctor command validates dependencies and detects deprecated file patterns, and project-config.ts parses a project's metro.config.js to determine whether Nativewind or Uniwind is active before writing components.json. The add command delegates component installation to shadcn. Several auth blocks contain explicit TODO placeholders for navigation and form-submission logic that consumers must implement. The dominant maintenance burden is the deliberate duplication across the two styling engines — every API or visual change must be mirrored in both variants, and the generated registry JSON can drift from source files. Dependencies (Expo SDK 56, React Native 0.85.3, Nativewind 4.2.2, Uniwind 1.6.3) are current, and the repo tracks its ecosystem proactively.
learnX is a React Native/Expo mobile application designed for Tsinghua University students to access the Web Learning platform (learn.tsinghua.edu.cn). It provides features such as SSO authentication, course management, assignment tracking, file handling, calendar synchronization, and course information sharing via the courseX platform. The app uses Redux for state management, React Navigation for routing, and React Native Paper for UI components, with TypeScript ensuring type safety. It includes background data synchronization and supports iOS, Android, macOS, and Windows (via WSA).
This repository is a React Native library that wraps Radar's native iOS and Android SDKs to provide geofencing, location tracking, trip tracking, geocoding, search, context, route/matrix, places, beacons, fraud verification, and in-app messaging capabilities. It exposes a JavaScript API (Radar.initialize, Radar.autocomplete, etc.) and optional UI components (Map, Autocomplete) for use in React Native applications. The architecture consists of a TypeScript/JavaScript layer that communicates with native code via React Native's bridge (old and new architectures), with vendored iOS xcframeworks and Android Java modules. The library handles native setup automation (AppDelegate injection, Podfile modification) through an Expo config plugin, and includes version sync scripts to keep SDK versions consistent across platforms. It supports both iOS and Android, with optional fraud and motion SDK extensions. The example app demonstrates usage with MapLibre for map display. The codebase is well-structured with CI workflows, tests for the Expo config plugin, and careful version management, though it carries binary xcframework artifacts and dual architecture support that increase maintenance surface.
ReadAny is a full-featured, cross-platform e-book reader application with deep AI integration. It supports reading EPUB, PDF, MOBI, FB2, and other formats via the modified foliate-js engine, and provides text-to-speech, annotations, reading statistics, and cross-device sync (WebDAV, S3, LAN). The AI subsystem offers chat with RAG (semantic search over book content), context-aware tools, and execution of user-defined skills. The application follows a local-first architecture with robust offline capabilities and optional cloud sync. The codebase is structured as a pnpm monorepo with four main packages: 'core' (shared business logic, types, stores, AI, RAG, sync, stats, TTS), 'app' (Tauri desktop client with React+shadcn UI), 'app-expo' (Expo/React Native mobile client), and 'cli' (agent integration via MCP and managed shims). The application exhibits high craftsmanship in its platform abstraction layer, persistent store pattern, and hybrid search engine. However, there is significant platform-driven code duplication (desktop vs. mobile UI components) and a complex dependency graph with multiple patched packages, indicating some architectural debt.
rnsec is a zero-configuration static analysis security scanner for React Native and Expo applications. It scans JavaScript/TypeScript, XML, plist, and JSON files for over 85 security rules covering storage, network, authentication, cryptography, logging, Android/iOS platform issues, and supply chain risks. The tool uses Babel AST parsing and regex pattern matching to detect hardcoded secrets, insecure configurations, and common vulnerabilities. It generates HTML, JSON, and Markdown reports, supports CI/CD integration with changed-files scanning, and can post results as GitHub PR comments. The architecture is a monolith CLI application built with Commander, with a modular rule engine that registers scanner groups. The codebase is well-structured, TypeScript strict, and includes comprehensive tests for all rules.
This repository provides a library and build-time plugin for embedding a React (or Preact / React Native Web) web application inside a React Native WebView, with automatic bundling and two-way communication between the native and web sides. It consists of a Metro transformer plugin that uses Babel AST analysis to detect entry files (those calling webViewRender or webViewCreateRoot), then bundles the web app via esbuild with custom asset loaders for images, CSS, JSON, text, Markdown, and WebAssembly. The bundled output is wrapped in an HTML string and returned as the module source, which is then loaded into a react-native-webview at runtime. The library exposes React hooks (useWebViewMessage for native, useNativeMessage and emit for web) that handle message passing via window.postMessage and ReactNativeWebView.postMessage. The architecture is a classic library + build plugin pattern, with clear separation between native (React Native) and web (React DOM) concerns. The codebase is TypeScript, has end-to-end Playwright tests with HTML snapshots, unit tests, and thorough type definitions. It is designed for rapid prototyping or features that require web-specific APIs (e.g., WebAssembly, contenteditable) without rewriting the entire UI for React Native.
A well-structured monorepo for building cross-platform Expo (React Native) applications using pnpm and Turborepo. The repository demonstrates a scalable architecture with three shared packages (eslint configuration, reusable UI components, and a home feature) and a single example Expo app that leverages Expo Router for navigation, react-native-reanimated for animations (parallax scroll, wave animation), expo-haptics for haptic feedback, and expo-symbols/expo-image for platform-adaptive icons and images. The code is organized following modern React Native best practices: typed routes, strict TypeScript, automatic dark/light mode, absolute imports, and Jest + testing-library/react-native tests for components. CI/CD is fully implemented via GitHub Actions with workflows for linting, building, testing, EAS deployments, and preview builds. While the application itself is a simple template (home screen with steps, an explore screen with informational collapsibles, and a modal), the architecture showcases a effective monorepo workflow with Turborepo caching and pnpm workspace protocols. The most notable technical components are a cross-platform icon abstraction (SF Symbols to Material Icons), a standalone parallax scroll view with Reanimated, and an in-app browser link adapter—all of which are modular and easily extracted for other projects.
JKVideo is a cross-platform (Android/iOS/Web) Expo React Native application that acts as an unofficial Bilibili client. It browses Bilibili recommendation feeds, searches videos, plays DASH video via a locally generated MPD consumed by react-native-video/ExoPlayer, streams live rooms over HLS, displays video and live danmaku, loads comments, supports QR-code login, downloads videos, and shares them over a LAN HTTP server. The code is organized into expo-router screens, React hooks, Zustand stores, a single API service module, and utility modules; it uses signed WBI requests and maintains Bilibili cookies/CSRF state. The implementation quality is above average for a community project: the service layer includes request deduplication and network-only retries; the video player uses Animated-driven seek bars with video-shot preview thumbnails and quality fallback chains; DASH MPD generation handles Dolby Vision and segment ranges; the download hook pauses on background and resumes on foreground. However, there are no automated tests, some dead/default code remains (App.tsx is not the real entry), a hardcoded Sentry DSN and an exposed EAS Sentry auth token are present, and the LAN-share QR code relies on an external QR API. Live 'real-time' danmaku is actually 1.5-second REST polling of Bilibili's history endpoint, despite README claims of WebSocket. The repository is explicitly deprecated: the Chinese README states Bilibili sent a legal letter and maintenance/Issues/PRs have ceased, even though the last commit is recent. This code is useful as a reference for Bilibili API integration, DASH MPD construction, danmaku rendering, and React Native video-player architecture, but it should not be selected for new production use.